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

@@ -1456,6 +1456,15 @@ where
 	Funded(FundedChannel<SP>),
 }
 
+pub(super) enum CommitmentSignedResult<SP: Deref>
+where
+	SP::Target: SignerProvider,
+{
+	ChannelMonitor(ChannelMonitor<<SP::Target as SignerProvider>::EcdsaSigner>),
+	ChannelMonitorUpdate(ChannelMonitorUpdate),
+	None,
+}
+
 impl<SP: Deref> Channel<SP>
 where
 	SP::Target: SignerProvider,
@@ -1781,7 +1790,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
 	{
@@ -1808,7 +1817,9 @@ 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, _)| {
+						CommitmentSignedResult::ChannelMonitor(monitor)
+					})
 					// TODO: Change to `inspect_err` when MSRV is high enough.
 					.map_err(|err| {
 						// We always expect a `ChannelError` close.
@@ -1835,15 +1846,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

@@ -60,9 +60,9 @@ use crate::ln::chan_utils::selected_commitment_sat_per_1000_weight;
 // Since this struct is returned in `list_channels` methods, expose it here in case users want to
 // construct one themselves.
 use crate::ln::channel::{
-	self, hold_time_since, Channel, ChannelError, ChannelUpdateStatus, FundedChannel,
-	InboundV1Channel, OutboundV1Channel, PendingV2Channel, ReconnectionMsg, ShutdownResult,
-	UpdateFulfillCommitFetch, WithChannelContext,
+	self, hold_time_since, Channel, ChannelError, ChannelUpdateStatus, CommitmentSignedResult,
+	FundedChannel, InboundV1Channel, OutboundV1Channel, PendingV2Channel, ReconnectionMsg,
+	ShutdownResult, UpdateFulfillCommitFetch, WithChannelContext,
 };
 use crate::ln::channel_state::ChannelDetails;
 use crate::ln::inbound_payment;
@@ -135,6 +135,7 @@ use crate::util::wakers::{Future, Notifier};
 
 #[cfg(all(test, async_payments))]
 use crate::blinded_path::payment::BlindedPaymentPath;
+
 #[cfg(async_payments)]
 use {
 	crate::blinded_path::message::BlindedMessagePath,
@@ -10346,27 +10347,32 @@ 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, _) = 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(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::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(())