fix(p2pk): allow listing and spending p2pk utxos created with uncompressed pubkeys

mm2src/coins/utxo/rpc_clients/electrum_rpc/client.rs

@@ -804,8 +804,13 @@ impl UtxoRpcClientOps for ElectrumClient {
 
         // If the plain pubkey is available, fetch the UTXOs found in P2PK outputs as well (if any).
         if let Some(pubkey) = address.pubkey() {
-            let p2pk_output_script = output_script_p2pk(pubkey);
-            output_scripts.push(p2pk_output_script);
+            let pubkey = try_f!(pubkey
+                .to_secp256k1_pubkey()
+                .map_err(|e| UtxoRpcError::Internal(format!("Couldn't get secp256k1 pubkey from public key: {}", e))));
+            let compressed_pubkey = keys::Public::Compressed(pubkey.serialize().into());
+            output_scripts.push(output_script_p2pk(&compressed_pubkey));
+            let uncompressed_pubkey = keys::Public::Normal(pubkey.serialize_uncompressed().into());
+            output_scripts.push(output_script_p2pk(&uncompressed_pubkey));
         }
 
         let this = self.clone();
@@ -934,9 +939,24 @@ impl UtxoRpcClientOps for ElectrumClient {
         let mut hashes = vec![hex::encode(electrum_script_hash(&output_script))];
 
         // If the plain pubkey is available, fetch the balance found in P2PK output as well (if any).
+        // The output script (scriptPubkey) of such utxos may have the full pubkey length of 65 bytes or the compressed
+        // version of it (33 bytes). Both are valid and accepted by the blockchain.
         if let Some(pubkey) = address.pubkey() {
-            let p2pk_output_script = output_script_p2pk(pubkey);
-            hashes.push(hex::encode(electrum_script_hash(&p2pk_output_script)));
+            let pubkey = try_f!(pubkey.to_secp256k1_pubkey().map_err(|err| {
+                JsonRpcError::new(
+                    UtxoJsonRpcClientInfo::client_info(self),
+                    rpc_req!(self, "blockchain.scripthash.get_balance").into(),
+                    JsonRpcErrorType::Internal(err.to_string()),
+                )
+            }));
+            let compressed_pubkey = keys::Public::Compressed(pubkey.serialize().into());
+            hashes.push(hex::encode(electrum_script_hash(&output_script_p2pk(
+                &compressed_pubkey,
+            ))));
+            let uncompressed_pubkey = keys::Public::Normal(pubkey.serialize_uncompressed().into());
+            hashes.push(hex::encode(electrum_script_hash(&output_script_p2pk(
+                &uncompressed_pubkey,
+            ))));
         }
 
         let this = self.clone();

mm2src/coins/utxo_signer/src/lib.rs

@@ -55,11 +55,6 @@ pub enum UtxoSignTxError {
         script: Script,
         prev_script: Script,
     },
-    #[display(
-        fmt = "Can't spend the UTXO with script = '{}'. This script format isn't supported",
-        script
-    )]
-    UnspendableUTXO { script: Script },
     #[display(fmt = "Transport error: {}", _0)]
     Transport(String),
     #[display(fmt = "Internal error: {}", _0)]
@@ -87,8 +82,8 @@ impl From<UtxoSignWithKeyPairError> for UtxoSignTxError {
             // that are expected to be checked by [`sign_common::UtxoSignTxParamsBuilder::build`] already.
             // So if this error happens, it's our internal error.
             UtxoSignWithKeyPairError::InputIndexOutOfBound { .. } => UtxoSignTxError::Internal(error),
-            UtxoSignWithKeyPairError::UnspendableUTXO { script } => UtxoSignTxError::UnspendableUTXO { script },
             UtxoSignWithKeyPairError::ErrorSigning(sign) => UtxoSignTxError::ErrorSigning(sign),
+            UtxoSignWithKeyPairError::InternalError(internal) => UtxoSignTxError::Internal(internal),
         }
     }
 }

mm2src/coins/utxo_signer/src/with_key_pair.rs

@@ -30,13 +30,10 @@ pub enum UtxoSignWithKeyPairError {
     },
     #[display(fmt = "Input index '{}' is out of bound. Total length = {}", index, len)]
     InputIndexOutOfBound { len: usize, index: usize },
-    #[display(
-        fmt = "Can't spend the UTXO with script = '{}'. This script format isn't supported",
-        script
-    )]
-    UnspendableUTXO { script: Script },
     #[display(fmt = "Error signing using a private key")]
     ErrorSigning(keys::Error),
