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::{policy, DummyKey, Miniscript};
+use miniscript::context::Segwitv0;
 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

fuzz/fuzz_targets/roundtrip_miniscript_script.rs

@@ -3,12 +3,13 @@ extern crate miniscript;
 
 use miniscript::Miniscript;
 use miniscript::bitcoin::blockdata::script;
+use miniscript::context::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);

fuzz/fuzz_targets/roundtrip_miniscript_str.rs

@@ -6,11 +6,12 @@ use std::str::FromStr;
 use regex::Regex;
 
 use miniscript::{DummyKey};
+use miniscript::context::Segwitv0;
 use miniscript::Miniscript;
 
 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();

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,12 +61,12 @@ 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> {
@@ -74,29 +75,43 @@ impl<Pk: MiniscriptKey> Descriptor<Pk> {
         &self,
         mut translatefpk: Fpk,
         mut translatefpkh: Fpkh,
-    ) -> Result<Descriptor<Q>, E>
+    ) -> Result<Result<Descriptor<Q>, Error>, E>
     where
         Fpk: FnMut(&Pk) -> Result<Q, E>,
         Fpkh: FnMut(&Pk::Hash) -> Result<Q::Hash, E>,
         Q: MiniscriptKey,
     {
         match *self {
-            Descriptor::Bare(ref ms) => Ok(Descriptor::Bare(
-                ms.translate_pk(&mut translatefpk, &mut translatefpkh)?,
-            )),
-            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::Sh(ref ms) => Ok(Descriptor::Sh(
-                ms.translate_pk(&mut translatefpk, &mut translatefpkh)?,
-            )),
-            Descriptor::Wsh(ref ms) => Ok(Descriptor::Wsh(
-                ms.translate_pk(&mut translatefpk, &mut translatefpkh)?,
-            )),
-            Descriptor::ShWsh(ref ms) => Ok(Descriptor::ShWsh(
-                ms.translate_pk(&mut translatefpk, &mut translatefpkh)?,
-            )),
+            Descriptor::Bare(ref ms) => Ok(ms
+                .translate_pk(&mut translatefpk, &mut translatefpkh)?
+                .map(Descriptor::Bare)),
+            Descriptor::Pk(ref pk) => translatefpk(pk).map(Descriptor::Pk).map(Ok),
+            Descriptor::Pkh(ref pk) => translatefpk(pk).map(Descriptor::Pkh).map(Ok),
+            Descriptor::Wpkh(ref pk) => {
+                //uncompressed pubkeys not allowed in segwit descriptors
+                if pk.is_uncompressed() {
+                    Ok(Err(Error::ContextError(ScriptContextError::CompressedOnly)))
+                } else {
+                    translatefpk(pk).map(Descriptor::Wpkh).map(Ok)
+                }
+            }
+            Descriptor::ShWpkh(ref pk) => {
+                //uncompressed pubkeys not allowed in segwit descriptors
+                if pk.is_uncompressed() {
+                    Ok(Err(Error::ContextError(ScriptContextError::CompressedOnly)))
+                } else {
+                    translatefpk(pk).map(Descriptor::ShWpkh).map(Ok)
+                }
+            }
+            Descriptor::Sh(ref ms) => Ok(ms
+                .translate_pk(&mut translatefpk, &mut translatefpkh)?
+                .map(Descriptor::Sh)),
+            Descriptor::Wsh(ref ms) => Ok(ms
+                .translate_pk(&mut translatefpk, &mut translatefpkh)?
+                .map(Descriptor::Wsh)),
+            Descriptor::ShWsh(ref ms) => Ok(ms
+                .translate_pk(&mut translatefpk, &mut translatefpkh)?
+                .map(Descriptor::ShWsh)),
         }
     }
 }
@@ -201,7 +216,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 +412,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 +430,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 {
@@ -585,6 +611,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]
@@ -874,6 +912,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!(