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

@@ -6,6 +6,7 @@
 from PyQt6.QtCore import (pyqtProperty, pyqtSignal, pyqtSlot, QObject, QTimer, pyqtEnum, QAbstractListModel, Qt,
                           QModelIndex)
 
+from electrum.gui.qml.qetxfinalizer import QETxFinalizer
 from electrum.i18n import _
 from electrum.bitcoin import DummyAddress
 from electrum.logging import get_logger
@@ -156,6 +157,7 @@ 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
@@ -213,6 +215,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):
@@ -545,24 +552,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()
@@ -627,7 +636,8 @@ def do_normal_swap(self, lightning_amount, 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)
+                # dummy_tx = self._create_tx(onchain_amount)
+                dummy_tx = self._finalized_tx
                 self.userinfo = _('Performing swap...')
                 self.state = QESwapHelper.State.Started
                 self._swap, invoice = await self._wallet.wallet.lnworker.swap_manager.request_normal_swap(
@@ -673,6 +683,27 @@ async def swap_task():
 
         asyncio.run_coroutine_threadsafe(swap_task(), get_asyncio_loop())
 
+    @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
+
+        # def acpt(tx):
+        #     raise Exception('EXPECTED!')
+        #     self._logger.info(f'acpt {tx=}')
+        #     assert tx == self._tx, 'acpt tx is not self._tx'
+        #     assert tx != self._tx, 'acpt tx is self._tx'
+
+        self._finalizer = QETxFinalizer(self, make_tx=mktx)  #, accept=acpt)
+        self._finalizer.canRbf = False
+        self._finalizer.amount = QEAmount(amount_sat=self._send_amount)
+        self._finalizer.wallet = self._wallet
+        self.finalizerChanged.emit()
+
     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

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: