cleanup

Author: satoshisound

coincube-gui/src/app/message.rs

@@ -77,6 +77,13 @@ pub enum Message {
     Export(ImportExportMessage),
     PaymentsLoaded(Result<Vec<breez_sdk_liquid::prelude::Payment>, BreezError>),
     RefundablesLoaded(Result<Vec<breez_sdk_liquid::prelude::RefundableSwap>, BreezError>),
+    /// Result of a debounced background poll started by
+    /// `App::refresh_refundables_task`. Distinct from `RefundablesLoaded`
+    /// (which is produced by manual panel reloads) so that only poll
+    /// responses touch the App's debounce/in-flight tracking. A reload
+    /// response racing ahead of a poll must not clear the in-flight flag,
+    /// or a second concurrent `list_refundables()` could be launched.
+    RefundablesPolled(Result<Vec<breez_sdk_liquid::prelude::RefundableSwap>, BreezError>),
     RefundCompleted(Result<breez_sdk_liquid::model::RefundResponse, BreezError>),
     BreezInfo(Result<breez_sdk_liquid::prelude::GetInfoResponse, BreezError>),
     BreezEvent(breez_sdk_liquid::prelude::SdkEvent),

coincube-gui/src/app/mod.rs

@@ -1265,8 +1265,10 @@ impl App {
 
     /// Kick off a background `list_refundables()` poll, debounced so that
     /// SDK events (which can fire several times a second during sync) don't
-    /// hammer the SDK. Result is routed back to `Message::RefundablesLoaded`,
-    /// which `LiquidTransactions::update()` already handles.
+    /// hammer the SDK. Result comes back as `Message::RefundablesPolled` —
+    /// a variant distinct from `RefundablesLoaded` (which manual panel
+    /// reloads produce) so that only poll responses touch the App's
+    /// debounce and in-flight fields.
     ///
     /// The Transactions panel itself fetches refundables on every reload()
     /// too — this debounced helper covers the case where the user is sitting
@@ -1292,7 +1294,7 @@ impl App {
         let client = self.breez_client.clone();
         Task::perform(
             async move { client.list_refundables().await },
-            Message::RefundablesLoaded,
+            Message::RefundablesPolled,
         )
     }
 
@@ -2064,16 +2066,27 @@ impl App {
             // handlers above) land on the correct panel even when the user is
             // sitting on a different screen. Otherwise the result would be
             // dropped into whatever panel happens to be current.
-            msg @ Message::RefundablesLoaded(_) | msg @ Message::RefundCompleted(_) => {
-                if let Message::RefundablesLoaded(result) = &msg {
-                    // Clear the in-flight guard regardless of outcome, but
-                    // only advance the debounce timestamp on success so a
-                    // failed poll doesn't suppress retries for 30s.
-                    self.refundables_fetch_in_flight = false;
-                    if result.is_ok() {
-                        self.last_refundables_fetch = Some(std::time::Instant::now());
-                    }
+            Message::RefundablesPolled(result) => {
+                // Poll response: clear the in-flight guard regardless of
+                // outcome, but only advance the debounce timestamp on
+                // success so a failed poll doesn't suppress retries for 30s.
+                // We intentionally *don't* touch these fields for a manual
+                // reload response — see the `RefundablesLoaded` arm below.
+                self.refundables_fetch_in_flight = false;
+                if result.is_ok() {
+                    self.last_refundables_fetch = Some(std::time::Instant::now());
                 }
+                // Forward the payload to LiquidTransactions through the
+                // panel's regular handler. The panel's reconciliation logic
+                // is origin-agnostic, so a poll result is converted to a
+                // `RefundablesLoaded` for it.
+                return self.panels.liquid_transactions.update(
+                    self.daemon.clone(),
+                    &self.cache,
+                    Message::RefundablesLoaded(result),
+                );
+            }
+            msg @ Message::RefundablesLoaded(_) | msg @ Message::RefundCompleted(_) => {
                 return self.panels.liquid_transactions.update(
                     self.daemon.clone(),
                     &self.cache,

coincube-gui/src/app/state/liquid/overview.rs

@@ -114,6 +114,7 @@ impl State for LiquidOverview {
                     fiat_converter,
                     cache.bitcoin_unit,
                     usdt_asset_id(self.breez_client.network()).unwrap_or(""),
+                    &[],
                 ),
             )
         } else {

coincube-gui/src/app/state/liquid/send.rs

@@ -397,6 +397,7 @@ impl State for LiquidSend {
                     fiat_converter,
                     cache.bitcoin_unit,
                     usdt_asset_id(self.breez_client.network()).unwrap_or(""),
+                    &[],
                 ),
             )
         } else {

coincube-gui/src/app/state/liquid/transactions.rs

@@ -107,9 +107,9 @@ impl LiquidTransactions {
         self.pending_fee_priority
     }
 
-    fn reconcile_in_flight(&mut self, refundables: Vec<RefundableSwap>) {
-        let returned: std::collections::HashSet<&String> =
-            refundables.iter().map(|r| &r.swap_address).collect();
+    fn reconcile_in_flight(&mut self, mut refundables: Vec<RefundableSwap>) {
+        let returned: std::collections::HashSet<String> =
+            refundables.iter().map(|r| r.swap_address.clone()).collect();
         let now = Instant::now();
         self.in_flight_refunds.retain(|addr, entry| {
             if returned.contains(addr) {
@@ -123,6 +123,19 @@ impl LiquidTransactions {
             // banner would disappear before the user sees it.
             entry.refund_txid.is_none() && now.duration_since(entry.submitted_at) < IN_FLIGHT_GRACE
         });
+        // Carry forward any locally-known RefundableSwap whose address still
+        // has a grace-window in_flight entry but that the SDK dropped. The
+        // view iterates `self.refundables` to render cards and only uses
+        // `in_flight_refunds` for extra metadata, so without this the
+        // "Refund broadcasting…" card would vanish the instant the SDK
+        // stopped listing the swap, defeating the grace window.
+        for prev in std::mem::take(&mut self.refundables) {
+            if !returned.contains(&prev.swap_address)
+                && self.in_flight_refunds.contains_key(&prev.swap_address)
+            {
+                refundables.push(prev);
+            }
+        }
         self.refundables = refundables;
     }
 
@@ -180,6 +193,11 @@ impl LiquidTransactions {
 impl State for LiquidTransactions {
     fn view<'a>(&'a self, menu: &'a Menu, cache: &'a Cache) -> Element<'a, view::Message> {
         let fiat_converter = cache.fiat_price.as_ref().and_then(|p| p.try_into().ok());
+        let refundable_swap_addresses: Vec<String> = self
+            .refundables
+            .iter()
+            .map(|r| r.swap_address.clone())
+            .collect();
         let content = if let Some(payment) = &self.selected_payment {
             view::dashboard(
                 menu,
@@ -189,6 +207,7 @@ impl State for LiquidTransactions {
                     fiat_converter,
                     cache.bitcoin_unit,
                     usdt_asset_id(self.breez_client.network()).unwrap_or(""),
+                    &refundable_swap_addresses,
                 ),
             )
         } else if let Some(refundable) = &self.selected_refundable {
@@ -489,16 +508,30 @@ impl State for LiquidTransactions {
                         }
                     },
                     move |rate: Option<usize>| {
-                        if let Some(rate) = rate {
-                            Message::View(view::Message::RefundFeerateEdited(rate.to_string()))
-                        } else {
-                            Message::View(view::Message::RefundFeeratePriorityFailed(
-                                "Failed to fetch fee rate".to_string(),
-                            ))
-                        }
+                        // Tag the result with the priority that kicked off
+                        // the fetch. The handler in the update loop will
+                        // discard it if `pending_fee_priority` has moved on.
+                        Message::View(view::Message::RefundFeeratePriorityResolved(priority, rate))
                     },
                 )
             }
+            Message::View(view::Message::RefundFeeratePriorityResolved(priority, rate)) => {
+                // Ignore stale responses: if the user typed a custom feerate
+                // (clearing `pending_fee_priority`) or clicked a different
+                // priority button, this in-flight result must not clobber
+                // their newer input.
+                if self.pending_fee_priority != Some(priority) {
+                    return Task::none();
+                }
+                match rate {
+                    Some(rate) => Task::done(Message::View(view::Message::RefundFeerateEdited(
+                        rate.to_string(),
+                    ))),
+                    None => Task::done(Message::View(view::Message::RefundFeeratePriorityFailed(
+                        "Failed to fetch fee rate".to_string(),
+                    ))),
+                }
+            }
             Message::View(view::Message::GenerateVaultRefundAddress) => {
                 // Reuse the Vault wallet's existing fresh-address derivation
                 // (`daemon.get_new_address()`). This intentionally does NOT
@@ -579,13 +612,16 @@ impl State for LiquidTransactions {
                 self.selected_refundable = None;
                 self.refund_address = form::Value::default();
                 self.refund_feerate = form::Value::default();
-                Task::batch(vec![
-                    Task::done(Message::View(view::Message::ShowToast(
-                        log::Level::Info,
-                        format!("Refund broadcast · {}", txid.get(..10).unwrap_or(&txid)),
-                    ))),
-                    Task::done(Message::View(view::Message::Close)),
-                ])
+                // Do NOT emit view::Message::Close here: it routes globally
+                // through App's panel router and would land on whatever
+                // panel is currently active, resetting unrelated state if
+                // the user navigated away while the refund was broadcasting.
+                // The local field clears above already collapse this panel
+                // back to the transactions list on the next render.
+                Task::done(Message::View(view::Message::ShowToast(
+                    log::Level::Info,
+                    format!("Refund broadcast · {}", txid.get(..10).unwrap_or(&txid)),
+                )))
             }
             Message::RefundCompleted(Err(e)) => {
                 self.refunding = false;
@@ -685,4 +721,48 @@ mod tests {
         state.test_reconcile_in_flight(vec![sample_refundable("bc1q_active")]);
         assert!(state.in_flight_refunds.contains_key("bc1q_active"));
     }
+
+    #[test]
+    fn in_flight_card_carried_forward_when_sdk_drops_optimistic_swap() {
+        // Regression: grace window preserves the in_flight entry *and* the
+        // RefundableSwap, so the view (which iterates self.refundables) keeps
+        // rendering the "Refund broadcasting…" card until RefundCompleted.
+        let mut state = new_state();
+        state.refundables = vec![sample_refundable("bc1q_racing")];
+        state.in_flight_refunds.insert(
+            "bc1q_racing".to_string(),
+            InFlightRefund {
+                refund_txid: None,
+                submitted_at: Instant::now(),
+            },
+        );
+
+        // SDK poll races ahead of RefundCompleted and no longer lists the swap.
+        state.test_reconcile_in_flight(vec![]);
+
+        assert!(state.in_flight_refunds.contains_key("bc1q_racing"));
+        assert_eq!(state.refundables.len(), 1);
+        assert_eq!(state.refundables[0].swap_address, "bc1q_racing");
+    }
+
+    #[test]
+    fn in_flight_card_dropped_once_entry_removed() {
+        // Carry-forward is tied to in_flight presence: once the entry is
+        // dropped (e.g. txid set + absent from SDK list), the refundable
+        // must also disappear.
+        let mut state = new_state();
+        state.refundables = vec![sample_refundable("bc1q_done")];
+        state.in_flight_refunds.insert(
+            "bc1q_done".to_string(),
+            InFlightRefund {
+                refund_txid: Some("deadbeef".to_string()),
+                submitted_at: Instant::now(),
+            },
+        );
+
+        state.test_reconcile_in_flight(vec![]);
+
+        assert!(!state.in_flight_refunds.contains_key("bc1q_done"));
+        assert!(state.refundables.is_empty());
+    }
 }