add option to show warnings on wallet close, add warning for ongoing submarine swap

Author: f321x

electrum/gui/messages.py

@@ -61,11 +61,15 @@ def to_rtf(msg):
     _("Please remain online until the funding transaction is confirmed.") + "\n\n" +
     _('The swap will be finalized once your transaction is confirmed.') + " " +
     _("After the funding transaction is mined, the server will reveal the preimage needed to "
-      "fulfill the pending received lightning HTLCs. The HTLCs expire in {} blocks. "
+      "fulfill the pending received lightning HTLCs.")
+)
+
+MSG_FORWARD_SWAP_HTLC_EXPIRY = _(
+      "The HTLCs expire in {} blocks. "
       "You will need to be online after the funding transaction is confirmed but before the HTLCs expire, "
       "to claim your money. If you go offline for several days while the swap is pending, "
       "you risk losing the swap amount!").format(MIN_FINAL_CLTV_DELTA_FOR_CLIENT)
-)
+
 
 MSG_REVERSE_SWAP_FUNDING_MEMPOOL = (
     _('The funding transaction has been detected.') + " " +

electrum/gui/qt/main_window.py

@@ -34,7 +34,7 @@
 from functools import partial
 import queue
 import asyncio
-from typing import Optional, TYPE_CHECKING, Sequence, Union, Dict, Mapping
+from typing import Optional, TYPE_CHECKING, Sequence, Union, Dict, Mapping, Callable, List, Set
 import concurrent.futures
 
 from PyQt6.QtGui import QPixmap, QKeySequence, QIcon, QCursor, QFont, QFontMetrics, QAction, QShortcut
@@ -271,6 +271,9 @@ def add_optional_tab(tabs, tab, icon, description):
 
         # network callbacks
         self.register_callbacks()
+        # wallet closing warning callbacks
+        self.closing_warning_callbacks = []  # type: List[Callable[[], Optional[str]]]
+        self.register_closing_warning_callback(self._check_ongoing_submarine_swaps_callback)
         # banner may already be there
         if self.network and self.network.banner:
             self.console.showMessage(self.network.banner)
@@ -2684,8 +2687,62 @@ def settings_dialog(self):
         if d.need_restart:
             self.show_warning(_('Please restart Electrum to activate the new GUI settings'), title=_('Success'))
 
+    def _show_closing_warnings(self) -> bool:
+        """Show any closing warnings and return True if the user chose to quit anyway."""
+
+        warnings: Set[str] = set()
+        for cb in self.closing_warning_callbacks:
+            if warning := cb():
+                warnings.add(warning)
+
+        for warning in list(warnings)[:3]:
+                warning = _("An ongoing operation prevents Electrum from closing:") + "\n\n" + warning
+                buttons = QMessageBox.StandardButton.Cancel | QMessageBox.StandardButton.Close
+                result = self.show_warning(
+                    msg=warning,
+                    title=_("Don't close Electrum yet!"),
+                    buttons=buttons,
+                    defaultButton=QMessageBox.StandardButton.Cancel,
+                )
+                if result == QMessageBox.StandardButton.Cancel:
+                    break
+        else:
+            # user chose to cancel all warnings or there were no warnings
+            return True
+        return False
+
+    def register_closing_warning_callback(self, callback: Callable[[], Optional[str]]) -> None:
+        """
+        Registers a callback that will be called when the wallet is closed. If the callback
+        returns a string it will be shown to the user as a warning to prevent them closing the wallet.
+        """
+        assert not asyncio.iscoroutinefunction(callback)
+        def warning_callback() -> Optional[str]:
+            try:
+                return callback()
+            except Exception:
+                self.logger.exception("Error in closing warning callback")
+                return None
+        self.logger.debug(f"registering wallet closing warning callback")
+        self.closing_warning_callbacks.append(warning_callback)
+
+    def _check_ongoing_submarine_swaps_callback(self) -> Optional[str]:
+        """Callback that will return a warning string if there is a unconfirmed swap funding."""
+        if not (self.wallet.has_lightning() and self.wallet.lnworker.swap_manager):
+            return None
+        if self.wallet.lnworker.swap_manager.has_pending_swaps():
+            return "\n".join((
+                _("Ongoing submarine swap:"),
+                _("Wait until the funding transaction of your swap confirms, "
+                  "otherwise you risk losing funds.")
+            ))
+        return None
+
     def closeEvent(self, event):
         # note that closeEvent is NOT called if the user quits with Ctrl-C
+        if not self._show_closing_warnings():
+            event.ignore()
+            return
         self.clean_up()
         event.accept()
 
@@ -2870,7 +2927,7 @@ def on_swap_result(self, txid: Optional[str], *, is_reverse: bool):
             if is_reverse:
                 msg += messages.MSG_REVERSE_SWAP_FUNDING_MEMPOOL
             else:
-                msg += messages.MSG_FORWARD_SWAP_FUNDING_MEMPOOL
+                msg += messages.MSG_FORWARD_SWAP_FUNDING_MEMPOOL + messages.MSG_FORWARD_SWAP_HTLC_EXPIRY
             self.show_message_signal.emit(msg)
         else:
             msg += _("Lightning funds were not received.")  # FIXME should this not depend on is_reverse?

electrum/submarine_swaps.py

@@ -1279,6 +1279,15 @@ def get_group_id_for_payment_hash(self, payment_hash):
         if swap:
             return swap.spending_txid if swap.is_reverse else swap.funding_txid
 
+    def has_pending_swaps(self) -> bool:
+        """Returns True if there are swaps with unconfirmed funding tx (require us to stay online)."""
+        for swap in self.swaps.values():
+            if swap.funding_txid and not swap.is_redeemed:
+                # swap is funded but not marked redeemed by _claim_swap
+                if self.lnworker.wallet.adb.get_tx_height(swap.funding_txid).height < 1:
+                    # funding TX is not yet confirmed, wallet should not be closed
+                    return True
+        return False
 
 class SwapServerTransport(Logger):