taproot descriptor parsing done

Author: SarcasticNastik

src/descriptor/mod.rs

@@ -45,6 +45,7 @@ mod bare;
 mod segwitv0;
 mod sh;
 mod sortedmulti;
+mod tr;
 // Descriptor Exports
 pub use self::bare::{Bare, Pkh};
 pub use self::segwitv0::{Wpkh, Wsh, WshInner};
@@ -53,6 +54,7 @@ pub use self::sortedmulti::SortedMultiVec;
 
 mod checksum;
 mod key;
+
 pub use self::key::{
     ConversionError, DescriptorKeyParseError, DescriptorPublicKey, DescriptorSecretKey,
     DescriptorSinglePriv, DescriptorSinglePub, DescriptorXKey, InnerXKey, Wildcard,

src/descriptor/tr.rs

@@ -0,0 +1,279 @@
+// Tapscript
+
+use super::checksum::{desc_checksum, verify_checksum};
+use bitcoin::hashes::_export::_core::fmt::Formatter;
+use errstr;
+use expression::{self, FromTree, Tree};
+use miniscript::{limits::TAPROOT_MAX_NODE_COUNT, Miniscript};
+use std::cmp::max;
+use std::sync::Arc;
+use std::{fmt, str::FromStr};
+use Segwitv0;
+use {Error, MiniscriptKey};
+
+#[derive(Clone, Ord, PartialOrd, Eq, PartialEq, Hash)]
+pub enum TapTree<Pk: MiniscriptKey> {
+    Tree(Arc<TapTree<Pk>>, Arc<TapTree<Pk>>),
+    Leaf(Arc<Miniscript<Pk, Segwitv0>>),
+}
+
+#[derive(Clone, Ord, PartialOrd, Eq, PartialEq, Hash)]
+pub struct Tr<Pk: MiniscriptKey> {
+    internal_key: Pk,
+    tree: Option<TapTree<Pk>>,
+}
+
+impl<Pk: MiniscriptKey> TapTree<Pk> {
+    pub fn to_string_no_checksum(&self) -> String {
+        match self {
+            TapTree::Tree(ref left, ref right) => {
+                format!("{{{},{}}}", *left, *right)
+            }
+            TapTree::Leaf(ref script) => format!("{}", *script),
+        }
+    }
+}
+
+impl<Pk: MiniscriptKey> fmt::Display for TapTree<Pk> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        let desc = self.to_string_no_checksum();
+        write!(f, "{}", &desc)
+    }
+}
+
+impl<Pk: MiniscriptKey> Tr<Pk> {
+    fn taptree_height(tree: &TapTree<Pk>) -> usize {
+        match tree {
+            TapTree::Tree(ref left_tree, ref right_tree) => {
+                1 + max(
+                    Self::taptree_height(&**left_tree),
+                    Self::taptree_height(&**right_tree),
+                )
+            }
+            TapTree::Leaf(_) => 1,
+        }
+    }
+
+    pub fn new(internal_key: Pk, tree: Option<TapTree<Pk>>) -> Result<Self, Error> {
+        let nodes = match tree {
+            Some(ref t) => Self::taptree_height(t),
+            None => 0,
+        };
+
+        if nodes > TAPROOT_MAX_NODE_COUNT {
+            Ok(Self { internal_key, tree })
+        } else {
+            Err(Error::MaxRecursiveDepthExceeded)
+        }
+    }
+
+    fn to_string_no_checksum(&self) -> String {
+        let key = &self.internal_key;
+        match self.tree {
+            Some(ref s) => format!("tr({},{})", key, s),
+            None => format!("tr({})", key),
+        }
+    }
+
+    pub fn get_internal_key(&self) -> Result<Pk, Error> {
+        Ok(self.internal_key.clone())
+    }
+
+    pub fn get_taptree(&self) -> Result<TapTree<Pk>, Error> {
+        match &self.tree {
+            Some(t) => Ok(t.clone()),
+            None => Err(Error::Unexpected("TapTree empty".to_string())),
+        }
+    }
+}
+
+impl<Pk> Tr<Pk>
+where
+    Pk: MiniscriptKey + FromStr,
+    Pk::Hash: FromStr,
+    <Pk as FromStr>::Err: ToString,
+    <<Pk as MiniscriptKey>::Hash as FromStr>::Err: ToString,
+{
+    fn parse_miniscript(script: &str) -> Result<Miniscript<Pk, Segwitv0>, Error> {
+        let (ref script_tree, rest) = Tree::from_slice(script)?;
+        if rest.is_empty() {
+            Miniscript::<Pk, Segwitv0>::from_tree(script_tree)
+        } else {
+            return Err(Error::Unexpected(format!(
+                "error parsing miniscript from tapscript"
+            )));
+        }
+    }
+
+    // helper function for semantic parsing of script paths
+    pub fn tr_script_path(tree: &Tree) -> Result<TapTree<Pk>, Error> {
+        match tree {
+            Tree { name, args } if name.len() > 0 && args.len() == 0 => {
+                let script = name;
+                let script = Self::parse_miniscript(script)?;
+                let script = Arc::new(script);
+                Ok(TapTree::Leaf(script))
+            }
+            Tree { name, args } if name.len() == 0 && args.len() == 2 => {
+                let left_branch = &args[0];
+                let right_branch = &args[1];
+                let left_tree = Self::tr_script_path(&left_branch)?;
+                let right_tree = Self::tr_script_path(&right_branch)?;
+                let left_ref = Arc::new(left_tree);
+                let right_ref = Arc::new(right_tree);
+                Ok(TapTree::Tree(left_ref, right_ref))
+            }
+            _ => {
+                return Err(Error::Unexpected(
+                    "unknown format for script spending paths while parsing taproot descriptor"
+                        .to_string(),
+                ));
+            }
+        }
+    }
+}
+
+impl<Pk: MiniscriptKey> FromTree for Tr<Pk>
+where
+    Pk: MiniscriptKey + FromStr,
+    Pk::Hash: FromStr,
+    <Pk as FromStr>::Err: ToString,
+    <<Pk as MiniscriptKey>::Hash as FromStr>::Err: ToString,
+{
+    fn from_tree(top: &Tree) -> Result<Self, Error> {
+        if top.name == "tr" {
+            match top.args.len() {
+                1 => {
+                    let key = &top.args[0];
+                    if key.args.len() > 0 {
+                        return Err(Error::Unexpected(format!(
+                            "#{} script associated with `key-path` while parsing taproot descriptor",
+                            key.args.len()
+                        )));
+                    }
+                    Ok(Tr {
+                        internal_key: expression::terminal(key, Pk::from_str)?,
+                        tree: None,
+                    })
+                }
+                2 => {
+                    let ref key = top.args[0];
+                    if key.args.len() > 0 {
+                        return Err(Error::Unexpected(format!(
+                            "#{} script associated with `key-path` while parsing taproot descriptor",
+                            key.args.len()
+                        )));
+                    }
+                    let ref tree = top.args[1];
+                    let ret = Tr::tr_script_path(tree)?;
+                    Ok(Tr {
+                        internal_key: expression::terminal(key, Pk::from_str)?,
+                        tree: Some(ret),
+                    })
+                }
+                _ => {
+                    return Err(Error::Unexpected(format!(
+                        "{}[#{} args] while parsing taproot descriptor",
+                        top.name,
+                        top.args.len()
+                    )));
+                }
+            }
+        } else {
+            return Err(Error::Unexpected(format!(
+                "{}[#{} args] while parsing taproot descriptor",
+                top.name,
+                top.args.len()
+            )));
+        }
+    }
+}
+
+impl<Pk: MiniscriptKey> FromStr for Tr<Pk>
+where
+    Pk: MiniscriptKey + FromStr,
+    Pk::Hash: FromStr,
+    <Pk as FromStr>::Err: ToString,
+    <<Pk as MiniscriptKey>::Hash as FromStr>::Err: ToString,
+{
+    type Err = Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let desc_str = verify_checksum(s)?;
+        let top = parse_tr(desc_str)?;
+        Self::from_tree(&top)
+    }
+}
+
+impl<Pk: MiniscriptKey> fmt::Display for Tr<Pk> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let desc = self.to_string_no_checksum();
+        let checksum = desc_checksum(&desc).map_err(|_| fmt::Error)?;
+        write!(f, "{}#{}", &desc, &checksum)
+    }
+}
+
+fn parse_tr(s: &str) -> Result<Tree, Error> {
+    for ch in s.bytes() {
+        if ch > 0x7f {
+            return Err(Error::Unprintable(ch));
+        }
+    }
+
+    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 internal_key = Tree {
+                name: rest,
+                args: vec![],
+            };
+            return Ok(Tree {
+                name: "tr",
+                args: vec![internal_key],
+            });
+        }
+        // use str::split_once() method to refactor this when compiler version bumps up
+        let (key, script) = split_once(rest, ',')
+            .ok_or_else(|| Error::BadDescriptor("invalid taproot descriptor".to_string()))?;
+        let internal_key = Tree {
+            name: key,
+            args: vec![],
+        };
+        if script.is_empty() {
+            return Ok(Tree {
+                name: "tr",
+                args: vec![internal_key],
+            });
+        }
+        let (tree, rest) = expression::Tree::from_slice_helper_curly(script, 1)?;
+        if rest.is_empty() {
+            Ok(Tree {
+                name: "tr",
+                args: vec![internal_key, tree],
+            })
+        } else {
+            Err(errstr(rest))
+        }
+    } else {
+        Err(Error::Unexpected("invalid taproot descriptor".to_string()))
+    };
+}
+
+fn split_once(inp: &str, delim: char) -> Option<(&str, &str)> {
+    return if inp.len() == 0 {
+        None
+    } else {
+        let mut found = 0;
+        for (idx, ch) in inp.chars().enumerate() {
+            if ch == delim {
+                found = idx;
+                break;
+            }
+        }
+        if found == inp.len() - 1 {
+            Some((&inp[..], &""))
+        } else {
+            Some((&inp[..found], &inp[found + 1..]))
+        }
+    };
+}