Add parse/parse_insane for schnorr keys

Author: sanket1729

fuzz/fuzz_targets/roundtrip_miniscript_script.rs

@@ -8,7 +8,7 @@ fn do_test(data: &[u8]) {
     // Try round-tripping as a script
     let script = script::Script::from(data.to_owned());
 
-    if let Ok(pt) = Miniscript::<_, Segwitv0>::parse(&script) {
+    if let Ok(pt) = Miniscript::<miniscript::bitcoin::PublicKey, Segwitv0>::parse(&script) {
         let output = pt.encode();
         assert_eq!(pt.script_size(), output.len());
         assert_eq!(output, script);

src/interpreter/inner.rs

@@ -50,7 +50,8 @@ fn script_from_stackelem<'a>(
 ) -> Result<Miniscript<bitcoin::PublicKey, NoChecks>, Error> {
     match *elem {
         stack::Element::Push(sl) => {
-            Miniscript::parse_insane(&bitcoin::Script::from(sl.to_owned())).map_err(Error::from)
+            Miniscript::<bitcoin::PublicKey, _>::parse_insane(&bitcoin::Script::from(sl.to_owned()))
+                .map_err(Error::from)
         }
         stack::Element::Satisfied => Miniscript::from_ast(::Terminal::True).map_err(Error::from),
         stack::Element::Dissatisfied => {
@@ -270,7 +271,7 @@ pub fn from_txdata<'txin>(
     // ** bare script **
     } else {
         if wit_stack.is_empty() {
-            let miniscript = Miniscript::parse_insane(spk)?;
+            let miniscript = Miniscript::<bitcoin::PublicKey, _>::parse_insane(spk)?;
             Ok((
                 Inner::Script(miniscript, ScriptType::Bare),
                 ssig_stack,

src/lib.rs

@@ -124,7 +124,7 @@ use bitcoin::hashes::{hash160, sha256, Hash};
 
 pub use descriptor::{Descriptor, DescriptorPublicKey, DescriptorTrait};
 pub use interpreter::Interpreter;
-pub use miniscript::context::{BareCtx, Legacy, ScriptContext, Segwitv0};
+pub use miniscript::context::{BareCtx, Legacy, ScriptContext, Segwitv0, Tap};
 pub use miniscript::decode::Terminal;
 pub use miniscript::satisfy::{BitcoinSig, Preimage32, Satisfier};
 pub use miniscript::Miniscript;

src/miniscript/mod.rs

@@ -30,7 +30,7 @@ use std::{fmt, str};
 use bitcoin;
 use bitcoin::blockdata::script;
 
-pub use self::context::{BareCtx, Legacy, Segwitv0};
+pub use self::context::{BareCtx, Legacy, Segwitv0, Tap};
 
 pub mod analyzable;
 pub mod astelem;
@@ -42,6 +42,7 @@ pub mod limits;
 pub mod satisfy;
 pub mod types;
 
+use self::decode::ParseableKey;
 use self::lex::{lex, TokenIter};
 use self::types::Property;
 pub use miniscript::context::ScriptContext;
@@ -137,17 +138,19 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> Miniscript<Pk, Ctx> {
     }
 }
 
-impl<Ctx: ScriptContext> Miniscript<bitcoin::PublicKey, Ctx> {
+impl<Pk, Ctx: ScriptContext> Miniscript<Pk, Ctx>
+where
+    Pk: ParseableKey + MiniscriptKey<Hash = bitcoin::hashes::hash160::Hash>,
+{
     /// Attempt to parse an insane(scripts don't clear sanity checks)
     /// script into a Miniscript representation.
     /// Use this to parse scripts with repeated pubkeys, timelock mixing, malleable
     /// scripts without sig or scripts that can exceed resource limits.
     /// Some of the analysis guarantees of miniscript are lost when dealing with
     /// insane scripts. In general, in a multi-party setting users should only
     /// accept sane scripts.
-    pub fn parse_insane(
-        script: &script::Script,
-    ) -> Result<Miniscript<bitcoin::PublicKey, Ctx>, Error> {
+    /// This function can be used any key that follow the `[decode::ParseableKey]` trait
+    pub fn parse_insane(script: &script::Script) -> Result<Miniscript<Pk, Ctx>, Error> {
         let tokens = lex(script)?;
         let mut iter = TokenIter::new(tokens);
 
@@ -168,7 +171,38 @@ impl<Ctx: ScriptContext> Miniscript<bitcoin::PublicKey, Ctx> {
     /// This function will fail parsing for scripts that do not clear
     /// the [Miniscript::sanity_check] checks. Use [Miniscript::parse_insane] to
     /// parse such scripts.
-    pub fn parse(script: &script::Script) -> Result<Miniscript<bitcoin::PublicKey, Ctx>, Error> {
+    /// ## Decode/Parse a miniscript from script hex
+    ///
+    /// ```rust
+    /// extern crate bitcoin;
+    /// extern crate miniscript;
+    ///
+    /// use miniscript::Miniscript;
+    /// use miniscript::{Segwitv0, Tap};
+    /// type XonlyKey = bitcoin::schnorr::PublicKey;
+    /// type Segwitv0Script = Miniscript<bitcoin::PublicKey, Segwitv0>;
+    /// type TapScript = Miniscript<XonlyKey, Tap>;
+    /// use bitcoin::hashes::hex::FromHex;
+    /// fn main() {
+    ///     // parse x-only miniscript in Taproot context
+    ///     let tapscript_ms = TapScript::parse_insane(&bitcoin::Script::from(Vec::<u8>::from_hex(
+    ///         "202788ee41e76f4f3af603da5bc8fa22997bc0344bb0f95666ba6aaff0242baa99ac",
+    ///     ).expect("Even length hex")))
+    ///     .expect("Xonly keys are valid only in taproot context");
+    ///     // tapscript fails decoding when we use them with compressed keys
+    ///     let err = TapScript::parse_insane(&bitcoin::Script::from(Vec::<u8>::from_hex(
+    ///         "21022788ee41e76f4f3af603da5bc8fa22997bc0344bb0f95666ba6aaff0242baa99ac",
+    ///     ).expect("Even length hex")))
+    ///     .expect_err("Compressed keys cannot be used in Taproot context");
+    ///     // Segwitv0 succeeds decoding with full keys.
+    ///     Segwitv0Script::parse_insane(&bitcoin::Script::from(Vec::<u8>::from_hex(
+    ///         "21022788ee41e76f4f3af603da5bc8fa22997bc0344bb0f95666ba6aaff0242baa99ac",
+    ///     ).expect("Even length hex")))
+    ///     .expect("Compressed keys are allowed in Segwit context");
+    ///
+    /// }
+    /// ```
+    pub fn parse(script: &script::Script) -> Result<Miniscript<Pk, Ctx>, Error> {
         let ms = Self::parse_insane(script)?;
         ms.sanity_check()?;
         Ok(ms)
@@ -417,8 +451,8 @@ serde_string_impl_pk!(Miniscript, "a miniscript", Ctx; ScriptContext);
 
 #[cfg(test)]
 mod tests {
-    use super::Segwitv0;
     use super::{Miniscript, ScriptContext};
+    use super::{Segwitv0, Tap};
     use hex_script;
     use miniscript::types::{self, ExtData, Property, Type};
     use miniscript::Terminal;
@@ -433,6 +467,7 @@ mod tests {
     use std::sync::Arc;
 
     type Segwitv0Script = Miniscript<bitcoin::PublicKey, Segwitv0>;
+    type Tapscript = Miniscript<bitcoin::schnorr::PublicKey, Tap>;
 
     fn pubkeys(n: usize) -> Vec<bitcoin::PublicKey> {
         let mut ret = Vec::with_capacity(n);
@@ -669,19 +704,19 @@ mod tests {
     fn verify_parse() {
         let ms = "and_v(v:hash160(20195b5a3d650c17f0f29f91c33f8f6335193d07),or_d(sha256(96de8fc8c256fa1e1556d41af431cace7dca68707c78dd88c3acab8b17164c47),older(16)))";
         let ms: Segwitv0Script = Miniscript::from_str_insane(ms).unwrap();
-        assert_eq!(ms, Miniscript::parse_insane(&ms.encode()).unwrap());
+        assert_eq!(ms, Segwitv0Script::parse_insane(&ms.encode()).unwrap());
 
         let ms = "and_v(v:sha256(96de8fc8c256fa1e1556d41af431cace7dca68707c78dd88c3acab8b17164c47),or_d(sha256(96de8fc8c256fa1e1556d41af431cace7dca68707c78dd88c3acab8b17164c47),older(16)))";
         let ms: Segwitv0Script = Miniscript::from_str_insane(ms).unwrap();
-        assert_eq!(ms, Miniscript::parse_insane(&ms.encode()).unwrap());
+        assert_eq!(ms, Segwitv0Script::parse_insane(&ms.encode()).unwrap());
 
         let ms = "and_v(v:ripemd160(20195b5a3d650c17f0f29f91c33f8f6335193d07),or_d(sha256(96de8fc8c256fa1e1556d41af431cace7dca68707c78dd88c3acab8b17164c47),older(16)))";
         let ms: Segwitv0Script = Miniscript::from_str_insane(ms).unwrap();
-        assert_eq!(ms, Miniscript::parse_insane(&ms.encode()).unwrap());
+        assert_eq!(ms, Segwitv0Script::parse_insane(&ms.encode()).unwrap());
 
         let ms = "and_v(v:hash256(96de8fc8c256fa1e1556d41af431cace7dca68707c78dd88c3acab8b17164c47),or_d(sha256(96de8fc8c256fa1e1556d41af431cace7dca68707c78dd88c3acab8b17164c47),older(16)))";
         let ms: Segwitv0Script = Miniscript::from_str_insane(ms).unwrap();
-        assert_eq!(ms, Miniscript::parse_insane(&ms.encode()).unwrap());
+        assert_eq!(ms, Segwitv0Script::parse_insane(&ms.encode()).unwrap());
     }
 
     #[test]
@@ -907,4 +942,65 @@ mod tests {
             .to_string()
             .contains("unprintable character"));
     }
+
+    #[test]
+    fn test_tapscript_rtt() {
+        // Test x-only invalid under segwitc0 context
+        let ms = Segwitv0Script::from_str_insane(&format!(
+            "pk(2788ee41e76f4f3af603da5bc8fa22997bc0344bb0f95666ba6aaff0242baa99)"
+        ));
+        assert_eq!(
+            ms.unwrap_err().to_string(),
+            "unexpected «Key secp256k1 error: secp: malformed public key»"
+        );
+        Tapscript::from_str_insane(&format!(
+            "pk(2788ee41e76f4f3af603da5bc8fa22997bc0344bb0f95666ba6aaff0242baa99)"
+        ))
+        .unwrap();
+
+        // Now test that bitcoin::PublicKey works with Taproot context
+        Miniscript::<bitcoin::PublicKey, Tap>::from_str_insane(&format!(
+            "pk(022788ee41e76f4f3af603da5bc8fa22997bc0344bb0f95666ba6aaff0242baa99)"
+        ))
+        .unwrap();
+
+        // uncompressed keys should not be allowed
+        Miniscript::<bitcoin::PublicKey, Tap>::from_str_insane(&format!(
+            "pk(04eed24a081bf1b1e49e3300df4bebe04208ac7e516b6f3ea8eb6e094584267c13483f89dcf194132e12238cc5a34b6b286fc7990d68ed1db86b69ebd826c63b29)"
+        ))
+        .unwrap_err();
+
+        //---------------- test script <-> miniscript ---------------
+        // Test parsing from scripts: x-only fails decoding in segwitv0 ctx
+        Segwitv0Script::parse_insane(&hex_script(
+            "202788ee41e76f4f3af603da5bc8fa22997bc0344bb0f95666ba6aaff0242baa99ac",
+        ))
+        .unwrap_err();
+        // x-only succeeds in tap ctx
+        Tapscript::parse_insane(&hex_script(
+            "202788ee41e76f4f3af603da5bc8fa22997bc0344bb0f95666ba6aaff0242baa99ac",
+        ))
+        .unwrap();
+        // tapscript fails decoding with compressed
+        Tapscript::parse_insane(&hex_script(
+            "21022788ee41e76f4f3af603da5bc8fa22997bc0344bb0f95666ba6aaff0242baa99ac",
+        ))
+        .unwrap_err();
+        // Segwitv0 succeeds decoding with tapscript.
+        Segwitv0Script::parse_insane(&hex_script(
+            "21022788ee41e76f4f3af603da5bc8fa22997bc0344bb0f95666ba6aaff0242baa99ac",
+        ))
+        .unwrap();
+
+        // multi not allowed in tapscript
+        Tapscript::from_str_insane(&format!(
+            "multi(1,2788ee41e76f4f3af603da5bc8fa22997bc0344bb0f95666ba6aaff0242baa99)"
+        ))
+        .unwrap_err();
+        // but allowed in segwit
+        Segwitv0Script::from_str_insane(&format!(
+            "multi(1,022788ee41e76f4f3af603da5bc8fa22997bc0344bb0f95666ba6aaff0242baa99)"
+        ))
+        .unwrap();
+    }
 }