Remove funding outpoint from MonitorEvent enum

Author: atalw

lightning/src/chain/chainmonitor.rs

@@ -301,7 +301,7 @@ where C::Target: chain::Filter,
 							monitor_state.channel_perm_failed.store(true, Ordering::Release);
 							let mut pending_monitor_events = self.pending_monitor_events.lock().unwrap();
 							let events = pending_monitor_events.entry(*funding_outpoint).or_insert(Vec::new());
-							events.push(MonitorEvent::UpdateFailed(*funding_outpoint));
+							events.push(MonitorEvent::UpdateFailed);
 							drop(pending_monitor_events);
 						},
 						Err(ChannelMonitorUpdateErr::TemporaryFailure) => {
@@ -461,7 +461,6 @@ where C::Target: chain::Filter,
 				let mut pending_monitor_events = self.pending_monitor_events.lock().unwrap();
 				let events = pending_monitor_events.entry(funding_txo).or_insert(Vec::new());
 				events.push(MonitorEvent::UpdateCompleted {
-					funding_txo,
 					monitor_update_id: monitor_data.monitor.get_latest_update_id(),
 				});
 				drop(pending_monitor_events);
@@ -485,7 +484,6 @@ where C::Target: chain::Filter,
 		let mut pending_monitor_events = self.pending_monitor_events.lock().unwrap();
 		let events = pending_monitor_events.entry(funding_txo).or_insert(Vec::new());
 		events.push(MonitorEvent::UpdateCompleted {
-			funding_txo,
 			monitor_update_id,
 		});
 	}

lightning/src/chain/channelmonitor.rs

