taproot descriptor: strucuture, parsing and testing done

Author: SarcasticNastik

src/descriptor/mod.rs

@@ -51,6 +51,7 @@ pub use self::bare::{Bare, Pkh};
 pub use self::segwitv0::{Wpkh, Wsh, WshInner};
 pub use self::sh::{Sh, ShInner};
 pub use self::sortedmulti::SortedMultiVec;
+pub use self::tr::Tr;
 
 mod checksum;
 mod key;
@@ -168,6 +169,9 @@ pub enum Descriptor<Pk: MiniscriptKey> {
     Sh(Sh<Pk>),
     /// Pay-to-Witness-ScriptHash with Segwitv0 context
     Wsh(Wsh<Pk>),
+    // /// Pay-to-Taproot with Segwitv0 context
+    // /// TODO: Update context to Segwitv1
+    // Tr(Tr<Pk>)
 }
 
 /// Descriptor Type of the descriptor
@@ -193,6 +197,8 @@ pub enum DescriptorType {
     WshSortedMulti,
     /// Sh Wsh Sorted Multi
     ShWshSortedMulti,
+    // /// Tr Descriptor
+    // Tr
 }
 
 impl<Pk: MiniscriptKey> Descriptor<Pk> {
@@ -279,6 +285,12 @@ impl<Pk: MiniscriptKey> Descriptor<Pk> {
         Ok(Descriptor::Wsh(Wsh::new_sortedmulti(k, pks)?))
     }
 
+    // /// Create new tr descriptor
+    // /// Errors when miniscript exceeds resource limits under Segwitv0 context
+    // pub fn new_tr(key: Pk, script: Option<tr::TapTree<Pk>>) -> Result<Self, Error> {
+    //     Ok(Descriptor::Tr(Tr::new(key, script)?))
+    // }
+
     /// Get the [DescriptorType] of [Descriptor]
     pub fn desc_type(&self) -> DescriptorType {
         match *self {
@@ -298,6 +310,7 @@ impl<Pk: MiniscriptKey> Descriptor<Pk> {
                 WshInner::SortedMulti(ref _smv) => DescriptorType::WshSortedMulti,
                 WshInner::Ms(ref _ms) => DescriptorType::Wsh,
             },
+            // Descriptor::Tr(_) => DescriptorType::Tr,
         }
     }
 }
@@ -625,6 +638,7 @@ serde_string_impl_pk!(Descriptor, "a script descriptor");
 mod tests {
     use super::checksum::desc_checksum;
     use super::DescriptorTrait;
+    use super::Tr;
     use bitcoin::blockdata::opcodes::all::{OP_CLTV, OP_CSV};
     use bitcoin::blockdata::script::Instruction;
     use bitcoin::blockdata::{opcodes, script};
@@ -1088,6 +1102,34 @@ mod tests {
         assert_eq!(check, &Ok(Instruction::Op(OP_CSV)))
     }
 
+    #[test]
+    fn tr_roundtrip_key() {
+        let script = Tr::<DummyKey>::from_str("tr()").unwrap().to_string();
+        assert_eq!(script, format!("tr()"))
+    }
+
+    #[test]
+    fn tr_roundtrip_script() {
+        let descriptor = Tr::<DummyKey>::from_str(&format!("tr(,{{pk(),pk()}})"))
+            .unwrap()
+            .to_string();
+
+        assert_eq!(descriptor, format!("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();
+
+        assert_eq!(
+            descriptor,
+            format!("tr(,{{pk(),{{pk(),or_d(pk(),pkh())}}}})")
+        )
+    }
+
     #[test]
     fn roundtrip_tests() {
         let descriptor = Descriptor::<bitcoin::PublicKey>::from_str("multi");

src/descriptor/tr.rs

@@ -5,19 +5,18 @@
 //     DescriptorTrait,
 // };
 use bitcoin::hashes::_export::_core::fmt::Formatter;
+use errstr;
 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};
 
-// TODO: Update this to infer version from descriptor.
-const VER: u8 = 0xc0;
-
 #[derive(Clone, Ord, PartialOrd, Eq, PartialEq, Hash)]
 pub enum TapTree<Pk: MiniscriptKey> {
     Tree(Arc<TapTree<Pk>>, Arc<TapTree<Pk>>),
-    Miniscript_(u8, Arc<Miniscript<Pk, Segwitv0>>),
+    Miniscript_(Arc<Miniscript<Pk, Segwitv0>>),
 }
 
 #[derive(Clone, Ord, PartialOrd, Eq, PartialEq, Hash)]
@@ -35,8 +34,10 @@ where
 {
     pub fn to_string_no_checksum(&self) -> String {
         match self {
-            TapTree::Tree(ref left, ref right) => format!("{{{},{}}}", *left, *right),
-            TapTree::Miniscript_(_, ref miniscript) => format!("{}", *miniscript),
+            TapTree::Tree(ref left, ref right) => {
+                format!("{{{},{}}}", *left.clone(), *right.clone())
+            }
+            TapTree::Miniscript_(ref script) => format!("{}", *script.clone()),
         }
     }
 }
@@ -51,7 +52,7 @@ where
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         let desc = self.to_string_no_checksum();
         // let checksum = desc_checksum(&desc).map_err(|_| fmt::Error)?;
-        // write!(f, "{}", &desc)
+        // write!(f, "{}#{}", &desc, &checksum)
         write!(f, "{}", &desc)
     }
 }
@@ -90,7 +91,7 @@ where
                 // Sanity checks
                 let script = Self::parse_miniscript(script)?;
                 let script = Arc::new(script);
-                Ok(TapTree::Miniscript_(VER, script))
+                Ok(TapTree::Miniscript_(script))
             }
             Tree { name, args } if name.len() == 0 && args.len() == 2 => {
                 // visit children
@@ -112,7 +113,7 @@ where
     }
 }
 
-impl<Pk> FromTree for Tr<Pk>
+impl<Pk: MiniscriptKey> FromTree for Tr<Pk>
 where
     Pk: MiniscriptKey + FromStr,
     Pk::Hash: FromStr,
@@ -143,32 +144,32 @@ where
                             key.args.len()
                         )));
                     }
-                    let ref tree = top.args[1]; // Tree name should be a valid miniscript except the base case
-                    let ret = Tr::tr_script_path(&tree)?;
+                    let ref tree = top.args[1];
+                    let ret = Tr::tr_script_path(tree)?;
                     Ok(Tr {
                         key_path: expression::terminal(key, Pk::from_str)?,
                         script_path: Some(ret),
                     })
                 }
                 _ => {
                     return Err(Error::Unexpected(format!(
-                        "{}({} args) while parsing taproot descriptor",
+                        "{}[#{} args] while parsing taproot descriptor",
                         top.name,
                         top.args.len()
                     )));
                 }
             }
         } else {
             return Err(Error::Unexpected(format!(
-                "{}({} args) while parsing taproot descriptor",
+                "{}[#{} args] while parsing taproot descriptor",
                 top.name,
                 top.args.len()
             )));
         }
     }
 }
 
-impl<Pk> FromStr for Tr<Pk>
+impl<Pk: MiniscriptKey> FromStr for Tr<Pk>
 where
     Pk: MiniscriptKey + FromStr,
     Pk::Hash: FromStr,
@@ -180,8 +181,10 @@ where
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         // let desc_str = verify_checksum(s)?;
         // let top = expression::Tree::from_str(desc_str)?;
-        let top = expression::Tree::from_str(s)?;
-        Self::from_tree(&top)
+
+        // Pass the TapTree then
+        let top = parse_tr(s)?;
+        Self::from_tree(&top) // parse taptree and tapscript differently
     }
 }
 
@@ -193,9 +196,113 @@ where
     <<Pk as MiniscriptKey>::Hash as FromStr>::Err: ToString,
 {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let key = &self.key_path;
         match self.script_path {
-            Some(ref s) => write!(f, "tr({},{})", self.key_path, s),
-            None => write!(f, "tr({})", self.key_path),
+            Some(ref s) => write!(f, "tr({},{})", key, s),
+            None => write!(f, "tr({})", key),
+        }
+    }
+}
+
+/// 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],
+                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))
         }
     }
 }