+    #[display(fmt = "{}", _0)]
+    InternalError(String),
 }
 
 impl From<keys::Error> for UtxoSignWithKeyPairError {
@@ -59,9 +56,10 @@ pub fn sign_tx(
                 ScriptType::PubKeyHash => p2pkh_spend(&unsigned, i, key_pair, signature_version, fork_id),
                 // Allow spending legacy P2PK utxos.
                 ScriptType::PubKey => p2pk_spend(&unsigned, i, key_pair, signature_version, fork_id),
-                _ => MmError::err(UtxoSignWithKeyPairError::UnspendableUTXO {
-                    script: input.prev_script.clone(),
-                }),
+                _ => MmError::err(UtxoSignWithKeyPairError::InternalError(format!(
+                    "Can't spend the UTXO with script = '{}'. This script format isn't supported",
+                    input.prev_script
+                ))),
             }
         })
         .collect::<UtxoSignWithKeyPairResult<_>>()?;
@@ -77,20 +75,30 @@ pub fn p2pk_spend(
     fork_id: u32,
 ) -> UtxoSignWithKeyPairResult<TransactionInput> {
     let unsigned_input = get_input(signer, input_index)?;
-
-    let script = Builder::build_p2pk(key_pair.public());
-    if script != unsigned_input.prev_script {
+    // P2PK UTXOs can have either compressed or uncompressed public keys in the scriptPubkey.
+    // We need to check that one of them matches the prev_script of the input being spent.
+    let pubkey = key_pair.public().to_secp256k1_pubkey().map_err(|e| {
+        UtxoSignWithKeyPairError::InternalError(format!("Couldn't get secp256k1 pubkey from keypair: {}", e))
+    })?;
+    // Build the scriptPubKey for both compressed and uncompressed public keys.
+    let possible_script_pubkeys = vec![
+        Builder::build_p2pk(&keys::Public::Compressed(pubkey.serialize().into())),
+        Builder::build_p2pk(&keys::Public::Normal(pubkey.serialize_uncompressed().into())),
+    ];
+    // Check that one of the scriptPubkeys matches the prev_script of the input being spent.
+    if !possible_script_pubkeys.contains(&unsigned_input.prev_script) {
         return MmError::err(UtxoSignWithKeyPairError::MismatchScript {
             script_type: "P2PK".to_owned(),
-            script,
+            // Safe indexing since the array has exactly 2 elements.
+            script: possible_script_pubkeys[0].clone(),
             prev_script: unsigned_input.prev_script.clone(),
         });
     }
 
     let signature = calc_and_sign_sighash(
         signer,
         input_index,
-        &script,
+        &unsigned_input.prev_script,
         key_pair,
         signature_version,
         SIGHASH_ALL,

mm2src/mm2_bitcoin/keys/src/public.rs

@@ -3,7 +3,7 @@ use crypto::dhash160;
 use hash::{H160, H264, H520};
 use hex::ToHex;
 use secp256k1::{recovery::{RecoverableSignature, RecoveryId},
-                Message as SecpMessage, PublicKey, Signature as SecpSignature};
+                Error as SecpError, Message as SecpMessage, PublicKey, Signature as SecpSignature};
 use std::{fmt, ops};
 use {CompactSignature, Error, Message, Signature};
 
@@ -80,6 +80,13 @@ impl Public {
             Public::Normal(_) => None,
         }
     }
+
+    pub fn to_secp256k1_pubkey(&self) -> Result<PublicKey, SecpError> {
+        match self {
+            Public::Compressed(public) => PublicKey::from_slice(&**public),
+            Public::Normal(public) => PublicKey::from_slice(&**public),
+        }
+    }
 }
 
 impl ops::Deref for Public {

mm2src/mm2_main/tests/mm2_tests/mm2_tests_inner.rs

@@ -255,6 +255,8 @@ fn test_my_balance() {
 }
 
 // TODO: Add a p2pk spending test in the docker tests when electrum nodes are available (also try to invoke the utxo cache by spending in rapid succession).
+// FIXME: This address has a legacy 33-byte pubkey utxo, add another 65-byte pubkey utxo to test that those appear as well.
+//        Also test `ElectrumClient::list_unspent` returns the said 2 utxos.
 #[test]
 fn test_p2pk_my_balance() {
     // PK of the P2PK balance: 03f8f8fa2062590ba9a0a7a86f937de22f540c015864aad35a2a9f6766de906265