batch payment manager:

The class TxBatcher handles the creation, broadcast and replacement
of replaceable transactions. Callers (LNWatcher, SwapManager) use
methods add_payment_output and add_sweep_info. Transactions
created by TxBatcher may combine sweeps and outgoing payments.

TxBatcher is always used when sweeping. When sending outgoing
payments with the GUI, its use is conditional to the config variable
WALLET_BATCH_RBF. This means that this config variable essentially
becomes a GUI setting.

Transactions created by TxBatcher will have their fee bumped
automatically (this was only the case for sweeps before).

    wallet:
     - instead of reading config variables, make_unsigned_transaction
       takes new parameters: base_tx, send_change_to_lighting

   tests:
     - add tests in test_txbatcher.py
     - remove test_sswaps.py
     - force regtests to use MPP, so that we sweep transactions with
       several HTLCs. This forces the payment manager to aggregate
       HTLC tx inputs.

   GUI:
    - if coin control is active, disable batching
    - forward submarine swaps can be batched

Note: If batching is enabled, the GUI will not merge duplicate
outputs. To enable that, we would need extra logic that matches
txbatcher._base_tx outputs to txbatcher.batch_payments
(Note that this is also what we would need in order to make payments
robust to reorgs, so it might be worth considering at one point.)

Author: ecdsa

electrum/gui/qt/confirm_tx_dialog.py

