Update to 0.28.0-rc.1

sanket1729 · sanket1729 · commit 73cd5a838ff4 · 2022-03-09T03:42:21.000-08:00
There are a few wierd changes that are waiting on upstream changes, but
we should be good for 0.28.0 release. These changes would be caught by
compiler after they are fixed upstream
diff --git a/Cargo.toml b/Cargo.toml
@@ -17,7 +17,7 @@ rand = ["bitcoin/rand"]
 
 [dependencies]
 # bitcoin = "0.27"
-bitcoin = {git = "https://github.com/rust-bitcoin/rust-bitcoin", rev = "0e2e55971275da64ceb62e8991a0a5fa962cb8b1"}
+bitcoin = "0.28.0-rc.1"
 
 [dependencies.serde]
 version = "1.0"
diff --git a/examples/verify_tx.rs b/examples/verify_tx.rs
@@ -167,7 +167,9 @@ fn main() {
 
     let iter = interpreter.iter(|pk, ecdsa_sig| {
         ecdsa_sig.hash_ty == bitcoin::EcdsaSigHashType::All
-            && secp.verify_ecdsa(&message, &ecdsa_sig.sig, &pk.key).is_ok()
+            && secp
+                .verify_ecdsa(&message, &ecdsa_sig.sig, &pk.inner)
+                .is_ok()
     });
     println!("\nExample three");
     for elem in iter {
diff --git a/integration_test/Cargo.toml b/integration_test/Cargo.toml
@@ -7,6 +7,6 @@ authors = ["Steven Roose <steven@stevenroose.org>", "Sanket K <sanket1729@gmail.
 miniscript = {path = "../"}
 
 # Until 0.26 support is released on rust-bitcoincore-rpc
-bitcoincore-rpc = {git = "https://github.com/sanket1729/rust-bitcoincore-rpc",rev = "ae3ad6cac0a83454f267cb7d5191f6607bb80297"}
-bitcoin = {git = "https://github.com/rust-bitcoin/rust-bitcoin", rev = "0e2e55971275da64ceb62e8991a0a5fa962cb8b1"}
+bitcoincore-rpc = {git = "https://github.com/sanket1729/rust-bitcoincore-rpc",rev = "bcc35944b3dd636cdff9710f90f8e0cfcab28f27"}
+bitcoin = "0.28.0-rc.1"
 log = "0.4"
diff --git a/src/descriptor/key.rs b/src/descriptor/key.rs
@@ -4,11 +4,10 @@ use bitcoin::{
     self,
     hashes::Hash,
     hashes::{hex::FromHex, HashEngine},
-    schnorr::XOnlyPublicKey,
     secp256k1,
     secp256k1::{Secp256k1, Signing},
     util::bip32,
-    XpubIdentifier,
+    XOnlyPublicKey, XpubIdentifier,
 };
 
 use {MiniscriptKey, ToPublicKey};
diff --git a/src/descriptor/mod.rs b/src/descriptor/mod.rs
@@ -1011,10 +1011,7 @@ mod tests {
         let secp = secp256k1::Secp256k1::new();
         let sk =
             secp256k1::SecretKey::from_slice(&b"sally was a secret key, she said"[..]).unwrap();
-        let pk = bitcoin::PublicKey {
-            key: secp256k1::PublicKey::from_secret_key(&secp, &sk),
-            compressed: true,
-        };
+        let pk = bitcoin::PublicKey::new(secp256k1::PublicKey::from_secret_key(&secp, &sk));
         let msg = secp256k1::Message::from_slice(&b"michael was a message, amusingly"[..])
             .expect("32 bytes");
         let sig = secp.sign_ecdsa(&msg, &sk);
diff --git a/src/descriptor/sortedmulti.rs b/src/descriptor/sortedmulti.rs
@@ -140,9 +140,9 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> SortedMultiVec<Pk, Ctx> {
         // Sort pubkeys lexicographically according to BIP 67
         pks.sort_by(|a, b| {
             a.to_public_key()
-                .key
+                .inner
                 .serialize()
-                .partial_cmp(&b.to_public_key().key.serialize())
+                .partial_cmp(&b.to_public_key().inner.serialize())
                 .unwrap()
         });
         Terminal::Multi(self.k, pks)
diff --git a/src/interpreter/inner.rs b/src/interpreter/inner.rs
@@ -154,7 +154,7 @@ pub fn from_txdata<'txin>(
             match wit_stack.pop() {
                 Some(elem) => {
                     let pk = pk_from_stackelem(&elem, true)?;
-                    if *spk == bitcoin::Script::new_v0_wpkh(&pk.to_pubkeyhash().into()) {
+                    if *spk == bitcoin::Script::new_v0_p2wpkh(&pk.to_pubkeyhash().into()) {
                         Ok((
                             Inner::PublicKey(pk, PubkeyType::Wpkh),
                             wit_stack,
@@ -177,7 +177,7 @@ pub fn from_txdata<'txin>(
                     let miniscript = script_from_stackelem(&elem)?;
                     let script = miniscript.encode();
                     let scripthash = sha256::Hash::hash(&script[..]);
-                    if *spk == bitcoin::Script::new_v0_wsh(&scripthash.into()) {
+                    if *spk == bitcoin::Script::new_v0_p2wsh(&scripthash.into()) {
                         Ok((
                             Inner::Script(miniscript, ScriptType::Wsh),
                             wit_stack,
@@ -208,8 +208,9 @@ pub fn from_txdata<'txin>(
                                 } else {
                                     let pk = pk_from_stackelem(&elem, true)?;
                                     if slice
-                                        == &bitcoin::Script::new_v0_wpkh(&pk.to_pubkeyhash().into())
-                                            [..]
+                                        == &bitcoin::Script::new_v0_p2wpkh(
+                                            &pk.to_pubkeyhash().into(),
+                                        )[..]
                                     {
                                         Ok((
                                             Inner::PublicKey(pk, PubkeyType::ShWpkh),
@@ -233,7 +234,8 @@ pub fn from_txdata<'txin>(
                                     let miniscript = script_from_stackelem(&elem)?;
                                     let script = miniscript.encode();
                                     let scripthash = sha256::Hash::hash(&script[..]);
-                                    if slice == &bitcoin::Script::new_v0_wsh(&scripthash.into())[..]
+                                    if slice
+                                        == &bitcoin::Script::new_v0_p2wsh(&scripthash.into())[..]
                                     {
                                         Ok((
                                             Inner::Script(miniscript, ScriptType::ShWsh),
@@ -322,7 +324,7 @@ mod tests {
 
             let pkhash = key.to_pubkeyhash().into();
             let wpkhash = key.to_pubkeyhash().into();
-            let wpkh_spk = bitcoin::Script::new_v0_wpkh(&wpkhash);
+            let wpkh_spk = bitcoin::Script::new_v0_p2wpkh(&wpkhash);
             let wpkh_scripthash = hash160::Hash::hash(&wpkh_spk[..]).into();
 
             KeyTestData {
@@ -670,7 +672,7 @@ mod tests {
         let wit_hash = sha256::Hash::hash(&witness_script[..]).into();
         let wit_stack = Witness::from_vec(vec![witness_script.to_bytes()]);
 
-        let spk = Script::new_v0_wsh(&wit_hash);
+        let spk = Script::new_v0_p2wsh(&wit_hash);
         let blank_script = bitcoin::Script::new();
 
         // wsh without witness
@@ -708,7 +710,7 @@ mod tests {
         let wit_hash = sha256::Hash::hash(&witness_script[..]).into();
         let wit_stack = Witness::from_vec(vec![witness_script.to_bytes()]);
 
-        let redeem_script = Script::new_v0_wsh(&wit_hash);
+        let redeem_script = Script::new_v0_p2wsh(&wit_hash);
         let script_sig = script::Builder::new()
             .push_slice(&redeem_script[..])
             .into_script();
diff --git a/src/interpreter/mod.rs b/src/interpreter/mod.rs
@@ -244,7 +244,8 @@ impl<'txin> Interpreter<'txin> {
                     bitcoin::EcdsaSigHashType::NonePlusAnyoneCanPay => sighashes[4],
                     bitcoin::EcdsaSigHashType::SinglePlusAnyoneCanPay => sighashes[5],
                 };
-                secp.verify_ecdsa(&sighash, &ecdsa_sig.sig, &pk.key).is_ok()
+                secp.verify_ecdsa(&sighash, &ecdsa_sig.sig, &pk.inner)
+                    .is_ok()
             },
         )
     }
@@ -825,7 +826,7 @@ mod tests {
 
             let sk = secp256k1::SecretKey::from_slice(&sk[..]).expect("secret key");
             let pk = bitcoin::PublicKey {
-                key: secp256k1::PublicKey::from_secret_key(&secp_sign, &sk),
+                inner: secp256k1::PublicKey::from_secret_key(&secp_sign, &sk),
                 compressed: true,
             };
             let sig = secp_sign.sign_ecdsa(&msg, &sk);
@@ -842,7 +843,8 @@ mod tests {
     fn sat_constraints() {
         let (pks, der_sigs, secp_sigs, sighash, secp) = setup_keys_sigs(10);
         let vfyfn_ = |pk: &bitcoin::PublicKey, ecdsa_sig: bitcoin::EcdsaSig| {
-            secp.verify_ecdsa(&sighash, &ecdsa_sig.sig, &pk.key).is_ok()
+            secp.verify_ecdsa(&sighash, &ecdsa_sig.sig, &pk.inner)
+                .is_ok()
         };
 
         fn from_stack<'txin, 'elem, F>(
diff --git a/src/lib.rs b/src/lib.rs
@@ -197,7 +197,7 @@ pub trait ToPublicKey: MiniscriptKey {
     /// Convert an object to x-only pubkey
     fn to_x_only_pubkey(&self) -> bitcoin::secp256k1::XOnlyPublicKey {
         let pk = self.to_public_key();
-        bitcoin::secp256k1::XOnlyPublicKey::from(pk.key)
+        bitcoin::secp256k1::XOnlyPublicKey::from(pk.inner)
     }
 
     /// Converts a hashed version of the public key to a `hash160` hash.
diff --git a/src/miniscript/iter.rs b/src/miniscript/iter.rs
@@ -473,7 +473,7 @@ pub mod test {
     pub fn gen_bitcoin_pubkeys(n: usize, compressed: bool) -> Vec<bitcoin::PublicKey> {
         gen_secp_pubkeys(n)
             .into_iter()
-            .map(|key| bitcoin::PublicKey { key, compressed })
+            .map(|inner| bitcoin::PublicKey { inner, compressed })
             .collect()
     }
 
diff --git a/src/miniscript/mod.rs b/src/miniscript/mod.rs
@@ -495,7 +495,7 @@ mod tests {
             sk[2] = (i >> 16) as u8;
 
             let pk = bitcoin::PublicKey {
-                key: secp256k1::PublicKey::from_secret_key(
+                inner: secp256k1::PublicKey::from_secret_key(
                     &secp,
                     &secp256k1::SecretKey::from_slice(&sk[..]).expect("secret key"),
                 ),
@@ -743,23 +743,23 @@ mod tests {
 
         string_rtt(
             script,
-            "[B/onduesm]c:[K/onduesm]pk_k(PublicKey { compressed: true, key: PublicKey(aa4c32e50fb34a95a372940ae3654b692ea35294748c3dd2c08b29f87ba9288c8294efcb73dc719e45b91c45f084e77aebc07c1ff3ed8f37935130a36304a340) })",
+            "[B/onduesm]c:[K/onduesm]pk_k(PublicKey { compressed: true, inner: PublicKey(aa4c32e50fb34a95a372940ae3654b692ea35294748c3dd2c08b29f87ba9288c8294efcb73dc719e45b91c45f084e77aebc07c1ff3ed8f37935130a36304a340) })",
             "pk(028c28a97bf8298bc0d23d8c749452a32e694b65e30a9472a3954ab30fe5324caa)"
         );
 
         let script: Segwitv0Script = ms_str!("pk({})", pubkey.to_string());
 
         string_rtt(
             script,
-            "[B/onduesm]c:[K/onduesm]pk_k(PublicKey { compressed: true, key: PublicKey(aa4c32e50fb34a95a372940ae3654b692ea35294748c3dd2c08b29f87ba9288c8294efcb73dc719e45b91c45f084e77aebc07c1ff3ed8f37935130a36304a340) })",
+            "[B/onduesm]c:[K/onduesm]pk_k(PublicKey { compressed: true, inner: PublicKey(aa4c32e50fb34a95a372940ae3654b692ea35294748c3dd2c08b29f87ba9288c8294efcb73dc719e45b91c45f084e77aebc07c1ff3ed8f37935130a36304a340) })",
             "pk(028c28a97bf8298bc0d23d8c749452a32e694b65e30a9472a3954ab30fe5324caa)"
         );
 
         let script: Segwitv0Script = ms_str!("tv:pk({})", pubkey.to_string());
 
         string_rtt(
             script,
-            "[B/onufsm]t[V/onfsm]v[B/onduesm]c:[K/onduesm]pk_k(PublicKey { compressed: true, key: PublicKey(aa4c32e50fb34a95a372940ae3654b692ea35294748c3dd2c08b29f87ba9288c8294efcb73dc719e45b91c45f084e77aebc07c1ff3ed8f37935130a36304a340) })",
+            "[B/onufsm]t[V/onfsm]v[B/onduesm]c:[K/onduesm]pk_k(PublicKey { compressed: true, inner: PublicKey(aa4c32e50fb34a95a372940ae3654b692ea35294748c3dd2c08b29f87ba9288c8294efcb73dc719e45b91c45f084e77aebc07c1ff3ed8f37935130a36304a340) })",
             "tv:pk(028c28a97bf8298bc0d23d8c749452a32e694b65e30a9472a3954ab30fe5324caa)"
         );
 
diff --git a/src/policy/compiler.rs b/src/policy/compiler.rs
@@ -1185,7 +1185,7 @@ mod tests {
             sk[2] = (i >> 16) as u8;
 
             let pk = bitcoin::PublicKey {
-                key: secp256k1::PublicKey::from_secret_key(
+                inner: secp256k1::PublicKey::from_secret_key(
                     &secp,
                     &secp256k1::SecretKey::from_slice(&sk[..]).expect("sk"),
                 ),
diff --git a/src/policy/mod.rs b/src/policy/mod.rs
@@ -343,7 +343,7 @@ mod tests {
 
         let ms_str: Miniscript<bitcoin::PublicKey, Segwitv0> = format!(
             "andor(multi(1,{}),older(42),c:pk_k({}))",
-            key_a.key, key_b.key
+            key_a.inner, key_b.inner
         )
         .parse()
         .unwrap();
diff --git a/src/psbt/finalizer.rs b/src/psbt/finalizer.rs
@@ -24,10 +24,10 @@ use util::{script_is_v1_tr, witness_size};
 use super::{sanity_check, Psbt};
 use super::{Error, InputError, PsbtInputSatisfier};
 use bitcoin::blockdata::witness::Witness;
-use bitcoin::schnorr::XOnlyPublicKey;
 use bitcoin::secp256k1::{self, Secp256k1};
+use bitcoin::util::key::XOnlyPublicKey;
 use bitcoin::util::taproot::LeafVersion;
-use bitcoin::{self, PublicKey, Script};
+use bitcoin::{self, EcdsaSigHashType, PublicKey, Script};
 use descriptor::DescriptorTrait;
 use interpreter;
 use Descriptor;
@@ -153,12 +153,17 @@ fn get_descriptor(psbt: &Psbt, index: usize) -> Result<Descriptor<PublicKey>, In
             .filter(|&(&pk, _sig)| {
                 // Indirect way to check the equivalence of pubkey-hashes.
                 // Create a pubkey hash and check if they are the same.
+                // THIS IS A BUG AND *WILL* PRODUCE WRONG SATISFACTIONS FOR UNCOMPRESSED KEYS
+                // Partial sigs loses the compressed flag that is necessary
+                // TODO: See https://github.com/rust-bitcoin/rust-bitcoin/pull/836
+                // The type checker will fail again after we update to 0.28 and this can be removed
+                let pk = bitcoin::PublicKey::new(pk);
                 let addr = bitcoin::Address::p2pkh(&pk, bitcoin::Network::Bitcoin);
                 *script_pubkey == addr.script_pubkey()
             })
             .next();
         match partial_sig_contains_pk {
-            Some((pk, _sig)) => Ok(Descriptor::new_pkh(pk.to_owned())),
+            Some((pk, _sig)) => Ok(Descriptor::new_pkh(bitcoin::PublicKey::new(*pk))),
             None => Err(InputError::MissingPubkey),
         }
     } else if script_pubkey.is_v0_p2wpkh() {
@@ -169,13 +174,14 @@ fn get_descriptor(psbt: &Psbt, index: usize) -> Result<Descriptor<PublicKey>, In
             .filter(|&(&pk, _sig)| {
                 // Indirect way to check the equivalence of pubkey-hashes.
                 // Create a pubkey hash and check if they are the same.
+                let pk = bitcoin::PublicKey::new(pk);
                 let addr = bitcoin::Address::p2wpkh(&pk, bitcoin::Network::Bitcoin)
                     .expect("Address corresponding to valid pubkey");
                 *script_pubkey == addr.script_pubkey()
             })
             .next();
         match partial_sig_contains_pk {
-            Some((pk, _sig)) => Ok(Descriptor::new_wpkh(pk.to_owned())?),
+            Some((pk, _sig)) => Ok(Descriptor::new_wpkh(bitcoin::PublicKey::new(*pk))?),
             None => Err(InputError::MissingPubkey),
         }
     } else if script_pubkey.is_v0_p2wsh() {
@@ -227,13 +233,16 @@ fn get_descriptor(psbt: &Psbt, index: usize) -> Result<Descriptor<PublicKey>, In
                         .partial_sigs
                         .iter()
                         .filter(|&(&pk, _sig)| {
+                            let pk = bitcoin::PublicKey::new(pk);
                             let addr = bitcoin::Address::p2wpkh(&pk, bitcoin::Network::Bitcoin)
                                 .expect("Address corresponding to valid pubkey");
                             *script_pubkey == addr.script_pubkey()
                         })
                         .next();
                     match partial_sig_contains_pk {
-                        Some((pk, _sig)) => Ok(Descriptor::new_sh_wpkh(pk.to_owned())?),
+                        Some((pk, _sig)) => {
+                            Ok(Descriptor::new_sh_wpkh(bitcoin::PublicKey::new(*pk))?)
+                        }
                         None => Err(InputError::MissingPubkey),
                     }
                 } else {
@@ -338,7 +347,13 @@ pub fn finalize_helper<C: secp256k1::Verification>(
 
     // Check well-formedness of input data
     for (n, input) in psbt.inputs.iter().enumerate() {
-        let target = input.sighash_type.unwrap_or(bitcoin::EcdsaSigHashType::All);
+        // TODO: fix this after https://github.com/rust-bitcoin/rust-bitcoin/issues/838
+        let target_ecdsa_sighash_ty = match input.sighash_type {
+            Some(psbt_hash_ty) => psbt_hash_ty
+                .ecdsa_hash_ty()
+                .map_err(|e| Error::InputError(InputError::NonStandardSigHashType(e), n))?,
+            None => EcdsaSigHashType::All,
+        };
         for (key, ecdsa_sig) in &input.partial_sigs {
             let flag = bitcoin::EcdsaSigHashType::from_u32_standard(ecdsa_sig.hash_ty as u32)
                 .map_err(|_| {
@@ -349,12 +364,12 @@ pub fn finalize_helper<C: secp256k1::Verification>(
                         n,
                     )
                 })?;
-            if target != flag {
+            if target_ecdsa_sighash_ty != flag {
                 return Err(Error::InputError(
                     InputError::WrongSigHashFlag {
-                        required: target,
+                        required: target_ecdsa_sighash_ty,
                         got: flag,
-                        pubkey: *key,
+                        pubkey: bitcoin::PublicKey::new(*key),
                     },
                     n,
                 ));
@@ -398,7 +413,7 @@ pub fn finalize_helper<C: secp256k1::Verification>(
         input.final_script_witness = if witness.is_empty() {
             None
         } else {
-            Some(witness)
+            Some(bitcoin::Witness::from_vec(witness))
         };
         //reset everything
         input.partial_sigs.clear(); // 0x02
diff --git a/src/psbt/mod.rs b/src/psbt/mod.rs

Original file line number	Diff line number	Diff line change
`@@ -197,7 +197,7 @@ pub trait ToPublicKey: MiniscriptKey {`
`197`	`197`	`/// Convert an object to x-only pubkey`
`198`	`198`	`fn to_x_only_pubkey(&self) -> bitcoin::secp256k1::XOnlyPublicKey {`
`199`	`199`	`let pk = self.to_public_key();`
`200`		`- bitcoin::secp256k1::XOnlyPublicKey::from(pk.key)`
	`200`	`+ bitcoin::secp256k1::XOnlyPublicKey::from(pk.inner)`
`201`	`201`	`}`
`202`	`202`
`203`	`203`	/// Converts a hashed version of the public key to a `hash160` hash.
Original file line number	Diff line number	Diff line change
`@@ -473,7 +473,7 @@ pub mod test {`
`473`	`473`	`pub fn gen_bitcoin_pubkeys(n: usize, compressed: bool) -> Vec<bitcoin::PublicKey> {`
`474`	`474`	`gen_secp_pubkeys(n)`
`475`	`475`	`.into_iter()`
`476`		`- .map(\|key\| bitcoin::PublicKey { key, compressed })`
	`476`	`+ .map(\|inner\| bitcoin::PublicKey { inner, compressed })`
`477`	`477`	`.collect()`
`478`	`478`	`}`
`479`	`479`