move bump_fee logic to payment_manager:

 - allow base_tx to sign several times

Author: ecdsa

electrum/submarine_swaps.py

@@ -346,7 +346,6 @@ async def _claim_swap(self, swap: SwapData) -> None:
             self._add_or_reindex_swap(swap)  # to update _swaps_by_funding_outpoint
             funding_height = self.lnwatcher.adb.get_tx_height(txin.prevout.txid.hex())
             spent_height = txin.spent_height
-            should_bump_fee = False
             if spent_height is not None:
                 swap.spending_txid = txin.spent_txid
                 if spent_height > 0:
@@ -388,13 +387,6 @@ async def _claim_swap(self, swap: SwapData) -> None:
                             self.logger.info(f'refund tx confirmed: {txin.spent_txid} {spent_height}')
                             self._fail_swap(swap, 'refund tx confirmed')
                             return
-                        else:
-                            claim_tx.add_info_from_wallet(self.wallet)
-                            claim_tx_fee = claim_tx.get_fee()
-                            recommended_fee = self.get_claim_fee()
-                            if claim_tx_fee * 1.1 < recommended_fee:
-                                should_bump_fee = True
-                                self.logger.info(f'claim tx fee too low {claim_tx_fee} < {recommended_fee}. we will bump the fee')
 
                 if remaining_time > 0:
                     # too early for refund
@@ -423,7 +415,7 @@ async def _claim_swap(self, swap: SwapData) -> None:
                     # for testing: do not create claim tx
                     return
 
-            if spent_height is not None and not should_bump_fee:
+            if spent_height is not None:
                 return
             try:
                 txin, locktime = self._create_claim_txin(txin=txin, swap=swap, config=self.wallet.config)

electrum/transaction.py

@@ -1736,13 +1736,15 @@ def finalize(self) -> None:
         def clear_fields_when_finalized():
             # BIP-174: "All other data except the UTXO and unknown fields in the
             #           input key-value map should be cleared from the PSBT"
+            # FIXME: serialize() should not side-effect the tx inputs
             self.sigs_ecdsa = {}
             self.tap_key_sig = None
             self.tap_merkle_root = None
             self.sighash = None
             self.bip32_paths = {}
             self.redeem_script = None
-            self.witness_script = None
+            if not hasattr(self, 'make_witness'):
+                self.witness_script = None
 
         if self.script_sig is not None and self.witness is not None:
             clear_fields_when_finalized()

electrum/wallet.py

@@ -1879,8 +1879,10 @@ def make_unsigned_transaction(
                 # make sure we don't try to spend change from the tx-to-be-replaced:
                 coins = [c for c in coins if c.prevout.txid.hex() != base_tx.txid()]
                 is_local = self.adb.get_tx_height(base_tx.txid()).height == TX_HEIGHT_LOCAL
-                base_tx = PartialTransaction.from_tx(base_tx)
-                base_tx.add_info_from_wallet(self)
+                if not isinstance(base_tx, PartialTransaction):
+                    # don't do this with a PartialTransaction, as this is destructive
+                    base_tx = PartialTransaction.from_tx(base_tx)
+                    base_tx.add_info_from_wallet(self)
                 base_tx_fee = base_tx.get_fee()
                 base_feerate = Decimal(base_tx_fee)/base_tx.estimated_size()
                 relayfeerate = Decimal(self.relayfee()) / 1000
@@ -2550,11 +2552,13 @@ def sign_transaction(self, tx: Transaction, password, *, ignore_warnings: bool =
 
         for i, txin in enumerate(tx.inputs()):
             if hasattr(txin, 'make_witness'):
+                self.logger.info(f'sign_transaction: adding witness using make_witness')
                 privkey = txin.privkey
                 sig = tx.sign_txin(i, privkey)
                 assert sig
                 assert txin.witness_script
                 txin.witness = txin.make_witness(sig)
+                assert txin.is_complete()
 
         # check if signing is dangerous
         sh_danger = self.check_sighash(tx)
@@ -3339,6 +3343,18 @@ def to_sweep_after(self, tx):
         tx_prevouts = set(txin.prevout for txin in tx.inputs())
         return dict((k,v) for k,v in self.batch_inputs.items() if k not in tx_prevouts)
 
+    def should_bump_fee(self, base_tx):
+        # fixme: since batch_txs is not persisted, we do not bump after a restart
+        # fixme: we use estimated_size because create_transaction returns a PartialTransaction
+        if base_tx is None:
+            return False
+        base_tx_fee = base_tx.get_fee()
+        recommended_fee = self.config.estimate_fee(base_tx.estimated_size(), allow_fallback_to_static_rates=True)
+        should_bump_fee = base_tx_fee * 1.1 < recommended_fee
+        if should_bump_fee:
+            self.logger.info(f'base tx fee too low {base_tx_fee} < {recommended_fee}. we will bump the fee')
+        return should_bump_fee
+
     @log_exceptions
     async def manage_batch_payments(self):
         #
@@ -3386,7 +3402,7 @@ async def manage_batch_payments(self):
             to_pay = self.to_pay_after(base_tx)
             to_sweep = self.to_sweep_after(base_tx)
             to_sweep_now = dict([(k,v) for k,v in to_sweep.items() if self.can_broadcast(v)[0] is True])
-            if not to_pay and not to_sweep_now:
+            if not to_pay and not to_sweep_now and not self.should_bump_fee(base_tx):
                 continue
             try:
                 tx = self.create_batch_tx(base_tx, to_sweep_now, to_pay, password)