move unsigned tx making

oren-z0 · oren-z0 · commit dfbcea0f6815 · 2025-03-03T18:53:33.000+02:00
diff --git a/electrum/plugins/timelock_recovery/qt.py b/electrum/plugins/timelock_recovery/qt.py
@@ -31,28 +31,27 @@
 from electrum.gui.common_qt.util import draw_qr
 from electrum.gui.fonts import get_font_id
 from electrum.gui.qt.paytoedit import PayToEdit
-from electrum.bitcoin import COIN, address_to_script, DummyAddress
+from electrum.bitcoin import DummyAddress
 from electrum.payment_identifier import PaymentIdentifierType
 from electrum.plugin import hook, run_hook
 from electrum.i18n import _
-from electrum.transaction import PartialTxInput, PartialTxOutput, TxOutpoint
-from electrum.util import make_dir, bfh
+from electrum.transaction import PartialTxOutput
+from electrum.util import make_dir
 from electrum.gui.qt.util import ColorScheme, WindowModalDialog, Buttons, HelpLabel
 from electrum.gui.qt.main_window import StatusBarButton
 from electrum.gui.qt.util import read_QIcon_from_bytes, read_QPixmap_from_bytes
 
 from . import version as plugin_version
-from .timelock_recovery import TimelockRecoveryPlugin, TimelockRecoveryContext, PartialTxInputWithFixedNsequence
+from .timelock_recovery import TimelockRecoveryPlugin, TimelockRecoveryContext
 
 
 if TYPE_CHECKING:
     from electrum.gui.qt import ElectrumGui
-    from electrum.transaction import PartialTransaction, TxOutput
+    from electrum.transaction import PartialTransaction
     from PyQt6.QtWidgets import QStatusBar
 
 
 AGREEMENT_TEXT = "I understand that using this wallet after generating a Timelock Recovery plan might break the plan"
-ANCHOR_OUTPUT_AMOUNT_SATS = 600
 MIN_LOCKTIME_DAYS = 2
 # 0xFFFF * 512 seconds = 388.36 days.
 MAX_LOCKTIME_DAYS = 388
@@ -350,21 +349,9 @@ def _verify_step1_details(self, context: TimelockRecoveryContext, next_button: Q
         next_button.setEnabled(True)
 
     def create_alert_fee_dialog(self, context: TimelockRecoveryContext):
-        alert_transaction_outputs = [
-            PartialTxOutput(scriptpubkey=address_to_script(context.get_alert_address()), value='!'),
-        ] + [
-            PartialTxOutput(scriptpubkey=output.scriptpubkey, value=ANCHOR_OUTPUT_AMOUNT_SATS)
-            for output in context.outputs
-        ]
-        make_tx = lambda fee_est, *, confirmed_only=False: context.wallet.make_unsigned_transaction(
-            coins=context.main_window.get_coins(confirmed_only=confirmed_only),
-            outputs=alert_transaction_outputs,
-            fee=fee_est,
-            is_sweep=False,
-        )
         tx: Optional['PartialTransaction']
         is_preview: bool
-        tx, is_preview = context.main_window.confirm_tx_dialog(make_tx, '!', allow_preview=False)
+        tx, is_preview = context.main_window.confirm_tx_dialog(context.make_unsigned_alert_tx, '!', allow_preview=False)
         if tx is None or is_preview or tx.has_dummy_output(DummyAddress.SWAP):
             return
         if not tx.is_segwit():
@@ -392,39 +379,9 @@ def sign_done(success: bool):
         )
 
     def create_recovery_fee_dialog(self, context: TimelockRecoveryContext):
-        prevouts: List[Tuple[int, 'TxOutput']] = [
-            (index, tx_output) for index, tx_output in enumerate(context.alert_tx.outputs())
-            if tx_output.address == context.get_alert_address() and tx_output.value != ANCHOR_OUTPUT_AMOUNT_SATS
-        ]
-        if len(prevouts) != 1:
-            context.main_window.show_error(_("Expected 1 output from the Alert transaction to the Alert Address, but got %d." % len(prevouts)))
-            return
-        prevout_index: int
-        prevout: 'TxOutput'
-        (prevout_index, prevout) = prevouts[0]
-
-        nsequence: int = round(context.timelock_days * 24 * 60 * 60 / 512)
-        if nsequence > 0xFFFF:
-            # Safety check - not expected to happen
-            raise ValueError("Sequence number is too large")
-        nsequence += 0x00400000 # time based lock instead of block-height based lock
-        tx_input = PartialTxInputWithFixedNsequence(
-            prevout=TxOutpoint(txid=bfh(context.alert_tx.txid()), out_idx=prevout_index),
-            nsequence=nsequence,
-        )
-        tx_input.utxo = context.alert_tx
-        tx_input.witness_utxo = prevout
-
-        make_tx = lambda fee_est, *, confirmed_only=False: context.wallet.make_unsigned_transaction(
-            coins=[tx_input],
-            outputs=[output for output in context.outputs if output.value != 0],
-            fee=fee_est,
-            is_sweep=False,
-        )
-
         tx: Optional['PartialTransaction']
         is_preview: bool
