bump elements and related dep

Author: RCasatta

Cargo.toml

@@ -19,9 +19,9 @@ rand = ["bitcoin/rand"]
 base64 = ["bitcoin/base64", "elements/base64"]
 
 [dependencies]
-bitcoin = "0.31.0"
-elements = "0.24.0"
-bitcoin-miniscript = { package = "miniscript", version = "11.0" }
+bitcoin = "0.32.0"
+elements = "0.25.0"
+bitcoin-miniscript = { package = "miniscript", version = "12.0" }
 simplicity = { package = "simplicity-lang", version = "0.2.0", optional = true }
 
 # Do NOT use this as a feature! Use the `serde` feature instead.
@@ -31,8 +31,8 @@ actual-serde = { package = "serde", version = "1.0", optional = true }
 serde_json = "1.0"
 actual-rand = { package = "rand", version = "0.8.4"}
 serde_test = "1.0.147"
-bitcoin = { version = "0.31.0", features = ["base64"] }
-secp256k1 = {version = "0.28.0", features = ["rand-std"]}
+bitcoin = { version = "0.32.0", features = ["base64"] }
+secp256k1 = { version = "0.29.0", features = ["rand-std"] }
 actual-base64 = { package = "base64", version = "0.13.0" }
 
 [lints.rust]

src/confidential/slip77.rs

