Merge #306: Misc: bug fixes

549f6a1 rust 1.59 warnings (sanket1729)
9036cda Implement Tr lifting (sanket1729)
b786cf0 Add breaking testcase for tr descriptor parsing (sanket1729)
6d8ed86 Fix tr descriptor parsing bug (sanket1729)
c1b516c Fix interpreter inference bug (sanket1729)
fbb393e Policy normalize bug (sanket1729)

Pull request description:

  Misc bug fixes

ACKs for top commit:
  apoelstra:
    ACK 549f6a1

Tree-SHA512: 4b922646979aedb7f2db4974f0caf59b02d37045dd27665d47675cb06323a714fb916e5cfae01d1a061cfa2d124229a2e81bdf33b0c51c00c13854d762f1ee1b

Author: sanket1729

src/descriptor/mod.rs

@@ -740,8 +740,14 @@ where
 
     fn from_str(s: &str) -> Result<Descriptor<Pk>, Error> {
         let desc_str = verify_checksum(s)?;
-        let top = expression::Tree::from_str(desc_str)?;
-        expression::FromTree::from_tree(&top)
+        // tr tree parsing has special code
+        if desc_str.starts_with("tr") {
+            let tr = Tr::from_str(desc_str)?;
+            Ok(Descriptor::Tr(tr))
+        } else {
+            let top = expression::Tree::from_str(desc_str)?;
+            expression::FromTree::from_tree(&top)
+        }
     }
 }
 
@@ -1252,7 +1258,12 @@ mod tests {
             .unwrap()
             .to_string();
 
-        assert_eq!(descriptor, "tr(,{pk(),pk()})#7dqr6v8r")
+        assert_eq!(descriptor, "tr(,{pk(),pk()})#7dqr6v8r");
+
+        let descriptor = Descriptor::<String>::from_str("tr(A,{pk(B),pk(C)})")
+            .unwrap()
+            .to_string();
+        assert_eq!(descriptor, "tr(A,{pk(B),pk(C)})#y0uc9t6x");
     }
 
     #[test]

src/descriptor/tr.rs

@@ -546,7 +546,13 @@ impl<Pk: MiniscriptKey> Liftable<Pk> for TapTree<Pk> {
 impl<Pk: MiniscriptKey> Liftable<Pk> for Tr<Pk> {
     fn lift(&self) -> Result<Policy<Pk>, Error> {
         match &self.tree {
-            Some(root) => root.lift(),
+            Some(root) => Ok(Policy::Threshold(
+                1,
+                vec![
+                    Policy::KeyHash(self.internal_key.to_pubkeyhash()),
+                    root.lift()?,
+                ],
+            )),
             None => Ok(Policy::KeyHash(self.internal_key.to_pubkeyhash())),
         }
     }

src/expression.rs

@@ -92,7 +92,7 @@ fn next_expr(sl: &str, delim: char) -> Found {
             }
         }
     } else {
-        unreachable!("Internal: delimiters in parsing must be '(' or '{'");
+        unreachable!("{}", "Internal: delimiters in parsing must be '(' or '{'");
     }
     found
 }

src/interpreter/mod.rs

@@ -385,7 +385,7 @@ impl<'txin> Interpreter<'txin> {
             inner::Inner::Script(_, inner::ScriptType::Sh) => true,
             inner::Inner::Script(_, inner::ScriptType::Wsh) => false,
             inner::Inner::Script(_, inner::ScriptType::ShWsh) => false, // lol "sorta"
-            inner::Inner::Script(_, inner::ScriptType::Tr) => true,
+            inner::Inner::Script(_, inner::ScriptType::Tr) => false,
         }
     }
 

src/policy/compiler.rs

@@ -1246,6 +1246,7 @@ mod tests {
         assert!(policy_compile_lift_check("and(pk(A),pk(B))").is_ok());
         assert!(policy_compile_lift_check("or(pk(A),pk(B))").is_ok());
         assert!(policy_compile_lift_check("thresh(2,pk(A),pk(B),pk(C))").is_ok());
+        assert!(policy_compile_lift_check("or(thresh(1,pk(A),pk(B)),pk(C))").is_ok());
 
         assert_eq!(
             policy_compile_lift_check("thresh(2,after(9),after(9),pk(A))"),

src/policy/mod.rs

@@ -181,7 +181,7 @@ impl<Pk: MiniscriptKey> Liftable<Pk> for Descriptor<Pk> {
             Descriptor::Wpkh(ref wpkh) => wpkh.lift(),
             Descriptor::Wsh(ref wsh) => wsh.lift(),
             Descriptor::Sh(ref sh) => sh.lift(),
-            Descriptor::Tr(ref _tr) => unimplemented!(),
+            Descriptor::Tr(ref tr) => tr.lift(),
         }
     }
 }

src/policy/semantic.rs

@@ -413,18 +413,15 @@ impl<Pk: MiniscriptKey> Policy<Pk> {
                 for sub in subs {
                     match sub {
                         Policy::Trivial | Policy::Unsatisfiable => {}
-                        Policy::Threshold(1, or_subs) => {
-                            if is_or {
-                                ret_subs.extend(or_subs);
-                            } else {
-                                ret_subs.push(Policy::Threshold(1, or_subs));
-                            }
-                        }
-                        Policy::Threshold(k, and_subs) => {
-                            if k == and_subs.len() && is_and {
-                                ret_subs.extend(and_subs)
-                            } else {
-                                ret_subs.push(Policy::Threshold(k, and_subs));
+                        Policy::Threshold(k, subs) => {
+                            match (is_and, is_or) {
+                                (true, true) => {
+                                    // means m = n = 1, thresh(1,X) type thing.
+                                    ret_subs.push(Policy::Threshold(k, subs));
+                                }
+                                (true, false) if k == subs.len() => ret_subs.extend(subs), // and case
+                                (false, true) if k == 1 => ret_subs.extend(subs), // or case
+                                _ => ret_subs.push(Policy::Threshold(k, subs)),
                             }
                         }
                         x => ret_subs.push(x),