Manual fixes to claudes changes

Author: tcharding

examples/psbt_sign_finalize.rs

@@ -9,6 +9,7 @@ use miniscript::bitcoin::script::ScriptPubKey;
 use miniscript::bitcoin::sighash::SighashCache;
 use miniscript::bitcoin::Witness;
 //use miniscript::bitcoin::secp256k1; // https://github.com/rust-lang/rust/issues/121684
+use miniscript::bitcoin::ext::*;
 use miniscript::bitcoin::{
     transaction, Address, Amount, Network, OutPoint, PrivateKey, Sequence, Transaction,
     TxIn, TxOut,
@@ -92,12 +93,12 @@ fn main() {
 
     psbt.unsigned_tx.outputs.push(TxOut {
         script_pubkey: receiver.script_pubkey(),
-        amount: Amount::from_sat(amount / 5 - 500).unwrap(),
+        amount: Amount::from_sat_u32(amount / 5 - 500),
     });
 
     psbt.unsigned_tx.outputs.push(TxOut {
         script_pubkey: bridge_descriptor.script_pubkey(),
-        amount: Amount::from_sat(amount * 4 / 5).unwrap(),
+        amount: Amount::from_sat_u32(amount * 4 / 5),
     });
 
     // Generating signatures & witness data
@@ -152,7 +153,7 @@ fn main() {
 fn get_vout(tx: &Transaction, spk: &ScriptPubKey) -> (OutPoint, TxOut) {
     for (i, txout) in tx.clone().outputs.into_iter().enumerate() {
         if spk == &txout.script_pubkey {
-            return (OutPoint { txid: tx.compute_txid(), vout: i as u32 }, txout);
+            return (OutPoint::new(tx.compute_txid(), u32::try_from(i).expect("index is always positive")), txout);
         }
     }
     panic!("Only call get vout on functions which have the expected outpoint");

examples/sign_multisig.rs

@@ -89,7 +89,7 @@ fn spending_transaction() -> bitcoin::Transaction {
         }],
         outputs: vec![bitcoin::TxOut {
             script_pubkey: ScriptPubKeyBuf::new(),
-            amount: Amount::from_sat(100_000_000).unwrap(),
+            amount: Amount::from_sat_u32(100_000_000),
         }],
     }
 }

examples/taptree_of_horror/taptree_of_horror.rs

@@ -217,15 +217,15 @@ fn main() {
         witness: Witness::default(),
     };
 
-    let prev_amount = Amount::from_sat(100_000_000).unwrap();
+    let prev_amount = Amount::from_sat_u32(100_000_000);
     let witness_utxo =
         TxOut { amount: prev_amount, script_pubkey: derived_descriptor.clone().script_pubkey() };
 
     let destination_address =
         Address::from_str("bcrt1p2tl8zasepqe3j6m7hx4tdmqzndddr5wa9ugglpdzgenjwv42rkws66dk5a")
             .unwrap();
     let destination_output: TxOut = TxOut {
-        amount: bitcoin::Amount::from_sat(99_999_000).unwrap(),
+        amount: bitcoin::Amount::from_sat_u32(99_999_000),
         script_pubkey: destination_address.assume_checked().script_pubkey(),
     };
 

src/descriptor/key.rs

@@ -720,11 +720,19 @@ impl DescriptorPublicKey {
                 if let Some((fingerprint, _)) = single.origin {
                     fingerprint
                 } else {
-                    let bytes = match single.key {
-                        SinglePubKey::FullKey(pk) => pk.to_bytes(),
-                        SinglePubKey::XOnly(x_only_pk) => x_only_pk.serialize().to_vec(),
-                    };
-                    let hash = hash160::Hash::hash(&bytes);
+                    use bitcoin::hashes::HashEngine as _;
+
+                    // FIXME: Should we support this usecase for `XKeyIdentifier`? I.e., should one
+                    // be able to hash arbitrary data into it without having to know the inner hash?
+                    let mut engine = hash160::Hash::engine();
+                    match single.key {
+                        SinglePubKey::FullKey(pk) => {
+                            pk.write_into(&mut engine).expect("engines don't error")
+                        }
+                        SinglePubKey::XOnly(x_only_pk) => engine.input(&x_only_pk.serialize()),
+                    }
+                    let hash = engine.finalize();
+                    // FIXME: This is also a bit klunky.
                     bip32::Fingerprint::from(
                         &hash.as_byte_array()[..4]
                             .try_into()
@@ -1252,12 +1260,7 @@ impl DefiniteDescriptorKey {
         match self.0 {
             DescriptorPublicKey::Single(ref pk) => match pk.key {
                 SinglePubKey::FullKey(pk) => pk,
-                SinglePubKey::XOnly(xpk) => {
-                    let bytes = xpk.serialize();
-                    let secp_xonly = bitcoin::secp256k1::XOnlyPublicKey::from_byte_array(bytes)
-                        .expect("32-byte array is valid XOnlyPublicKey");
-                    secp_xonly.to_public_key()
-                },
+                SinglePubKey::XOnly(xpk) => xpk.to_public_key(),
             },
             DescriptorPublicKey::XPub(ref xpk) => match xpk.wildcard {
                 Wildcard::Unhardened | Wildcard::Hardened => {

src/interpreter/inner.rs

@@ -128,8 +128,9 @@ pub(super) fn from_txdata<'txin>(
             Err(Error::NonEmptyWitness)
         } else {
             match ssig_stack.pop() {
+                // FIXME: Andrew to check that we are happy with the new more-restrictive hashes API.
                 Some(elem) => {
-                        let pk = pk_from_stack_elem(&elem, false)?;
+                    let pk = pk_from_stack_elem(&elem, false)?;
                     let hash160 = pk.to_pubkeyhash(SigType::Ecdsa);
                     let pkh = bitcoin::key::PubkeyHash::from_byte_array(hash160.to_byte_array());
                     if *spk == ScriptPubKeyBuf::new_p2pkh(pkh) {
@@ -399,6 +400,8 @@ impl<Ctx: ScriptContext> ToNoChecks for Miniscript<bitcoin::key::XOnlyPublicKey,
     }
 }
 
+// FIXME: Added by Claude, is this correct or should we refactor no that there is a new
+// `XOnlyPublicKey` wrapper type in `bitcoin`?
 impl<Ctx: ScriptContext> ToNoChecks for Miniscript<bitcoin::secp256k1::XOnlyPublicKey, Ctx> {
     fn to_no_checks_ms(&self) -> Miniscript<BitcoinKey, NoChecks> {
         struct TranslateSecp256k1XOnlyPk;

src/interpreter/mod.rs

@@ -96,12 +96,7 @@ impl BitcoinKey {
     fn to_pubkeyhash(self, sig_type: SigType) -> hash160::Hash {
         match self {
             BitcoinKey::Fullkey(pk) => pk.to_pubkeyhash(sig_type),
-            BitcoinKey::XOnlyPublicKey(pk) => {
-                // XOnly keys are used in Taproot (Schnorr signatures)
-                // Convert to full public key assuming even parity
-                let full_pk = pk.public_key(secp256k1::Parity::Even);
-                full_pk.to_pubkeyhash(sig_type)
-            }
+            BitcoinKey::XOnlyPublicKey(pk) => pk.to_pubkeyhash(sig_type),
         }
     }
 }
@@ -111,11 +106,7 @@ impl fmt::Display for BitcoinKey {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
             BitcoinKey::Fullkey(pk) => pk.to_public_key().fmt(f),
-            BitcoinKey::XOnlyPublicKey(pk) => {
-                // Convert XOnly key to full public key assuming even parity
-                let full_pk = pk.public_key(secp256k1::Parity::Even);
-                full_pk.fmt(f)
-            }
+            BitcoinKey::XOnlyPublicKey(pk) => pk.to_public_key().fmt(f),
         }
     }
 }
@@ -252,7 +243,7 @@ impl<'txin> Interpreter<'txin> {
                 };
 
                 let success = msg.map(|msg| {
-                    secp.verify_ecdsa(msg, &ecdsa_sig.signature, &key.inner)
+                    secp256k1::ecdsa::verify(&ecdsa_sig.signature, msg, &key.inner)
                         .is_ok()
                 });
                 success.unwrap_or(false) // unwrap_or checks for errors, while success would have checksig results
@@ -287,7 +278,7 @@ impl<'txin> Interpreter<'txin> {
                 let success = sighash_msg.map(|hash| {
                     let msg_bytes = hash.to_byte_array();
                     if let Ok(secp_xpk) = bitcoin::secp256k1::XOnlyPublicKey::from_byte_array(xpk.serialize()) {
-                        secp.verify_schnorr(&schnorr_sig.signature, &msg_bytes, &secp_xpk).is_ok()
+                        secp256k1::schnorr::verify(&schnorr_sig.signature, &msg_bytes, &secp_xpk).is_ok()
                     } else {
                         false
                     }
@@ -1104,7 +1095,7 @@ mod tests {
                 inner: secp256k1::PublicKey::from_secret_key(&sk),
                 compressed: true,
             };
-            let signature = secp.sign_ecdsa(msg, &sk);
+            let signature = secp256k1::ecdsa::sign(msg, &sk);
             ecdsa_sigs.push(bitcoin::ecdsa::Signature {
                 signature,
                 sighash_type: bitcoin::sighash::EcdsaSighashType::All,
@@ -1134,14 +1125,20 @@ mod tests {
             setup_keys_sigs(10);
         let secp_ref = &secp;
         let vfyfn = |pksig: &KeySigPair| match pksig {
-            KeySigPair::Ecdsa(pk, ecdsa_sig) => secp_ref
-                .verify_ecdsa(sighash, &ecdsa_sig.signature, &pk.inner)
-                .is_ok(),
+            KeySigPair::Ecdsa(pk, ecdsa_sig) => secp256k1::ecdsa::verify(
+                &ecdsa_sig.signature,
+                &sighash,
+                &pk.inner
+            )
+            .is_ok(),
             KeySigPair::Schnorr(xpk, schnorr_sig) => {
                 use crate::ToPublicKey;
-                secp_ref
-                    .verify_schnorr(&schnorr_sig.signature, sighash.as_ref(), &xpk.to_x_only_pubkey())
-                    .is_ok()
+                secp256k1::schnorr::verify(
+                    &schnorr_sig.signature,
+                    sighash.as_ref(),
+                    &xpk.to_x_only_pubkey()
+                )
+                .is_ok()
             }
         };
 

src/psbt/finalizer.rs

@@ -355,7 +355,7 @@ fn interpreter_inp_check<C: secp256k1::Verification, T: Borrow<TxOut>>(
         let interpreter =
             interpreter::Interpreter::from_txdata(&spk, script_sig, witness, csv, cltv)
                 .map_err(|e| Error::InputError(InputError::Interpreter(e), index))?;
-        let iter = interpreter.iter(secp, &psbt.unsigned_tx, index, utxos);
+        let iter = interpreter.iter(&psbt.unsigned_tx, index, utxos);
         if let Some(error) = iter.filter_map(Result::err).next() {
             return Err(Error::InputError(InputError::Interpreter(error), index));
         };

src/psbt/mod.rs

@@ -1584,7 +1584,7 @@ mod tests {
             lock_time: absolute::LockTime::ZERO,
             inputs: vec![],
             outputs: vec![TxOut {
-                amount: Amount::from_sat(1_000).unwrap(),
+                amount: Amount::from_sat_u32(1_000),
                 script_pubkey: ScriptPubKeyBuf::from_hex(
                     "5120a60869f0dbcf1dc659c9cecbaf8050135ea9e8cdc487053f1dc6880949dc684c",
                 )
@@ -1648,7 +1648,7 @@ mod tests {
             lock_time: absolute::LockTime::ZERO,
             inputs: vec![],
             outputs: vec![TxOut {
-                amount: Amount::from_sat(1_000).unwrap(),
+                amount: Amount::from_sat_u32(1_000),
                 script_pubkey: ScriptPubKeyBuf::from_hex(
                     "5120a60869f0dbcf1dc659c9cecbaf8050135ea9e8cdc487053f1dc6880949dc684c",
                 )