ref(signer): Use Psbt::sighash_ecdsa for computing sighashes

- Change param `hash` to `&Message` in `sign_psbt_ecdsa`
- Remove unused methods `compute_legacy_sighash`,
and `compute_segwitv0_sighash`.
- Match on `self.ctx` when signing for `SignerWrapper<PrivateKey>`

Author: ValuedMammal

crates/wallet/src/wallet/signer.rs

@@ -166,6 +166,8 @@ pub enum SignerError {
     /// [`TransactionSigner`], so that they can return their own custom errors, without having to
     /// modify [`SignerError`] in BDK.
     External(String),
+    /// PSBT sign error.
+    Psbt(psbt::SignError),
 }
 
 impl From<sighash::Error> for SignerError {
@@ -191,6 +193,7 @@ impl fmt::Display for SignerError {
             Self::SighashError(err) => write!(f, "Error while computing the hash to sign: {}", err),
             Self::MiniscriptPsbt(err) => write!(f, "Miniscript PSBT error: {}", err),
             Self::External(err) => write!(f, "{}", err),
+            Self::Psbt(err) => write!(f, "{}", err),
         }
     }
 }
@@ -453,92 +456,86 @@ impl InputSigner for SignerWrapper<PrivateKey> {
         }
 
         let pubkey = PublicKey::from_private_key(secp, self);
