Incomplete: Draft commit

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");

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))
@@ -852,6 +857,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!(

src/descriptor/satisfied_constraints.rs

@@ -15,6 +15,7 @@
 use bitcoin::hashes::{hash160, ripemd160, sha256, sha256d, Hash};
 use bitcoin::{self, secp256k1};
 use fmt;
+use miniscript::{Any, Legacy, ScriptContext, Segwitv0};
 use Descriptor;
 use Terminal;
 use {error, Miniscript};
@@ -200,9 +201,9 @@ pub enum SatisfiedConstraint<'desc, 'stack> {
 ///the top of the stack, we need to decide whether to execute right child or not.
 ///This is also useful for wrappers and thresholds which push a value on the stack
 ///depending on evaluation of the children.
-struct NodeEvaluationState<'desc> {
+struct NodeEvaluationState<'desc, Ctx: ScriptContext> {
     ///The node which is being evaluated
-    node: &'desc Miniscript<bitcoin::PublicKey>,
+    node: &'desc Miniscript<bitcoin::PublicKey, Ctx>,
     ///number of children evaluated
     n_evaluated: usize,
     ///number of children satisfied
@@ -217,24 +218,35 @@ struct NodeEvaluationState<'desc> {
 /// In case the script would abort on the given witness stack OR if the entire
 /// script is dissatisfied, this would return keep on returning values
 ///_until_Error.
-pub struct SatisfiedConstraints<'desc, 'stack, F: FnMut(&bitcoin::PublicKey, BitcoinSig) -> bool> {
+pub struct SatisfiedConstraintsIter<
+    'desc,
+    'stack,
+    Ctx: ScriptContext,
+    F: FnMut(&bitcoin::PublicKey, BitcoinSig) -> bool,
+> {
     verify_sig: F,
     public_key: Option<&'desc bitcoin::PublicKey>,
-    state: Vec<NodeEvaluationState<'desc>>,
+    state: Vec<NodeEvaluationState<'desc, Ctx>>,
     stack: Stack<'stack>,
     age: u32,
     height: u32,
     has_errored: bool,
 }
 
+pub enum SatisfiedConstraints<'desc, 'stack, F: FnMut(&bitcoin::PublicKey, BitcoinSig) -> bool> {
+    Legacy(SatisfiedConstraintsIter<'desc, 'stack, Legacy, F>),
+    Segwitv0(SatisfiedConstraintsIter<'desc, 'stack, Segwitv0, F>),
+    Any(SatisfiedConstraintsIter<'desc, 'stack, Any, F>),
+}
 /// Stack Data structure representing the stack input to Miniscript. This Stack
 /// is created from the combination of ScriptSig and Witness stack.
 #[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Debug, Hash)]
 pub struct Stack<'stack>(pub Vec<StackElement<'stack>>);
 
-///Iterator for SatisfiedConstraints
-impl<'desc, 'stack, F> Iterator for SatisfiedConstraints<'desc, 'stack, F>
+///Iterator for SatisfiedConstraintsIter
+impl<'desc, 'stack, Ctx, F> Iterator for SatisfiedConstraintsIter<'desc, 'stack, Ctx, F>
 where
+    Ctx: ScriptContext,
     F: FnMut(&bitcoin::PublicKey, BitcoinSig) -> bool,
 {
     type Item = Result<SatisfiedConstraint<'desc, 'stack>, Error>;
@@ -257,36 +269,21 @@ impl<'desc, 'stack, F> SatisfiedConstraints<'desc, 'stack, F>
 where
     F: FnMut(&bitcoin::PublicKey, BitcoinSig) -> bool,
 {
-    /// Helper function to push a NodeEvaluationState on state stack
-    fn push_evaluation_state(
-        &mut self,
-        node: &'desc Miniscript<bitcoin::PublicKey>,
-        n_evaluated: usize,
-        n_satisfied: usize,
-    ) -> () {
-        self.state.push(NodeEvaluationState {
-            node,
-            n_evaluated,
-            n_satisfied,
-        })
-    }
-
-    /// Creates a new iterator over all constraints satisfied for a given
+    // Creates a new iterator over all constraints satisfied for a given
     /// descriptor by a given witness stack. Because this iterator is lazy,
     /// it may return satisfied constraints even if these turn out to be
     /// irrelevant to the final (dis)satisfaction of the descriptor.
+    /// Because the iterator is dependent evaluating the miniscript, it is
+    /// dependent on scriptContext
     pub fn from_descriptor(
         des: &'desc Descriptor<bitcoin::PublicKey>,
         stack: Stack<'stack>,
         verify_sig: F,
         age: u32,
         height: u32,
-    ) -> SatisfiedConstraints<'desc, 'stack, F> {
+    ) -> SatisfiedConstraintsIter<'desc, 'stack, Any, F> {
         match des {
-            &Descriptor::Pk(ref pk)
-            | &Descriptor::Pkh(ref pk)
-            | &Descriptor::ShWpkh(ref pk)
-            | &Descriptor::Wpkh(ref pk) => SatisfiedConstraints {
+            &Descriptor::Pk(ref pk) | &Descriptor::Pkh(ref pk) => SatisfiedConstraintsIter {
                 verify_sig: verify_sig,
                 public_key: Some(pk),
                 state: vec![],
@@ -295,24 +292,67 @@ where
                 height,
                 has_errored: false,
             },
-            &Descriptor::Sh(ref miniscript)
-            | &Descriptor::Bare(ref miniscript)
-            | &Descriptor::ShWsh(ref miniscript)
-            | &Descriptor::Wsh(ref miniscript) => SatisfiedConstraints {
+            &Descriptor::ShWpkh(ref pk) | &Descriptor::Wpkh(ref pk) => SatisfiedConstraintsIter {
                 verify_sig: verify_sig,
-                public_key: None,
-                state: vec![NodeEvaluationState {
-                    node: miniscript,
-                    n_evaluated: 0,
-                    n_satisfied: 0,
-                }],
+                public_key: Some(pk),
+                state: vec![],
                 stack: stack,
                 age,
                 height,
                 has_errored: false,
             },
+            &Descriptor::Wsh(ref miniscript) | &Descriptor::ShWsh(ref miniscript) => {
+                SatisfiedConstraintsIter {
+                    verify_sig: verify_sig,
+                    public_key: None,
+                    state: vec![NodeEvaluationState {
+                        node: Any::from_segwitv0(miniscript),
+                        n_evaluated: 0,
+                        n_satisfied: 0,
+                    }],
+                    stack: stack,
+                    age,
+                    height,
+                    has_errored: false,
+                }
+            }
+            &Descriptor::Sh(ref miniscript) | &Descriptor::Bare(ref miniscript) => {
+                SatisfiedConstraintsIter {
+                    verify_sig: verify_sig,
+                    public_key: None,
+                    state: vec![NodeEvaluationState {
+                        node: Any::from_legacy(miniscript),
+                        n_evaluated: 0,
+                        n_satisfied: 0,
+                    }],
+                    stack: stack,
+                    age,
+                    height,
+                    has_errored: false,
+                }
+            }
         }
     }
+}
+
+impl<'desc, 'stack, Ctx, F> SatisfiedConstraintsIter<'desc, 'stack, Ctx, F>
+where
+    Ctx: ScriptContext,
+    F: FnMut(&bitcoin::PublicKey, BitcoinSig) -> bool,
+{
+    /// Helper function to push a NodeEvaluationState on state stack
+    fn push_evaluation_state(
+        &mut self,
+        node: &'desc Miniscript<bitcoin::PublicKey, Ctx>,
+        n_evaluated: usize,
+        n_satisfied: usize,
+    ) -> () {
+        self.state.push(NodeEvaluationState {
+            node,
+            n_evaluated,
+            n_satisfied,
+        })
+    }
 
     /// Helper function to step the iterator
     fn iter_next(&mut self) -> Option<Result<SatisfiedConstraint<'desc, 'stack>, Error>> {
@@ -1019,9 +1059,10 @@ mod tests {
     use bitcoin::hashes::{hash160, ripemd160, sha256, sha256d, Hash};
     use bitcoin::secp256k1::{self, Secp256k1, VerifyOnly};
     use descriptor::satisfied_constraints::{
-        Error, HashLockType, NodeEvaluationState, SatisfiedConstraint, SatisfiedConstraints, Stack,
-        StackElement,
+        Error, HashLockType, NodeEvaluationState, SatisfiedConstraint, SatisfiedConstraintsIter,
+        Stack, StackElement,
     };
+    use miniscript::Legacy;
     use std::str::FromStr;
     use BitcoinSig;
     use Miniscript;
@@ -1074,12 +1115,12 @@ mod tests {
         fn from_stack<'stack, 'elem, F>(
             verify_fn: F,
             stack: Stack<'stack>,
-            ms: &'elem Miniscript<bitcoin::PublicKey>,
-        ) -> SatisfiedConstraints<'elem, 'stack, F>
+            ms: &'elem Miniscript<bitcoin::PublicKey, Legacy>,
+        ) -> SatisfiedConstraintsIter<'elem, 'stack, Legacy, F>
         where
             F: FnMut(&bitcoin::PublicKey, BitcoinSig) -> bool,
         {
-            SatisfiedConstraints {
+            SatisfiedConstraintsIter {
                 verify_sig: verify_fn,
                 stack: stack,
                 public_key: None,