Make `Channel::monitor_updating_restored`'s return tuple a struct

This improves readability at the callsite and in the function.

diff --git a/lightning/src/ln/channel.rs b/lightning/src/ln/channel.rs
index 8a91b6e3d11a9e5a981d553edf7b4d5686df8870..4cd19c6ac06e5b5833dca292d7316ef06d053538 100644 (file)
--- a/lightning/src/ln/channel.rs
+++ b/lightning/src/ln/channel.rs
@@ -349,6 +349,17 @@ pub(super) struct RAAUpdates {
        pub holding_cell_failed_htlcs: Vec<(HTLCSource, PaymentHash)>,
 }
 
+/// The return value of `monitor_updating_restored`
+pub(super) struct MonitorRestoreUpdates {
+       pub raa: Option<msgs::RevokeAndACK>,
+       pub commitment_update: Option<msgs::CommitmentUpdate>,
+       pub order: RAACommitmentOrder,
+       pub accepted_htlcs: Vec<(PendingHTLCInfo, u64)>,
+       pub failed_htlcs: Vec<(HTLCSource, PaymentHash, HTLCFailReason)>,
+       pub funding_broadcastable: Option<Transaction>,
+       pub funding_locked: Option<msgs::FundingLocked>,
+}
+
 /// If the majority of the channels funds are to the fundee and the initiator holds only just
 /// enough funds to cover their reserve value, channels are at risk of getting "stuck". Because the
 /// initiator controls the feerate, if they then go to increase the channel fee, they may have no
@@ -3097,7 +3108,7 @@ impl<Signer: Sign> Channel<Signer> {
        /// Indicates that the latest ChannelMonitor update has been committed by the client
        /// successfully and we should restore normal operation. Returns messages which should be sent
        /// to the remote side.
-       pub fn monitor_updating_restored<L: Deref>(&mut self, logger: &L) -> (Option<msgs::RevokeAndACK>, Option<msgs::CommitmentUpdate>, RAACommitmentOrder, Vec<(PendingHTLCInfo, u64)>, Vec<(HTLCSource, PaymentHash, HTLCFailReason)>, Option<Transaction>, Option<msgs::FundingLocked>) where L::Target: Logger {
+       pub fn monitor_updating_restored<L: Deref>(&mut self, logger: &L) -> MonitorRestoreUpdates where L::Target: Logger {
                assert_eq!(self.channel_state & ChannelState::MonitorUpdateFailed as u32, ChannelState::MonitorUpdateFailed as u32);
                self.channel_state &= !(ChannelState::MonitorUpdateFailed as u32);
 
@@ -3120,15 +3131,18 @@ impl<Signer: Sign> Channel<Signer> {
                        })
                } else { None };
 
-               let mut forwards = Vec::new();
-               mem::swap(&mut forwards, &mut self.monitor_pending_forwards);
-               let mut failures = Vec::new();
-               mem::swap(&mut failures, &mut self.monitor_pending_failures);
+               let mut accepted_htlcs = Vec::new();
+               mem::swap(&mut accepted_htlcs, &mut self.monitor_pending_forwards);
+               let mut failed_htlcs = Vec::new();
+               mem::swap(&mut failed_htlcs, &mut self.monitor_pending_failures);
 
                if self.channel_state & (ChannelState::PeerDisconnected as u32) != 0 {
                        self.monitor_pending_revoke_and_ack = false;
                        self.monitor_pending_commitment_signed = false;
-                       return (None, None, RAACommitmentOrder::RevokeAndACKFirst, forwards, failures, funding_broadcastable, funding_locked);
+                       return MonitorRestoreUpdates {
+                               raa: None, commitment_update: None, order: RAACommitmentOrder::RevokeAndACKFirst,
+                               accepted_htlcs, failed_htlcs, funding_broadcastable, funding_locked
+                       };
                }
 
                let raa = if self.monitor_pending_revoke_and_ack {
@@ -3145,7 +3159,9 @@ impl<Signer: Sign> Channel<Signer> {
                        log_bytes!(self.channel_id()), if funding_broadcastable.is_some() { "a funding broadcastable, " } else { "" },
                        if commitment_update.is_some() { "a" } else { "no" }, if raa.is_some() { "an" } else { "no" },
                        match order { RAACommitmentOrder::CommitmentFirst => "commitment", RAACommitmentOrder::RevokeAndACKFirst => "RAA"});
-               (raa, commitment_update, order, forwards, failures, funding_broadcastable, funding_locked)
+               MonitorRestoreUpdates {
+                       raa, commitment_update, order, accepted_htlcs, failed_htlcs, funding_broadcastable, funding_locked
+               }
        }
 
        pub fn update_fee<F: Deref>(&mut self, fee_estimator: &F, msg: &msgs::UpdateFee) -> Result<(), ChannelError>

diff --git a/lightning/src/ln/channelmanager.rs b/lightning/src/ln/channelmanager.rs
index 56bedc3a491ade6ff7a79d7a13b476e6a91500e8..9cbbf32387caf73b1547b03d876bd394ee8ddb20 100644 (file)
--- a/lightning/src/ln/channelmanager.rs
+++ b/lightning/src/ln/channelmanager.rs
@@ -3419,8 +3419,8 @@ impl<Signer: Sign, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> ChannelMana
                                return;
                        }
 
-                       let (raa, commitment_update, order, pending_forwards, pending_failures, funding_broadcastable, funding_locked) = channel.get_mut().monitor_updating_restored(&self.logger);
-                       let channel_update = if funding_locked.is_some() && channel.get().is_usable() && !channel.get().should_announce() {
+                       let updates = channel.get_mut().monitor_updating_restored(&self.logger);
+                       let channel_update = if updates.funding_locked.is_some() && channel.get().is_usable() && !channel.get().should_announce() {
                                // We only send a channel_update in the case where we are just now sending a
                                // funding_locked and the channel is in a usable state. Further, we rely on the
                                // normal announcement_signatures process to send a channel_update for public
@@ -3430,11 +3430,11 @@ impl<Signer: Sign, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> ChannelMana
                                        msg: self.get_channel_update_for_unicast(channel.get()).unwrap(),
                                })
                        } else { None };
-                       chan_restoration_res = handle_chan_restoration_locked!(self, channel_lock, channel_state, channel, raa, commitment_update, order, None, pending_forwards, funding_broadcastable, funding_locked);
+                       chan_restoration_res = handle_chan_restoration_locked!(self, channel_lock, channel_state, channel, updates.raa, updates.commitment_update, updates.order, None, updates.accepted_htlcs, updates.funding_broadcastable, updates.funding_locked);
                        if let Some(upd) = channel_update {
                                channel_state.pending_msg_events.push(upd);
                        }
-                       pending_failures
+                       updates.failed_htlcs
                };
                post_handle_chan_restoration!(self, chan_restoration_res);
                for failure in pending_failures.drain(..) {