-        let x_only_pubkey = XOnlyPublicKey::from(pubkey.inner);
-
-        if let SignerContext::Tap { is_internal_key } = self.ctx {
-            if let Some(psbt_internal_key) = psbt.inputs[input_index].tap_internal_key {
-                if is_internal_key
-                    && psbt.inputs[input_index].tap_key_sig.is_none()
-                    && sign_options.sign_with_tap_internal_key
-                    && x_only_pubkey == psbt_internal_key
-                {
-                    let (hash, hash_ty) = compute_tap_sighash(psbt, input_index, None)?;
-                    sign_psbt_schnorr(
-                        &self.inner,
-                        x_only_pubkey,
-                        None,
-                        &mut psbt.inputs[input_index],
-                        hash,
-                        hash_ty,
-                        secp,
-                    );
+
+        match self.ctx {
+            SignerContext::Tap { is_internal_key } => {
+                let x_only_pubkey = XOnlyPublicKey::from(pubkey.inner);
+
+                if let Some(psbt_internal_key) = psbt.inputs[input_index].tap_internal_key {
+                    if is_internal_key
+                        && psbt.inputs[input_index].tap_key_sig.is_none()
+                        && sign_options.sign_with_tap_internal_key
+                        && x_only_pubkey == psbt_internal_key
+                    {
+                        let (hash, hash_ty) = compute_tap_sighash(psbt, input_index, None)?;
+                        sign_psbt_schnorr(
+                            &self.inner,
+                            x_only_pubkey,
+                            None,
+                            &mut psbt.inputs[input_index],
+                            hash,
+                            hash_ty,
+                            secp,
+                        );
+                    }
                 }
-            }
 
-            if let Some((leaf_hashes, _)) =
-                psbt.inputs[input_index].tap_key_origins.get(&x_only_pubkey)
-            {
-                let leaf_hashes = leaf_hashes
-                    .iter()
-                    .filter(|lh| {
-                        // Removing the leaves we shouldn't sign for
-                        let should_sign = match &sign_options.tap_leaves_options {
-                            TapLeavesOptions::All => true,
-                            TapLeavesOptions::Include(v) => v.contains(lh),
-                            TapLeavesOptions::Exclude(v) => !v.contains(lh),
-                            TapLeavesOptions::None => false,
-                        };
-                        // Filtering out the leaves without our key
-                        should_sign
-                            && !psbt.inputs[input_index]
-                                .tap_script_sigs
-                                .contains_key(&(x_only_pubkey, **lh))
-                    })
-                    .cloned()
-                    .collect::<Vec<_>>();
-                for lh in leaf_hashes {
-                    let (hash, hash_ty) = compute_tap_sighash(psbt, input_index, Some(lh))?;
-                    sign_psbt_schnorr(
-                        &self.inner,
-                        x_only_pubkey,
-                        Some(lh),
-                        &mut psbt.inputs[input_index],
-                        hash,
-                        hash_ty,
-                        secp,
-                    );
+                if let Some((leaf_hashes, _)) =
+                    psbt.inputs[input_index].tap_key_origins.get(&x_only_pubkey)
+                {
+                    let leaf_hashes = leaf_hashes
+                        .iter()
+                        .filter(|lh| {
+                            // Removing the leaves we shouldn't sign for
+                            let should_sign = match &sign_options.tap_leaves_options {
+                                TapLeavesOptions::All => true,
+                                TapLeavesOptions::Include(v) => v.contains(lh),
+                                TapLeavesOptions::Exclude(v) => !v.contains(lh),
+                                TapLeavesOptions::None => false,
+                            };
+                            // Filtering out the leaves without our key
+                            should_sign
+                                && !psbt.inputs[input_index]
+                                    .tap_script_sigs
+                                    .contains_key(&(x_only_pubkey, **lh))
+                        })
+                        .cloned()
+                        .collect::<Vec<_>>();
+                    for lh in leaf_hashes {
+                        let (hash, hash_ty) = compute_tap_sighash(psbt, input_index, Some(lh))?;
+                        sign_psbt_schnorr(
+                            &self.inner,
+                            x_only_pubkey,
+                            Some(lh),
+                            &mut psbt.inputs[input_index],
+                            hash,
+                            hash_ty,
+                            secp,
+                        );
+                    }
                 }
             }
+            SignerContext::Segwitv0 | SignerContext::Legacy => {
+                if psbt.inputs[input_index].partial_sigs.contains_key(&pubkey) {
+                    return Ok(());
+                }
 
-            return Ok(());
-        }
-
-        if psbt.inputs[input_index].partial_sigs.contains_key(&pubkey) {
-            return Ok(());
-        }
-
-        let (hash, hash_ty) = match self.ctx {
-            SignerContext::Segwitv0 => {
-                let (h, t) = compute_segwitv0_sighash(psbt, input_index)?;
-                let h = h.to_raw_hash();
-                (h, t)
-            }
-            SignerContext::Legacy => {
-                let (h, t) = compute_legacy_sighash(psbt, input_index)?;
-                let h = h.to_raw_hash();
-                (h, t)
+                let mut sighasher = sighash::SighashCache::new(psbt.unsigned_tx.clone());
+                let (msg, hash_ty) = psbt
+                    .sighash_ecdsa(input_index, &mut sighasher)
+                    .map_err(SignerError::Psbt)?;
+
+                sign_psbt_ecdsa(
+                    &self.inner,
+                    pubkey,
+                    &mut psbt.inputs[input_index],
+                    &msg,
+                    hash_ty,
+                    secp,
+                    sign_options.allow_grinding,
+                );
             }
-            _ => return Ok(()), // handled above
-        };
-        sign_psbt_ecdsa(
-            &self.inner,
-            pubkey,
-            &mut psbt.inputs[input_index],
-            hash,
-            hash_ty,
-            secp,
-            sign_options.allow_grinding,
-        );
+        }
 
         Ok(())
     }
@@ -548,12 +545,11 @@ fn sign_psbt_ecdsa(
     secret_key: &secp256k1::SecretKey,
     pubkey: PublicKey,
     psbt_input: &mut psbt::Input,
-    hash: impl bitcoin::hashes::Hash + bitcoin::secp256k1::ThirtyTwoByteHash,
+    msg: &Message,
     hash_ty: EcdsaSighashType,
     secp: &SecpCtx,
     allow_grinding: bool,
 ) {
-    let msg = &Message::from(hash);
     let sig = if allow_grinding {
         secp.sign_ecdsa_low_r(msg, secret_key)
     } else {
@@ -845,119 +841,6 @@ impl Default for SignOptions {
     }
 }
 
-/// Computes the legacy sighash.
-fn compute_legacy_sighash(
-    psbt: &Psbt,
-    input_index: usize,
-) -> Result<(sighash::LegacySighash, EcdsaSighashType), SignerError> {
-    if input_index >= psbt.inputs.len() || input_index >= psbt.unsigned_tx.input.len() {
-        return Err(SignerError::InputIndexOutOfRange);
-    }
-
-    let psbt_input = &psbt.inputs[input_index];
-    let tx_input = &psbt.unsigned_tx.input[input_index];
-
-    let sighash = psbt_input
-        .sighash_type
-        .unwrap_or_else(|| EcdsaSighashType::All.into())
-        .ecdsa_hash_ty()
-        .map_err(|_| SignerError::InvalidSighash)?;
-    let script = match psbt_input.redeem_script {
-        Some(ref redeem_script) => redeem_script.clone(),
-        None => {
-            let non_witness_utxo = psbt_input
-                .non_witness_utxo
-                .as_ref()
-                .ok_or(SignerError::MissingNonWitnessUtxo)?;
-            let prev_out = non_witness_utxo
-                .output
-                .get(tx_input.previous_output.vout as usize)
-                .ok_or(SignerError::InvalidNonWitnessUtxo)?;
-
-            prev_out.script_pubkey.clone()
-        }
-    };
-
-    Ok((
-        sighash::SighashCache::new(&psbt.unsigned_tx).legacy_signature_hash(
-            input_index,
-            &script,
-            sighash.to_u32(),
-        )?,
-        sighash,
-    ))
-}
-
-/// Computes the segwitv0 sighash.
-fn compute_segwitv0_sighash(
-    psbt: &Psbt,
-    input_index: usize,
-) -> Result<(sighash::SegwitV0Sighash, EcdsaSighashType), SignerError> {
-    if input_index >= psbt.inputs.len() || input_index >= psbt.unsigned_tx.input.len() {
-        return Err(SignerError::InputIndexOutOfRange);
-    }
-
-    let psbt_input = &psbt.inputs[input_index];
-    let tx_input = &psbt.unsigned_tx.input[input_index];
-
-    let sighash_type = psbt_input
-        .sighash_type
-        .unwrap_or_else(|| EcdsaSighashType::All.into())
-        .ecdsa_hash_ty()
-        .map_err(|_| SignerError::InvalidSighash)?;
-
-    // Always try first with the non-witness utxo
-    let utxo = if let Some(prev_tx) = &psbt_input.non_witness_utxo {
-        // Check the provided prev-tx
-        if prev_tx.txid() != tx_input.previous_output.txid {
-            return Err(SignerError::InvalidNonWitnessUtxo);
-        }
-
-        // The output should be present, if it's missing the `non_witness_utxo` is invalid
-        prev_tx
-            .output
-            .get(tx_input.previous_output.vout as usize)
-            .ok_or(SignerError::InvalidNonWitnessUtxo)?
-    } else if let Some(witness_utxo) = &psbt_input.witness_utxo {
-        // Fallback to the witness_utxo. If we aren't allowed to use it, signing should fail
-        // before we get to this point
-        witness_utxo
-    } else {
-        // Nothing has been provided
-        return Err(SignerError::MissingNonWitnessUtxo);
-    };
-    let value = utxo.value;
-
-    let mut sighasher = sighash::SighashCache::new(&psbt.unsigned_tx);
-
-    let sighash = match psbt_input.witness_script {
-        Some(ref witness_script) => {
-            sighasher.p2wsh_signature_hash(input_index, witness_script, value, sighash_type)?
-        }
-        None => {
-            if utxo.script_pubkey.is_p2wpkh() {
-                sighasher.p2wpkh_signature_hash(
-                    input_index,
-                    &utxo.script_pubkey,
-                    value,
-                    sighash_type,
-                )?
-            } else if psbt_input
-                .redeem_script
-                .as_ref()
-                .map(|s| s.is_p2wpkh())
-                .unwrap_or(false)
-            {
-                let script_pubkey = psbt_input.redeem_script.as_ref().unwrap();
-                sighasher.p2wpkh_signature_hash(input_index, script_pubkey, value, sighash_type)?
-            } else {
-                return Err(SignerError::MissingWitnessScript);
-            }
-        }
-    };
-    Ok((sighash, sighash_type))
-}
-
 /// Computes the taproot sighash.
 fn compute_tap_sighash(
     psbt: &Psbt,