fixup: Prevent abandoning JIT channel after channel creation or payment forwarding

- Added a state check in channel_open_abandoned to ensure a channel cannot be abandoned after creation or payment forwarding, returning an error if attempted.
- Refactored state handling to use matches! macro for clarity.
- Addressed minor nits: fixed indentation and import ordering.

Author: martinsaposnic

lightning-liquidity/src/lsps2/service.rs

@@ -38,7 +38,6 @@ use lightning::ln::msgs::{ErrorAction, LightningError};
 use lightning::ln::types::ChannelId;
 use lightning::util::errors::APIError;
 use lightning::util::logger::Level;
-
 use lightning_types::payment::PaymentHash;
 
 use bitcoin::secp256k1::PublicKey;
@@ -1029,6 +1028,21 @@ where
 				err: format!("Could not find a channel with user_channel_id {}", user_channel_id),
 			})?;
 
+		if let Some(jit_channel) =
+			peer_state.outbound_channels_by_intercept_scid.get(&intercept_scid)
+		{
+			if !matches!(
+				jit_channel.state,
+				OutboundJITChannelState::PendingInitialPayment { .. }
+					| OutboundJITChannelState::PendingChannelOpen { .. }
+			) {
+				return Err(APIError::APIMisuseError {
+					err: "Cannot abandon channel open after channel creation or payment forwarding"
+						.to_string(),
+				});
+			}
+		}
+
 		peer_state.outbound_channels_by_intercept_scid.remove(&intercept_scid);
 
 		peer_state.intercept_scid_by_channel_id.retain(|_, &mut scid| scid != intercept_scid);
@@ -1064,41 +1078,45 @@ where
 			})?;
 
 		let jit_channel = peer_state
-        .outbound_channels_by_intercept_scid
-        .get_mut(&intercept_scid)
-        .ok_or_else(|| APIError::APIMisuseError {
+			.outbound_channels_by_intercept_scid
+			.get_mut(&intercept_scid)
+			.ok_or_else(|| APIError::APIMisuseError {
             err: format!(
                 "Failed to map the stored intercept_scid {} for the provided user_channel_id {} to a channel.",
                 intercept_scid, user_channel_id,
             ),
         })?;
 
-		jit_channel.state = match &jit_channel.state {
-			OutboundJITChannelState::PendingChannelOpen { payment_queue, .. } => {
-				let mut queue = payment_queue.lock().unwrap();
-				let payment_hashes: Vec<_> = queue
-					.clear()
-					.into_iter()
-					.map(|htlc| htlc.payment_hash)
-					.collect::<HashSet<_>>()
-					.into_iter()
-					.collect();
-
-				for payment_hash in payment_hashes {
-					self.channel_manager.get_cm().fail_htlc_backwards_with_reason(
-						&payment_hash,
-						FailureCode::TemporaryNodeFailure,
-					);
-				}
-				OutboundJITChannelState::PendingInitialPayment {
-					payment_queue: payment_queue.clone(),
-				}
-			},
-			_ => {
-				return Err(APIError::APIMisuseError {
-					err: "Channel is not in the PendingChannelOpen state.".to_string(),
-				})
-			},
+		if !matches!(jit_channel.state, OutboundJITChannelState::PendingChannelOpen { .. }) {
+			return Err(APIError::APIMisuseError {
+				err: "Channel is not in the PendingChannelOpen state.".to_string(),
+			});
+		}
+
+		let payment_queue_arc =
+			if let OutboundJITChannelState::PendingChannelOpen { payment_queue, .. } =
+				&jit_channel.state
+			{
+				Arc::clone(payment_queue)
+			} else {
+				unreachable!()
+			};
+		let mut queue = payment_queue_arc.lock().unwrap();
+		let payment_hashes: Vec<_> = queue
+			.clear()
+			.into_iter()
+			.map(|htlc| htlc.payment_hash)
+			.collect::<HashSet<_>>()
+			.into_iter()
+			.collect();
+		for payment_hash in payment_hashes {
+			self.channel_manager
+				.get_cm()
+				.fail_htlc_backwards_with_reason(&payment_hash, FailureCode::TemporaryNodeFailure);
+		}
+
+		jit_channel.state = OutboundJITChannelState::PendingInitialPayment {
+			payment_queue: Arc::clone(&payment_queue_arc),
 		};
 
 		Ok(())