Merge pull request #95 from Forte11Cuba/fix/mint-http-polling-fallback

fix: add HTTP polling fallback for mint quote payment detection

rust/src/api/wallet.rs

@@ -211,12 +211,21 @@ impl Wallet {
             return Ok(());
         }
 
-        // Subscribe to quote state changes via WebSocket (NUT-17) with HTTP polling fallback
-        let mut subscription = self
+        // Try WebSocket (NUT-17) subscription — if unavailable, HTTP polling still works
+        let subscription = match self
             .inner
             .subscribe(WalletSubscription::Bolt11MintQuoteState(vec![quote.id.clone()]))
             .await
-            .map_err(|e| Error::Cdk(e.to_string()))?;
+        {
+            Ok(sub) => Some(sub),
+            Err(e) => {
+                info!(
+                    "Mint quote {}: WebSocket unavailable, using HTTP polling only: {e}",
+                    quote.id
+                );
+                None
+            }
+        };
 
         let _self = self.clone();
         flutter_rust_bridge::spawn(async move {
@@ -234,14 +243,84 @@ impl Wallet {
             let expired_amount = quote.amount;
             let expired_expiry = quote.expiry;
 
-            let result = tokio::time::timeout(timeout_dur, async {
-                while let Some(event) = subscription.recv().await {
+            // Detect payment via two parallel paths:
+            // - Path A: WebSocket (NUT-17) — fast when it works (sats on most mints)
+            // - Path B: HTTP polling every 5s — fallback for mints that don't send
+            //   WebSocket notifications for all units (e.g. Nutshell 0.20.0 + USD)
+            // First one to detect payment wins.
+            let quote_id_for_poll = quote.id.clone();
+            let poll_wallet = _self.clone();
+
+            // Timeout only covers detection, not minting.
+            // If payment is detected near expiry, mint() must still complete.
+            enum Detected {
+                Paid,
+                Issued,
+            }
+
+            let mut subscription = subscription;
+            let detected = tokio::time::timeout(timeout_dur, async {
+                tokio::select! {
+                    // Path A: WebSocket subscription (skipped if unavailable)
+                    result = async {
+                        let Some(ref mut sub) = subscription else {
+                            return std::future::pending::<Detected>().await;
+                        };
+                        while let Some(event) = sub.recv().await {
                             match event.into_inner() {
                                 NotificationPayload::MintQuoteBolt11Response(info)
                                     if info.state == CdkMintQuoteState::Paid =>
                                 {
-                            info!("Mint quote {} paid via subscription", quote.id);
+                                    info!("Mint quote {} paid via WebSocket", quote.id);
+                                    return Detected::Paid;
+                                }
+                                NotificationPayload::MintQuoteBolt11Response(info)
+                                    if info.state == CdkMintQuoteState::Issued =>
+                                {
+                                    return Detected::Issued;
+                                }
+                                _ => continue,
+                            }
+                        }
+                        std::future::pending::<Detected>().await
+                    } => result,
 
+                    // Path B: HTTP polling fallback
+                    result = async {
+                        loop {
+                            tokio::time::sleep(Duration::from_secs(5)).await;
+                            match poll_wallet.inner.check_mint_quote_status(&quote_id_for_poll).await {
+                                Ok(q) if q.state == CdkMintQuoteState::Paid => {
+                                    info!("Mint quote {} paid via HTTP polling", quote_id_for_poll);
+                                    return Detected::Paid;
+                                }
+                                Ok(q) if q.state == CdkMintQuoteState::Issued => {
+                                    return Detected::Issued;
+                                }
+                                _ => continue,
+                            }
+                        }
+                    } => result,
+                }
+            })
+            .await;
+
+            // Handle detection result — mint logic runs outside the timeout
+            match detected {
+                Err(_) => {
+                    // Timeout: quote expired
+                    let _ = sink.add(MintQuote {
+                        id: expired_id,
+                        request: expired_request,
+                        amount: expired_amount.map(|a| a.into()),
+                        expiry: Some(expired_expiry),
+                        state: MintQuoteState::Error,
+                        token: None,
+                        error: Some("Quote expired".to_string()),
+                        transaction_id: None,
+                    });
+                }
+                Ok(Detected::Paid) => {
                     // Notify Dart: payment detected
                     let _ = sink.add(MintQuote {
                         id: quote.id.clone(),
@@ -254,7 +333,7 @@ impl Wallet {
                         transaction_id: None,
                     });
 
-                            // Mint the ecash tokens
+                    // Mint the ecash tokens (outside timeout)
                     match _self
                         .inner
                         .mint(&quote.id, SplitTarget::None, None)
@@ -304,13 +383,9 @@ impl Wallet {
                             });
                         }
                     }
-                            return;
                 }
-                        NotificationPayload::MintQuoteBolt11Response(info)
-                            if info.state == CdkMintQuoteState::Issued =>
-                        {
-                            // Already issued (recovered from previous session) — notify Dart
-                            // so it can clean up pending metadata and show success UI
+                Ok(Detected::Issued) => {
+                    // Already issued (recovered from previous session)
                     let _ = sink.add(MintQuote {
                         id: quote.id.clone(),
                         request: quote.request.clone(),
@@ -322,26 +397,7 @@ impl Wallet {
                         transaction_id: None,
                     });
                     _self.update_balance_streams().await;
-                            return;
                 }
-                        _ => continue,
-                    }
-                }
-            })
-            .await;
-
-            if result.is_err() {
-                // Timeout: quote expired
-                let _ = sink.add(MintQuote {
-                    id: expired_id,
-                    request: expired_request,
-                    amount: expired_amount.map(|a| a.into()),
-                    expiry: Some(expired_expiry),
-                    state: MintQuoteState::Error,
-                    token: None,
-                    error: Some("Quote expired".to_string()),
-                    transaction_id: None,
-                });
             }
         });
         Ok(())