bump elements and related dep

Author: RCasatta

Cargo.toml

@@ -19,10 +19,10 @@ rand = ["bitcoin/rand"]
 base64 = ["bitcoin/base64", "elements/base64"]
 
 [dependencies]
-bitcoin = "0.31.0"
-elements = "0.24.0"
-bitcoin-miniscript = { package = "miniscript", version = "11.0" }
-simplicity = { package = "simplicity-lang", version = "0.2.0", optional = true }
+bitcoin = "0.32.0"
+elements = "0.25.0"
+bitcoin-miniscript = { package = "miniscript", version = "12.0" }
+simplicity = { package = "simplicity-lang", version = "0.3.0", optional = true }
 
 # Do NOT use this as a feature! Use the `serde` feature instead.
 actual-serde = { package = "serde", version = "1.0", optional = true }
@@ -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]

bitcoind-tests/Cargo.toml

@@ -10,4 +10,4 @@ edition = "2018"
 elements-miniscript = { path = "../" }
 elementsd = { version = "0.9.0" }
 actual-rand = { package = "rand", version = "0.8.4" }
-secp256k1 = { version = "0.28.1", features = ["rand-std"] }
+secp256k1 = { version = "0.29.0", features = ["rand-std"] }

bitcoind-tests/tests/test_arith.rs

@@ -125,7 +125,7 @@ pub fn test_desc_satisfy(cl: &ElementsD, testdata: &TestData, desc: &str) -> Vec
                         testdata.pubdata.genesis_hash,
                     )
                     .unwrap();
