Handle error if unable to update monitor on preimage receipt after channel close

If we receive a preimage right as the channel hits the chain, we need to
update the corresponding ChannelMonitor with this preimage. However, if
updating the ChannelMonitor then fails with a PermanentError, we should
send an error to the preimage-sending node.

Author: valentinewallace

lightning/src/chain/channelmonitor.rs

@@ -695,6 +695,8 @@ pub struct ChannelMonitor<ChanSigner: ChannelKeys> {
 	// the full block_connected).
 	last_block_hash: BlockHash,
 	secp_ctx: Secp256k1<secp256k1::All>, //TODO: dedup this a bit...
+
+	counterparty_node_id: PublicKey
 }
 
 #[cfg(any(test, feature = "fuzztarget"))]
@@ -927,6 +929,7 @@ impl<ChanSigner: ChannelKeys + Writeable> ChannelMonitor<ChanSigner> {
 
 		self.lockdown_from_offchain.write(writer)?;
 		self.holder_tx_signed.write(writer)?;
+		self.counterparty_node_id.write(writer)?;
 
 		Ok(())
 	}
@@ -938,7 +941,8 @@ impl<ChanSigner: ChannelKeys> ChannelMonitor<ChanSigner> {
 			counterparty_htlc_base_key: &PublicKey, counterparty_delayed_payment_base_key: &PublicKey,
 			on_holder_tx_csv: u16, funding_redeemscript: Script, channel_value_satoshis: u64,
 			commitment_transaction_number_obscure_factor: u64,
-			initial_holder_commitment_tx: HolderCommitmentTransaction) -> ChannelMonitor<ChanSigner> {
+			initial_holder_commitment_tx: HolderCommitmentTransaction,
+			counterparty_node_id: PublicKey) -> ChannelMonitor<ChanSigner> {
 
 		assert!(commitment_transaction_number_obscure_factor <= (1 << 48));
 		let our_channel_close_key_hash = WPubkeyHash::hash(&shutdown_pubkey.serialize());
@@ -1010,6 +1014,8 @@ impl<ChanSigner: ChannelKeys> ChannelMonitor<ChanSigner> {
 			lockdown_from_offchain: false,
 			holder_tx_signed: false,
 
+			counterparty_node_id,
+
 			last_block_hash: Default::default(),
 			secp_ctx: Secp256k1::new(),
 		}
@@ -1755,7 +1761,8 @@ impl<ChanSigner: ChannelKeys> ChannelMonitor<ChanSigner> {
 							source: htlc_update.0,
 							monitor_info: MonitorUpdateInfo {
 								funding_outpoint: self.funding_info.0,
-								latest_monitor_update_id
+								latest_monitor_update_id,
+								counterparty_node_id: self.counterparty_node_id
 							}
 						}));
 					},
@@ -2029,7 +2036,8 @@ impl<ChanSigner: ChannelKeys> ChannelMonitor<ChanSigner> {
 							payment_hash,
 							monitor_info: MonitorUpdateInfo {
 								funding_outpoint: self.funding_info.0,
-								latest_monitor_update_id
+								latest_monitor_update_id,
+								counterparty_node_id: self.counterparty_node_id
 							}
 						}));
 					}
@@ -2046,7 +2054,8 @@ impl<ChanSigner: ChannelKeys> ChannelMonitor<ChanSigner> {
 							payment_hash,
 							monitor_info: MonitorUpdateInfo {
 								funding_outpoint: self.funding_info.0,
-								latest_monitor_update_id
+								latest_monitor_update_id,
+								counterparty_node_id: self.counterparty_node_id
 							}
 						}));
 					}
@@ -2379,6 +2388,7 @@ impl<ChanSigner: ChannelKeys + Readable> Readable for (BlockHash, ChannelMonitor
 
 		let lockdown_from_offchain = Readable::read(reader)?;
 		let holder_tx_signed = Readable::read(reader)?;
+		let counterparty_node_id = Readable::read(reader)?;
 
 		Ok((last_block_hash.clone(), ChannelMonitor {
 			latest_update_id,
@@ -2423,6 +2433,8 @@ impl<ChanSigner: ChannelKeys + Readable> Readable for (BlockHash, ChannelMonitor
 			lockdown_from_offchain,
 			holder_tx_signed,
 
+			counterparty_node_id,
+
 			last_block_hash,
 			secp_ctx: Secp256k1::new(),
 		}))
@@ -2459,6 +2471,7 @@ mod tests {
 		let logger = Arc::new(TestLogger::new());
 
 		let dummy_key = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
+		let dummy_counterparty_nodeid = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[43; 32]).unwrap());
 		let dummy_tx = Transaction { version: 0, lock_time: 0, input: Vec::new(), output: Vec::new() };
 
 		let mut preimages = Vec::new();
@@ -2524,7 +2537,7 @@ mod tests {
 			(OutPoint { txid: Txid::from_slice(&[43; 32]).unwrap(), index: 0 }, Script::new()),
 			&PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[44; 32]).unwrap()),
 			&PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[45; 32]).unwrap()),
