Merge rust-bitcoin#254: Add timelock mix tests from miniscript alloy spec

003226e Add all tests from alloy spec (sanket1729)
0a7e9b4 Add malleable test vectors (sanket1729)
f98ecbc Add timelock tests (sanket1729)
e0af5b7 Don't enforce strict cannonical wrappers (sanket1729)

Pull request description:

  There found one bug in the current type system! The last commit disables the test while I work on fuzzer fix for rust-secp256k1.

ACKs for top commit:
  apoelstra:
    ACK 003226e

Tree-SHA512: 399c8d2cc6c872d7c4a908809c492c495c04cbf59e757602f913fc11fb8d69ecb567da63a824faacfcf8dd0b116748c74ff4858ccb4e4d7c4444ce7bf6049481

Author: apoelstra

fuzz/fuzz_targets/roundtrip_descriptor.rs

@@ -8,28 +8,10 @@ use std::str::FromStr;
 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 str2 = desc.to_string();
+        let desc2 = Descriptor::<DummyKey>::from_str(&str2).unwrap();
 
-        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 mut checksum_split = output.split('#');
-        let pre_checksum = checksum_split.next().unwrap();
-        assert!(checksum_split.next().is_some());
-        assert!(checksum_split.next().is_none());
-
-        if normalize_aliases.len() == output.len() {
-            let len = pre_checksum.len();
-            assert_eq!(normalize_aliases[..len].to_lowercase(), pre_checksum.to_lowercase());
-        } else {
-            assert_eq!(normalize_aliases.to_lowercase(), pre_checksum.to_lowercase());
-        }
+        assert_eq!(desc, desc2);
     }
 }
 
@@ -62,4 +44,3 @@ mod tests {
         do_test(b"pkh()");
     }
 }
-

fuzz/fuzz_targets/roundtrip_miniscript_str.rs

@@ -11,18 +11,10 @@ use miniscript::Segwitv0;
 fn do_test(data: &[u8]) {
     let s = String::from_utf8_lossy(data);
     if let Ok(desc) = Miniscript::<DummyKey, Segwitv0>::from_str(&s) {
-        let output = desc.to_string();
+        let str2 = desc.to_string();
+        let desc2 = Miniscript::<DummyKey, Segwitv0>::from_str(&str2).unwrap();
 
-        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(");
-
-        assert_eq!(normalize_aliases.to_lowercase(), output.to_lowercase());
+        assert_eq!(desc, desc2);
     }
 }
 

src/lib.rs

@@ -469,10 +469,6 @@ pub enum Error {
     MultiAt(String),
     /// Name of a fragment contained `@` but we were not parsing an OR
     AtOutsideOr(String),
-    /// Fragment was an `and_v(_, true)` which should be written as `t:`
-    NonCanonicalTrue,
-    /// Fragment was an `or_i(_, false)` or `or_i(false,_)` which should be written as `u:` or `l:`
-    NonCanonicalFalse,
     /// Encountered a `l:0` which is syntactically equal to `u:0` except stupid
     LikelyFalse,
     /// Encountered a wrapping character that we don't recognize
@@ -595,10 +591,6 @@ impl fmt::Display for Error {
             Error::MultiColon(ref s) => write!(f, "«{}» has multiple instances of «:»", s),
             Error::MultiAt(ref s) => write!(f, "«{}» has multiple instances of «@»", s),
             Error::AtOutsideOr(ref s) => write!(f, "«{}» contains «@» in non-or() context", s),
-            Error::NonCanonicalTrue => f.write_str("Use «t:X» rather than «and_v(X,true())»"),
-            Error::NonCanonicalFalse => {
-                f.write_str("Use «u:X» «l:X» rather than «or_i(X,false)» «or_i(false,X)»")
-            }
             Error::LikelyFalse => write!(f, "0 is not very likely (use «u:0»)"),
             Error::UnknownWrapper(ch) => write!(f, "unknown wrapper «{}:»", ch),
             Error::NonTopLevel(ref s) => write!(f, "non-T miniscript: {}", s),

src/miniscript/astelem.rs

@@ -503,15 +503,7 @@ where
             }),
             ("1", 0) => Ok(Terminal::True),
             ("0", 0) => Ok(Terminal::False),
-            ("and_v", 2) => {
-                let expr = expression::binary(top, Terminal::AndV)?;
-                if let Terminal::AndV(_, ref right) = expr {
-                    if let Terminal::True = right.node {
-                        return Err(Error::NonCanonicalTrue);
-                    }
-                }
-                Ok(expr)
-            }
+            ("and_v", 2) => expression::binary(top, Terminal::AndV),
             ("and_b", 2) => expression::binary(top, Terminal::AndB),
             ("and_n", 2) => Ok(Terminal::AndOr(
                 expression::FromTree::from_tree(&top.args[0])?,
@@ -526,15 +518,7 @@ where
             ("or_b", 2) => expression::binary(top, Terminal::OrB),
             ("or_d", 2) => expression::binary(top, Terminal::OrD),
             ("or_c", 2) => expression::binary(top, Terminal::OrC),
-            ("or_i", 2) => {
-                let expr = expression::binary(top, Terminal::OrI)?;
-                if let Terminal::OrI(ref left, ref right) = expr {
-                    if left.node == Terminal::False || right.node == Terminal::False {
-                        return Err(Error::NonCanonicalFalse);
-                    }
-                }
-                Ok(expr)
-            }
+            ("or_i", 2) => expression::binary(top, Terminal::OrI),
             ("thresh", n) => {
                 if n == 0 {
                     return Err(errstr("no arguments given"));

src/miniscript/mod.rs

@@ -54,6 +54,8 @@ use std::sync::Arc;
 use MiniscriptKey;
 use {expression, Error, ForEach, ForEachKey, ToPublicKey, TranslatePk};
 
+#[cfg(test)]
+mod ms_tests;
 /// Top-level script AST type
 #[derive(Clone, Hash)]
 pub struct Miniscript<Pk: MiniscriptKey, Ctx: ScriptContext> {