Payjoin tests

electrum/gui/qt/main_window.py

@@ -64,7 +64,7 @@
 from electrum.invoices import PR_TYPE_ONCHAIN, PR_TYPE_LN, PR_DEFAULT_EXPIRATION_WHEN_CREATING, Invoice
 from electrum.invoices import PR_PAID, PR_FAILED, pr_expiration_values, LNInvoice, OnchainInvoice
 from electrum.transaction import (Transaction, PartialTxInput,
-                                  PartialTransaction, PartialTxOutput)
+                                  PartialTransaction, PartialTxOutput, PayjoinTransaction)
 from electrum.address_synchronizer import AddTransactionException
 from electrum.wallet import (Multisig_Wallet, CannotBumpFee, Abstract_Wallet,
                              sweep_preparations, InternalAddressCorruption)
@@ -80,7 +80,7 @@
 from .amountedit import AmountEdit, BTCAmountEdit, FreezableLineEdit, FeerateEdit
 from .qrcodewidget import QRCodeWidget, QRDialog
 from .qrtextedit import ShowQRTextEdit, ScanQRTextEdit
-from .transaction_dialog import show_transaction
+from .transaction_dialog import show_transaction, PreviewTxDialog
 from .fee_slider import FeeSlider, FeeComboBox
 from .util import (read_QIcon, ColorScheme, text_dialog, icon_path, WaitingDialog,
                    WindowModalDialog, ChoicesLayout, HelpLabel, Buttons,
@@ -95,7 +95,6 @@
 from .update_checker import UpdateCheck, UpdateCheckThread
 from .channels_list import ChannelsList
 from .confirm_tx_dialog import ConfirmTxDialog
-from .transaction_dialog import PreviewTxDialog
 
 if TYPE_CHECKING:
     from . import ElectrumGui
@@ -1566,6 +1565,7 @@ def do_save_invoice(self):
 
     def do_pay(self):
         invoice = self.read_invoice()
+        print('main -invoice: ', invoice)#
         if not invoice:
             return
         self.wallet.save_invoice(invoice)
@@ -1585,7 +1585,7 @@ def do_pay_invoice(self, invoice: 'Invoice'):
             self.pay_lightning_invoice(invoice.invoice, amount_msat=invoice.get_amount_msat())
         elif invoice.type == PR_TYPE_ONCHAIN:
             assert isinstance(invoice, OnchainInvoice)
-            self.pay_onchain_dialog(self.get_coins(), invoice.outputs)
+            self.pay_onchain_dialog(self.get_coins(), invoice.outputs, payjoin=invoice.bip78_payjoin)
         else:
             raise Exception('unknown invoice type')
 
@@ -1605,6 +1605,7 @@ def get_manually_selected_coins(self) -> Optional[Sequence[PartialTxInput]]:
 
     def pay_onchain_dialog(self, inputs: Sequence[PartialTxInput],
                            outputs: List[PartialTxOutput], *,
+                           payjoin=None,
                            external_keypairs=None) -> None:
         # trustedcoin requires this
         if run_hook('abort_send', self):
@@ -1632,7 +1633,8 @@ def pay_onchain_dialog(self, inputs: Sequence[PartialTxInput],
         # shortcut to advanced preview (after "enough funds" check!)
         if self.config.get('advanced_preview'):
             self.preview_tx_dialog(make_tx=make_tx,
-                                   external_keypairs=external_keypairs)
+                                   external_keypairs=external_keypairs,
+                                   payjoin=payjoin)
             return
 
         cancelled, is_send, password, tx = d.run()
@@ -1646,11 +1648,13 @@ def sign_done(success):
                                        external_keypairs=external_keypairs)
         else:
             self.preview_tx_dialog(make_tx=make_tx,
-                                   external_keypairs=external_keypairs)
+                                   external_keypairs=external_keypairs,
+                                   payjoin=payjoin)
 
-    def preview_tx_dialog(self, *, make_tx, external_keypairs=None):
+    def preview_tx_dialog(self, *, make_tx, external_keypairs=None, payjoin=None):
+        print('preview_tx_dialog: ', payjoin)#
         d = PreviewTxDialog(make_tx=make_tx, external_keypairs=external_keypairs,
-                            window=self)
+                            window=self, payjoin=payjoin)
         d.show()
 
     def broadcast_or_show(self, tx: Transaction):
@@ -1726,7 +1730,46 @@ def broadcast_done(result):
 
         WaitingDialog(self, _('Broadcasting transaction...'),
                       broadcast_thread, broadcast_done, self.on_error)