@@ -122,15 +122,13 @@ pub enum MonitorEvent {
 	HTLCEvent(HTLCUpdate),
 
 	/// A monitor event that the Channel's commitment transaction was confirmed.
-	CommitmentTxConfirmed(OutPoint),
+	CommitmentTxConfirmed,
 
 	/// Indicates a [`ChannelMonitor`] update has completed. See
 	/// [`ChannelMonitorUpdateErr::TemporaryFailure`] for more information on how this is used.
 	///
 	/// [`ChannelMonitorUpdateErr::TemporaryFailure`]: super::ChannelMonitorUpdateErr::TemporaryFailure
 	UpdateCompleted {
-		/// The funding outpoint of the [`ChannelMonitor`] that was updated
-		funding_txo: OutPoint,
 		/// The Update ID from [`ChannelMonitorUpdate::update_id`] which was applied or
 		/// [`ChannelMonitor::get_latest_update_id`].
 		///
@@ -143,19 +141,18 @@ pub enum MonitorEvent {
 	/// [`ChannelMonitorUpdateErr::PermanentFailure`] for more information on how this is used.
 	///
 	/// [`ChannelMonitorUpdateErr::PermanentFailure`]: super::ChannelMonitorUpdateErr::PermanentFailure
-	UpdateFailed(OutPoint),
+	UpdateFailed,
 }
 impl_writeable_tlv_based_enum_upgradable!(MonitorEvent,
 	// Note that UpdateCompleted and UpdateFailed are currently never serialized to disk as they are
 	// generated only in ChainMonitor
-	(0, UpdateCompleted) => {
-		(0, funding_txo, required),
-		(2, monitor_update_id, required),
+	(1, UpdateCompleted) => {
+		(0, monitor_update_id, required),
 	},
+	(3, CommitmentTxConfirmed) => {},
+	(5, UpdateFailed) => {},
 ;
 	(2, HTLCEvent),
-	(4, CommitmentTxConfirmed),
-	(6, UpdateFailed),
 );
 
 /// Simple structure sent back by `chain::Watch` when an HTLC from a forward channel is detected on
@@ -166,14 +163,12 @@ pub struct HTLCUpdate {
 	pub(crate) payment_hash: PaymentHash,
 	pub(crate) payment_preimage: Option<PaymentPreimage>,
 	pub(crate) source: HTLCSource,
-	pub(crate) sink_channel_id: Option<[u8; 32]>,
 	pub(crate) onchain_value_satoshis: Option<u64>,
 }
 impl_writeable_tlv_based!(HTLCUpdate, {
 	(0, payment_hash, required),
 	(1, onchain_value_satoshis, option),
 	(2, source, required),
-	(3, sink_channel_id, option),
 	(4, payment_preimage, option),
 });
 
@@ -903,7 +898,7 @@ impl<Signer: Sign> Writeable for ChannelMonitorImpl<Signer> {
 
 		writer.write_all(&(self.pending_monitor_events.iter().filter(|ev| match ev {
 			MonitorEvent::HTLCEvent(_) => true,
-			MonitorEvent::CommitmentTxConfirmed(_) => true,
+			MonitorEvent::CommitmentTxConfirmed => true,
 			_ => false,
 		}).count() as u64).to_be_bytes())?;
 		for event in self.pending_monitor_events.iter() {
@@ -912,7 +907,7 @@ impl<Signer: Sign> Writeable for ChannelMonitorImpl<Signer> {
 					0u8.write(writer)?;
 					upd.write(writer)?;
 				},
-				MonitorEvent::CommitmentTxConfirmed(_) => 1u8.write(writer)?,
+				MonitorEvent::CommitmentTxConfirmed => 1u8.write(writer)?,
 				_ => {}, // Covered in the TLV writes below
 			}
 		}
@@ -1893,7 +1888,7 @@ impl<Signer: Sign> ChannelMonitorImpl<Signer> {
 			log_info!(logger, "Broadcasting local {}", log_tx!(tx));
 			broadcaster.broadcast_transaction(tx);
 		}
-		self.pending_monitor_events.push(MonitorEvent::CommitmentTxConfirmed(self.funding_info.0));
+		self.pending_monitor_events.push(MonitorEvent::CommitmentTxConfirmed);
 	}
 
 	pub fn update_monitor<B: Deref, F: Deref, L: Deref>(&mut self, updates: &ChannelMonitorUpdate, broadcaster: &B, fee_estimator: &F, logger: &L) -> Result<(), ()>
@@ -2483,7 +2478,7 @@ impl<Signer: Sign> ChannelMonitorImpl<Signer> {
 			let funding_outp = HolderFundingOutput::build(self.funding_redeemscript.clone());
 			let commitment_package = PackageTemplate::build_package(self.funding_info.0.txid.clone(), self.funding_info.0.index as u32, PackageSolvingData::HolderFundingOutput(funding_outp), self.best_block.height(), false, self.best_block.height());
 			claimable_outpoints.push(commitment_package);
-			self.pending_monitor_events.push(MonitorEvent::CommitmentTxConfirmed(self.funding_info.0));
+			self.pending_monitor_events.push(MonitorEvent::CommitmentTxConfirmed);
 			let commitment_tx = self.onchain_tx_handler.get_fully_signed_holder_tx(&self.funding_redeemscript);
 			self.holder_tx_signed = true;
 			// Because we're broadcasting a commitment transaction, we should construct the package
@@ -2547,7 +2542,6 @@ impl<Signer: Sign> ChannelMonitorImpl<Signer> {
 						payment_preimage: None,
 						source: source.clone(),
 						onchain_value_satoshis,
-						sink_channel_id: Some(self.funding_info.0.to_channel_id()),
 					}));
 					if let Some(idx) = input_idx {
 						self.htlcs_resolved_on_chain.push(IrrevocablyResolvedHTLC { input_idx: idx, payment_preimage: None });
@@ -2887,7 +2881,6 @@ impl<Signer: Sign> ChannelMonitorImpl<Signer> {
 							payment_preimage: Some(payment_preimage),
 							payment_hash,
 							onchain_value_satoshis: Some(amount_msat / 1000),
-							sink_channel_id: Some(self.funding_info.0.to_channel_id()),
 						}));
 					}
 				} else if offered_preimage_claim {
@@ -2909,7 +2902,6 @@ impl<Signer: Sign> ChannelMonitorImpl<Signer> {
 							payment_preimage: Some(payment_preimage),
 							payment_hash,
 							onchain_value_satoshis: Some(amount_msat / 1000),
-							sink_channel_id: Some(self.funding_info.0.to_channel_id()),
 						}));
 					}
 				} else {
@@ -3195,7 +3187,7 @@ impl<'a, Signer: Sign, K: KeysInterface<Signer = Signer>> ReadableArgs<&'a K>
 		for _ in 0..pending_monitor_events_len {
 			let ev = match <u8 as Readable>::read(reader)? {
 				0 => MonitorEvent::HTLCEvent(Readable::read(reader)?),
-				1 => MonitorEvent::CommitmentTxConfirmed(funding_info.0),
+				1 => MonitorEvent::CommitmentTxConfirmed,
 				_ => return Err(DecodeError::InvalidValue)
 			};
 			pending_monitor_events.as_mut().unwrap().push(ev);

lightning/src/ln/channelmanager.rs

@@ -4044,7 +4044,6 @@ impl<Signer: Sign, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> ChannelMana
 
 						let mut pending_events = self.pending_events.lock().unwrap();
 						let source_channel_id = Some(prev_outpoint.to_channel_id());
-						// let sink_channel_id = Some(funding_txo.to_channel_id());
 						let sink_channel_id = Some(sink_channel_id);
 
 						pending_events.push(events::Event::PaymentForwarded {
@@ -4836,21 +4835,21 @@ impl<Signer: Sign, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> ChannelMana
 							self.fail_htlc_backwards_internal(self.channel_state.lock().unwrap(), htlc_update.source, &htlc_update.payment_hash, HTLCFailReason::Reason { failure_code: 0x4000 | 8, data: Vec::new() });
 						}
 					},
-					MonitorEvent::CommitmentTxConfirmed(funding_outpoint) |
-						MonitorEvent::UpdateFailed(funding_outpoint) => {
+					MonitorEvent::CommitmentTxConfirmed |
+						MonitorEvent::UpdateFailed => {
 							let mut channel_lock = self.channel_state.lock().unwrap();
 							let channel_state = &mut *channel_lock;
 							let by_id = &mut channel_state.by_id;
 							let pending_msg_events = &mut channel_state.pending_msg_events;
-							if let hash_map::Entry::Occupied(chan_entry) = by_id.entry(funding_outpoint.to_channel_id()) {
+							if let hash_map::Entry::Occupied(chan_entry) = by_id.entry(funding_txo.to_channel_id()) {
 								let mut chan = remove_channel!(self, channel_state, chan_entry);
 								failed_channels.push(chan.force_shutdown(false));
 								if let Ok(update) = self.get_channel_update_for_broadcast(&chan) {
 									pending_msg_events.push(events::MessageSendEvent::BroadcastChannelUpdate {
 										msg: update
 									});
 								}
-								let reason = if let MonitorEvent::UpdateFailed(_) = monitor_event {
+								let reason = if let MonitorEvent::UpdateFailed = monitor_event {
 									ClosureReason::ProcessingError { err: "Failed to persist ChannelMonitor update during chain sync".to_string() }
 								} else {
 									ClosureReason::CommitmentTxConfirmed
@@ -4864,7 +4863,7 @@ impl<Signer: Sign, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> ChannelMana
 								});
 							}
 					},
-					MonitorEvent::UpdateCompleted { funding_txo, monitor_update_id } => {
+					MonitorEvent::UpdateCompleted { monitor_update_id } => {
 						self.channel_monitor_updated(&funding_txo, monitor_update_id);
 					},
 				}

lightning/src/util/events.rs

@@ -346,6 +346,8 @@ pub enum Event {
 		/// The channel between the source node and us. Optional because versions prior to 0.0.107
 		/// do not serialize this field.
 		source_channel_id: Option<[u8; 32]>,
+		/// The channel between the destination node and us. Optional because versions prior to 0.0.107
+		/// do not serialize this field.
 		sink_channel_id: Option<[u8; 32]>,
 		/// The fee, in milli-satoshis, which was earned as a result of the payment.
 		///