Don't enforce strict cannonical wrappers

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