Create CommitmentSignedResult enum for Channel::commitment_signed();

The return type of commitment_signed() started groing into a really
long and unwieldy tuple. We introduce a dedicated enum return type for
it here.

Author: dunxen

lightning/src/ln/channel.rs

@@ -1461,6 +1461,19 @@ where
 	Funded(FundedChannel<SP>),
 }
 
+pub(super) enum CommitmentSignedResult<SP: Deref>
+where
+	SP::Target: SignerProvider,
+{
+	ChannelMonitor(ChannelMonitor<<SP::Target as SignerProvider>::EcdsaSigner>),
+	ChannelMonitorWithUnsignedFundingTransaction(
+		ChannelMonitor<<SP::Target as SignerProvider>::EcdsaSigner>,
+		Transaction,
+	),
+	ChannelMonitorUpdate(ChannelMonitorUpdate),
+	None,
+}
+
 impl<SP: Deref> Channel<SP>
 where
 	SP::Target: SignerProvider,
@@ -1786,7 +1799,7 @@ where
 	#[rustfmt::skip]
 	pub fn commitment_signed<L: Deref>(
 		&mut self, msg: &msgs::CommitmentSigned, best_block: BestBlock, signer_provider: &SP, logger: &L
-	) -> Result<(Option<ChannelMonitor<<SP::Target as SignerProvider>::EcdsaSigner>>, Option<ChannelMonitorUpdate>, Option<Transaction>), ChannelError>
+	) -> Result<CommitmentSignedResult<SP>, ChannelError>
 	where
 		L::Target: Logger
 	{
@@ -1813,7 +1826,15 @@ where
 					pending_splice: None,
 				};
 				let res = funded_channel.commitment_signed_initial_v2(msg, best_block, signer_provider, logger)