-			10, Script::new(), 46, 0, HolderCommitmentTransaction::dummy());
+			10, Script::new(), 46, 0, HolderCommitmentTransaction::dummy(), dummy_counterparty_nodeid);
 
 		monitor.provide_latest_holder_commitment_tx_info(HolderCommitmentTransaction::dummy(), preimages_to_holder_htlcs!(preimages[0..10])).unwrap();
 		monitor.provide_latest_counterparty_commitment_tx_info(&dummy_tx, preimages_slice_to_htlc_outputs!(preimages[5..15]), 281474976710655, dummy_key, &logger);

lightning/src/ln/channel.rs

@@ -1563,7 +1563,7 @@ impl<ChanSigner: ChannelKeys> Channel<ChanSigner> {
 				                                              &counterparty_pubkeys.htlc_basepoint, &counterparty_pubkeys.delayed_payment_basepoint,
 				                                              self.counterparty_selected_contest_delay, funding_redeemscript.clone(), self.channel_value_satoshis,
 				                                              self.get_commitment_transaction_number_obscure_factor(),
-				                                              initial_commitment_tx.clone());
+				                                              initial_commitment_tx.clone(), self.counterparty_node_id);
 
 				channel_monitor.provide_latest_counterparty_commitment_tx_info(&counterparty_initial_commitment_tx, Vec::new(), self.cur_counterparty_commitment_transaction_number, self.counterparty_cur_commitment_point.unwrap(), logger);
 				channel_monitor
@@ -1627,7 +1627,7 @@ impl<ChanSigner: ChannelKeys> Channel<ChanSigner> {
 				                                              &counterparty_pubkeys.htlc_basepoint, &counterparty_pubkeys.delayed_payment_basepoint,
 				                                              self.counterparty_selected_contest_delay, funding_redeemscript.clone(), self.channel_value_satoshis,
 				                                              self.get_commitment_transaction_number_obscure_factor(),
-				                                              commitment_tx);
+				                                              commitment_tx, self.counterparty_node_id);
 
 				channel_monitor.provide_latest_counterparty_commitment_tx_info(&counterparty_initial_commitment_tx, Vec::new(), self.cur_counterparty_commitment_transaction_number, self.counterparty_cur_commitment_point.unwrap(), logger);
 
@@ -1950,7 +1950,8 @@ impl<ChanSigner: ChannelKeys> Channel<ChanSigner> {
 			Ok(res) => {
 				let mon_info = MonitorUpdateInfo {
 					funding_outpoint: self.funding_txo.unwrap(),
-					latest_monitor_update_id: self.latest_monitor_update_id
+					latest_monitor_update_id: self.latest_monitor_update_id,
+					counterparty_node_id: self.counterparty_node_id
 				};
 				Ok((res, mon_info))
 			},

lightning/src/ln/channelmanager.rs

@@ -707,9 +707,10 @@ macro_rules! maybe_break_monitor_err {
 #[derive(Clone, PartialEq)]
 pub(crate) struct MonitorUpdateInfo {
 	pub(crate) funding_outpoint: OutPoint,
-	pub(crate) latest_monitor_update_id: u64
+	pub(crate) latest_monitor_update_id: u64,
+	pub(crate) counterparty_node_id: PublicKey
 }
-impl_writeable!(MonitorUpdateInfo, 0, { funding_outpoint, latest_monitor_update_id });
+impl_writeable!(MonitorUpdateInfo, 0, { funding_outpoint, latest_monitor_update_id, counterparty_node_id });
 
 impl<ChanSigner: ChannelKeys, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> ChannelManager<ChanSigner, M, T, K, F, L>
 	where M::Target: chain::Watch<Keys=ChanSigner>,
@@ -2157,10 +2158,17 @@ impl<ChanSigner: ChannelKeys, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref>
 								payment_preimage: payment_preimage.clone(),
 							}],
 						};
-						if let Err(_) = self.chain_monitor.update_channel(monitor_update_info.funding_outpoint, preimage_update) {
-							// TODO(val): figure out what to do here
+						match self.chain_monitor.update_channel(monitor_update_info.funding_outpoint, preimage_update) {
+							Err(ChannelMonitorUpdateErr::PermanentFailure) => {
+								let err_msg = MsgHandleErrInternal::send_err_msg_no_close("Failed to update channel with preimage".to_owned(), monitor_update_info.funding_outpoint.to_channel_id());
+								Err((monitor_update_info.counterparty_node_id, err_msg))
+							}
+							Err(ChannelMonitorUpdateErr::TemporaryFailure) => {
+								let err_msg = MsgHandleErrInternal::from_chan_no_close(ChannelError::Ignore("Failed to update channel with preimage".to_owned()), monitor_update_info.funding_outpoint.to_channel_id());
+								Err((monitor_update_info.counterparty_node_id, err_msg))
+							}
+							Ok(()) => Ok(())
 						}
-						Ok(())
 					},
 					Err(Some(res)) => Err(res),
 				} {