descriptors: allow whitespace in string parsing. Improve error type

Author: dr-orlovsky

descriptors/src/compiler/compile.rs

@@ -443,6 +443,10 @@ where K::Err: core::error::Error
 ////////////////////////////////////////
 // Combinators
 
+fn trim_start_expr<'s>(s: &'s str, expr: &'static str) -> Option<&'s str> {
+    s.trim_start().strip_prefix(expr).and_then(|rest| rest.trim_start().strip_prefix("("))
+}
+
 impl<K: DeriveSet + Display + FromStr> FromStr for Sh<K>
 where
     K::Err: core::error::Error,
@@ -452,11 +456,14 @@ where
     type Err = DescrParseError<K::Err>;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
-        if s.starts_with("sh(wsh(") {
+        let Some(rest) = trim_start_expr(s, "sh") else {
+            return Err(DescrParseError::NoRequiredScript("sh"));
+        };
+        if rest.starts_with("wsh") {
             Ok(ShWsh::from_str(s)?.into())
-        } else if s.starts_with("sh(sortedmulti(") {
+        } else if rest.starts_with("sortedmulti") {
             ShSortedMulti::from_str(s).map(Sh::ShSortedMulti)
-        } else if s.starts_with("sh(multi(") {
+        } else if rest.starts_with("multi") {
             ShMulti::from_str(s).map(Sh::ShMulti)
         } else {
             ShScript::from_str(s).map(Sh::ShScript)
@@ -470,9 +477,13 @@ where K::Err: core::error::Error
     type Err = DescrParseError<K::Err>;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
-        if s.starts_with("wsh(multi(") {
+        let Some(rest) = trim_start_expr(s, "wsh") else {
+            return Err(DescrParseError::NoRequiredScript("wsh"));
+        };
+        let rest = rest.trim_start();
+        if rest.starts_with("multi") {
             WshMulti::from_str(s).map(Wsh::Multi)
-        } else if s.starts_with("wsh(sortedmulti(") {
+        } else if rest.starts_with("sortedmulti") {
             WshSortedMulti::from_str(s).map(Wsh::SortedMulti)
         } else {
             WshScript::from_str(s).map(Wsh::Script)
@@ -486,14 +497,18 @@ where K::Err: core::error::Error
     type Err = DescrParseError<K::Err>;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
-        if s.starts_with("sh(wsh(multi(") {
+        let Some(rest) = trim_start_expr(s, "sh") else {
+            return Err(DescrParseError::NoRequiredScript("sh"));
+        };
+        let Some(rest) = trim_start_expr(rest, "wsh") else {
+            return Err(DescrParseError::NoRequiredScript("wsh"));
+        };
+        if rest.starts_with("multi") {
             ShWshMulti::from_str(s).map(ShWsh::Multi)
-        } else if s.starts_with("sh(wsh(sortedmulti(") {
+        } else if rest.starts_with("sortedmulti") {
             ShWshSortedMulti::from_str(s).map(ShWsh::SortedMulti)
-        } else if s.starts_with("sh(wsh(") {
-            ShWshScript::from_str(s).map(ShWsh::Script)
         } else {
-            Err(DescrParseError::InvalidScriptExpr(s.to_owned()))
+            ShWshScript::from_str(s).map(ShWsh::Script)
         }
     }
 }
@@ -526,7 +541,7 @@ where
     type Err = DescrParseError<K::Err>;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
-        Ok(match s {
+        Ok(match s.trim_start() {
             s if s.starts_with("pkh") => Self::Pkh(Pkh::from_str(s)?),
             s if s.starts_with("wpkh") => Self::Wpkh(Wpkh::from_str(s)?),
 

descriptors/src/compiler/parser.rs

@@ -54,6 +54,9 @@ pub enum DescrParseError<E: Error> {
     /// script expression '{0}' must have a name.
     NoName(String),
 
+    /// the descriptor must start with '{0}' script expression.
+    NoRequiredScript(&'static str),
+
     /// unexpected token '{token}' when {expected} is expected.
     UnexpectedToken {
         descr: String,
@@ -75,10 +78,10 @@ pub enum DescrParseError<E: Error> {
     /// invalid descriptor tree expression '{0}'.
     InvalidTreeExpr(String),
 
-    /// invalid key expression: {0}.
-    Key(E),
+    /// invalid {0} expression. {1}
+    Expr(&'static str, E),
 
-    /// invalid number literal: {0}.
+    /// invalid number literal. {0}
     #[from]
     Lit(ParseIntError),
 
@@ -100,6 +103,7 @@ impl<E1: Error> DescrParseError<E1> {
             DescrParseError::Empty => Self::Empty,
             DescrParseError::Lexer(err) => Self::Lexer(err),
             DescrParseError::NoName(s) => Self::NoName(s),
+            DescrParseError::NoRequiredScript(s) => Self::NoRequiredScript(s),
             DescrParseError::UnexpectedToken {
                 descr,
                 pos,
@@ -122,7 +126,7 @@ impl<E1: Error> DescrParseError<E1> {
             },
             DescrParseError::InvalidScriptExpr(s) => Self::InvalidScriptExpr(s),
             DescrParseError::InvalidTreeExpr(s) => Self::InvalidTreeExpr(s),
-            DescrParseError::Key(err) => Self::Key(err.into()),
+            DescrParseError::Expr(msg, err) => Self::Expr(msg, err.into()),
             DescrParseError::Lit(err) => Self::Lit(err),
             DescrParseError::Confinement(err) => Self::Confinement(err),
             DescrParseError::InvalidArgs(s) => Self::InvalidArgs(s),