-					.map(|(monitor, funding_tx_opt)| (Some(monitor), None, funding_tx_opt))
+					.map(|(monitor, funding_tx_opt)| {
+						if let Some(funding_tx) = funding_tx_opt {
+							CommitmentSignedResult::ChannelMonitorWithUnsignedFundingTransaction(
+								monitor, funding_tx,
+							)
+						} else {
+							CommitmentSignedResult::ChannelMonitor(monitor)
+						}
+					})
 					// TODO: Change to `inspect_err` when MSRV is high enough.
 					.map_err(|err| {
 						// We always expect a `ChannelError` close.
@@ -1840,15 +1861,33 @@ where
 				let res = if has_negotiated_pending_splice && !session_received_commitment_signed {
 					funded_channel
 						.splice_initial_commitment_signed(msg, logger)
-						.map(|monitor_update_opt| (None, monitor_update_opt, None))
+						.map(|monitor_update_opt|
+							if let Some(monitor_update) = monitor_update_opt {
+								CommitmentSignedResult::ChannelMonitorUpdate(monitor_update)
+							} else {
+								CommitmentSignedResult::None
+							}
+						)
 				} else {
 					funded_channel.commitment_signed(msg, logger)
-						.map(|monitor_update_opt| (None, monitor_update_opt, None))
+						.map(|monitor_update_opt|
+							if let Some(monitor_update) = monitor_update_opt {
+								CommitmentSignedResult::ChannelMonitorUpdate(monitor_update)
+							} else {
+								CommitmentSignedResult::None
+							}
+						)
 				};
 
 				#[cfg(not(splicing))]
 				let res = funded_channel.commitment_signed(msg, logger)
-					.map(|monitor_update_opt| (None, monitor_update_opt, None));
+					.map(|monitor_update_opt|
+						if let Some(monitor_update) = monitor_update_opt {
+							CommitmentSignedResult::ChannelMonitorUpdate(monitor_update)
+						} else {
+							CommitmentSignedResult::None
+						}
+					);
 
 				self.phase = ChannelPhase::Funded(funded_channel);
 				res

lightning/src/ln/channelmanager.rs

@@ -130,8 +130,10 @@ use crate::util::ser::{
 };
 use crate::util::wakers::{Future, Notifier};
 
+use super::channel::CommitmentSignedResult;
 #[cfg(all(test, async_payments))]
 use crate::blinded_path::payment::BlindedPaymentPath;
+
 #[cfg(async_payments)]
 use {
 	crate::blinded_path::message::BlindedMessagePath,
@@ -9621,37 +9623,44 @@ This indicates a bug inside LDK. Please report this error at https://github.com/
 				let chan = chan_entry.get_mut();
 				let logger = WithChannelContext::from(&self.logger, &chan.context(), None);
 				let funding_txo = chan.funding().get_funding_txo();
-				let (monitor_opt, monitor_update_opt, funding_tx_opt) = try_channel_entry!(
+				let res = try_channel_entry!(
 					self, peer_state, chan.commitment_signed(msg, best_block, &self.signer_provider, &&logger),
 					chan_entry);
 
 				if let Some(chan) = chan.as_funded_mut() {
-					if let Some(unsigned_transaction) = funding_tx_opt {
-						let mut pending_events = self.pending_events.lock().unwrap();
-						pending_events.push_back((
-							Event::FundingTransactionReadyForSigning {
-								unsigned_transaction,
-								counterparty_node_id: *counterparty_node_id,
-								channel_id: msg.channel_id,
-								user_channel_id: chan.context.get_user_id(),
-							}, None));
-					}
-					if let Some(monitor) = monitor_opt {
-						let monitor_res = self.chain_monitor.watch_channel(monitor.channel_id(), monitor);
-						if let Ok(persist_state) = monitor_res {
-							handle_new_monitor_update!(self, persist_state, peer_state_lock, peer_state,
-								per_peer_state, chan, INITIAL_MONITOR);
-						} else {
-							let logger = WithChannelContext::from(&self.logger, &chan.context, None);
-							log_error!(logger, "Persisting initial ChannelMonitor failed, implying the channel ID was duplicated");
-							let msg = "Channel ID was a duplicate";
-							let reason = ClosureReason::ProcessingError { err: msg.to_owned() };
-							let err = ChannelError::Close((msg.to_owned(), reason));
-							try_channel_entry!(self, peer_state, Err(err), chan_entry)
-						}
-					} else if let Some(monitor_update) = monitor_update_opt {
-						handle_new_monitor_update!(self, funding_txo.unwrap(), monitor_update, peer_state_lock,
-							peer_state, per_peer_state, chan);
+					let monitor = match res {
+						CommitmentSignedResult::ChannelMonitor(monitor) => monitor,
+						CommitmentSignedResult::ChannelMonitorWithUnsignedFundingTransaction(monitor, unsigned_transaction) => {
+							let mut pending_events = self.pending_events.lock().unwrap();
+							pending_events.push_back((
+								Event::FundingTransactionReadyForSigning {
+									unsigned_transaction,
+									counterparty_node_id: *counterparty_node_id,
+									channel_id: msg.channel_id,
+									user_channel_id: chan.context.get_user_id(),
+								}, None));
+
+							monitor
+						},
+						CommitmentSignedResult::ChannelMonitorUpdate(monitor_update) => {
+							handle_new_monitor_update!(self, funding_txo.unwrap(), monitor_update, peer_state_lock,
+								peer_state, per_peer_state, chan);
+							return Ok(());
+						},
+						CommitmentSignedResult::None => return Ok(()),
+					};
+
+					let monitor_res = self.chain_monitor.watch_channel(monitor.channel_id(), monitor);
+					if let Ok(persist_state) = monitor_res {
+						handle_new_monitor_update!(self, persist_state, peer_state_lock, peer_state,
+							per_peer_state, chan, INITIAL_MONITOR);
+					} else {
+						let logger = WithChannelContext::from(&self.logger, &chan.context, None);
+						log_error!(logger, "Persisting initial ChannelMonitor failed, implying the channel ID was duplicated");
+						let msg = "Channel ID was a duplicate";
+						let reason = ClosureReason::ProcessingError { err: msg.to_owned() };
+						let err = ChannelError::Close((msg.to_owned(), reason));
+						try_channel_entry!(self, peer_state, Err(err), chan_entry)
 					}
 				}
 				Ok(())