-                let msg = secp256k1::Message::from_slice(&sighash_msg[..]).unwrap();
+                let msg = secp256k1::Message::from_digest_slice(&sighash_msg[..]).unwrap();
                 let mut aux_rand = [0u8; 32];
                 rand::thread_rng().fill_bytes(&mut aux_rand);
                 let sig = secp.sign_schnorr_with_aux_rand(&msg, &keypair, &aux_rand);

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,7 +24,7 @@ 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::{self, verify_checksum};
@@ -100,6 +100,7 @@ impl_from_tree!(
             //
             // 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))
@@ -242,7 +243,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

@@ -31,6 +31,7 @@ use bitcoin::blockdata::script::PushBytes;
 use bitcoin::blockdata::{opcodes, script};
 use bitcoin::hashes::{hash160, ripemd160, sha256, Hash};
 use bitcoin::{self, hashes, ScriptBuf as BtcScript};
+use bitcoin_miniscript::miniscript::limits::MAX_PUBKEYS_PER_MULTISIG;
 use bitcoin_miniscript::TranslatePk as BtcTranslatePk;
 use elements::secp256k1_zkp;
 
@@ -114,16 +115,15 @@ impl MiniscriptKey for LegacyPeginKey {
 /// Legacy Pegin Descriptor
 #[derive(Clone, Ord, PartialOrd, Eq, PartialEq)]
 pub struct LegacyPegin<Pk: MiniscriptKey> {
-    /// The federation pks
-    pub fed_pks: Vec<LegacyPeginKey>,
     /// The federation threshold
-    pub fed_k: usize,
-    /// The emergency pks
-    pub emer_pks: Vec<LegacyPeginKey>,
+    fed: bitcoin_miniscript::Threshold<LegacyPeginKey, MAX_PUBKEYS_PER_MULTISIG>,
+
     /// The emergency threshold
-    pub emer_k: usize,
+    emer: bitcoin_miniscript::Threshold<LegacyPeginKey, MAX_PUBKEYS_PER_MULTISIG>,
+
     /// csv timelock
-    pub timelock: bitcoin::Sequence,
+    timelock: bitcoin_miniscript::RelLockTime,
+
     /// The elements descriptor required to redeem
     ///
     /// TODO: Allow extension user descriptors when claiming pegins
@@ -136,30 +136,29 @@ pub struct LegacyPegin<Pk: MiniscriptKey> {
 impl<Pk: MiniscriptKey> LegacyPegin<Pk> {
     /// Create a new LegacyPegin descriptor
     pub fn new(
-        fed_pks: Vec<LegacyPeginKey>,
-        fed_k: usize,
-        emer_pks: Vec<LegacyPeginKey>,
-        emer_k: usize,
-        timelock: bitcoin::Sequence,
+        fed: bitcoin_miniscript::Threshold<LegacyPeginKey, MAX_PUBKEYS_PER_MULTISIG>,
+        emer: bitcoin_miniscript::Threshold<LegacyPeginKey, MAX_PUBKEYS_PER_MULTISIG>,
+        timelock: bitcoin_miniscript::RelLockTime,
         desc: Descriptor<Pk, CovenantExt<CovExtArgs>>,
     ) -> Self {
-        let fed_ms = BtcMiniscript::from_ast(BtcTerminal::Multi(fed_k, fed_pks.clone()))
+        let fed_ms = BtcMiniscript::from_ast(BtcTerminal::Multi(fed.clone()))
             .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()))
+        let emer_ms = BtcMiniscript::from_ast(BtcTerminal::Multi(emer.clone()))
             .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)))
             .expect("Type check");
         Self {
-            fed_pks,
-            fed_k,
-            emer_pks,
-            emer_k,
+            fed,
+            emer,
             timelock,
             desc,
             ms,
@@ -175,21 +174,19 @@ impl<Pk: MiniscriptKey> LegacyPegin<Pk> {
         // Miniscript is a bunch of Arc's. So, cloning is not as bad.
         // 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)
+        let (fed, right) = if let BtcTerminal::OrD(ref a, ref b) = ms_clone.node {
+            if let (BtcTerminal::Multi(t), right) = (&a.node, &b.node) {
+                (t.clone(), 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)
-            {
+        let (timelock, emer) = if let BtcTerminal::AndV(l, r) = right {
+            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.clone())
                 } else {
                     unreachable!("Only valid pegin miniscripts");
                 }
@@ -200,10 +197,8 @@ impl<Pk: MiniscriptKey> LegacyPegin<Pk> {
             unreachable!("Only valid pegin miniscripts");
         };
         Self {
-            fed_pks: fed_pks.to_vec(),
-            fed_k,
-            emer_pks: emer_pks.to_vec(),
-            emer_k,
+            fed,
+            emer,
             timelock,
             desc,
             ms,
@@ -222,18 +217,18 @@ impl<Pk: MiniscriptKey> LegacyPegin<Pk> {
         // Hopefully, we never have to use this and dynafed is deployed
         let mut builder = script::Builder::new()
             .push_opcode(opcodes::all::OP_DEPTH)
-            .push_int(self.fed_k as i64 + 1)
+            .push_int(self.fed.k() as i64 + 1)
             .push_opcode(opcodes::all::OP_EQUAL)
             .push_opcode(opcodes::all::OP_IF)
             // manually serialize the left CMS branch, without the OP_CMS
-            .push_int(self.fed_k as i64);
+            .push_int(self.fed.k() as i64);
 
-        for key in &self.fed_pks {
+        for key in self.fed.iter() {
             let tweaked_pk = tweak_key(key.as_untweaked(), secp, tweak.as_byte_array());
             builder = builder.push_key(&tweaked_pk);
         }
         let mut nearly_done = builder
-            .push_int(self.fed_pks.len() as i64)
+            .push_int(self.fed.n() as i64)
             .push_opcode(opcodes::all::OP_ELSE)
             .into_script()
             .to_bytes();
@@ -298,6 +293,8 @@ impl<Pk: MiniscriptKey> LegacyPegin<Pk> {
             .map(|pk| LegacyPeginKey::Functionary(bitcoin::PublicKey::from_str(pk).unwrap()))
             .collect();
 
+        let fed = bitcoin_miniscript::Threshold::new(22, fed_pks).expect("statically defined");
+
         let emer_pks = "
                     03aab896d53a8e7d6433137bbba940f9c521e085dd07e60994579b64a6d992cf79,
                     0291b7d0b1b692f8f524516ed950872e5da10fb1b808b5a526dedc6fed1cf29807,
@@ -307,12 +304,12 @@ impl<Pk: MiniscriptKey> LegacyPegin<Pk> {
             .map(|pk| LegacyPeginKey::Functionary(bitcoin::PublicKey::from_str(pk).unwrap()))
             .collect();
 
+        let emer = bitcoin_miniscript::Threshold::new(2, emer_pks).expect("statically defined");
+
         Self::new(
-            fed_pks,
-            11,
-            emer_pks,
-            2,
-            bitcoin::Sequence::from_consensus(4032),
+            fed,
+            emer,
+            bitcoin_miniscript::RelLockTime::from_consensus(4032).expect("statically defined"),
             user_desc,
         )
     }
@@ -473,28 +470,28 @@ impl<Pk: MiniscriptKey> LegacyPegin<Pk> {
         let tweak = hashes::sha256::Hash::hash(&tweak_vec);
         let unsigned_script_sig = self.bitcoin_unsigned_script_sig(secp);
         let mut sigs = vec![];
-        for key in &self.fed_pks {
+        for key in self.fed.iter() {
             let tweaked_pk = tweak_key(key.as_untweaked(), secp, tweak.as_byte_array());
             if let Some(sig) = satisfier.lookup_ecdsa_sig(&tweaked_pk) {
                 sigs.push(sig.to_vec());
             }
         }
         sigs.sort_by_key(|a| a.len());
-        if sigs.len() >= self.fed_k {
+        if sigs.len() >= self.fed.k() {
             // Prefer using federation keys over emergency paths
-            let mut sigs: Vec<Vec<u8>> = sigs.into_iter().take(self.fed_k).collect();
+            let mut sigs: Vec<Vec<u8>> = sigs.into_iter().take(self.fed.k()).collect();
             sigs.push(vec![0]); // CMS extra value
             Ok((sigs, unsigned_script_sig))
         } else {
             let mut emer_sigs = vec![];
-            for emer_key in &self.emer_pks {
+            for emer_key in self.emer.iter() {
                 if let Some(sig) = satisfier.lookup_ecdsa_sig(emer_key.as_untweaked()) {
                     emer_sigs.push(sig.to_vec());
                 }
             }
             emer_sigs.sort_by_key(|a| a.len());
-            if emer_sigs.len() >= self.emer_k {
-                let mut sigs: Vec<Vec<u8>> = emer_sigs.into_iter().take(self.emer_k).collect();
+            if emer_sigs.len() >= self.emer.k() {
+                let mut sigs: Vec<Vec<u8>> = emer_sigs.into_iter().take(self.emer.k()).collect();
                 sigs.push(vec![0]); // CMS extra value
                 Ok((sigs, unsigned_script_sig))
             } else {

src/descriptor/tr.rs

@@ -553,9 +553,9 @@ impl<'a, Pk: ToPublicKey, Ext: ParseableExt> TapLeafScript<'a, Pk, Ext> {
             TapLeafScript::Simplicity(sim) => {
                 let satisfier = crate::simplicity::SatisfierWrapper::new(satisfier);
                 let program = sim.satisfy(&satisfier).map_err(|_| Error::CouldNotSatisfy)?;
-                let program_and_witness_bytes = program.encode_to_vec();
-                Ok(vec![program_and_witness_bytes])
-            },
+                let (program_bytes, witness_bytes) = program.encode_to_vec();
+                Ok(vec![program_bytes, witness_bytes])
+            }
         }
     }
 }