Fix dummy wallet test stalls

The dummy trusted wallet can miss payment wakeups or leave the
rebalancer waiting after a failed LDK payment.

Bound the dummy payment wait path and route test-only LDK shutdown
through async timeouts so failures surface as test errors instead of
CI stalls.

Author: benthecarman

orange-sdk/src/trusted_wallet/dummy.rs

@@ -166,6 +166,8 @@ impl DummyTrustedWallet {
 								.await
 								.unwrap();
 						}
+
+						let _ = payment_success_sender.send(());
 					},
 					Event::PaymentReceived { payment_id, amount_msat, payment_hash, .. } => {
 						// convert id
@@ -258,10 +260,8 @@ impl DummyTrustedWallet {
 		DummyTrustedWallet { current_bal_msats, payments, ldk_node, payment_success_flag }
 	}
 
-	pub(crate) async fn await_payment_success(&self) {
-		let mut flag = self.payment_success_flag.clone();
-		flag.mark_unchanged();
-		let _ = flag.changed().await;
+	fn payment_wait_timeout() -> Duration {
+		if std::env::var("CI").is_ok() { Duration::from_secs(120) } else { Duration::from_secs(20) }
 	}
 }
 
@@ -384,6 +384,8 @@ impl TrustedWalletInterface for DummyTrustedWallet {
 	) -> Pin<Box<dyn Future<Output = Option<ReceivedLightningPayment>> + Send + '_>> {
 		Box::pin(async move {
 			let id = channelmanager::PaymentId(payment_hash);
+			let mut flag = self.payment_success_flag.clone();
+			flag.mark_unchanged();
 			loop {
 				if let Some(payment) = self.ldk_node.payment(&id) {
 					let counterparty_skimmed_fee_msat = match payment.kind {
@@ -408,7 +410,12 @@ impl TrustedWalletInterface for DummyTrustedWallet {
 						PaymentStatus::Failed => return None,
 					}
 				}
-				self.await_payment_success().await;
+				if !matches!(
+					tokio::time::timeout(Self::payment_wait_timeout(), flag.changed()).await,
+					Ok(Ok(()))
+				) {
+					return None;
+				}
 			}
 		})
 	}

orange-sdk/tests/integration_tests.rs

@@ -2208,7 +2208,7 @@ async fn test_lsp_connectivity_fallback() {
 		assert!(!uri_with_lsp.from_trusted);
 
 		// Now simulate LSP being offline by stopping it
-		let _ = lsp.stop();
+		test_utils::stop_ldk_node("lsp", Arc::clone(&lsp)).await;
 
 		// Wait a moment for the stop to take effect
 		tokio::time::sleep(Duration::from_secs(2)).await;

orange-sdk/tests/test_utils.rs

@@ -267,7 +267,7 @@ pub struct TestParams {
 
 impl TestParams {
 	async fn stop(&self) {
-		self.wallet.stop().await;
+		stop_wallet("wallet", Arc::clone(&self.wallet)).await;
 
 		#[cfg(feature = "_cashu-tests")]
 		let _ = self._mint.stop().await;
@@ -279,7 +279,25 @@ impl TestParams {
 	}
 }
 
-async fn stop_ldk_node(name: &'static str, node: Arc<Node>) {
+async fn stop_wallet(name: &'static str, wallet: Arc<orange_sdk::Wallet>) {
+	let (sender, receiver) = tokio::sync::oneshot::channel();
+	std::thread::spawn(move || {
+		let res = tokio::runtime::Builder::new_multi_thread()
+			.enable_all()
+			.build()
+			.map(|runtime| runtime.block_on(async move { wallet.stop().await }));
+		if let Err(e) = res {
+			eprintln!("Warning: failed to create runtime for {name} stop: {e}");
+		}
+		let _ = sender.send(());
+	});
+
+	if tokio::time::timeout(Duration::from_secs(20), receiver).await.is_err() {
+		eprintln!("Warning: {name} stop timed out");
+	}
+}
+
+pub(crate) async fn stop_ldk_node(name: &'static str, node: Arc<Node>) {
 	let (sender, receiver) = tokio::sync::oneshot::channel();
 	std::thread::spawn(move || {
 		let _ = node.stop();
@@ -317,13 +335,13 @@ where
 		res = &mut test_task => Ok(res),
 		_ = tokio::time::sleep(test_timeout) => {
 			test_task.abort();
-			let _ = test_task.await;
+			let _ = tokio::time::timeout(Duration::from_secs(5), &mut test_task).await;
 			Err(())
 		},
 	};
 
 	// Always clean up
-	let timeout = Duration::from_secs(30);
+	let timeout = Duration::from_secs(45);
 	if tokio::time::timeout(timeout, params.stop()).await.is_err() {
 		eprintln!("Warning: params stop timed out after {timeout:?}");
 	}