Added ScriptContext to Miniscript

Author: sanket1729

examples/verify_tx.rs

@@ -103,7 +103,6 @@ fn main() {
         0,
         0,
     );
-
     println!("\nExample one");
     for elem in iter {
         match elem.expect("no evaluation error") {
@@ -129,7 +128,6 @@ fn main() {
         0,
         0,
     );
-
     println!("\nExample two");
     for elem in iter {
         match elem.expect("no evaluation error") {
@@ -154,7 +152,6 @@ fn main() {
         0,
         0,
     );
-
     println!("\nExample three");
     for elem in iter {
         let error = elem.expect_err("evaluation error");

fuzz/fuzz_targets/compile_descriptor.rs

@@ -1,18 +1,19 @@
 extern crate miniscript;
 
+use miniscript::Segwitv0;
 use miniscript::{policy, DummyKey, Miniscript};
 use policy::Liftable;
 
 use std::str::FromStr;
 
-type DummyScript = Miniscript<DummyKey>;
+type DummyScript = Miniscript<DummyKey, Segwitv0>;
 type DummyPolicy = policy::Concrete<DummyKey>;
 
 fn do_test(data: &[u8]) {
     let data_str = String::from_utf8_lossy(data);
     if let Ok(pol) = DummyPolicy::from_str(&data_str) {
         // Compile
-        if let Ok(desc) = pol.compile() {
+        if let Ok(desc) = pol.compile::<Segwitv0>() {
             // Lift
             assert_eq!(desc.clone().lift(), pol.clone().lift());
             // Try to roundtrip the output of the compiler
@@ -37,7 +38,8 @@ fn main() {
 }
 
 #[cfg(feature = "honggfuzz")]
-#[macro_use] extern crate honggfuzz;
+#[macro_use]
+extern crate honggfuzz;
 #[cfg(feature = "honggfuzz")]
 fn main() {
     loop {

fuzz/fuzz_targets/roundtrip_concrete.rs

@@ -1,9 +1,8 @@
-
 extern crate miniscript;
 extern crate regex;
-use std::str::FromStr;
 use miniscript::{policy, DummyKey};
 use regex::Regex;
+use std::str::FromStr;
 
 type DummyPolicy = policy::Concrete<DummyKey>;
 
@@ -29,7 +28,8 @@ fn main() {
 }
 
 #[cfg(feature = "honggfuzz")]
-#[macro_use] extern crate honggfuzz;
+#[macro_use]
+extern crate honggfuzz;
 #[cfg(feature = "honggfuzz")]
 fn main() {
     loop {

fuzz/fuzz_targets/roundtrip_descriptor.rs

@@ -1,4 +1,3 @@
-
 extern crate miniscript;
 extern crate regex;
 
@@ -10,13 +9,15 @@ fn do_test(data: &[u8]) {
     let s = String::from_utf8_lossy(data);
     if let Ok(desc) = Descriptor::<DummyKey>::from_str(&s) {
         let output = desc.to_string();
-        
+
         let multi_wrap_pk_re = Regex::new("([a-z]+)c:pk_k\\(").unwrap();
         let multi_wrap_pkh_re = Regex::new("([a-z]+)c:pk_h\\(").unwrap();
 
         let normalize_aliases = multi_wrap_pk_re.replace_all(&s, "$1:pk(");
         let normalize_aliases = multi_wrap_pkh_re.replace_all(&normalize_aliases, "$1:pkh(");
-        let normalize_aliases = normalize_aliases.replace("c:pk_k(", "pk(").replace("c:pk_h(", "pkh(");
+        let normalize_aliases = normalize_aliases
+            .replace("c:pk_k(", "pk(")
+            .replace("c:pk_h(", "pkh(");
 
         assert_eq!(normalize_aliases.to_lowercase(), output.to_lowercase());
     }
@@ -32,7 +33,8 @@ fn main() {
 }
 
 #[cfg(feature = "honggfuzz")]
-#[macro_use] extern crate honggfuzz;
+#[macro_use]
+extern crate honggfuzz;
 #[cfg(feature = "honggfuzz")]
 fn main() {
     loop {

fuzz/fuzz_targets/roundtrip_miniscript_script.rs

@@ -1,14 +1,14 @@
-
 extern crate miniscript;
 
-use miniscript::Miniscript;
 use miniscript::bitcoin::blockdata::script;
+use miniscript::Miniscript;
+use miniscript::Segwitv0;
 
 fn do_test(data: &[u8]) {
     // Try round-tripping as a script
     let script = script::Script::from(data.to_owned());
 
-    if let Ok(pt) = Miniscript::parse(&script) {
+    if let Ok(pt) = Miniscript::<_, Segwitv0>::parse(&script) {
         let output = pt.encode();
         assert_eq!(pt.script_size(), output.len());
         assert_eq!(output, script);
@@ -25,7 +25,8 @@ fn main() {
 }
 
 #[cfg(feature = "honggfuzz")]
-#[macro_use] extern crate honggfuzz;
+#[macro_use]
+extern crate honggfuzz;
 #[cfg(feature = "honggfuzz")]
 fn main() {
     loop {

fuzz/fuzz_targets/roundtrip_miniscript_str.rs

@@ -1,27 +1,28 @@
-
 extern crate miniscript;
 extern crate regex;
 
-use std::str::FromStr;
 use regex::Regex;
+use std::str::FromStr;
 
-use miniscript::{DummyKey};
+use miniscript::DummyKey;
 use miniscript::Miniscript;
+use miniscript::Segwitv0;
 
 fn do_test(data: &[u8]) {
     let s = String::from_utf8_lossy(data);
-    if let Ok(desc) = Miniscript::<DummyKey>::from_str(&s) {
+    if let Ok(desc) = Miniscript::<DummyKey, Segwitv0>::from_str(&s) {
         let output = desc.to_string();
-        
+
         let multi_wrap_pk_re = Regex::new("([a-z]+)c:pk_k\\(").unwrap();
         let multi_wrap_pkh_re = Regex::new("([a-z]+)c:pk_h\\(").unwrap();
 
         let normalize_aliases = multi_wrap_pk_re.replace_all(&s, "$1:pk(");
         let normalize_aliases = multi_wrap_pkh_re.replace_all(&normalize_aliases, "$1:pkh(");
-        let normalize_aliases = normalize_aliases.replace("c:pk_k(", "pk(").replace("c:pk_h(", "pkh(");
+        let normalize_aliases = normalize_aliases
+            .replace("c:pk_k(", "pk(")
+            .replace("c:pk_h(", "pkh(");
 
         assert_eq!(normalize_aliases.to_lowercase(), output.to_lowercase());
-
     }
 }
 
@@ -35,7 +36,8 @@ fn main() {
 }
 
 #[cfg(feature = "honggfuzz")]
-#[macro_use] extern crate honggfuzz;
+#[macro_use]
+extern crate honggfuzz;
 #[cfg(feature = "honggfuzz")]
 fn main() {
     loop {

fuzz/fuzz_targets/roundtrip_semantic.rs

@@ -1,8 +1,7 @@
-
 extern crate miniscript;
 
-use std::str::FromStr;
 use miniscript::{policy, DummyKey};
+use std::str::FromStr;
 
 type DummyPolicy = policy::Semantic<DummyKey>;
 
@@ -24,12 +23,13 @@ fn main() {
 }
 
 #[cfg(feature = "honggfuzz")]
-#[macro_use] extern crate honggfuzz;
+#[macro_use]
+extern crate honggfuzz;
 #[cfg(feature = "honggfuzz")]
 fn main() {
     loop {
         fuzz!(|data| {
             do_test(data);
         });
     }
-}
+}

src/descriptor/create_descriptor.rs

@@ -9,7 +9,7 @@ use bitcoin::blockdata::script::Instruction;
 use descriptor::satisfied_constraints::Error as IntError;
 use descriptor::satisfied_constraints::{Stack, StackElement};
 use descriptor::Descriptor;
-use miniscript::Miniscript;
+use miniscript::{Legacy, Miniscript, Segwitv0};
 use Error;
 use ToPublicKey;
 
@@ -112,7 +112,7 @@ fn verify_wsh<'txin>(
     script_pubkey: &bitcoin::Script,
     script_sig: &bitcoin::Script,
     witness: &'txin [Vec<u8>],
-) -> Result<(Miniscript<bitcoin::PublicKey>, Stack<'txin>), Error> {
+) -> Result<(Miniscript<bitcoin::PublicKey, Segwitv0>, Stack<'txin>), Error> {
     if !script_sig.is_empty() {
         return Err(Error::NonEmptyScriptSig);
     }
@@ -121,7 +121,7 @@ fn verify_wsh<'txin>(
         if witness_script.to_v0_p2wsh() != *script_pubkey {
             return Err(Error::IncorrectScriptHash);
         }
-        let ms = Miniscript::parse(&witness_script)?;
+        let ms = Miniscript::<bitcoin::PublicKey, Segwitv0>::parse(&witness_script)?;
         //only iter till len -1 to not include the witness script
         let stack: Vec<StackElement> = witness
             .iter()
@@ -218,7 +218,7 @@ pub fn from_txin_with_witness_stack<'txin>(
             if !witness.is_empty() {
                 return Err(Error::NonEmptyWitness);
             }
-            let ms = Miniscript::parse(&redeem_script)?;
+            let ms = Miniscript::<bitcoin::PublicKey, Legacy>::parse(&redeem_script)?;
             Ok((Descriptor::Sh(ms), stack))
         }
     } else {
@@ -230,7 +230,7 @@ pub fn from_txin_with_witness_stack<'txin>(
         if !witness.is_empty() {
             return Err(Error::NonEmptyWitness);
         }
-        let ms = Miniscript::parse(script_pubkey)?;
+        let ms = Miniscript::<bitcoin::PublicKey, Legacy>::parse(script_pubkey)?;
         Ok((Descriptor::Bare(ms), Stack(stack?)))
     }
 }

src/descriptor/mod.rs

@@ -32,7 +32,8 @@ use std::str::{self, FromStr};
 
 use expression;
 use miniscript;
-use miniscript::Miniscript;
+use miniscript::context::ScriptContextError;
+use miniscript::{Legacy, Miniscript, Segwitv0};
 use Error;
 use MiniscriptKey;
 use Satisfier;
@@ -50,8 +51,8 @@ pub use self::satisfied_constraints::Stack;
 /// Script descriptor
 #[derive(Clone, PartialEq, Eq, PartialOrd, Ord)]
 pub enum Descriptor<Pk: MiniscriptKey> {
-    /// A raw scriptpubkey (including pay-to-pubkey)
-    Bare(Miniscript<Pk>),
+    /// A raw scriptpubkey (including pay-to-pubkey) under Legacy context
+    Bare(Miniscript<Pk, Legacy>),
     /// Pay-to-Pubkey
     Pk(Pk),
     /// Pay-to-PubKey-Hash
@@ -60,16 +61,18 @@ pub enum Descriptor<Pk: MiniscriptKey> {
     Wpkh(Pk),
     /// Pay-to-Witness-PubKey-Hash inside P2SH
     ShWpkh(Pk),
-    /// Pay-to-ScriptHash
-    Sh(Miniscript<Pk>),
-    /// Pay-to-Witness-ScriptHash
-    Wsh(Miniscript<Pk>),
-    /// P2SH-P2WSH
-    ShWsh(Miniscript<Pk>),
+    /// Pay-to-ScriptHash with Legacy context
+    Sh(Miniscript<Pk, Legacy>),
+    /// Pay-to-Witness-ScriptHash with Segwitv0 context
+    Wsh(Miniscript<Pk, Segwitv0>),
+    /// P2SH-P2WSH with Segwitv0 context
+    ShWsh(Miniscript<Pk, Segwitv0>),
 }
 
 impl<Pk: MiniscriptKey> Descriptor<Pk> {
     /// Convert a descriptor using abstract keys to one using specific keys
+    /// This will panic while converting to Segwit descriptor using
+    /// using uncompressed pubkeys.
     pub fn translate_pk<Fpk, Fpkh, Q, E>(
         &self,
         mut translatefpk: Fpk,
@@ -86,8 +89,18 @@ impl<Pk: MiniscriptKey> Descriptor<Pk> {
             )),
             Descriptor::Pk(ref pk) => translatefpk(pk).map(Descriptor::Pk),
             Descriptor::Pkh(ref pk) => translatefpk(pk).map(Descriptor::Pkh),
-            Descriptor::Wpkh(ref pk) => translatefpk(pk).map(Descriptor::Wpkh),
-            Descriptor::ShWpkh(ref pk) => translatefpk(pk).map(Descriptor::ShWpkh),
+            Descriptor::Wpkh(ref pk) => {
+                if pk.is_uncompressed() {
+                    panic!("Uncompressed pubkeys are not allowed in segwit v0 scripts");
+                }
+                translatefpk(pk).map(Descriptor::Wpkh)
+            }
+            Descriptor::ShWpkh(ref pk) => {
+                if pk.is_uncompressed() {
+                    panic!("Uncompressed pubkeys are not allowed in segwit v0 scripts");
+                }
+                translatefpk(pk).map(Descriptor::ShWpkh)
+            }
             Descriptor::Sh(ref ms) => Ok(Descriptor::Sh(
                 ms.translate_pk(&mut translatefpk, &mut translatefpkh)?,
             )),
@@ -201,7 +214,8 @@ impl<Pk: MiniscriptKey + ToPublicKey> Descriptor<Pk> {
                 let addr = bitcoin::Address::p2wpkh(&pk.to_public_key(), bitcoin::Network::Bitcoin);
                 addr.script_pubkey()
             }
-            Descriptor::Sh(ref d) | Descriptor::Wsh(ref d) | Descriptor::ShWsh(ref d) => d.encode(),
+            Descriptor::Sh(ref d) => d.encode(),
+            Descriptor::Wsh(ref d) | Descriptor::ShWsh(ref d) => d.encode(),
         }
     }
 
@@ -396,7 +410,12 @@ where
                 expression::terminal(&top.args[0], |pk| Pk::from_str(pk).map(Descriptor::Pkh))
             }
             ("wpkh", 1) => {
-                expression::terminal(&top.args[0], |pk| Pk::from_str(pk).map(Descriptor::Wpkh))
+                let wpkh = expression::terminal(&top.args[0], |pk| Pk::from_str(pk))?;
+                if wpkh.is_uncompressed() {
+                    Err(Error::ContextError(ScriptContextError::CompressedOnly))
+                } else {
+                    Ok(Descriptor::Wpkh(wpkh))
+                }
             }
             ("sh", 1) => {
                 let newtop = &top.args[0];
@@ -409,9 +428,14 @@ where
                             Ok(Descriptor::ShWsh(sub))
                         }
                     }
-                    ("wpkh", 1) => expression::terminal(&newtop.args[0], |pk| {
-                        Pk::from_str(pk).map(Descriptor::ShWpkh)
-                    }),
+                    ("wpkh", 1) => {
+                        let wpkh = expression::terminal(&newtop.args[0], |pk| Pk::from_str(pk))?;
+                        if wpkh.is_uncompressed() {
+                            Err(Error::ContextError(ScriptContextError::CompressedOnly))
+                        } else {
+                            Ok(Descriptor::ShWpkh(wpkh))
+                        }
+                    }
                     _ => {
                         let sub = Miniscript::from_tree(&top.args[0])?;
                         if sub.ty.corr.base != miniscript::types::Base::B {
@@ -586,6 +610,18 @@ mod tests {
         StdDescriptor::from_str("nl:0").unwrap_err(); //issue 63
 
         StdDescriptor::from_str(TEST_PK).unwrap();
+
+        let uncompressed_pk =
+        "0414fc03b8df87cd7b872996810db8458d61da8448e531569c8517b469a119d267be5645686309c6e6736dbd93940707cc9143d3cf29f1b877ff340e2cb2d259cf";
+
+        // Context tests
+        StdDescriptor::from_str(&format!("pk({})", uncompressed_pk)).unwrap();
+        StdDescriptor::from_str(&format!("pkh({})", uncompressed_pk)).unwrap();
+        StdDescriptor::from_str(&format!("sh(pk({}))", uncompressed_pk)).unwrap();
+        StdDescriptor::from_str(&format!("wpkh({})", uncompressed_pk)).unwrap_err();
+        StdDescriptor::from_str(&format!("sh(wpkh({}))", uncompressed_pk)).unwrap_err();
+        StdDescriptor::from_str(&format!("wsh(pk{})", uncompressed_pk)).unwrap_err();
+        StdDescriptor::from_str(&format!("sh(wsh(pk{}))", uncompressed_pk)).unwrap_err();
     }
 
     #[test]
@@ -875,6 +911,8 @@ mod tests {
         );
         assert_eq!(sh.unsigned_script_sig(), bitcoin::Script::new());
 
+        let ms = ms_str!("c:pk_k({})", pk);
+
         let wsh = Descriptor::Wsh(ms.clone());
         wsh.satisfy(&mut txin, &satisfier).expect("satisfaction");
         assert_eq!(