+
+<<<<<<< Updated upstream
+=======
+    def exchange_psbt_http(self, payjoin):
+        """ """
+        import requests, copy
+        assert payjoin.is_complete()
+
+        print(payjoin.to_json())
+        print(payjoin.serialize_as_base64())
+
+        for txin in payjoin.inputs():
+            print(txin)
+            print(txin.utxo)
+            print(txin.utxo.outputs())
+            print
+            self.utxo.outputs()[self.prevout.out_idx]
+
+
+
+
+        url = 'https://testnet.demo.btcpayserver.org/BTC/pj'
+        payload = payjoin.serialize_as_base64()
+        headers = {'content-type': 'text/plain',
+                   'content-length': str(len(payload))
+                   }
+        print(headers)
+        """
+        try:
+            r = requests.post(url, data=payload, headers=headers)
+        except:
+            pass
+
+        print(payload)
+        print(r.status_code)
+        print(r.headers)
+        print(r.text)
+        """
 
+>>>>>>> Stashed changes
     def mktx_for_open_channel(self, funding_sat):
         coins = self.get_coins(nonlocal_only=True)
         make_tx = lambda fee_est: self.wallet.lnworker.mktx_for_open_channel(coins=coins,
@@ -1869,7 +1912,7 @@ def pay_to_URI(self, URI):
         if not URI:
             return
         try:
-            out = util.parse_URI(URI, self.on_pr)
+            out = util.parse_bip21_uri(URI, self.on_pr)
         except InvalidBitcoinURI as e:
             self.show_error(_("Error parsing URI") + f":\n{e}")
             return
@@ -1895,14 +1938,31 @@ def pay_to_URI(self, URI):
         if amount:
             self.amount_e.setAmount(amount)
             self.amount_e.textEdited.emit("")
-
+        self._set_payjoin_availability(self.payto_URI)
+
+    def _set_payjoin_availability(self, out):
+        """  """
+        pj = out.get('pj')
+        pjos = out.get('pjos')
+        print('pj in main:', pj)#
+        print('pjos in main:', pjos)#
+        if pj:
+            self.pj_available = True
+            self.pj = pj
+            self.pjos = pjos
+        else:
+            self.pj_available = False
+        print('pj_available in main:', self.pj_available)#
 
     def do_clear(self):
         self.max_button.setChecked(False)
         self.payment_request = None
         self.payto_URI = None
         self.payto_e.is_pr = False
         self.set_onchain(False)
+        self.pj_available = False
+        self.pj = None
+        self.pjos = None
         for e in [self.payto_e, self.message_e, self.amount_e]:
             e.setText('')
             e.setFrozen(False)

electrum/gui/qt/transaction_dialog.py

@@ -45,7 +45,8 @@
 from electrum.i18n import _
 from electrum.plugin import run_hook
 from electrum import simple_config
-from electrum.transaction import SerializationError, Transaction, PartialTransaction, PartialTxInput
+from electrum.transaction import (SerializationError, Transaction, PartialTransaction, PartialTxInput, PayjoinTransaction,
+                                  PayJoinProposalValidationException, PayJoinExchangeException)
 from electrum.logging import get_logger
 
 from .util import (MessageBoxMixin, read_QIcon, Buttons, icon_path,
@@ -92,7 +93,7 @@ def show_transaction(tx: Transaction, *, parent: 'ElectrumWindow', desc=None, pr
 
 class BaseTxDialog(QDialog, MessageBoxMixin):
 
-    def __init__(self, *, parent: 'ElectrumWindow', desc, prompt_if_unsaved, finalized: bool, external_keypairs=None):
+    def __init__(self, *, parent: 'ElectrumWindow', desc, prompt_if_unsaved, finalized: bool, external_keypairs=None, payjoin=None):
         '''Transactions in the wallet will show their description.
         Pass desc to give a description for txs not yet in the wallet.
         '''
@@ -105,6 +106,10 @@ def __init__(self, *, parent: 'ElectrumWindow', desc, prompt_if_unsaved, finaliz
         self.config = parent.config
         self.wallet = parent.wallet
         self.prompt_if_unsaved = prompt_if_unsaved
+
+        self.payjoin = PayjoinTransaction(payjoin)
+        self.payjoin_finished = False
+
         self.saved = False
         self.desc = desc
         self.setMinimumWidth(950)
@@ -217,7 +222,46 @@ def set_tx(self, tx: 'Transaction'):
         # note: this might fetch prev txs over the network.
         tx.add_info_from_wallet(self.wallet)
 
-    def do_broadcast(self):
+    def do_payjoin(self) -> None:
+        def sign_done(success):
+            self.payjoin_finished = True
+            if self.tx.get_fee_rate() < self.payjoin._minfeerate:
+                self.set_tx(original_tx)
+                _logger.warning("The receiver used a too low fee rate.")
+                self.show_error(
+                    _("Error creating a payjoin") + ":\n" +
+                    _("The receiver used a too low fee rate") + "\n" +
+                    _("Sending the original transaction"))
+            self.update()
+            self.main_window.pop_top_level_window(self)
+            self.do_broadcast()
+
+        self.main_window.push_top_level_window(self)
+        original_tx = copy.deepcopy(self.tx)
+        _logger.info(f"Starting Payjoin Session")
+        try:
+            self.payjoin.set_tx(self.tx)
+            print('tx1: ',self.tx.to_json())#
+            self.payjoin.do_payjoin()
+            print('tx2: ', self.payjoin.payjoin_proposal.to_json())  #
+            self.payjoin.payjoin_proposal.add_info_from_wallet(self.wallet)
+            print('tx3: ', self.payjoin.payjoin_proposal.to_json())  #
+            self.payjoin.validate_payjoin_proposal()
+        except (PayJoinProposalValidationException, PayJoinExchangeException) as e:
+            _logger.warning(repr(e))
+            self.payjoin_cb.setChecked(False)
+            self.show_error(_("Error creating a payjoin") + ":\n" + str(e) + "\n" +
+                            _("Sending the original transaction"))
+            self.do_broadcast()
+            return
+        tx = self.payjoin.payjoin_proposal
+        self.set_tx(tx)
+        self.main_window.sign_tx(self.tx, callback=sign_done, external_keypairs=self.external_keypairs)
+
+    def do_broadcast(self) -> None:
+        if self.payjoin_cb.isChecked() and self.payjoin.is_available() and not self.payjoin_finished:
+            self.do_payjoin()
+            return
         self.main_window.push_top_level_window(self)
         try:
             self.main_window.broadcast_transaction(self.tx)
@@ -641,6 +685,12 @@ def add_tx_stats(self, vbox):
 
         self.block_height_label = TxDetailLabel()
         vbox_right.addWidget(self.block_height_label)
+
+        self.payjoin_cb = QCheckBox(_('PayJoin'))
+        self.payjoin_cb.setChecked(bool(self.config.get('use_payjoin', True)))
+        vbox_right.addWidget(self.payjoin_cb)
+        #visibility
+
         vbox_right.addStretch(1)
         hbox_stats.addLayout(vbox_right, 50)
 
@@ -653,6 +703,7 @@ def add_tx_stats(self, vbox):
         # set visibility after parenting can be determined by Qt
         self.rbf_label.setVisible(self.finalized)
         self.rbf_cb.setVisible(not self.finalized)
+        self.payjoin_cb.setVisible(self.payjoin.is_available())
         self.locktime_final_label.setVisible(self.finalized)
         self.locktime_setter_widget.setVisible(not self.finalized)
 
@@ -687,10 +738,11 @@ def __init__(self, tx: Transaction, *, parent: 'ElectrumWindow', desc, prompt_if
 
 class PreviewTxDialog(BaseTxDialog, TxEditor):
 
-    def __init__(self, *, make_tx, external_keypairs, window: 'ElectrumWindow'):
+    def __init__(self, *, make_tx, external_keypairs, window: 'ElectrumWindow', payjoin):
         TxEditor.__init__(self, window=window, make_tx=make_tx, is_sweep=bool(external_keypairs))
         BaseTxDialog.__init__(self, parent=window, desc='', prompt_if_unsaved=False,
-                              finalized=False, external_keypairs=external_keypairs)
+                              finalized=False, external_keypairs=external_keypairs, payjoin=payjoin)
+        print('pj_available in Preview dialog: ', payjoin)#
         BlockingWaitingDialog(window, _("Preparing transaction..."),
                               lambda: self.update_tx(fallback_to_zero_fee=True))
         self.update()

electrum/invoices.py

@@ -120,6 +120,7 @@ class OnchainInvoice(Invoice):
     outputs = attr.ib(kw_only=True, converter=_decode_outputs)  # type: List[PartialTxOutput]
     bip70 = attr.ib(type=str, kw_only=True)  # type: Optional[str]
     requestor = attr.ib(type=str, kw_only=True)  # type: Optional[str]
+    bip78_payjoin = attr.ib(type=Dict, kw_only=True, default=None)  # type: Optional[Dict]   
 
     def get_address(self) -> str:
         assert len(self.outputs) == 1

electrum/plugins/hw_wallet/qt.py

@@ -40,7 +40,7 @@
 
 from electrum.i18n import _
 from electrum.logging import Logger
-from electrum.util import parse_URI, InvalidBitcoinURI, UserCancelled, UserFacingException
+from electrum.util import parse_bip21_uri, InvalidBitcoinURI, UserCancelled, UserFacingException
 from electrum.plugin import hook, DeviceUnpairableError
 
 from .plugin import OutdatedHwFirmwareException, HW_PluginBase, HardwareHandlerBase