-        tx, is_preview = context.main_window.confirm_tx_dialog(make_tx, '!', allow_preview=False)
+        tx, is_preview = context.main_window.confirm_tx_dialog(context.make_unsigned_recovery_tx, '!', allow_preview=False)
         if tx is None or is_preview or tx.has_dummy_output(DummyAddress.SWAP):
             return
         if not tx.is_segwit():
@@ -545,33 +502,9 @@ def create_cancellation_dialog(self, context: TimelockRecoveryContext):
         return bool(cancel_dialog.exec())
 
     def create_cancellation_fee_dialog(self, context: TimelockRecoveryContext):
-        prevouts = [
-            (index, tx_output) for index, tx_output in enumerate(context.alert_tx.outputs())
-            if tx_output.address == context.get_alert_address() and tx_output.value != ANCHOR_OUTPUT_AMOUNT_SATS
-        ]
-        if len(prevouts) != 1:
-            context.main_window.show_error(_("Expected 1 output from the Alert transaction to the Alert Address, but got %d." % len(prevouts)))
-            return
-        (prevout_index, prevout) = prevouts[0]
-
-        tx_input = PartialTxInput(
-            prevout=TxOutpoint(txid=bfh(context.alert_tx.txid()), out_idx=prevout_index),
-        )
-        tx_input.utxo = context.alert_tx
-        tx_input.witness_utxo = prevout
-
-        make_tx = lambda fee_est, *, confirmed_only=False: context.wallet.make_unsigned_transaction(
-            coins=[tx_input],
-            outputs=[
-                PartialTxOutput(scriptpubkey=address_to_script(context.get_cancellation_address()), value='!'),
-            ],
-            fee=fee_est,
-            is_sweep=False,
-        )
-
         tx: Optional['PartialTransaction']
         is_preview: bool
-        tx, is_preview = context.main_window.confirm_tx_dialog(make_tx, '!', allow_preview=False)
+        tx, is_preview = context.main_window.confirm_tx_dialog(context.make_unsigned_cancellation_tx, '!', allow_preview=False)
         if tx is None or is_preview or tx.has_dummy_output(DummyAddress.SWAP):
             return
         if not tx.is_segwit():
