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

003226ee34cd13048eda165404bddda644a736be Add all tests from alloy spec (sanket1729)
0a7e9b4390befa8ac1582574f8db460c0bb2cc11 Add malleable test vectors (sanket1729)
f98ecbc8bfed7a60a039547e5d3d0c2ac458ca19 Add timelock tests (sanket1729)
e0af5b7c9164e5fcb3634ad0a6def2e34f02244d 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 003226ee34cd13048eda165404bddda644a736be

Tree-SHA512: 399c8d2cc6c872d7c4a908809c492c495c04cbf59e757602f913fc11fb8d69ecb567da63a824faacfcf8dd0b116748c74ff4858ccb4e4d7c4444ce7bf6049481

Author: heap-coder

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> {