Add data_loss_protect support

Author: SWvheerden

src/ln/channel.rs

@@ -371,6 +371,7 @@ pub const MAX_FUNDING_SATOSHIS: u64 = (1 << 24);
 pub(super) enum ChannelError {
 	Ignore(&'static str),
 	Close(&'static str),
+	CloseNoPublish(&'static str),
 }
 
 macro_rules! secp_check {
@@ -383,6 +384,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
@@ -2293,6 +2299,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);
@@ -2374,6 +2395,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)),

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,
 		}
@@ -323,6 +332,7 @@ pub struct ChannelManager {
 	total_consistency_lock: RwLock<()>,
 
 	keys_manager: Arc<KeysInterface>,
+	channels_awaiting_claiming : HashMap<[u8; 32], Vec<bitcoin::Transaction>>,
 
 	logger: Arc<Logger>,
 }
@@ -392,7 +402,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 {
@@ -420,6 +430,13 @@ 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)) => {
+				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()))
+			},
 		}
 	}
 }
@@ -438,6 +455,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()))
+			},
 		}
 	}
 }
@@ -478,7 +502,7 @@ impl ChannelManager {
 
 			pending_events: Mutex::new(Vec::new()),
 			total_consistency_lock: RwLock::new(()),
-
+			channels_awaiting_claiming : HashMap::new(),
 			keys_manager,
 
 			logger,
@@ -615,14 +639,18 @@ impl ChannelManager {
 	}
 
 	#[inline]
-	fn finish_force_close_channel(&self, shutdown_res: ShutdownResult) {
+	fn finish_force_close_channel(&mut self, shutdown_res: ShutdownResult,dont_claim_from_chain : Option<[u8; 32]>) {
 		let (local_txn, mut failed_htlcs) = shutdown_res;
 		for htlc_source in failed_htlcs.drain(..) {
 			// unknown_next_peer...I dunno who that is anymore....
 			self.fail_htlc_backwards_internal(self.channel_state.lock().unwrap(), htlc_source.0, &htlc_source.1, HTLCFailReason::Reason { failure_code: 0x4000 | 10, 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 {
+			self.channels_awaiting_claiming.insert(dont_claim_from_chain.unwrap(), local_txn);
 		}
 		//TODO: We need to have a way where outbound HTLC claims can result in us claiming the
 		//now-on-chain HTLC output for ourselves (and, thereafter, passing the HTLC backwards).
@@ -635,7 +663,7 @@ impl ChannelManager {
 
 	/// 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(&mut self, channel_id: &[u8; 32], store_closed : bool) {
 		let _ = self.total_consistency_lock.read().unwrap();
 
 		let mut chan = {
@@ -650,7 +678,12 @@ impl ChannelManager {
 				return;
 			}
 		};
-		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 {
@@ -661,13 +694,13 @@ 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);
 		}
 	}
 
-	fn handle_monitor_update_fail(&self, mut channel_state_lock: MutexGuard<ChannelHolder>, channel_id: &[u8; 32], err: ChannelMonitorUpdateErr, reason: RAACommitmentOrder) {
+	fn handle_monitor_update_fail(&mut self, mut channel_state_lock: MutexGuard<ChannelHolder>, channel_id: &[u8; 32], err: ChannelMonitorUpdateErr, reason: RAACommitmentOrder) {
 		match err {
 			ChannelMonitorUpdateErr::PermanentFailure => {
 				let mut chan = {
@@ -679,7 +712,7 @@ impl ChannelManager {
 					chan
 				};
 				mem::drop(channel_state_lock);
-				self.finish_force_close_channel(chan.force_shutdown());
+				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 {
@@ -1194,7 +1227,7 @@ impl ChannelManager {
 	///
 	/// Raises APIError::RoutError when invalid route or forward parameter
 	/// (cltv_delta, fee, node public key) is specified
-	pub fn send_payment(&self, route: Route, payment_hash: [u8; 32]) -> Result<(), APIError> {
+	pub fn send_payment(&mut self, route: Route, payment_hash: [u8; 32]) -> Result<(), APIError> {
 		if route.hops.len() < 1 || route.hops.len() > 20 {
 			return Err(APIError::RouteError{err: "Route didn't go anywhere/had bogus size"});
 		}
@@ -1737,7 +1770,7 @@ 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);
 		}
 	}
 
@@ -2659,7 +2692,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.bitcoin_hash();
@@ -2692,7 +2725,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();
@@ -2781,7 +2814,7 @@ impl ChannelMessageHandler for ChannelManager {
 		handle_error!(self, self.internal_channel_reestablish(their_node_id, msg), their_node_id)
 	}
 
-	fn peer_disconnected(&self, their_node_id: &PublicKey, no_connection_possible: bool) {
+	fn peer_disconnected(&mut self, their_node_id: &PublicKey, no_connection_possible: bool) {
 		let _ = self.total_consistency_lock.read().unwrap();
 		let mut failed_channels = Vec::new();
 		let mut failed_payments = Vec::new();
@@ -2830,7 +2863,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(..) {
@@ -2866,17 +2899,17 @@ impl ChannelMessageHandler for ChannelManager {
 		//TODO: Also re-broadcast announcement_signatures
 	}
 
-	fn handle_error(&self, their_node_id: &PublicKey, msg: &msgs::ErrorMessage) {
+	fn handle_error(&mut self, their_node_id: &PublicKey, msg: &msgs::ErrorMessage) {
 		let _ = self.total_consistency_lock.read().unwrap();
 
 		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);
 		}
 	}
 }
@@ -3225,7 +3258,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,
@@ -3250,11 +3283,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 : 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.
 		}

src/ln/msgs.rs

@@ -70,6 +70,13 @@ impl LocalFeatures {
 	pub(crate) fn requires_data_loss_protect(&self) -> bool {
 		self.flags.len() > 0 && (self.flags[0] & 1) != 0
 	}
+	pub(crate) fn set_supports_data_loss_protect(&mut self) {
+		if self.flags.len() == 0 {
+			self.flags.resize(1, 3);
+		} else {
+			self.flags[0] |= 3;
+		}
+	}
 
 	pub(crate) fn initial_routing_sync(&self) -> bool {
 		self.flags.len() > 0 && (self.flags[0] & (1 << 3)) != 0
@@ -465,6 +472,11 @@ pub enum ErrorAction {
 		/// The message to send.
 		msg: ErrorMessage
 	},
+	///We encountered a state where we cannot recover from we should drop the channel without redeeming as we might loose all channel funds.
+	DropChannel {
+		/// The message to log.
+		msg: ErrorMessage
+	},
 }
 
 /// An Err type for failure to process messages.
@@ -565,7 +577,7 @@ pub trait ChannelMessageHandler : events::MessageSendEventsProvider + Send + Syn
 	/// is believed to be possible in the future (eg they're sending us messages we don't
 	/// understand or indicate they require unknown feature bits), no_connection_possible is set
 	/// and any outstanding channels should be failed.
-	fn peer_disconnected(&self, their_node_id: &PublicKey, no_connection_possible: bool);
+	fn peer_disconnected(&mut self, their_node_id: &PublicKey, no_connection_possible: bool);
 
 	/// Handle a peer reconnecting, possibly generating channel_reestablish message(s).
 	fn peer_connected(&self, their_node_id: &PublicKey);
@@ -574,7 +586,7 @@ pub trait ChannelMessageHandler : events::MessageSendEventsProvider + Send + Syn
 
 	// Error:
 	/// Handle an incoming error message from the given peer.
-	fn handle_error(&self, their_node_id: &PublicKey, msg: &ErrorMessage);
+	fn handle_error(&mut self, their_node_id: &PublicKey, msg: &ErrorMessage);
 }
 
 /// A trait to describe an object which can receive routing messages.