@@ -733,7 +666,7 @@ def _save_recovery_plan_json(self, context: TimelockRecoveryContext, download_di
                     "wallet_version": version.ELECTRUM_VERSION,
                     "wallet_name": context.wallet_name,
                     "timelock_days": context.timelock_days,
-                    "anchor_amount_sats": ANCHOR_OUTPUT_AMOUNT_SATS,
+                    "anchor_amount_sats": context.ANCHOR_OUTPUT_AMOUNT_SATS,
                     "anchor_addresses": [output.address for output in context.outputs],
                     "alert_address": context.get_alert_address(),
                     "alert_inputs": [tx_input.prevout.to_str() for tx_input in context.alert_tx.inputs()],
@@ -935,7 +868,7 @@ def _save_recovery_plan_pdf(self, context: TimelockRecoveryContext, download_dia
                     f"as we'll explain later):\n"
                 )
                 for output in context.alert_tx.outputs():
-                    if output.address != context.get_alert_address() and output.value == ANCHOR_OUTPUT_AMOUNT_SATS:
+                    if output.address != context.get_alert_address() and output.value == context.ANCHOR_OUTPUT_AMOUNT_SATS:
                         step1_text += f"• {output.address}\n"
             else:
                 step1_text += "except for a small fee.\n"
diff --git a/electrum/plugins/timelock_recovery/timelock_recovery.py b/electrum/plugins/timelock_recovery/timelock_recovery.py
@@ -1,11 +1,13 @@
 from datetime import datetime
-from typing import TYPE_CHECKING, List, Optional
+from typing import TYPE_CHECKING, List, Optional, Tuple
+from electrum.bitcoin import address_to_script
 from electrum.plugin import BasePlugin
-from electrum.transaction import PartialTxInput
+from electrum.transaction import PartialTxOutput, PartialTxInput, TxOutpoint
+from electrum.util import bfh
 
 if TYPE_CHECKING:
     from electrum.gui.qt import ElectrumWindow
-    from electrum.transaction import PartialTxOutput, PartialTransaction
+    from electrum.transaction import PartialTransaction, TxOutput
     from electrum.wallet import Abstract_Wallet
 
 ALERT_ADDRESS_LABEL = "Timelock Recovery Alert Address"
@@ -40,6 +42,11 @@ class TimelockRecoveryContext:
     recovery_plan_created_at: Optional[datetime] = None
     _alert_address: Optional[str] = None
     _cancellation_address: Optional[str] = None
+    _alert_tx_outputs: Optional[List[PartialTxOutput]] = None
+    _recovery_tx_input: Optional[PartialTxInputWithFixedNsequence] = None
+    _cancellation_tx_input: Optional[PartialTxInput] = None
+
+    ANCHOR_OUTPUT_AMOUNT_SATS = 600
 
     def __init__(self, main_window: 'ElectrumWindow'):
         self.main_window = main_window
@@ -72,6 +79,74 @@ def get_cancellation_address(self) -> str:
             self._cancellation_address = self._get_address_by_label(CANCELLATION_ADDRESS_LABEL)
         return self._cancellation_address
 
+    def make_unsigned_alert_tx(self, fee_est, *, confirmed_only=False) -> 'PartialTransaction':
+        if self._alert_tx_outputs is None:
+            self._alert_tx_outputs = [
+                PartialTxOutput(scriptpubkey=address_to_script(self.get_alert_address()), value='!'),
+            ] + [
+                PartialTxOutput(scriptpubkey=output.scriptpubkey, value=self.ANCHOR_OUTPUT_AMOUNT_SATS)
+                for output in self.outputs
+            ]
+        return self.wallet.make_unsigned_transaction(
+            coins=self.main_window.get_coins(confirmed_only=confirmed_only),
+            outputs=self._alert_tx_outputs,
+            fee=fee_est,
+            is_sweep=False,
+        )
+
+    def _alert_tx_output(self) -> Tuple[int, 'TxOutput']:
+        tx_outputs: List[Tuple[int, 'TxOutput']] = [
+            (index, tx_output) for index, tx_output in enumerate(self.alert_tx.outputs())
+            if tx_output.address == self.get_alert_address() and tx_output.value != self.ANCHOR_OUTPUT_AMOUNT_SATS
+        ]
+        if len(tx_outputs) != 1:
+            # Safety check - not expected to happen
+            raise ValueError(f"Expected 1 output from the Alert transaction to the Alert Address, but got {len(tx_outputs)}.")
+        return tx_outputs[0]
+
+    def _alert_tx_outpoint(self, out_idx: int) -> TxOutpoint:
+        return TxOutpoint(txid=bfh(self.alert_tx.txid()), out_idx=out_idx)
+
+    def make_unsigned_recovery_tx(self, fee_est, *, confirmed_only=False) -> 'PartialTransaction':
+        if self._recovery_tx_input is None:
+            prevout_index, prevout = self._alert_tx_output()
+            nsequence: int = round(self.timelock_days * 24 * 60 * 60 / 512)
+            if nsequence > 0xFFFF:
+                # Safety check - not expected to happen
+                raise ValueError("Sequence number is too large")
+            nsequence += 0x00400000 # time based lock instead of block-height based lock
+            self._recovery_tx_input = PartialTxInputWithFixedNsequence(
+                prevout=self._alert_tx_outpoint(prevout_index),
+                nsequence=nsequence,
+            )
+            self._recovery_tx_input.utxo = self.alert_tx
+            self._recovery_tx_input.witness_utxo = prevout
+
+        return self.wallet.make_unsigned_transaction(
+            coins=[self._recovery_tx_input],
+            outputs=[output for output in self.outputs if output.value != 0],
+            fee=fee_est,
+            is_sweep=False,
+        )
+
+    def make_unsigned_cancellation_tx(self, fee_est, *, confirmed_only=False) -> 'PartialTransaction':
+        if self._cancellation_tx_input is None:
+            prevout_index, prevout = self._alert_tx_output()
+            self._cancellation_tx_input = PartialTxInput(
+                prevout=self._alert_tx_outpoint(prevout_index),
+            )
+            self._cancellation_tx_input.utxo = self.alert_tx
+            self._cancellation_tx_input.witness_utxo = prevout
+
+        return self.wallet.make_unsigned_transaction(
+            coins=[self._cancellation_tx_input],
+            outputs=[
+                PartialTxOutput(scriptpubkey=address_to_script(self.get_cancellation_address()), value='!'),
+            ],
+            fee=fee_est,
+            is_sweep=False,
+        )
+
 class TimelockRecoveryPlugin(BasePlugin):
     def __init__(self, parent, config, name):
         BasePlugin.__init__(self, parent, config, name)
