qml: let user finalize forward swap onchain tx before initiating swap

Author: accumulator

electrum/gui/qml/components/SwapDialog.qml

@@ -293,7 +293,19 @@ ElDialog {
                 enabled: swaphelper.valid && (swaphelper.state == SwapHelper.ServiceReady || swaphelper.state == SwapHelper.Failed)
 
                 onClicked: {
-                    swaphelper.executeSwap()
+                    if (swaphelper.isReverse) {
+                        swaphelper.executeSwap()
+                    } else {
+                        swaphelper.prepNormalSwap()
+                        var dialog = forwardSwapTxDialog.createObject(app, {
+                            finalizer: swaphelper.finalizer,
+                            satoshis: swaphelper.finalizer.amount
+                        })
+                        dialog.accepted.connect(function() {
+                            swaphelper.executeSwap()
+                        })
+                        dialog.open()
+                    }
                 }
             }
             FlatButton {
@@ -331,6 +343,15 @@ ElDialog {
         }
     }
 
+    Component {
+        id: forwardSwapTxDialog
+        ConfirmTxDialog {
+            amountLabelText: qsTr('Amount to swap')
+            sendButtonText: qsTr('Swap')
+            finalizer: swaphelper.finalizer
+        }
+    }
+
     Component.onCompleted: {
         swapslider.value = swaphelper.sliderPos
     }

electrum/gui/qml/qeswaphelper.py

@@ -7,6 +7,7 @@
                           QModelIndex)
 from PyQt6.QtGui import QColor
 
+from electrum.gui.qml.qetxfinalizer import QETxFinalizer
 from electrum.i18n import _
 from electrum.bitcoin import DummyAddress
 from electrum.logging import get_logger
@@ -158,10 +159,12 @@ def __init__(self, parent=None):
         super().__init__(parent)
 
         self._wallet = None  # type: Optional[QEWallet]
+        self._finalizer = None  # type: Optional[QETxFinalizer]
         self._sliderPos = 0
         self._rangeMin = -1
         self._rangeMax = 1
-        self._tx = None
+        self._tx = None  # updated on feeslider move and fee histogram updates, used for estimation
+        self._finalized_tx = None  # updated by finalizer, used for actual forward swap
         self._valid = False
         self._state = QESwapHelper.State.Initialized
         self._userinfo = QESwapHelper.MESSAGE_SWAP_HOWTO
@@ -215,6 +218,11 @@ def wallet(self, wallet: QEWallet):
             self.run_swap_manager()
             self.walletChanged.emit()
 
+    finalizerChanged = pyqtSignal()
+    @pyqtProperty(QETxFinalizer, notify=finalizerChanged)
+    def finalizer(self):
+        return self._finalizer
+
     sliderPosChanged = pyqtSignal()
     @pyqtProperty(float, notify=sliderPosChanged)
     def sliderPos(self):
@@ -547,24 +555,26 @@ def initSwapSliderRange(self):
         self.swap_slider_moved()
 
     @profiler
-    def update_tx(self, onchain_amount: Union[int, str]):
+    def update_tx(self, onchain_amount: Union[int, str], fee_policy: Optional[FeePolicy] = None):
         """Updates the transaction associated with a forward swap."""
         if onchain_amount is None:
             self._tx = None
             self.valid = False
             return
-        outputs = [PartialTxOutput.from_address_and_value(DummyAddress.SWAP, onchain_amount)]
-        coins = self._wallet.wallet.get_spendable_coins(None)
-        fee_policy = FeePolicy('eta:2')
         try:
-            self._tx = self._wallet.wallet.make_unsigned_transaction(
-                coins=coins,
-                outputs=outputs,
-                fee_policy=fee_policy)
+            self._tx = self._create_swap_tx(onchain_amount, fee_policy)
         except (NotEnoughFunds, NoDynamicFeeEstimates):
             self._tx = None
             self.valid = False
 
+    def _create_swap_tx(self, onchain_amount: int | str, fee_policy: Optional[FeePolicy] = None):
+        outputs = [PartialTxOutput.from_address_and_value(DummyAddress.SWAP, onchain_amount)]
+        coins = self._wallet.wallet.get_spendable_coins(None)
+        fee_policy = fee_policy if fee_policy else FeePolicy('eta:2')
+        return self._wallet.wallet.make_unsigned_transaction(
+            coins=coins, outputs=outputs, fee_policy=fee_policy
+        )
+
     @qt_event_listener
     def on_event_fee_histogram(self, *args):
         self.swap_slider_moved()
@@ -623,13 +633,15 @@ def fwd_swap_updatetx(self):
 
     def do_normal_swap(self, lightning_amount, onchain_amount):
         assert self._tx
+        assert self._finalized_tx
         if lightning_amount is None or onchain_amount is None:
             return
 
+        assert self._finalized_tx.get_dummy_output(DummyAddress.SWAP).value == onchain_amount
+
         async def swap_task():
             assert self.swap_transport is not None, "Swap transport not available"
             try:
