add some tests

Author: rage-proof

electrum/gui/qt/main_window.py

@@ -1683,8 +1683,10 @@ def on_failure(exc_info):
         on_success = run_hook('tc_sign_wrapper', self.wallet, tx, on_success, on_failure) or on_success
         if external_keypairs:
             # can sign directly
+            print('\nexternal keys: ',external_keypairs)#
             task = partial(tx.sign, external_keypairs)
         else:
+            print('\nexternal keys2: ', external_keypairs)  #
             task = partial(self.wallet.sign_transaction, tx, password)
         msg = _('Signing transaction...')
         WaitingDialog(self, msg, task, on_success, on_failure)
@@ -1731,57 +1733,6 @@ def broadcast_done(result):
         WaitingDialog(self, _('Broadcasting transaction...'),
                       broadcast_thread, broadcast_done, self.on_error)
 
-    def exchange_psbt_http(self, payjoin):
-        """ """
-        import requests
-        assert payjoin.is_complete()
-        
-        print(payjoin.to_json())
-        print(payjoin.serialize_as_base64())
-
-        for txin in payjoin.inputs():
-            print(txin)
-            print(txin.utxo)
-            print('\n',txin.witness_utxo)
-            print('\n', txin.to_json())
-
-            if txin.utxo:
-                print(txin.utxo.outputs())
-                print(txin.prevout.out_idx)
-                print(txin.utxo.outputs()[txin.prevout.out_idx])
-
-                print()
-
-
-            print('\n',txin.utxo)
-            txin.convert_utxo_to_witness_utxo()
-            print('\n', txin.witness_utxo)
-            print('\n', txin.to_json())
-        print()
-        payjoin.convert_all_utxos_to_witness_utxos()
-        print(payjoin.serialize_as_base64())
-        print(payjoin.to_json())
-
-
-        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)
-        
-
-
     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,

electrum/gui/qt/transaction_dialog.py

@@ -45,7 +45,7 @@
 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
 from electrum.logging import get_logger
 
 from .util import (MessageBoxMixin, read_QIcon, Buttons, icon_path,
@@ -105,12 +105,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
-        if payjoin:
-            self.pj = payjoin['pj']
-            self.pjos = payjoin['pjos']
-            self.pj_available = True
-        else:
-            self.pj_available = False
+
+        self.payjoin = PayjoinTransaction(payjoin)
+        print(self.payjoin)#
+
         self.saved = False
         self.desc = desc
         self.setMinimumWidth(950)
@@ -224,15 +222,31 @@ 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):
         self.main_window.push_top_level_window(self)
+
         if self.payjoin_cb.isChecked():
-            self.main_window.exchange_psbt_http(self._gettx_for_coinjoin())
-        else:
-            try:
-                self.main_window.broadcast_transaction(self.tx)
-            finally:
-                self.main_window.pop_top_level_window(self)
+            self.payjoin.set_tx(self.tx)
+            tx = self.payjoin.do_payjoin()
+            if tx is not None:
+                #self.set_tx(tx)
+                self.tx = copy.deepcopy(tx)
+                print('broadcast1: ', self.tx.to_json())#
+                print('broadcast1: ', self.tx.serialize_as_base64())#
+                self.sign()
+                print('external keyspairs', self.external_keypairs)
+                print('broadcast2: ', self.tx.to_json())#
+                print('broadcast2: ', self.tx.serialize_as_base64())#
+                print('broadcast2: ', self.tx._serialize_as_base64()) #
+                print('broadcast2: ', self.tx.is_complete())  #
+        """
+        try:
+            self.main_window.broadcast_transaction(self.tx)
+        finally:
+            self.main_window.pop_top_level_window(self)
+        """
         self.saved = True
         self.update()
 
@@ -671,8 +685,8 @@ 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.pj_available)
-        print('pj_available in dialog:', self.pj_available)#
+        self.payjoin_cb.setVisible(self.payjoin.is_available())
+        print('pj_available in dialog:', self.payjoin.is_available())#
         self.locktime_final_label.setVisible(self.finalized)
         self.locktime_setter_widget.setVisible(not self.finalized)
 

electrum/transaction.py

@@ -38,6 +38,8 @@
 from enum import IntEnum
 import itertools
 import binascii
+import requests
+import copy
 
 from . import ecc, bitcoin, constants, segwit_addr, bip32
 from .bip32 import BIP32Node
@@ -1345,12 +1347,14 @@ def scriptpubkey(self) -> Optional[bytes]:
         return None
 
     def is_complete(self) -> bool:
-        if self.script_sig is not None and self.witness is not None:
+        if self.script_sig is not None or self.witness is not None:
             return True
         if self.is_coinbase_input():
             return True
         if self.script_sig is not None and not Transaction.is_segwit_input(self):
             return True
+        if self.witness is not None and Transaction.is_segwit_input(self):
+            return True
         signatures = list(self.part_sigs.values())
         s = len(signatures)
         # note: The 'script_type' field is currently only set by the wallet,
@@ -1374,7 +1378,7 @@ def clear_fields_when_finalized():
             self.redeem_script = None
             self.witness_script = None
 
-        if self.script_sig is not None and self.witness is not None:
+        if self.script_sig is not None or self.witness is not None:
             clear_fields_when_finalized()
             return  # already finalized
         if self.is_complete():
@@ -1992,29 +1996,115 @@ def remove_signatures(self):
         self.invalidate_ser_cache()
 
 