@@ -77,7 +77,7 @@ def __init__(self, *, title='',
         self.no_dynfee_estimates = False
         self.needs_update = False
         # preview is disabled for lightning channel funding
-        self.allow_preview = allow_preview
+        self._allow_preview = allow_preview
         self.is_preview = False
 
         self.locktime_e = LockTimeEdit(self)
@@ -103,14 +103,20 @@ def __init__(self, *, title='',
         vbox.addStretch(1)
         vbox.addLayout(buttons)
 
-        self.set_io_visible(self.config.GUI_QT_TX_EDITOR_SHOW_IO)
+        self.set_io_visible()
         self.set_fee_edit_visible(self.config.GUI_QT_TX_EDITOR_SHOW_FEE_DETAILS)
         self.set_locktime_visible(self.config.GUI_QT_TX_EDITOR_SHOW_LOCKTIME)
         self.update_fee_target()
         self.resize(self.layout().sizeHint())
 
         self.main_window.gui_object.timer.timeout.connect(self.timer_actions)
 
+    def is_batching(self):
+        return self.config.WALLET_BATCH_RBF and not self.main_window.utxo_list.is_coincontrol_active()
+
+    def should_show_io(self):
+        return self.config.GUI_QT_TX_EDITOR_SHOW_IO
+
     def timer_actions(self):
         if self.needs_update:
             self.update()
@@ -363,10 +369,13 @@ def update_fee_fields(self):
         # feerate_label needs to be updated from feerate_e
         self.update_feerate_label()
 
+    def allow_preview(self):
+        return self._allow_preview and not self.is_batching()
+
     def create_buttons_bar(self):
         self.preview_button = QPushButton(_('Preview'))
         self.preview_button.clicked.connect(self.on_preview)
-        self.preview_button.setVisible(self.allow_preview)
+        self.preview_button.setVisible(self.allow_preview())
         self.ok_button = QPushButton(_('OK'))
         self.ok_button.clicked.connect(self.on_send)
         self.ok_button.setDefault(True)
@@ -450,7 +459,10 @@ def toggle_multiple_change(self):
     def toggle_batch_rbf(self):
         b = not self.config.WALLET_BATCH_RBF
         self.config.WALLET_BATCH_RBF = b
+        self.set_io_visible()
+        self.resize_to_fit_content()
         self.trigger_update()
+        self.preview_button.setVisible(self.allow_preview())
 
     def toggle_merge_duplicate_outputs(self):
         b = not self.config.WALLET_MERGE_DUPLICATE_OUTPUTS
@@ -470,7 +482,7 @@ def toggle_confirmed_only(self):
     def toggle_io_visibility(self):
         b = not self.config.GUI_QT_TX_EDITOR_SHOW_IO
         self.config.GUI_QT_TX_EDITOR_SHOW_IO = b
-        self.set_io_visible(b)
+        self.set_io_visible()
         self.resize_to_fit_content()
 
     def toggle_fee_details(self):
@@ -485,7 +497,8 @@ def toggle_locktime(self):
         self.set_locktime_visible(b)
         self.resize_to_fit_content()
 
-    def set_io_visible(self, b):
+    def set_io_visible(self):
+        b = self.should_show_io()
         self.io_widget.setVisible(b)
 
     def set_fee_edit_visible(self, b):
@@ -552,31 +565,33 @@ def get_messages(self):
         assert fee is not None
         amount = self.tx.output_value() if self.output_value == '!' else self.output_value
         tx_size = self.tx.estimated_size()
-        fee_warning_tuple = self.wallet.get_tx_fee_warning(
-            invoice_amt=amount, tx_size=tx_size, fee=fee)
-        if fee_warning_tuple:
-            allow_send, long_warning, short_warning = fee_warning_tuple
-            if not allow_send:
-                self.error = long_warning
-            else:
-                messages.append(long_warning)
-        if self.tx.has_dummy_output(DummyAddress.SWAP):
+        if not self.is_batching():
+            fee_warning_tuple = self.wallet.get_tx_fee_warning(
+                invoice_amt=amount, tx_size=tx_size, fee=fee)
+            if fee_warning_tuple:
+                allow_send, long_warning, short_warning = fee_warning_tuple
+                if not allow_send:
+                    self.error = long_warning
+                else:
+                    messages.append(long_warning)
+        if self.tx.get_dummy_output(DummyAddress.SWAP):
             messages.append(_('This transaction will send funds to a submarine swap.'))
         # warn if spending unconf
         if any((txin.block_height is not None and txin.block_height<=0) for txin in self.tx.inputs()):
             messages.append(_('This transaction will spend unconfirmed coins.'))
         # warn if we merge from mempool
-        if self.tx.rbf_merge_txid:
-            messages.append(_('This payment will be merged with another existing transaction.'))
-        # warn if we use multiple change outputs
-        num_change = sum(int(o.is_change) for o in self.tx.outputs())
-        num_ismine = sum(int(o.is_mine) for o in self.tx.outputs())
-        if num_change > 1:
-            messages.append(_('This transaction has {} change outputs.'.format(num_change)))
-        # warn if there is no ismine output, as it might be problematic to RBF the tx later.
-        # (though RBF is still possible by adding new inputs, if the wallet has more utxos)
-        if num_ismine == 0:
-            messages.append(_('Make sure you pay enough mining fees; you will not be able to bump the fee later.'))
+        if self.is_batching():
+            messages.append(_('Transaction batching is active. The fee will be bumped automatically if needed'))
+        else:
+            # warn if we use multiple change outputs
+            num_change = sum(int(o.is_change) for o in self.tx.outputs())
+            num_ismine = sum(int(o.is_mine) for o in self.tx.outputs())
+            if num_change > 1:
+                messages.append(_('This transaction has {} change outputs.'.format(num_change)))
+            # warn if there is no ismine output, as it might be problematic to RBF the tx later.
+            # (though RBF is still possible by adding new inputs, if the wallet has more utxos)
+            if num_ismine == 0:
+                messages.append(_('Make sure you pay enough mining fees; you will not be able to bump the fee later.'))
 
         # TODO: warn if we send change back to input address
         return messages
@@ -637,16 +652,17 @@ def _update_amount_label(self):
     def update_tx(self, *, fallback_to_zero_fee: bool = False):
         fee_estimator = self.get_fee_estimator()
         confirmed_only = self.config.WALLET_SPEND_CONFIRMED_ONLY
+        is_batching = self.is_batching()
         try:
-            self.tx = self.make_tx(fee_estimator, confirmed_only=confirmed_only)
+            self.tx = self.make_tx(fee_estimator, confirmed_only=confirmed_only, is_batching=is_batching)
             self.not_enough_funds = False
             self.no_dynfee_estimates = False
         except NotEnoughFunds:
             self.not_enough_funds = True
             self.tx = None
             if fallback_to_zero_fee:
                 try:
-                    self.tx = self.make_tx(0, confirmed_only=confirmed_only)
+                    self.tx = self.make_tx(0, confirmed_only=confirmed_only, is_batching=is_batching)
                 except BaseException:
                     return
             else:
@@ -655,7 +671,7 @@ def update_tx(self, *, fallback_to_zero_fee: bool = False):
             self.no_dynfee_estimates = True
             self.tx = None
             try:
-                self.tx = self.make_tx(0, confirmed_only=confirmed_only)
+                self.tx = self.make_tx(0, confirmed_only=confirmed_only, is_batching=is_batching)
             except NotEnoughFunds:
                 self.not_enough_funds = True
                 return
@@ -670,7 +686,7 @@ def update_tx(self, *, fallback_to_zero_fee: bool = False):
     def can_pay_assuming_zero_fees(self, confirmed_only) -> bool:
         # called in send_tab.py
         try:
-            tx = self.make_tx(0, confirmed_only=confirmed_only)
+            tx = self.make_tx(0, confirmed_only=confirmed_only, is_batching=False)
         except NotEnoughFunds:
             return False
         else:

electrum/gui/qt/main_window.py

@@ -460,6 +460,11 @@ def on_event_channel(self, *args):
     def on_event_banner(self, *args):
         self.console.showMessage(args[0])
 
+    @qt_event_listener
+    def on_event_adb_set_future_tx(self, adb, txid):
+        if adb == self.wallet.adb:
+            self.history_model.refresh('set_future_tx')
+
     @qt_event_listener
     def on_event_verified(self, *args):
         wallet, tx_hash, tx_mined_status = args
@@ -1417,7 +1422,7 @@ def confirm_tx_dialog(self, make_tx, output_value, allow_preview=True):
                 text = self.send_tab.get_text_not_enough_funds_mentioning_frozen()
                 self.show_message(text)
                 return
-        return d.run(), d.is_preview
+        return d.run(), d.is_preview, d.is_batching()
 
     @protected
     def _open_channel(self, connect_str, funding_sat, push_amt, funding_tx, password):

electrum/gui/qt/send_tab.py

@@ -317,34 +317,64 @@ def pay_onchain_dialog(
         # we call get_coins inside make_tx, so that inputs can be changed dynamically
         if get_coins is None:
             get_coins = self.window.get_coins
-        make_tx = lambda fee_est, *, confirmed_only=False: self.wallet.make_unsigned_transaction(
-            coins=get_coins(nonlocal_only=nonlocal_only, confirmed_only=confirmed_only),
-            outputs=outputs,
-            fee=fee_est,
-            is_sweep=is_sweep)
+
+        def make_tx(fee_est, *, confirmed_only=False, is_batching=False):
+            base_tx = self.wallet.txbatcher.get_base_tx() if is_batching else None
+            merge_duplicate_outputs = self.config.WALLET_MERGE_DUPLICATE_OUTPUTS if not is_batching else False
+            coins = get_coins(nonlocal_only=nonlocal_only, confirmed_only=confirmed_only)
+            return self.wallet.make_unsigned_transaction(
+                coins=coins,
+                outputs=outputs,
+                base_tx=base_tx,
+                fee=fee_est,
+                is_sweep=is_sweep,
+                send_change_to_lightning=self.config.WALLET_SEND_CHANGE_TO_LIGHTNING,
+                merge_duplicate_outputs=merge_duplicate_outputs,
+            )
+
         output_values = [x.value for x in outputs]
         is_max = any(parse_max_spend(outval) for outval in output_values)
         output_value = '!' if is_max else sum(output_values)
 
-        tx, is_preview = self.window.confirm_tx_dialog(make_tx, output_value)
+        tx, is_preview, is_batching = self.window.confirm_tx_dialog(make_tx, output_value)
         if tx is None:
             # user cancelled
             return
 
-        if tx.has_dummy_output(DummyAddress.SWAP):
+        if swap_dummy_output := tx.get_dummy_output(DummyAddress.SWAP):
             sm = self.wallet.lnworker.swap_manager
             with self.window.create_sm_transport() as transport:
                 if not self.window.initialize_swap_manager(transport):
                     return
-                coro = sm.request_swap_for_tx(transport, tx)
+                coro = sm.request_swap_for_amount(transport, swap_dummy_output.value)
                 try:
-                    swap, invoice, tx = self.window.run_coroutine_dialog(coro, _('Requesting swap invoice...'))
+                    swap, invoice = self.window.run_coroutine_dialog(coro, _('Requesting swap invoice...'))
                 except SwapServerError as e:
                     self.show_error(str(e))
                     return
-                assert not tx.has_dummy_output(DummyAddress.SWAP)
-                tx.swap_invoice = invoice
-                tx.swap_payment_hash = swap.payment_hash
+
+                if is_batching:
+                    self.save_pending_invoice()
+                    funding_output = PartialTxOutput.from_address_and_value(swap.lockup_address, swap_dummy_output.value)
+                    coro = sm.wait_for_htlcs_and_broadcast(transport, swap=swap, invoice=invoice, output=funding_output)
+                    try:
+                        funding_txid = self.window.run_coroutine_dialog(coro, _('Awaiting lightning payment...'))
+                    except UserCancelled:
+                        sm.cancel_normal_swap(swap)
+                        return
+                    self.window.on_swap_result(funding_txid, is_reverse=False)
+                    return
+                else:
+                    tx.replace_output_address(DummyAddress.SWAP, swap.lockup_address)
+                    assert tx.get_dummy_output(DummyAddress.SWAP) is None
+                    tx.swap_invoice = invoice
+                    tx.swap_payment_hash = swap.payment_hash
+
+        if is_batching:
+            self.save_pending_invoice()
+            for output in outputs:
+                self.wallet.txbatcher.add_batch_payment(output)
+            return
 
         if is_preview:
             self.window.show_transaction(tx, external_keypairs=external_keypairs, payment_identifier=payment_identifier)

electrum/gui/qt/utxo_list.py

@@ -223,6 +223,9 @@ def get_spend_list(self) -> Optional[Sequence[PartialTxInput]]:
         utxos = [self._utxo_dict[x] for x in self._spend_set]
         return copy.deepcopy(utxos)  # copy so that side-effects don't affect utxo_dict
 
+    def is_coincontrol_active(self):
+        return bool(self._spend_set)
+
     def _maybe_reset_coincontrol(self, current_wallet_utxos: Sequence[PartialTxInput]) -> None:
         if not bool(self._spend_set):
             return