qml: add deadline property to QETxFinalizer, use deadline for submarine swaps

Author: accumulator

electrum/gui/qml/components/controls/FeeMethodComboBox.qml

@@ -11,7 +11,10 @@ ElComboBox {
     textRole: 'text'
     valueRole: 'value'
 
-    model: [
+    // NOTE: deadline property only exists on QETxFinalizer, but as undefined == false, that's ok.
+    model: feeslider.deadline ? [
+        { text: qsTr('ETA'), value: FeeSlider.FSMethod.ETA }
+    ] : [
         { text: qsTr('ETA'), value: FeeSlider.FSMethod.ETA },
         { text: qsTr('Mempool'), value: FeeSlider.FSMethod.MEMPOOL },
         { text: qsTr('Feerate'), value: FeeSlider.FSMethod.FEERATE },

electrum/gui/qml/qeswaphelper.py

@@ -13,7 +13,9 @@
 from electrum.transaction import PartialTxOutput, PartialTransaction
 from electrum.util import (NotEnoughFunds, NoDynamicFeeEstimates, profiler, get_asyncio_loop, age,
                            wait_for2, send_exception_to_crash_reporter)
-from electrum.submarine_swaps import NostrTransport, SwapServerTransport, pubkey_to_rgb_color
+from electrum.submarine_swaps import (
+    NostrTransport, SwapServerTransport, pubkey_to_rgb_color, LOCKTIME_DELTA_REFUND, LOCKTIME_DELTA_REFUND_BUFFER
+)
 from electrum.fee_policy import FeePolicy
 
 from electrum.gui.common_qt.util import QtEventListener, qt_event_listener
@@ -708,6 +710,7 @@ def mktx(amt, fee_policy: FeePolicy):
         self._finalizer.canRbf = False
         self._finalizer.amount = QEAmount(amount_sat=self._send_amount)
         self._finalizer.wallet = self._wallet
+        self._finalizer.deadline = LOCKTIME_DELTA_REFUND - LOCKTIME_DELTA_REFUND_BUFFER  # 10-block buffer before refund deadline
         self.finalizerChanged.emit()
 
     def do_reverse_swap(self, lightning_amount, onchain_amount):

electrum/gui/qml/qetxfinalizer.py

@@ -408,6 +408,7 @@ def __init__(
         self._effectiveAmount = QEAmount()
         self._extraFee = QEAmount()
         self._canRbf = False
+        self._deadline = 0  # if deadline is set > 0, finalizer should only allow ETA feepolicies
 
     addressChanged = pyqtSignal()
     @pyqtProperty(str, notify=addressChanged)
@@ -462,6 +463,22 @@ def canRbf(self, canRbf):
             self.canRbfChanged.emit()
         self.rbf = self._canRbf  # if we can RbF, we do RbF
 
+    deadlineChanged = pyqtSignal()
+    @pyqtProperty(int, notify=deadlineChanged)
+    def deadline(self):
+        return self._deadline
+
+    @deadline.setter
+    def deadline(self, relative_num_blocks: int) -> None:
+        """if set, limits the finalizer to ETA fee policies that meet the deadline.
+           deadline is in relative blocks"""
+        if self._deadline != relative_num_blocks:
+            self._deadline = relative_num_blocks
+            self.deadlineChanged.emit()
+            if self._deadline > 0:
+                self.method = FeeSlider.FSMethod.ETA
+            self.update()
+
     @profiler
     def make_tx(self, amount: int | str) -> PartialTransaction:
         self._logger.debug(f'make_tx amount={amount}')
@@ -508,6 +525,14 @@ def update(self):
             self.validChanged.emit()
             return
 
+        if self._deadline:
+            if self._deadline < self._fee_policy.value:
+                self._logger.info(f"current fee '{str(self._fee_policy)}' below deadline {str(self._deadline)}")
+                self.warning = _("Current fee doesn't meet deadline of {} blocks").format(self._deadline)
+                self._valid = False
+                self.validChanged.emit()
+                return
+
         self._tx = tx
 
         amount = self._amount.satsInt if not self._amount.isMax else tx.output_value()

electrum/submarine_swaps.py

@@ -70,6 +70,7 @@
 assert MAX_LOCKTIME_DELTA < lnutil.MIN_FINAL_CLTV_DELTA_ACCEPTED
 assert MAX_LOCKTIME_DELTA < MIN_FINAL_CLTV_DELTA_FOR_CLIENT
 
+LOCKTIME_DELTA_REFUND_BUFFER = 10  # used for min ETA fee calculation
 
 # The script of the reverse swaps has one extra check in it to verify
 # that the length of the preimage is 32. This is required because in