-                dummy_tx = self._create_tx(onchain_amount)
                 self.userinfo = _('Performing swap...')
                 self.state = QESwapHelper.State.Started
                 self._swap, invoice = await self._wallet.wallet.lnworker.swap_manager.request_normal_swap(
@@ -638,10 +650,11 @@ async def swap_task():
                     expected_onchain_amount_sat=onchain_amount,
                 )
 
-                tx = self._wallet.wallet.lnworker.swap_manager.create_funding_tx(self._swap, dummy_tx, password=self._wallet.password)
-                coro2 = self._wallet.wallet.lnworker.swap_manager.wait_for_htlcs_and_broadcast(
+                tx = self._wallet.wallet.lnworker.swap_manager.create_funding_tx(
+                    self._swap, self._finalized_tx, password=self._wallet.password)
+                coro = self._wallet.wallet.lnworker.swap_manager.wait_for_htlcs_and_broadcast(
                     transport=self.swap_transport, swap=self._swap, invoice=invoice, tx=tx)
-                self._fut_htlc_wait = fut = asyncio.create_task(coro2)
+                self._fut_htlc_wait = fut = asyncio.create_task(coro)
 
                 self.canCancel = True
                 txid = await fut
@@ -675,32 +688,20 @@ async def swap_task():
 
         asyncio.run_coroutine_threadsafe(swap_task(), get_asyncio_loop())
 
-    def _create_tx(self, onchain_amount: Union[int, str, None]) -> PartialTransaction:
-        # TODO: func taken from qt GUI, this should be common code
-        assert not self.isReverse
-        if onchain_amount is None:
-            raise InvalidSwapParameters("onchain_amount is None")
-        # coins = self.window.get_coins()
-        coins = self._wallet.wallet.get_spendable_coins()
-        if onchain_amount == '!':
-            max_amount = sum(c.value_sats() for c in coins)
-            max_swap_amount = self._wallet.wallet.lnworker.swap_manager.client_max_amount_forward_swap()
-            if max_swap_amount is None:
-                raise InvalidSwapParameters("swap_manager.client_max_amount_forward_swap() is None")
-            if max_amount > max_swap_amount:
-                onchain_amount = max_swap_amount
-        outputs = [PartialTxOutput.from_address_and_value(DummyAddress.SWAP, onchain_amount)]
-        fee_policy = FeePolicy('eta:2')
-        try:
-            tx = self._wallet.wallet.make_unsigned_transaction(
-                coins=coins,
-                outputs=outputs,
-                send_change_to_lightning=False,
-                fee_policy=fee_policy
-            )
-        except (NotEnoughFunds, NoDynamicFeeEstimates) as e:
-            raise InvalidSwapParameters(str(e)) from e
-        return tx
+    @pyqtSlot()
+    def prepNormalSwap(self):
+        def mktx(amt, fee_policy: FeePolicy):
+            try:
+                self._finalized_tx = self._create_swap_tx(amt, fee_policy)
+            except (NotEnoughFunds, NoDynamicFeeEstimates):
+                self._finalized_tx = None
+            return self._finalized_tx
+
+        self._finalizer = QETxFinalizer(self, make_tx=mktx)
+        self._finalizer.canRbf = False
+        self._finalizer.amount = QEAmount(amount_sat=self._send_amount)
+        self._finalizer.wallet = self._wallet
+        self.finalizerChanged.emit()
 
     def do_reverse_swap(self, lightning_amount, onchain_amount):
         if lightning_amount is None or onchain_amount is None:

electrum/gui/qml/qetxfinalizer.py

@@ -2,7 +2,7 @@
 from enum import IntEnum
 import threading
 from decimal import Decimal
-from typing import Optional, TYPE_CHECKING
+from typing import Optional, TYPE_CHECKING, Callable
 from functools import partial
 
 from PyQt6.QtCore import pyqtProperty, pyqtSignal, pyqtSlot, QObject, pyqtEnum
@@ -54,7 +54,7 @@ def __init__(self, parent=None):
         self._wallet = None  # type: Optional[QEWallet]
         self._sliderSteps = 0
         self._sliderPos = 0
-        self._fee_policy = None
+        self._fee_policy: Optional[FeePolicy] = None
         self._target = ''
         self._config = None  # type: Optional[SimpleConfig]
 
@@ -314,7 +314,13 @@ class QETxFinalizer(TxFeeSlider):
     finished = pyqtSignal([bool, bool, bool], arguments=['signed', 'saved', 'complete'])
     signError = pyqtSignal([str], arguments=['message'])
 
-    def __init__(self, parent=None, *, make_tx=None, accept=None):
+    def __init__(
+            self,
+            parent=None,
+            *,
+            make_tx: Optional[Callable[[int | str, Optional[FeePolicy]], PartialTransaction]] = None,
+            accept: Optional[Callable[[PartialTransaction], None]] = None
+    ):
         super().__init__(parent)
         self.f_make_tx = make_tx
         self.f_accept = accept
@@ -377,7 +383,7 @@ def canRbf(self, canRbf):
         self.rbf = self._canRbf  # if we can RbF, we do RbF
 
     @profiler
-    def make_tx(self, amount):
+    def make_tx(self, amount: int | str) -> PartialTransaction:
         self._logger.debug(f'make_tx amount={amount}')
 
         if self.f_make_tx: