tr.rs: refactor tr descriptor parsing

Author: SarcasticNastik

src/descriptor/mod.rs

@@ -1110,24 +1110,20 @@ mod tests {
 
     #[test]
     fn tr_roundtrip_script() {
-        let descriptor = Tr::<DummyKey>::from_str(&format!("tr(,{{pk(),pk()}})"))
+        let descriptor = Tr::<DummyKey>::from_str("tr(,{pk(),pk()})")
             .unwrap()
             .to_string();
 
-        assert_eq!(descriptor, format!("tr(,{{pk(),pk()}})"))
+        assert_eq!(descriptor, "tr(,{pk(),pk()})")
     }
 
     #[test]
     fn tr_roundtrip_tree() {
-        let descriptor =
-            Tr::<DummyKey>::from_str(&format!("tr(,{{pk(),{{pk(),or_d(pk(),pkh())}}}})"))
-                .unwrap()
-                .to_string();
+        let descriptor = Tr::<DummyKey>::from_str("tr(,{pk(),{pk(),or_d(pk(),pkh())}})")
+            .unwrap()
+            .to_string();
 
-        assert_eq!(
-            descriptor,
-            format!("tr(,{{pk(),{{pk(),or_d(pk(),pkh())}}}})")
-        )
+        assert_eq!(descriptor, "tr(,{pk(),{pk(),or_d(pk(),pkh())}})",)
     }
 
     #[test]

src/descriptor/tr.rs

@@ -10,7 +10,6 @@ use expression::{self, FromTree, Tree};
 use std::sync::Arc;
 use std::{fmt, str::FromStr};
 use Segwitv0;
-use MAX_RECURSION_DEPTH;
 use {miniscript::Miniscript, Error, MiniscriptKey};
 
 #[derive(Clone, Ord, PartialOrd, Eq, PartialEq, Hash)]
@@ -204,105 +203,50 @@ where
     }
 }
 
-/// TODO: Refactor to make from_str more generic in `expression.rs`?
 fn parse_tr<'a>(s: &'a str) -> Result<Tree<'a>, Error> {
     for ch in s.bytes() {
         if ch > 0x7f {
             return Err(Error::Unprintable(ch));
         }
     }
 
-    let (top, rem) = parse_tr_helper(s, 0)?;
-    if rem.is_empty() {
-        Ok(top)
-    } else {
-        Err(errstr(rem))
-    }
-}
-
-/// Helper function to parse Taproot Descriptor into key_path and TapTree
-fn parse_tr_helper<'a>(mut sl: &'a str, depth: u32) -> Result<(Tree<'a>, &'a str), Error> {
-    if depth >= MAX_RECURSION_DEPTH {
-        return Err(Error::MaxRecursiveDepthExceeded);
-    }
-
-    enum Found {
-        Nothing,
-        Lparen(usize),
-        Comma(usize),
-        Rparen(usize),
-    }
-
-    let mut found = Found::Nothing;
-    for (n, ch) in sl.char_indices() {
-        match ch {
-            '(' => {
-                found = Found::Lparen(n);
-                break;
-            }
-            ',' => {
-                found = Found::Comma(n);
-                break;
-            }
-            ')' => {
-                found = Found::Rparen(n);
-                break;
-            }
-            _ => {}
-        }
-    }
-
-    match found {
-        // String-ending terminal
-        Found::Nothing => Ok((
-            Tree {
-                name: &sl[..],
-                args: vec![],
-            },
-            "",
-        )),
-        // Terminal
-        Found::Comma(n) | Found::Rparen(n) => Ok((
-            Tree {
-                name: &sl[..n],
-                args: vec![],
-            },
-            &sl[n..],
-        )),
-        // Function call
-        Found::Lparen(n) => {
-            let mut ret = Tree {
-                name: &sl[..n],
+    // let (top, rem) = parse_tr_helper(s, 0)?;
+    // parsing a taproot descriptor
+    return if s.len() > 3 && &s[..3] == "tr(" && s.as_bytes()[s.len() - 1] == b')' {
+        let rest = &s[3..s.len() - 1];
+        if !rest.contains(',') {
+            let key_path = Tree {
+                name: rest,
                 args: vec![],
             };
-
-            sl = &sl[n + 1..];
-            let mut prev_sl: &str = "";
-            let mut prev_arg: Tree;
-            loop {
-                if prev_sl.contains("{") {
-                    let (arg, new_sl) = expression::Tree::from_slice_helper_curly(sl, depth + 1)?;
-                    prev_arg = arg;
-                    prev_sl = new_sl;
-                } else {
-                    let (arg, new_sl) = parse_tr_helper(sl, depth + 1)?;
-                    prev_arg = arg;
-                    prev_sl = new_sl;
-                }
-                ret.args.push(prev_arg);
-
-                if prev_sl.is_empty() {
-                    return Err(Error::ExpectedChar(')'));
-                }
-
-                sl = &prev_sl[1..];
-                match prev_sl.as_bytes()[0] {
-                    b',' => {}
-                    b')' => break,
-                    _ => return Err(Error::ExpectedChar(')')),
-                }
-            }
-            Ok((ret, sl))
+            return Ok(Tree {
+                name: "tr",
+                args: vec![key_path],
+            });
         }
-    }
+        let (key, script) = rest
+            .split_once(',')
+            .ok_or_else(|| Error::BadDescriptor("invalid taproot descriptor".to_string()))?;
+        let key_path = Tree {
+            name: key,
+            args: vec![],
+        };
+        if script.is_empty() {
+            return Ok(Tree {
+                name: "tr",
+                args: vec![key_path],
+            });
+        }
+        let (script_path, rest) = expression::Tree::from_slice_helper_curly(script, 0)?;
+        if rest.is_empty() {
+            Ok(Tree {
+                name: "tr",
+                args: vec![key_path, script_path],
+            })
+        } else {
+            Err(errstr(rest))
+        }
+    } else {
+        Err(Error::Unexpected("invalid taproot descriptor".to_string()))
+    };
 }

src/expression.rs

@@ -40,11 +40,7 @@ pub trait FromTree: Sized {
 impl<'a> Tree<'a> {
     pub fn from_slice(sl: &'a str) -> Result<(Tree<'a>, &'a str), Error> {
         // Parsing TapTree or just miniscript
-        if sl.contains("{") {
-            Self::from_slice_helper_curly(sl, 0u32) // parser the tr descriptor
-        } else {
-            Self::from_slice_helper_round(sl, 0u32)
-        }
+        Self::from_slice_helper_round(sl, 0u32)
     }
 
     fn from_slice_helper_round(mut sl: &'a str, depth: u32) -> Result<(Tree<'a>, &'a str), Error> {