ScriptContext added to Miniscript

temp

More fixes

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

@@ -4,11 +4,12 @@ extern crate miniscript;
 use std::str::FromStr;
 
 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();
         assert_eq!(s, output);
     }

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

@@ -31,7 +31,7 @@ use std::fmt;
 use std::str::{self, FromStr};
 
 use expression;
-use miniscript::Miniscript;
+use miniscript::{Legacy, Miniscript, Segwitv0};
 use Error;
 use MiniscriptKey;
 use Satisfier;
@@ -50,7 +50,7 @@ pub use self::satisfied_constraints::Stack;
 #[derive(Clone, PartialEq, Eq, PartialOrd, Ord)]
 pub enum Descriptor<Pk: MiniscriptKey> {
     /// A raw scriptpubkey (including pay-to-pubkey)
-    Bare(Miniscript<Pk>),
+    Bare(Miniscript<Pk, Legacy>),
     /// Pay-to-Pubkey
     Pk(Pk),
     /// Pay-to-PubKey-Hash
@@ -60,11 +60,11 @@ pub enum Descriptor<Pk: MiniscriptKey> {
     /// Pay-to-Witness-PubKey-Hash inside P2SH
     ShWpkh(Pk),
     /// Pay-to-ScriptHash
-    Sh(Miniscript<Pk>),
+    Sh(Miniscript<Pk, Legacy>),
     /// Pay-to-Witness-ScriptHash
-    Wsh(Miniscript<Pk>),
+    Wsh(Miniscript<Pk, Segwitv0>),
     /// P2SH-P2WSH
-    ShWsh(Miniscript<Pk>),
+    ShWsh(Miniscript<Pk, Segwitv0>),
 }
 
 impl<Pk: MiniscriptKey> Descriptor<Pk> {
@@ -200,7 +200,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(),
         }
     }
 
@@ -395,25 +396,29 @@ 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::BadDescriptor)
+                } else {
+                    Ok(Descriptor::Wpkh(wpkh))
+                }
             }
             ("sh", 1) => {
                 let newtop = &top.args[0];
                 match (newtop.name, newtop.args.len()) {
-                    ("wsh", 1) => {
-                        let sub = Miniscript::from_tree(&newtop.args[0])?;
-                        Ok(Descriptor::ShWsh(sub))
-                    }
-                    ("wpkh", 1) => expression::terminal(&newtop.args[0], |pk| {
-                        Pk::from_str(pk).map(Descriptor::ShWpkh)
-                    }),
-                    _ => {
-                        let sub = Miniscript::from_tree(&top.args[0])?;
-                        Ok(Descriptor::Sh(sub))
+                    ("wsh", 1) => Miniscript::from_tree(&newtop.args[0]).map(Descriptor::ShWsh),
+                    ("wpkh", 1) => {
+                        let wpkh = expression::terminal(&newtop.args[0], |pk| Pk::from_str(pk))?;
+                        if wpkh.is_uncompressed() {
+                            Err(Error::BadDescriptor)
+                        } else {
+                            Ok(Descriptor::ShWpkh(wpkh))
+                        }
                     }
+                    _ => Miniscript::from_tree(&top.args[0]).map(Descriptor::Sh),
                 }
             }
-            ("wsh", 1) => expression::unary(top, Descriptor::Wsh),
+            ("wsh", 1) => Miniscript::from_tree(&top.args[0]).map(Descriptor::Wsh),
             _ => {
                 let sub = expression::FromTree::from_tree(&top)?;
                 Ok(Descriptor::Bare(sub))
@@ -841,6 +846,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!(