-class PayjoinTransaction(PartialTransaction):
+class PayjoinTransaction():
 
-    @classmethod
-    def from_tx(cls, tx: Transaction) -> 'PayjoinTransaction':
-        res = cls(None)
-        res._inputs = [PartialTxInput.from_txin(txin, strip_witness = False) for txin in tx.inputs()]
-        res._outputs = [PartialTxOutput.from_txout(txout) for txout in tx.outputs()]
-        res.version = tx.version
-        res.locktime = tx.locktime
-        return res
+    def __init__(self, payjoin_link=None):
+        self._version = 1
+        self.pj = payjoin_link.get('pj') if payjoin_link else None
+        self.pjos = payjoin_link.get('pjos') if payjoin_link else None
 
-    def serialize_as_base64(self, force_psbt = True) -> str:
-        raw_bytes = self.serialize_as_bytes(force_psbt = force_psbt)
-        return base64.b64encode(raw_bytes).decode('ascii')
+        self.payjoin_original = None
+        self.pj_proposal_received = False
 
-    def check_for_encrypted_connection(self):
-        pass
 
-    def create_original_psbt(self):
-        pass
+    def is_available(self):
+        return self.pj is not None
 
-    def check_payjoin_proposal(self):
-        pass
+    def set_tx(self, tx: PartialTransaction) -> None:
+        if self.is_available():
+            self.tx = copy.deepcopy(tx)
+
+    def prepare_original_psbt(self):
+        assert not self.pj_proposal_received
+        assert self.tx.is_complete()
+        self.payjoin_original = copy.deepcopy(self.tx)
+        self.payjoin_original.prepare_for_export_for_coinjoin()
+        self.payjoin_original.convert_all_utxos_to_witness_utxos()
+
+    def do_payjoin(self):
+        self.prepare_original_psbt()
+        print('\noriginal psbt',self.payjoin_original.to_json())#
+        for i,txin in enumerate(self.payjoin_original.inputs()):#
+            print('\n txinputs:',i,txin.to_json()) #
+
+
+        if not self.exchange_payjoin_original():
+            return None
+        self.pj_proposal = PartialTransaction.from_raw_psbt(self.payjoin_proposal_b64)
+        self.pj_proposal_received  = True
+        if not self.validate_payjoin_proposal():
+            return None
+        return self.pj_proposal
+
+
+
+    def exchange_payjoin_original(self, url=None):
+        """ """
+        url = self.pj
+        payload = self.payjoin_original.serialize_as_base64()
+        headers = {'content-type': 'text/plain',
+                   'content-length': str(len(payload))
+                   }
+        print('header ',headers)#
+        try:
+            r = requests.post(url, data=payload, headers=headers)
+            print(r.status_code)#
+            print(r.text)#
+            if r.status_code==200:
+                self.payjoin_proposal_b64 = r.text
+                print(self.payjoin_proposal_b64)#
+            else:
+                _logger.debug(f"payjoin is flawed {r.text}")
+                return False
+        except Exception as e:
+            print(repr(e))#
+            return False
+        return True
+
+    @staticmethod
+    def validate_inputs_and_outputs(pj_original: PartialTransaction, pj_proposal: PartialTransaction) -> Optional[bool]:
+        for txin in pj_original.inputs():
+            # check if order is important
+            if not txin.prevout.to_str() in [x.prevout.to_str() for x in pj_proposal.inputs()]:
+                # list(payjoin_proposal.inputs()).prevout.to_str():
+                raise Exception(f"Inputs from the original payjoin missing in payjoin proposal.")
+        for txin in pj_proposal.inputs():
+            if not txin.is_complete() and not txin.prevout.to_str() in [x.prevout.to_str() for x in pj_original.inputs()]:
+                raise Exception(f"Newly added inputs are not signed.")
+
+        for txout in pj_original.outputs():
+            # check if order is important
+            if txout.is_mine and not txout.scriptpubkey.hex() in [x.scriptpubkey.hex() for x in pj_proposal.outputs()]:
+                raise Exception(f"Sender outputs from the original payjoin missing in payjoin proposal.")
+        for txout in pj_proposal.outputs():
+            if not txout.scriptpubkey.hex() in [x.scriptpubkey.hex() for x in pj_original.outputs()]:
+                raise Exception(f"Newly added outputs.")
+        return True
+
+
+    def validate_payjoin_proposal(self):
+
+        if not self.validate_inputs_and_outputs(self.payjoin_original, self.pj_proposal):
+            return False
+        """
+        if self.payjoin_original.get_fee() > self.payjoin_proposal.get_fee():
+            return False
+        """
+        for i, txin in enumerate(self.tx.inputs()):
+            if self.pj_proposal._inputs[i].prevout.to_str() != txin.prevout.to_str():
+                raise Exception(f"Inputs from the original payjoin missing in payjoin proposal2.")
+            else:
+                print('\n sig \n',txin.to_json())
+                #procedure for parttxin
+                txin.part_sigs = {}
+                txin.script_sig = None
+                txin.witness = None
+                self.pj_proposal._inputs[i] = txin
+                print('\n sig2 \n', txin.to_json())
+
+
+        self.pj_proposal.invalidate_ser_cache()
+        return True
 
 
 def pack_bip32_root_fingerprint_and_int_path(xfp: bytes, path: Sequence[int]) -> bytes: