Merge branch 'dev' into master

commit 152fc497a543af1c41cec7a529ec736fde80b5f7
Author: OPReturnCode <mask.em@protonmail.com>
Date:   Tue Jan 7 16:54:27 2025 +0000

    Modify the on_connect behaviour to prevent connection attempt in watchin-only wallets

commit d6489a17480701c9dc00a1684caa9fbf3dab7fde
Author: OPReturnCode <mask.em@protonmail.com>
Date:   Tue Jan 7 16:41:02 2025 +0000

    Add support for more complex contracts that need user pubkey and signature

commit 02dc0f7270458fc1c31ed46e136583df6c363ba6
Author: OPReturnCode <mask.em@protonmail.com>
Date:   Wed Jan 1 22:00:12 2025 +0000

    Fix incorrect address storage location

Author: OPReturnCode

transaction.py

@@ -0,0 +1,54 @@
+from electroncash import token
+from electroncash.util import *
+from electroncash.bitcoin import *
+from electroncash.transaction import Transaction, InputValueMissing
+
+
+# The EC Transaction class does not support SIGHASH_UTXOS
+class TransactionWithSighashUTXOS(Transaction):
+
+    def get_hash_utxos(self):
+        buf = b''
+        for i in self.inputs():
+            script_bytes = bfh(i['walletconnect_locking_bytecode'])
+            buf += int_to_bytes(i['value'], 8)
+            buf += var_int_bytes(len(script_bytes))
+            buf += script_bytes
+        return Hash(buf)
+
+    # This method is taken and edited from electroncash/transaction.py from the official Electron Cash project repo at
+    # https://github.com/Electron-Cash/Electron-Cash
+    def serialize_preimage_bytes(self, i, nHashType=0x00000041, use_cache=False) -> bytes:
+        """ See `.calc_common_sighash` for explanation of use_cache feature """
+
+        if (nHashType & 0xff) != 0x61:
+            raise ValueError("other hashtypes not supported.")
+
+        nVersion = int_to_bytes(self.version, 4)
+        nHashType = int_to_bytes(nHashType, 4)
+        nLocktime = int_to_bytes(self.locktime, 4)
+
+        txin = self.inputs()[i]
+        outpoint = self.serialize_outpoint_bytes(txin)
+        preimage_script = bfh(self.get_preimage_script(txin))
+        input_token = txin.get('token_data')
+        if input_token is not None:
+            serInputToken = token.PREFIX_BYTE + input_token.serialize()
+        else:
+            serInputToken = b''
+        scriptCode = var_int_bytes(len(preimage_script)) + preimage_script
+        try:
+            amount = int_to_bytes(txin['value'], 8)
+        except KeyError:
+            raise InputValueMissing
+        nSequence = int_to_bytes(txin.get('sequence', 0xffffffff - 1), 4)
+
+        hashPrevouts, hashSequence, hashOutputs = self.calc_common_sighash(use_cache=use_cache)
+        hashUtxos = self.get_hash_utxos()
+
+        preimage = (nVersion + hashPrevouts + hashUtxos + hashSequence + outpoint + serInputToken + scriptCode + amount + nSequence
+                    + hashOutputs + nLocktime + nHashType)
+        print("preimage: ", nVersion.hex(), hashPrevouts.hex(), hashUtxos.hex(), hashSequence.hex(), outpoint.hex(),
+              serInputToken.hex(), scriptCode.hex(), amount.hex(), nSequence.hex(), hashOutputs.hex(), nLocktime.hex(),
+              nHashType.hex())
+        return preimage

ui.py

@@ -24,6 +24,7 @@ def __init__(self, parent, plugin):
         self.parent = parent
         self.wallet = self.parent.wallet
         self.address = None
+        self.password = None
 
         self.wallet_connect = None
         self.proxy_opts = None
@@ -120,9 +121,23 @@ def on_connect_btn(self):
             self.wallet_connect.close_session()
             self.active_sessions.clear()
 
+        if self.wallet.is_watching_only():
+            self.parent.show_warning(_(
+                "This wallet is watching-only."
+                "This means you are not able to sign transactions or messages. Or spend BCH in any way."))
+            return
+
         try:
+            if self.wallet.has_password():
+                pd = PasswordDialog()
+                password = pd.run()
+                self.wallet.check_password(password)
+                self.password = password
+                del pd
+
             self.wallet_connect = w_connect2.WalletConnect(
-                self.wallet_connect_uri_text_edit.text(), self.address.to_token_string(), self.wallet, self.proxy_opts)
+                self.wallet_connect_uri_text_edit.text(), self.address.to_token_string(),
+                self.wallet, self.password, self.proxy_opts)
 
             session_data = self.wallet_connect.open_session()
 
@@ -159,12 +174,23 @@ def approve_transaction_sign(self):
         pass
 
     def get_wallet_address(self):
+
+        # For backward compatibility, check if an address is stored in the incorrect location and fix it.
+        # This section can be removed in future iterations, as it is only relevant to users of the initial version.
         address_str = self.parent.config.get("wallet_connect_address")
+        if address_str:
+            self.wallet.is_mine(address.Address.from_string(address_str))
+            self.wallet.storage.put("wallet_connect_address", address_str)
+            self.wallet.storage.write()
+            self.parent.config.set_key("wallet_connect_address", None)
+
+        address_str = self.wallet.storage.get("wallet_connect_address")
         if address_str:
             self.address = address.Address.from_string(address_str)
         else:
             self.address = self.wallet.get_unused_address(frozen_ok=False)
-            self.parent.config.set_key("wallet_connect_address", self.address.to_cashaddr())
+            self.wallet.storage.put("wallet_connect_address", self.address.to_cashaddr())
+            self.wallet.storage.write()
         self.wallet.set_frozen_state([self.address], True)
 
         return self.address

utils.py

@@ -1,25 +1,30 @@
 import re
 
-from electroncash.address import UnknownAddress
-from electroncash import transaction, token, bitcoin
+from electroncash.address import UnknownAddress, Address
+from electroncash import transaction, token, bitcoin, util
+
+from .transaction import TransactionWithSighashUTXOS
 
 
 def extract_hex_from_libauth_extended_json_string(s):
     hex_regex = r'0x[0-9a-f-A-F]+'
 
     match = re.search(hex_regex, s)
     if match:
-        return match.group(0)
+        group = match.group(0)
+        group = group[2:] if group.startswith('0x') else group
+        return group
 
 def extract_bigint_from_libauth_extended_json_string(s):
     bigint_regex = r'[0-9]+'
 
     match = re.search(bigint_regex, s)
     if match:
-        return match.group(0)
-
+        group = match.group(0)
+        group = group[:-1] if group.endswith('n') else group
+        return group
 
-def generate_electron_cash_tx_from_libauth_format(tx_data, wallet):
+def generate_electron_cash_tx_from_libauth_format(tx_data, wallet, wallet_connect_address, password):
 
     transaction_data = tx_data['transaction']
     source_outputs_data = tx_data['sourceOutputs']
@@ -28,22 +33,21 @@ def generate_electron_cash_tx_from_libauth_format(tx_data, wallet):
     ec_inputs_bytes = list()
     for index, item in enumerate(transaction_data['inputs']):
         prevout_hash = extract_hex_from_libauth_extended_json_string(item['outpointTransactionHash'])
-        prevout_hash = prevout_hash[2:] if prevout_hash.startswith('0x') else prevout_hash
         script_sig = extract_hex_from_libauth_extended_json_string(item['unlockingBytecode'])
 
+        # in case of empty script_sig, first check if it's a contract and the contract contains the script_sig
+        if not script_sig and ('contract' in source_outputs_data[index].keys() and
+                source_outputs_data[index]['contract']['artifact']['contractName']):
+            script_sig = extract_hex_from_libauth_extended_json_string(source_outputs_data[index]['unlockingBytecode'])
+
 
         address = None
-        locking_byte_code = extract_hex_from_libauth_extended_json_string(
+        locking_bytecode = extract_hex_from_libauth_extended_json_string(
             source_outputs_data[index]['lockingBytecode'])
-        locking_byte_code = locking_byte_code[2:] if locking_byte_code.startswith('0x') else locking_byte_code
-        type, possible_address = transaction.get_address_from_output_script(bytes.fromhex(locking_byte_code))
+        type, possible_address = transaction.get_address_from_output_script(bytes.fromhex(locking_bytecode))
         if type in [bitcoin.TYPE_ADDRESS, bitcoin.TYPE_PUBKEY]:
             address = possible_address
 
-        if script_sig:
-            script_sig = script_sig[2:] if script_sig.startswith('0x') else script_sig
-        else:
-            script_sig = None
         ec_input = {
             'prevout_n': item['outpointIndex'],
             'prevout_hash': prevout_hash,
@@ -54,8 +58,20 @@ def generate_electron_cash_tx_from_libauth_format(tx_data, wallet):
             'x_pubkeys': [],
             'pubkeys': [],
             'signatures': {},
+            'walletconnect_locking_bytecode': locking_bytecode
         }
 
+        token_output_data = None
+        if 'token' in source_outputs_data[index].keys():
+            token_output_data = generate_token_data_output_from_token_dict(source_outputs_data[index]['token'])
+            ec_input['token_data'] = token_output_data
+        ec_input['walletconnect_locking_bytecode'] = token.wrap_spk(
+                token_output_data, bytes.fromhex(locking_bytecode)).hex()
+
+        value = extract_bigint_from_libauth_extended_json_string(source_outputs_data[index]['valueSatoshis'])
+        value = int(value)
+        ec_input['value'] = value
+
         if script_sig:
             try:
                 script_sig_data = {}
@@ -94,10 +110,9 @@ def generate_electron_cash_tx_from_libauth_format(tx_data, wallet):
     token_data_list = list()
     for item in transaction_data['outputs']:
         locking_bytecode = extract_hex_from_libauth_extended_json_string(item['lockingBytecode'])
-        locking_bytecode = locking_bytecode[2:] if locking_bytecode.startswith('0x') else locking_bytecode
 
         item['valueSatoshis'] = extract_bigint_from_libauth_extended_json_string(item['valueSatoshis'])
-        value = int(item['valueSatoshis'][:-1]) if item['valueSatoshis'].endswith('n') else int(item['valueSatoshis'])
+        value = int(item['valueSatoshis'])
 
         address = transaction.get_address_from_output_script(bytes.fromhex(locking_bytecode))
         ec_output = address + (value,)
@@ -106,42 +121,8 @@ def generate_electron_cash_tx_from_libauth_format(tx_data, wallet):
         output_bytes = b''
         output_bytes += bitcoin.int_to_bytes(value, 8)
 
-        amount = None
         if 'token' in item.keys():
-            item['token']['category'] = extract_hex_from_libauth_extended_json_string(item['token']['category'])
-            category_id = item['token']['category']
-            category_id = category_id[2:] if category_id.startswith('0x') else category_id
-            category_id_arr = bytearray.fromhex(category_id)
-            category_id_arr.reverse()
-            category_id = bytes(category_id_arr)
-
-            bitfield = 0
-            if 'amount' in item['token'].keys():
-                item['token']['amount'] = extract_bigint_from_libauth_extended_json_string(item['token']['amount'])
-                amount = item['token']['amount']
-                amount = int(amount) if amount.endswith('n') else int(amount)
-                if amount and amount > 0:
-                    bitfield |= token.Structure.HasAmount
-
-            commitment = b''
-            if 'nft' in item['token'].keys():
-                bitfield |= token.Structure.HasNFT
-                commitment = item['token']['nft'].get('commitment')
-                commitment = commitment.encode() if commitment else b''
-
-                capability = item['token']['nft'].get('capability')
-
-                if not capability or capability == 'none':
-                    bitfield |= token.Capability.NoCapability
-                elif capability == 'mutable':
-                    bitfield |= token.Capability.Mutable
-                elif capability == 'minting':
-                    bitfield |= token.Capability.Minting
-
-                if commitment and len(commitment) > 0:
-                    bitfield |= token.Structure.HasCommitmentLength
-
-            token_output_data = token.OutputData(category_id, amount, commitment, bitfield)
+            token_output_data = generate_token_data_output_from_token_dict(item['token'])
             token_data_list.append(token_output_data)
 
             wrapped_locking_bytecode = token.wrap_spk(token_output_data, bytes.fromhex(locking_bytecode))
@@ -187,4 +168,72 @@ def generate_electron_cash_tx_from_libauth_format(tx_data, wallet):
     ec_tx = transaction.Transaction.from_io(
         inputs=ec_inputs, outputs=ec_outputs, locktime=locktime, token_datas=token_data_list, version=version)
     ec_tx._sign_schnorr = True
+
+    for index, input in enumerate(ec_tx.inputs()):
+        sig_placeholder = "41" + bytearray(65).hex()
+        pubkey_placeholder = "21" + bytearray(33).hex()
+
+        address = Address.from_string(wallet_connect_address)
+        priv_key = wallet.export_private_key(address, password)
+        if input['scriptSig'] and input['scriptSig'].find(sig_placeholder) != -1:
+            source_output = source_outputs_data[index]
+            assert "contract" in source_output.keys()
+            assert "redeemScript" in source_output['contract'].keys()
+            redeem_script = source_output['contract']['redeemScript']
+            redeem_script = extract_hex_from_libauth_extended_json_string(redeem_script)
+            input['scriptCode'] = redeem_script
+
+            ec_tx.__class__ = TransactionWithSighashUTXOS
+            hash_type = 0x1 | 0x40 | 0x20 # SIGHASH_ALL | SIGHASH_FORKID | SIGHASH_UTXOS # Consistency
+            type, priv_key, _ = bitcoin.deserialize_privkey(priv_key)
+            pre_hash = bitcoin.Hash(ec_tx.serialize_preimage_bytes(index, hash_type))
+            sig = ec_tx._schnorr_sign(bitcoin.public_key_from_private_key(priv_key, True), priv_key, pre_hash)
+            sig = '41' + util.bh2u(sig + bytes((hash_type & 0xff,)))
+            input['scriptSig'] = input['scriptSig'].replace(sig_placeholder, sig)
+            ec_tx.__class__ = transaction.Transaction
+
+        if input['scriptSig'] and input['scriptSig'].find(pubkey_placeholder) != -1:
+            pubkey = '21' + bitcoin.public_key_from_private_key(priv_key, True)
+            input['scriptSig'] = input['scriptSig'].replace(pubkey_placeholder, pubkey)
+
     return ec_tx
+
+
+
+def generate_token_data_output_from_token_dict(token_dict):
+    token_dict['category'] = extract_hex_from_libauth_extended_json_string(token_dict['category'])
+    category_id = token_dict['category']
+    category_id_arr = bytearray.fromhex(category_id)
+    category_id_arr.reverse()
+    category_id = bytes(category_id_arr)
+
+    amount = None
+    bitfield = 0
+    if 'amount' in token_dict.keys():
+        token_dict['amount'] = extract_bigint_from_libauth_extended_json_string(token_dict['amount'])
+        amount = int(token_dict['amount'])
+        if amount and amount > 0:
+            bitfield |= token.Structure.HasAmount
+
+    commitment = b''
+    if 'nft' in token_dict.keys():
+        bitfield |= token.Structure.HasNFT
+        commitment = token_dict['nft'].get('commitment')
+        commitment = extract_hex_from_libauth_extended_json_string(commitment) if commitment else None
+        commitment = bytes.fromhex(commitment) if commitment else b''
+
+        capability = token_dict['nft'].get('capability')
+
+        if not capability or capability == 'none':
+            bitfield |= token.Capability.NoCapability
+        elif capability == 'mutable':
+            bitfield |= token.Capability.Mutable
+        elif capability == 'minting':
+            bitfield |= token.Capability.Minting
+
+        if commitment and len(commitment) > 0:
+            bitfield |= token.Structure.HasCommitmentLength
+
+    token_output_data = token.OutputData(category_id, amount, commitment, bitfield)
+
+    return token_output_data

w_connect2.py

@@ -34,7 +34,7 @@
 
 
 class WalletConnect:
-    def __init__(self, wallet_connect_uri, wallet_address, wallet, proxy_opts):
+    def __init__(self, wallet_connect_uri, wallet_address, wallet, password, proxy_opts):
         # assert proxy_opts is not None
 
         self.session_data = None
@@ -43,6 +43,7 @@ def __init__(self, wallet_connect_uri, wallet_address, wallet, proxy_opts):
         self.wallet_connect_uri = wallet_connect_uri
         self.wallet_address = wallet_address
         self.wallet = wallet
+        self.password = password
         self.proxy_opts = proxy_opts
 
         self.wc_client = WCClient.from_wc_uri(self.wallet_connect_uri, socks_opts=self.proxy_opts)
@@ -90,7 +91,8 @@ def get_message(self):
 
                     elif params["request"]["method"] == WALLET_CONNECT_SIGN_TRANSACTION:
                         tx_data = params['request']['params']
-                        ec_tx = utils.generate_electron_cash_tx_from_libauth_format(tx_data, self.wallet)
+                        ec_tx = utils.generate_electron_cash_tx_from_libauth_format(
+                            tx_data, self.wallet, self.wallet_address, self.password)
                         task_data = {
                             "type": WALLET_CONNECT_SIGN_TRANSACTION,
                             "message_id": message_id,