f - fix lock order bug

Author: jkczyz

lightning/src/ln/channelmanager.rs

@@ -13576,7 +13576,7 @@ where
 	#[rustfmt::skip]
 	fn peer_disconnected(&self, counterparty_node_id: PublicKey) {
 		let _persistence_guard = PersistenceNotifierGuard::optionally_notify(self, || {
-			let mut persist = NotifyOption::SkipPersistHandleEvents;
+			let mut splice_failed_events = Vec::new();
 			let mut failed_channels: Vec<(Result<Infallible, _>, _)> = Vec::new();
 			let mut per_peer_state = self.per_peer_state.write().unwrap();
 			let remove_peer = {
@@ -13589,23 +13589,21 @@ where
 					let mut peer_state_lock = peer_state_mutex.lock().unwrap();
 					let peer_state = &mut *peer_state_lock;
 					let pending_msg_events = &mut peer_state.pending_msg_events;
-					let pending_events = &mut self.pending_events.lock().unwrap();
 					peer_state.channel_by_id.retain(|_, chan| {
 						let logger = WithChannelContext::from(&self.logger, &chan.context(), None);
 						let DisconnectResult { is_resumable, splice_funding_failed } =
 							chan.peer_disconnected_is_resumable(&&logger);
 
 						if let Some(splice_funding_failed) = splice_funding_failed {
-							pending_events.push_back((events::Event::SpliceFailed {
+							splice_failed_events.push(events::Event::SpliceFailed {
 								channel_id: chan.context().channel_id(),
 								counterparty_node_id,
 								user_channel_id: chan.context().get_user_id(),
 								abandoned_funding_txo: splice_funding_failed.funding_txo,
 								channel_type: splice_funding_failed.channel_type,
 								contributed_inputs: splice_funding_failed.contributed_inputs,
 								contributed_outputs: splice_funding_failed.contributed_outputs,
-							}, None));
-							persist = NotifyOption::DoPersist;
+							});
 						}
 
 						if is_resumable {
@@ -13691,6 +13689,18 @@ where
 			}
 			mem::drop(per_peer_state);
 
+			let persist = if splice_failed_events.is_empty() {
+				NotifyOption::SkipPersistHandleEvents
+			} else {
+				NotifyOption::DoPersist
+			};
+
+			let mut pending_events = self.pending_events.lock().unwrap();
+			for event in splice_failed_events {
+				pending_events.push_back((event, None));
+			}
+			mem::drop(pending_events);
+
 			for (err, counterparty_node_id) in failed_channels.drain(..) {
 				let _ = handle_error!(self, err, counterparty_node_id);
 			}