Added Script Context

Author: sanket1729

.gitignore

@@ -14,3 +14,6 @@ fuzz/hfuzz_workspace
 
 #emacs
 *~
+
+#VsCode files
+.vscode

.travis.yml

@@ -9,7 +9,7 @@ matrix:
       env: DO_FUZZ=true DO_LINT=true
     - rust: beta
     - rust: nightly
-      env: DO_BENCH=true
+      env: DO_BENCH=true DO_MIRI=true
     - rust: 1.22.0
 
 script:

contrib/test.sh

@@ -43,6 +43,23 @@ then
     )
 fi
 
+# Miri Checks if told to
+# Only supported in nightly
+if [ "$DO_MIRI" = true ]
+then
+    (
+        MIRI_NIGHTLY=nightly-$(curl -s https://rust-lang.github.io/rustup-components-history/x86_64-unknown-linux-gnu/miri)
+        echo "Installing latest nightly with Miri: $MIRI_NIGHTLY"
+        rustup set profile minimal
+        rustup default "$MIRI_NIGHTLY"
+        rustup component add rustfmt
+        cargo miri test -- -- any_unsafe_transmute_miri_test
+
+        # Change back to latest nightly possibly without Miri
+        rustup default nightly
+    )
+fi
+
 # Bench if told to
 if [ "$DO_BENCH" = true ]
 then

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,8 @@ use std::fmt;
 use std::str::{self, FromStr};
 
 use expression;
-use miniscript::Miniscript;
+use miniscript::context::ScriptContextError;
+use miniscript::{Legacy, Miniscript, Segwitv0};
 use Error;
 use MiniscriptKey;
 use Satisfier;
@@ -49,8 +50,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
@@ -59,12 +60,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> {
@@ -73,29 +74,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)),
         }
     }
 }
@@ -200,7 +215,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 +411,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::ContextError(ScriptContextError::CompressedOnly))
+                } 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::ContextError(ScriptContextError::CompressedOnly))
+                        } 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))
@@ -563,6 +583,18 @@ mod tests {
         StdDescriptor::from_str("pk()").unwrap_err();
 
         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]
@@ -852,6 +884,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!(