@@ -92,15 +92,10 @@ impl MasterBlindingKey {
 }
 
 impl hex::FromHex for MasterBlindingKey {
-    type Err = hex::HexToArrayError;
+    type Error = hex::HexToArrayError;
 
-    fn from_byte_iter<I>(iter: I) -> Result<Self, Self::Err>
-    where
-        I: Iterator<Item = Result<u8, hex::HexToBytesError>>
-            + ExactSizeIterator
-            + DoubleEndedIterator,
-    {
-        Ok(MasterBlindingKey(<[u8; 32]>::from_byte_iter(iter)?))
+    fn from_hex(s: &str) -> Result<Self, Self::Error> {
+        Ok(MasterBlindingKey(<[u8; 32]>::from_hex(s)?))
     }
 }
 

src/descriptor/key.rs

@@ -1286,23 +1286,23 @@ mod test {
         assert_eq!(public_key.master_fingerprint().to_string(), "abcdef00");
         assert_eq!(
             public_key.full_derivation_path().unwrap().to_string(),
-            "m/0'/1'/2"
+            "0'/1'/2"
         );
         assert!(!public_key.has_wildcard());
 
         let public_key = DescriptorPublicKey::from_str("[abcdef00/0'/1']tpubDBrgjcxBxnXyL575sHdkpKohWu5qHKoQ7TJXKNrYznh5fVEGBv89hA8ENW7A8MFVpFUSvgLqc4Nj1WZcpePX6rrxviVtPowvMuGF5rdT2Vi/*").unwrap();
         assert_eq!(public_key.master_fingerprint().to_string(), "abcdef00");
         assert_eq!(
             public_key.full_derivation_path().unwrap().to_string(),
-            "m/0'/1'"
+            "0'/1'"
         );
         assert!(public_key.has_wildcard());
 
         let public_key = DescriptorPublicKey::from_str("[abcdef00/0'/1']tpubDBrgjcxBxnXyL575sHdkpKohWu5qHKoQ7TJXKNrYznh5fVEGBv89hA8ENW7A8MFVpFUSvgLqc4Nj1WZcpePX6rrxviVtPowvMuGF5rdT2Vi/*h").unwrap();
         assert_eq!(public_key.master_fingerprint().to_string(), "abcdef00");
         assert_eq!(
             public_key.full_derivation_path().unwrap().to_string(),
-            "m/0'/1'"
+            "0'/1'"
         );
         assert!(public_key.has_wildcard());
     }
@@ -1317,7 +1317,7 @@ mod test {
         assert_eq!(public_key.master_fingerprint().to_string(), "2cbe2a6d");
         assert_eq!(
             public_key.full_derivation_path().unwrap().to_string(),
-            "m/0'/1'/2"
+            "0'/1'/2"
         );
         assert!(!public_key.has_wildcard());
 
@@ -1327,7 +1327,7 @@ mod test {
         assert_eq!(public_key.master_fingerprint().to_string(), "2cbe2a6d");
         assert_eq!(
             public_key.full_derivation_path().unwrap().to_string(),
-            "m/0'/1'/2'"
+            "0'/1'/2'"
         );
 
         let secret_key = DescriptorSecretKey::from_str("tprv8ZgxMBicQKsPcwcD4gSnMti126ZiETsuX7qwrtMypr6FBwAP65puFn4v6c3jrN9VwtMRMph6nyT63NrfUL4C3nBzPcduzVSuHD7zbX2JKVc/0/1/2").unwrap();
@@ -1336,7 +1336,7 @@ mod test {
         assert_eq!(public_key.master_fingerprint().to_string(), "2cbe2a6d");
         assert_eq!(
             public_key.full_derivation_path().unwrap().to_string(),
-            "m/0/1/2"
+            "0/1/2"
         );
 
         let secret_key = DescriptorSecretKey::from_str("[aabbccdd]tprv8ZgxMBicQKsPcwcD4gSnMti126ZiETsuX7qwrtMypr6FBwAP65puFn4v6c3jrN9VwtMRMph6nyT63NrfUL4C3nBzPcduzVSuHD7zbX2JKVc/0/1/2").unwrap();
@@ -1345,7 +1345,7 @@ mod test {
         assert_eq!(public_key.master_fingerprint().to_string(), "aabbccdd");
         assert_eq!(
             public_key.full_derivation_path().unwrap().to_string(),
-            "m/0/1/2"
+            "0/1/2"
         );
 
         let secret_key = DescriptorSecretKey::from_str("[aabbccdd/90']tprv8ZgxMBicQKsPcwcD4gSnMti126ZiETsuX7qwrtMypr6FBwAP65puFn4v6c3jrN9VwtMRMph6nyT63NrfUL4C3nBzPcduzVSuHD7zbX2JKVc/0'/1'/2").unwrap();
@@ -1354,7 +1354,7 @@ mod test {
         assert_eq!(public_key.master_fingerprint().to_string(), "aabbccdd");
         assert_eq!(
             public_key.full_derivation_path().unwrap().to_string(),
-            "m/90'/0'/1'/2"
+            "90'/0'/1'/2"
         );
     }
 

src/descriptor/pegin/dynafed_pegin.rs

@@ -24,16 +24,16 @@ use std::convert::TryFrom;
 use std::fmt;
 
 use bitcoin::blockdata::script::{self, PushBytes};
-use bitcoin::{self, ScriptBuf as BtcScript};
+use bitcoin::{self, ScriptBuf as BtcScript, Weight};
 use elements::secp256k1_zkp;
 
 use crate::descriptor::checksum::{desc_checksum, verify_checksum};
 use crate::expression::{self, FromTree};
 use crate::extensions::{CovExtArgs, CovenantExt};
 use crate::policy::{semantic, Liftable};
 use crate::{
-    tweak_key, BtcDescriptor, BtcError, BtcFromTree, BtcLiftable, BtcPolicy, BtcSatisfier, BtcTree,
-    Descriptor, Error, MiniscriptKey, ToPublicKey,
+    tweak_key, BtcDescriptor, BtcError, BtcLiftable, BtcPolicy, BtcSatisfier, Descriptor, Error,
+    MiniscriptKey, ToPublicKey,
 };
 
 /// New Pegin Descriptor with Miniscript support
@@ -94,14 +94,17 @@ impl_from_tree!(
         if top.name == "pegin" && top.args.len() == 2 {
             // a roundtrip hack to use FromTree from bitcoin::Miniscript from
             // expression::Tree in elements.
-            let ms_str = top.args[0].to_string();
-            let ms_expr = BtcTree::from_str(&ms_str)?;
+            // let ms_str = top.args[0].to_string();
+            // let ms_expr = BtcTree::from_str(&ms_str)?;
             //
             // TODO: Confirm with Andrew about the descriptor type for dynafed
             // Assuming sh(wsh) for now.
-            let fed_desc = BtcDescriptor::<Pk>::from_tree(&ms_expr)?;
-            let elem_desc = Descriptor::<Pk, CovenantExt<CovExtArgs>>::from_tree(&top.args[1])?;
-            Ok(Pegin::new(fed_desc, elem_desc))
+            // let fed_desc = crate::BtcDescriptor::<Pk>::from_tree(&ms_expr)?;
+
+            // let fed_desc = BtcDescriptor::<Pk>::from_tree(&ms_expr)?;
+            // let elem_desc = Descriptor::<Pk, CovenantExt<CovExtArgs>>::from_tree(&top.args[1])?;
+            // Ok(Pegin::new(fed_desc, elem_desc))
+            todo!()
         } else {
             Err(Error::Unexpected(format!(
                 "{}({} args) while parsing legacy_pegin descriptor",
@@ -241,7 +244,7 @@ impl<Pk: MiniscriptKey> Pegin<Pk> {
     /// and sighash suffix. Includes the weight of the VarInts encoding the
     /// scriptSig and witness stack length.
     // FIXME: the ToPublicKey bound here should not needed. Fix after upstream
-    pub fn max_satisfaction_weight(&self) -> Result<usize, Error>
+    pub fn max_satisfaction_weight(&self) -> Result<Weight, Error>
     where
         Pk: ToPublicKey,
     {

src/descriptor/pegin/legacy_pegin.rs

@@ -143,14 +143,21 @@ impl<Pk: MiniscriptKey> LegacyPegin<Pk> {
         timelock: bitcoin::Sequence,
         desc: Descriptor<Pk, CovenantExt<CovExtArgs>>,
     ) -> Self {
-        let fed_ms = BtcMiniscript::from_ast(BtcTerminal::Multi(fed_k, fed_pks.clone()))
-            .expect("Multi type check can't fail");
+        let fed_ms = BtcMiniscript::from_ast(BtcTerminal::Multi(
+            bitcoin_miniscript::Threshold::new(fed_k, fed_pks.clone()).expect("TODO"),
+        ))
+        .expect("Multi type check can't fail");
         let csv = BtcMiniscript::from_ast(BtcTerminal::Verify(Arc::new(
-            BtcMiniscript::from_ast(BtcTerminal::Older(timelock)).unwrap(),
+            BtcMiniscript::from_ast(BtcTerminal::Older(
+                bitcoin_miniscript::RelLockTime::try_from(timelock).expect("TODO"),
+            ))
+            .unwrap(),
         )))
         .unwrap();
-        let emer_ms = BtcMiniscript::from_ast(BtcTerminal::Multi(emer_k, emer_pks.clone()))
-            .expect("Multi type check can't fail");
+        let emer_ms = BtcMiniscript::from_ast(BtcTerminal::Multi(
+            bitcoin_miniscript::Threshold::new(emer_k, emer_pks.clone()).expect("TODO"),
+        ))
+        .expect("Multi type check can't fail");
         let emer_ms =
             BtcMiniscript::from_ast(BtcTerminal::AndV(Arc::new(csv), Arc::new(emer_ms))).unwrap();
         let ms = BtcMiniscript::from_ast(BtcTerminal::OrD(Arc::new(fed_ms), Arc::new(emer_ms)))
@@ -176,20 +183,18 @@ impl<Pk: MiniscriptKey> LegacyPegin<Pk> {
         // Can we avoid this without NLL?
         let ms_clone = ms.clone();
         let (fed_pks, fed_k, right) = if let BtcTerminal::OrD(ref a, ref b) = ms_clone.node {
-            if let (BtcTerminal::Multi(fed_k, fed_pks), right) = (&a.node, &b.node) {
-                (fed_pks, *fed_k, right)
+            if let (BtcTerminal::Multi(t), right) = (&a.node, &b.node) {
+                (t.data(), t.k(), right)
             } else {
                 unreachable!("Only valid pegin miniscripts");
             }
         } else {
             unreachable!("Only valid pegin miniscripts");
         };
         let (timelock, emer_pks, emer_k) = if let BtcTerminal::AndV(l, r) = right {
-            if let (BtcTerminal::Verify(csv), BtcTerminal::Multi(emer_k, emer_pks)) =
-                (&l.node, &r.node)
-            {
+            if let (BtcTerminal::Verify(csv), BtcTerminal::Multi(t)) = (&l.node, &r.node) {
                 if let BtcTerminal::Older(timelock) = csv.node {
-                    (timelock, emer_pks, *emer_k)
+                    (timelock, t.data(), t.k())
                 } else {
                     unreachable!("Only valid pegin miniscripts");
                 }
@@ -204,7 +209,7 @@ impl<Pk: MiniscriptKey> LegacyPegin<Pk> {
             fed_k,
             emer_pks: emer_pks.to_vec(),
             emer_k,
-            timelock,
+            timelock: timelock.into(),
             desc,
             ms,
         }

src/lib.rs

@@ -134,20 +134,20 @@ pub mod miniscript;
 pub mod policy;
 pub mod psbt;
 
+#[cfg(feature = "simplicity")]
+mod simplicity;
 #[cfg(test)]
 mod test_utils;
 mod util;
-#[cfg(feature = "simplicity")]
-mod simplicity;
 
 use std::{cmp, error, fmt, str};
 
 use elements::hashes::sha256;
 use elements::secp256k1_zkp::Secp256k1;
 use elements::{locktime, opcodes, script, secp256k1_zkp};
 
-pub use crate::confidential::Descriptor as ConfidentialDescriptor;
 pub use crate::confidential::slip77;
+pub use crate::confidential::Descriptor as ConfidentialDescriptor;
 pub use crate::descriptor::{DefiniteDescriptorKey, Descriptor, DescriptorPublicKey};
 pub use crate::extensions::{CovenantExt, Extension, NoExt, TxEnv};
 pub use crate::interpreter::Interpreter;
@@ -291,7 +291,7 @@ pub enum Error {
     /// rust-bitcoin script error
     Script(script::Error),
     /// rust-bitcoin address error
-    AddrError(bitcoin::address::Error),
+    AddrError(bitcoin::address::ParseError),
     /// A `CHECKMULTISIG` opcode was preceded by a number > 20
     CmsTooManyKeys(u32),
     /// A tapscript multi_a cannot support more than MAX_BLOCK_WEIGHT/32 keys
@@ -319,7 +319,9 @@ pub enum Error {
     /// Parsed a miniscript but there were more script opcodes after it
     Trailing(String),
     /// Failed to parse a push as a public key
-    BadPubkey(bitcoin::key::Error),
+    BadPubkey(bitcoin::key::ParsePublicKeyError),
+    /// Failed to parse a slice as public key
+    BadPubkeySlice(bitcoin::key::FromSliceError),
     /// Could not satisfy a script (fragment) because of a missing hash preimage
     MissingHash(sha256::Hash),
     /// Could not satisfy a script (fragment) because of a missing signature
@@ -430,14 +432,21 @@ impl From<elements::secp256k1_zkp::UpstreamError> for Error {
 }
 
 #[doc(hidden)]
-impl From<bitcoin::key::Error> for Error {
-    fn from(e: bitcoin::key::Error) -> Error {
+impl From<bitcoin::key::ParsePublicKeyError> for Error {
+    fn from(e: bitcoin::key::ParsePublicKeyError) -> Error {
         Error::BadPubkey(e)
     }
 }
 
-impl From<bitcoin::address::Error> for Error {
-    fn from(e: bitcoin::address::Error) -> Error {
+#[doc(hidden)]
+impl From<bitcoin::key::FromSliceError> for Error {
+    fn from(e: bitcoin::key::FromSliceError) -> Error {
+        Error::BadPubkeySlice(e)
+    }
+}
+
+impl From<bitcoin::address::ParseError> for Error {
+    fn from(e: bitcoin::address::ParseError) -> Error {
         Error::AddrError(e)
     }
 }
@@ -486,6 +495,7 @@ impl fmt::Display for Error {
             ),
             Error::CouldNotSatisfy => f.write_str("could not satisfy"),
             Error::BadPubkey(ref e) => fmt::Display::fmt(e, f),
+            Error::BadPubkeySlice(ref e) => fmt::Display::fmt(e, f),
             Error::TypeCheck(ref e) => write!(f, "typecheck: {}", e),
             Error::BadDescriptor(ref e) => write!(f, "Invalid descriptor: {}", e),
             Error::Secp(ref e) => fmt::Display::fmt(e, f),
@@ -569,6 +579,7 @@ impl error::Error for Error {
             Script(_e) => None, // should be Some(e), but requires changes upstream
             AddrError(e) => Some(e),
             BadPubkey(e) => Some(e),
+            BadPubkeySlice(e) => Some(e),
             Secp(e) => Some(e),
             #[cfg(feature = "compiler")]
             CompilerError(e) => Some(e),

src/miniscript/decode.rs

@@ -48,7 +48,7 @@ impl ParseableKey for bitcoin::key::XOnlyPublicKey {
 #[derive(Debug, PartialEq, Eq)]
 pub enum KeyParseError {
     /// Bitcoin PublicKey parse error
-    FullKeyParseError(bitcoin::key::Error),
+    FullKeyParseError(bitcoin::key::FromSliceError),
     /// Xonly key parse Error
     XonlyKeyParseError(bitcoin::secp256k1::Error),
 }

src/miniscript/mod.rs

@@ -1088,7 +1088,7 @@ mod tests {
         );
         assert_eq!(
             ms.unwrap_err().to_string(),
-            "unexpected «pubkey hex should be 66 or 130 digits long, got: 64»",
+            "unexpected «pubkey string should be 66 or 130 digits long, got: 64»",
         );
         Tapscript::from_str_insane(
             "pk(2788ee41e76f4f3af603da5bc8fa22997bc0344bb0f95666ba6aaff0242baa99)",

src/policy/mod.rs

@@ -229,7 +229,7 @@ impl<Pk: MiniscriptKey> Liftable<Pk> for Concrete<Pk> {
 // Implement lifting from bitcoin policy to elements one
 impl<Pk: MiniscriptKey> Liftable<Pk> for BtcPolicy<Pk> {
     fn lift(&self) -> Result<Semantic<Pk>, Error> {
-        match *self {
+        match self {
             BtcPolicy::Unsatisfiable => Ok(Semantic::Unsatisfiable),
             BtcPolicy::Trivial => Ok(Semantic::Trivial),
             BtcPolicy::Key(ref pkh) => Ok(Semantic::Key(pkh.clone())),
@@ -241,10 +241,13 @@ impl<Pk: MiniscriptKey> Liftable<Pk> for BtcPolicy<Pk> {
                 n.to_consensus_u32(),
             ))),
             BtcPolicy::Older(n) => Ok(Semantic::Older(Sequence(n.to_consensus_u32()))),
-            BtcPolicy::Threshold(k, ref subs) => {
-                let new_subs: Result<Vec<Semantic<Pk>>, _> =
-                    subs.iter().map(|sub| Liftable::lift(sub)).collect();
-                Ok(Semantic::Threshold(k, new_subs?))
+            BtcPolicy::Thresh(t) => {
+                let new_subs: Result<Vec<Semantic<Pk>>, _> = t
+                    .data()
+                    .iter()
+                    .map(|sub| Liftable::lift(sub.as_ref()))
+                    .collect();
+                Ok(Semantic::Threshold(t.k(), new_subs?))
             }
         }
     }

src/psbt/mod.rs

@@ -106,7 +106,7 @@ pub enum InputError {
     /// Get the secp Errors directly
     SecpErr(elements::secp256k1_zkp::Error),
     /// Key errors
-    KeyErr(bitcoin::key::Error),
+    KeyErr(bitcoin::key::FromSliceError),
     /// Error doing an interpreter-check on a finalized psbt
     Interpreter(interpreter::Error),
     /// Redeem script does not match the p2sh hash
@@ -257,8 +257,8 @@ impl From<elements::secp256k1_zkp::Error> for InputError {
 }
 
 #[doc(hidden)]
-impl From<bitcoin::key::Error> for InputError {
-    fn from(e: bitcoin::key::Error) -> InputError {
+impl From<bitcoin::key::FromSliceError> for InputError {
+    fn from(e: bitcoin::key::FromSliceError) -> InputError {
         InputError::KeyErr(e)
     }
 }
@@ -1664,7 +1664,7 @@ mod tests {
             let (leaf_hashes, (key_fingerprint, deriv_path)) =
                 psbt_input.tap_key_origins.get(&key_0_1).unwrap();
             assert_eq!(key_fingerprint, &fingerprint);
-            assert_eq!(&deriv_path.to_string(), "m/86'/0'/0'/0/1");
+            assert_eq!(&deriv_path.to_string(), "86'/0'/0'/0/1");
             assert_eq!(leaf_hashes.len(), 2);
             assert!(leaf_hashes.contains(&first_leaf_hash));
         }
@@ -1678,7 +1678,7 @@ mod tests {
             let (leaf_hashes, (key_fingerprint, deriv_path)) =
                 psbt_input.tap_key_origins.get(&key_1_0).unwrap();
             assert_eq!(key_fingerprint, &fingerprint);
-            assert_eq!(&deriv_path.to_string(), "m/86'/0'/0'/1/0");
+            assert_eq!(&deriv_path.to_string(), "86'/0'/0'/1/0");
             assert_eq!(leaf_hashes.len(), 1);
             assert!(!leaf_hashes.contains(&first_leaf_hash));
         }