Add data_loss_protect support

Author: SWvheerden

src/ln/channel.rs

@@ -346,6 +346,8 @@ pub(super) struct Channel {
 
 	channel_monitor: ChannelMonitor,
 
+	local_feature_flags: Option<msgs::LocalFeatures>,
+
 	logger: Arc<Logger>,
 }
 
@@ -381,6 +383,7 @@ pub const OFFERED_HTLC_SCRIPT_WEIGHT: usize = 133;
 pub(super) enum ChannelError {
 	Ignore(&'static str),
 	Close(&'static str),
+	CloseNoPublish(&'static str),
 }
 
 macro_rules! secp_check {
@@ -393,6 +396,11 @@ macro_rules! secp_check {
 }
 
 impl Channel {
+	// get functions
+	pub fn get_channel_id(&self) -> [u8; 32] {
+		self.channel_id
+	}
+
 	// Convert constants + channel value to limits:
 	fn get_our_max_htlc_value_in_flight_msat(channel_value_satoshis: u64) -> u64 {
 		channel_value_satoshis * 1000 / 10 //TODO
@@ -422,7 +430,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_value_satoshis: u64, push_msat: u64, user_id: u64, logger: Arc<Logger>, config: &UserConfig, local_feature_flags: &Option<msgs::LocalFeatures>) -> Result<Channel, APIError> {
 		let chan_keys = keys_provider.get_channel_keys(false);
 
 		if channel_value_satoshis >= MAX_FUNDING_SATOSHIS {
@@ -516,7 +524,7 @@ impl Channel {
 			their_shutdown_scriptpubkey: None,
 
 			channel_monitor: channel_monitor,
-
+			local_feature_flags: local_feature_flags.clone(),
 			logger,
 		})
 	}
@@ -533,7 +541,7 @@ 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, keys_provider: &Arc<KeysInterface>, their_node_id: PublicKey, msg: &msgs::OpenChannel, user_id: u64, logger: Arc<Logger>, config: &UserConfig) -> Result<Channel, ChannelError> {
+	pub fn new_from_req(fee_estimator: &FeeEstimator, keys_provider: &Arc<KeysInterface>, their_node_id: PublicKey, msg: &msgs::OpenChannel, user_id: u64, logger: Arc<Logger>, config: &UserConfig, local_feature_flags: &Option<msgs::LocalFeatures>) -> Result<Channel, ChannelError> {
 		let chan_keys = keys_provider.get_channel_keys(true);
 		let mut local_config = (*config).channel_options.clone();
 
@@ -706,6 +714,7 @@ impl Channel {
 			their_shutdown_scriptpubkey: None,
 
 			channel_monitor: channel_monitor,
+			local_feature_flags: local_feature_flags.clone(),
 
 			logger,
 		};
@@ -2325,6 +2334,21 @@ impl Channel {
 			return Err(ChannelError::Close("Peer sent a garbage channel_reestablish"));
 		}
 
+		//Check for dataloss fields and fail channel
+		if msg.next_remote_commitment_number > 0 {
+			if let Some(ref data_loss) = msg.data_loss_protect {
+				//check if provided signature is a valid signature from us
+				if chan_utils::build_commitment_secret(self.local_keys.commitment_seed, msg.next_remote_commitment_number-1) != data_loss.your_last_per_commitment_secret{
+					return Err(ChannelError::Close("Peer sent a garbage channel_reestablish with secret key not matching the  commitment height provided"));
+				}
+				//check if we have fallen beind
+				//We should not broadcast commitment transaction or continue
+				if msg.next_remote_commitment_number > self.cur_local_commitment_transaction_number{
+					return Err(ChannelError::CloseNoPublish("We have fallen behind and we cannot catch up, need to close channel but not publish commitment"));
+				}
+			}
+		}
+
 		// Go ahead and unmark PeerDisconnected as various calls we may make check for it (and all
 		// remaining cases either succeed or ErrorMessage-fail).
 		self.channel_state &= !(ChannelState::PeerDisconnected as u32);
@@ -2406,6 +2430,7 @@ impl Channel {
 				// now!
 				match self.free_holding_cell_htlcs() {
 					Err(ChannelError::Close(msg)) => return Err(ChannelError::Close(msg)),
+					Err(ChannelError::CloseNoPublish(msg)) => return Err(ChannelError::CloseNoPublish(msg)),
 					Err(ChannelError::Ignore(_)) => panic!("Got non-channel-failing result from free_holding_cell_htlcs"),
 					Ok(Some((commitment_update, channel_monitor))) => return Ok((resend_funding_locked, required_revoke, Some(commitment_update), Some(channel_monitor), order, shutdown_msg)),
 					Ok(None) => return Ok((resend_funding_locked, required_revoke, None, None, order, shutdown_msg)),
@@ -3085,6 +3110,19 @@ impl Channel {
 	pub fn get_channel_reestablish(&self) -> msgs::ChannelReestablish {
 		assert_eq!(self.channel_state & ChannelState::PeerDisconnected as u32, ChannelState::PeerDisconnected as u32);
 		assert_ne!(self.cur_remote_commitment_transaction_number, INITIAL_COMMITMENT_NUMBER);
+		let data_loss_protect = if let Some(ref local_features) = self.local_feature_flags{
+			if local_features.supports_data_loss_protect() && self.their_cur_commitment_point.is_some() && self.channel_monitor.get_last_seen_secret().is_some(){
+				let data_loss = msgs::DataLossProtect{
+					your_last_per_commitment_secret: self.channel_monitor.get_last_seen_secret().unwrap(),
+					my_current_per_commitment_point: self.their_cur_commitment_point.unwrap(),
+				};
+				Some(data_loss)
+			} else {
+				None
+			}
+		} else{
+			None
+		};
 		msgs::ChannelReestablish {
 			channel_id: self.channel_id(),
 			// The protocol has two different commitment number concepts - the "commitment
@@ -3105,7 +3143,7 @@ impl Channel {
 			// dropped this channel on disconnect as it hasn't yet reached FundingSent so we can't
 			// overflow here.
 			next_remote_commitment_number: INITIAL_COMMITMENT_NUMBER - self.cur_remote_commitment_transaction_number - 1,
-			data_loss_protect: None,
+			data_loss_protect: data_loss_protect,
 		}
 	}
 
@@ -3640,7 +3678,7 @@ impl Writeable for Channel {
 		self.their_node_id.write(writer)?;
 
 		write_option!(self.their_shutdown_scriptpubkey);
-
+		write_option!(self.local_feature_flags);
 		self.channel_monitor.write_for_disk(writer)?;
 		Ok(())
 	}
@@ -3814,6 +3852,7 @@ impl<R : ::std::io::Read> ReadableArgs<R, Arc<Logger>> for Channel {
 		let their_node_id = Readable::read(reader)?;
 
 		let their_shutdown_scriptpubkey = read_option!();
+		let local_feature_flags = read_option!();
 		let (monitor_last_block, channel_monitor) = ReadableArgs::read(reader, logger.clone())?;
 		// We drop the ChannelMonitor's last block connected hash cause we don't actually bother
 		// doing full block connection operations on the internal CHannelMonitor copies
@@ -3893,7 +3932,7 @@ impl<R : ::std::io::Read> ReadableArgs<R, Arc<Logger>> for Channel {
 			their_shutdown_scriptpubkey,
 
 			channel_monitor,
-
+			local_feature_flags,
 			logger,
 		})
 	}
@@ -3985,7 +4024,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, 10000000, 100000, 42, Arc::clone(&logger), &config, &None).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

@@ -196,6 +196,15 @@ impl MsgHandleErrInternal {
 						},
 					}),
 				},
+				ChannelError::CloseNoPublish(msg) => HandleError {
+					err: msg,
+					action: Some(msgs::ErrorAction::SendErrorMessage {
+						msg: msgs::ErrorMessage {
+							channel_id,
+							data: msg.to_string()
+						},
+					}),
+				},
 			},
 			shutdown_finish: None,
 		}
@@ -326,6 +335,7 @@ pub struct ChannelManager {
 	total_consistency_lock: RwLock<()>,
 
 	keys_manager: Arc<KeysInterface>,
+	channels_awaiting_claiming : Mutex<HashMap<[u8; 32], Vec<bitcoin::Transaction>>>,
 
 	logger: Arc<Logger>,
 }
@@ -386,7 +396,7 @@ macro_rules! handle_error {
 			Ok(msg) => Ok(msg),
 			Err(MsgHandleErrInternal { err, shutdown_finish }) => {
 				if let Some((shutdown_res, update_option)) = shutdown_finish {
-					$self.finish_force_close_channel(shutdown_res);
+					$self.finish_force_close_channel(shutdown_res,None);
 					if let Some(update) = update_option {
 						let mut channel_state = $self.channel_state.lock().unwrap();
 						channel_state.pending_msg_events.push(events::MessageSendEvent::BroadcastChannelUpdate {
@@ -415,6 +425,14 @@ macro_rules! break_chan_entry {
 				}
 				break Err(MsgHandleErrInternal::from_finish_shutdown(msg, channel_id, chan.force_shutdown(), $self.get_channel_update(&chan).ok()))
 			},
+			Err(ChannelError::CloseNoPublish(msg)) => {
+				log_trace!($self, "Closing channel {} due to Close-No_publish_required error: {}", log_bytes!($entry.key()[..]), msg);
+				let (channel_id, mut chan) = $entry.remove_entry();
+				if let Some(short_id) = chan.get_short_channel_id() {
+					$channel_state.short_to_id.remove(&short_id);
+				}
+				break Err(MsgHandleErrInternal::from_finish_shutdown(msg, channel_id, chan.force_shutdown(), $self.get_channel_update(&chan).ok()))
+			},
 		}
 	}
 }
@@ -434,6 +452,13 @@ macro_rules! try_chan_entry {
 				}
 				return Err(MsgHandleErrInternal::from_finish_shutdown(msg, channel_id, chan.force_shutdown(), $self.get_channel_update(&chan).ok()))
 			},
+			Err(ChannelError::CloseNoPublish(msg)) => {
+				let (channel_id, mut chan) = $entry.remove_entry();
+				if let Some(short_id) = chan.get_short_channel_id() {
+					$channel_state.short_to_id.remove(&short_id);
+				}
+				return Err(MsgHandleErrInternal::from_finish_shutdown(msg, channel_id, chan.force_shutdown(), $self.get_channel_update(&chan).ok()))
+			},
 		}
 	}
 }
@@ -529,7 +554,7 @@ impl ChannelManager {
 
 			pending_events: Mutex::new(Vec::new()),
 			total_consistency_lock: RwLock::new(()),
-
+			channels_awaiting_claiming : Mutex::new(HashMap::new()),
 			keys_manager,
 
 			logger,
@@ -551,12 +576,12 @@ 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> {
+	pub fn create_channel(&self, their_network_key: PublicKey, channel_value_satoshis: u64, push_msat: u64, user_id: u64, local_feature_flags : &Option<msgs::LocalFeatures>) -> 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_value_satoshis, push_msat, user_id, Arc::clone(&self.logger), &self.default_configuration, local_feature_flags)?;
 		let res = channel.get_open_channel(self.genesis_hash.clone(), &*self.fee_estimator);
 
 		let _ = self.total_consistency_lock.read().unwrap();
@@ -665,20 +690,25 @@ impl ChannelManager {
 	}
 
 	#[inline]
-	fn finish_force_close_channel(&self, shutdown_res: ShutdownResult) {
+	fn finish_force_close_channel(&self, shutdown_res: ShutdownResult,dont_claim_from_chain : Option<[u8; 32]>) {
 		let (local_txn, mut failed_htlcs) = shutdown_res;
 		log_trace!(self, "Finishing force-closure of channel with {} transactions to broadcast and {} HTLCs to fail", local_txn.len(), failed_htlcs.len());
 		for htlc_source in failed_htlcs.drain(..) {
 			self.fail_htlc_backwards_internal(self.channel_state.lock().unwrap(), htlc_source.0, &htlc_source.1, HTLCFailReason::Reason { failure_code: 0x4000 | 8, data: Vec::new() });
 		}
-		for tx in local_txn {
-			self.tx_broadcaster.broadcast_transaction(&tx);
+		if dont_claim_from_chain == None{
+			for tx in local_txn {
+				self.tx_broadcaster.broadcast_transaction(&tx);
+			}
+		} else {
+			let mut hashmap = self.channels_awaiting_claiming.lock().unwrap();
+			hashmap.insert(dont_claim_from_chain.unwrap(), local_txn);
 		}
 	}
 
 	/// Force closes a channel, immediately broadcasting the latest local commitment transaction to
 	/// the chain and rejecting new HTLCs on the given channel.
-	pub fn force_close_channel(&self, channel_id: &[u8; 32]) {
+	pub fn force_close_channel(&self, channel_id: &[u8; 32], store_closed : bool) {
 		let _ = self.total_consistency_lock.read().unwrap();
 
 		let mut chan = {
@@ -694,7 +724,12 @@ impl ChannelManager {
 			}
 		};
 		log_trace!(self, "Force-closing channel {}", log_bytes!(channel_id[..]));
-		self.finish_force_close_channel(chan.force_shutdown());
+		if store_closed{
+			self.finish_force_close_channel(chan.force_shutdown(),Some(chan.get_channel_id()));
+		} else
+		{
+			self.finish_force_close_channel(chan.force_shutdown(),None);
+		}
 		if let Ok(update) = self.get_channel_update(&chan) {
 			let mut channel_state = self.channel_state.lock().unwrap();
 			channel_state.pending_msg_events.push(events::MessageSendEvent::BroadcastChannelUpdate {
@@ -705,9 +740,9 @@ impl ChannelManager {
 
 	/// Force close all channels, immediately broadcasting the latest local commitment transaction
 	/// for each to the chain and rejecting new HTLCs on each.
-	pub fn force_close_all_channels(&self) {
+	pub fn force_close_all_channels(&mut self) {
 		for chan in self.list_channels() {
-			self.force_close_channel(&chan.channel_id);
+			self.force_close_channel(&chan.channel_id, false);
 		}
 	}
 
@@ -1605,16 +1640,16 @@ impl ChannelManager {
 		self.forward_htlcs(&mut htlc_forwards[..]);
 
 		for res in close_results.drain(..) {
-			self.finish_force_close_channel(res);
+			self.finish_force_close_channel(res, None);
 		}
 	}
 
-	fn internal_open_channel(&self, their_node_id: &PublicKey, msg: &msgs::OpenChannel) -> Result<(), MsgHandleErrInternal> {
+	fn internal_open_channel(&self, their_node_id: &PublicKey, msg: &msgs::OpenChannel, local_feature_flags : &Option<msgs::LocalFeatures>) -> Result<(), MsgHandleErrInternal> {
 		if msg.chain_hash != self.genesis_hash {
 			return Err(MsgHandleErrInternal::send_err_msg_no_close("Unknown genesis block hash", msg.temporary_channel_id.clone()));
 		}
 
-		let channel = Channel::new_from_req(&*self.fee_estimator, &self.keys_manager, their_node_id.clone(), msg, 0, Arc::clone(&self.logger), &self.default_configuration)
+		let channel = Channel::new_from_req(&*self.fee_estimator, &self.keys_manager, their_node_id.clone(), msg, 0, Arc::clone(&self.logger), &self.default_configuration, local_feature_flags)
 			.map_err(|e| MsgHandleErrInternal::from_chan_no_close(e, msg.temporary_channel_id))?;
 		let mut channel_state_lock = self.channel_state.lock().unwrap();
 		let channel_state = channel_state_lock.borrow_parts();
@@ -2385,7 +2420,7 @@ impl ChainListener for ChannelManager {
 			});
 		}
 		for failure in failed_channels.drain(..) {
-			self.finish_force_close_channel(failure);
+			self.finish_force_close_channel(failure, None);
 		}
 		self.latest_block_height.store(height as usize, Ordering::Release);
 		*self.last_block_hash.try_lock().expect("block_(dis)connected must not be called in parallel") = header_hash;
@@ -2418,7 +2453,7 @@ impl ChainListener for ChannelManager {
 			});
 		}
 		for failure in failed_channels.drain(..) {
-			self.finish_force_close_channel(failure);
+			self.finish_force_close_channel(failure, None);
 		}
 		self.latest_block_height.fetch_sub(1, Ordering::AcqRel);
 		*self.last_block_hash.try_lock().expect("block_(dis)connected must not be called in parallel") = header.bitcoin_hash();
@@ -2427,9 +2462,9 @@ impl ChainListener for ChannelManager {
 
 impl ChannelMessageHandler for ChannelManager {
 	//TODO: Handle errors and close channel (or so)
-	fn handle_open_channel(&self, their_node_id: &PublicKey, msg: &msgs::OpenChannel) -> Result<(), HandleError> {
+	fn handle_open_channel(&self, their_node_id: &PublicKey, msg: &msgs::OpenChannel, local_feature_flags: &Option<msgs::LocalFeatures>) -> Result<(), HandleError> {
 		let _ = self.total_consistency_lock.read().unwrap();
-		handle_error!(self, self.internal_open_channel(their_node_id, msg), their_node_id)
+		handle_error!(self, self.internal_open_channel(their_node_id, msg, local_feature_flags), their_node_id)
 	}
 
 	fn handle_accept_channel(&self, their_node_id: &PublicKey, msg: &msgs::AcceptChannel) -> Result<(), HandleError> {
@@ -2556,7 +2591,7 @@ impl ChannelMessageHandler for ChannelManager {
 			}
 		}
 		for failure in failed_channels.drain(..) {
-			self.finish_force_close_channel(failure);
+			self.finish_force_close_channel(failure, None);
 		}
 		for (chan_update, mut htlc_sources) in failed_payments {
 			for (htlc_source, payment_hash) in htlc_sources.drain(..) {
@@ -2598,11 +2633,11 @@ impl ChannelMessageHandler for ChannelManager {
 		if msg.channel_id == [0; 32] {
 			for chan in self.list_channels() {
 				if chan.remote_network_id == *their_node_id {
-					self.force_close_channel(&chan.channel_id);
+					self.force_close_channel(&chan.channel_id, false);
 				}
 			}
 		} else {
-			self.force_close_channel(&msg.channel_id);
+			self.force_close_channel(&msg.channel_id, false);
 		}
 	}
 }
@@ -2981,7 +3016,7 @@ impl<'a, R : ::std::io::Read> ReadableArgs<R, ChannelManagerReadArgs<'a>> for (S
 			claimable_htlcs.insert(payment_hash, previous_hops);
 		}
 
-		let channel_manager = ChannelManager {
+		let mut channel_manager = ChannelManager {
 			genesis_hash,
 			fee_estimator: args.fee_estimator,
 			monitor: args.monitor,
@@ -3006,11 +3041,12 @@ impl<'a, R : ::std::io::Read> ReadableArgs<R, ChannelManagerReadArgs<'a>> for (S
 			total_consistency_lock: RwLock::new(()),
 			keys_manager: args.keys_manager,
 			logger: args.logger,
+			channels_awaiting_claiming : Mutex::new(HashMap::new()),
 			default_configuration: args.default_config,
 		};
 
 		for close_res in closed_channels.drain(..) {
-			channel_manager.finish_force_close_channel(close_res);
+			channel_manager.finish_force_close_channel(close_res, None);
 			//TODO: Broadcast channel update for closed channels, but only after we've made a
 			//connection or two.
 		}