Merge rust-bitcoin/rust-miniscript#306: Misc: bug fixes

549f6a10384644b951738e81304609b80553a9ae rust 1.59 warnings (sanket1729)
9036cdaeac03109b6f07fbff9485bb1303eccc41 Implement Tr lifting (sanket1729)
b786cf06d3abbb8bd8342e56979568f3b0cd7b8b Add breaking testcase for tr descriptor parsing (sanket1729)
6d8ed86b6865d4e785e5f611e09390a24d18cd59 Fix tr descriptor parsing bug (sanket1729)
c1b516c5f4505efdaaa160cb86106a3eb04d1ef3 Fix interpreter inference bug (sanket1729)
fbb393e1ed3f7e3162b526edd27e6a9c8a8c377a Policy normalize bug (sanket1729)

Pull request description:

  Misc bug fixes

ACKs for top commit:
  apoelstra:
    ACK 549f6a10384644b951738e81304609b80553a9ae

Tree-SHA512: 4b922646979aedb7f2db4974f0caf59b02d37045dd27665d47675cb06323a714fb916e5cfae01d1a061cfa2d124229a2e81bdf33b0c51c00c13854d762f1ee1b

Author: heap-coder

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),