policy: clean up error types in compile_tr

This adds a couple variants to policy::compiler::Error and eliminates a
couple calls to errstr. It also changes a few internal functions to
return compiler errors instead of the top-level error.

Author: apoelstra

src/policy/compiler.rs

@@ -50,6 +50,16 @@ pub enum CompilerError {
     /// There may exist other miniscripts which are under these limits but the
     /// compiler currently does not find them.
     LimitsExceeded,
+    /// In a Taproot compilation, no "unspendable key" was provided and no in-policy
+    /// key could be used as an internal key.
+    NoInternalKey,
+    /// When compiling to Taproot, policy had too many Tapleaves
+    TooManyTapleaves {
+        /// Number of Tapleaves inferred from the policy.
+        n: usize,
+        /// Maximum allowed number of Tapleaves.
+        max: usize,
+    },
     ///Policy related errors
     PolicyError(policy::concrete::PolicyError),
 }
@@ -66,6 +76,12 @@ impl fmt::Display for CompilerError {
             CompilerError::LimitsExceeded => f.write_str(
                 "At least one spending path has exceeded the standardness or consensus limits",
             ),
+            CompilerError::NoInternalKey => {
+                f.write_str("Taproot compilation had no internal key available")
+            }
+            CompilerError::TooManyTapleaves { n, max } => {
+                write!(f, "Policy had too many Tapleaves (found {}, maximum {})", n, max)
+            }
             CompilerError::PolicyError(ref e) => fmt::Display::fmt(e, f),
         }
     }
@@ -77,7 +93,11 @@ impl error::Error for CompilerError {
         use self::CompilerError::*;
 
         match self {
-            TopLevelNonSafe | ImpossibleNonMalleableCompilation | LimitsExceeded => None,
+            TopLevelNonSafe
+            | ImpossibleNonMalleableCompilation
+            | LimitsExceeded
+            | NoInternalKey
+            | TooManyTapleaves { .. } => None,
             PolicyError(e) => Some(e),
         }
     }

src/policy/concrete.rs

@@ -187,7 +187,7 @@ impl<Pk: MiniscriptKey> Policy<Pk> {
 
     /// Extracts the internal_key from this policy tree.
     #[cfg(feature = "compiler")]
-    fn extract_key(self, unspendable_key: Option<Pk>) -> Result<(Pk, Policy<Pk>), Error> {
+    fn extract_key(self, unspendable_key: Option<Pk>) -> Result<(Pk, Policy<Pk>), CompilerError> {
         let internal_key = self
             .tapleaf_probability_iter()
             .filter_map(|(prob, ref pol)| match pol {
@@ -200,7 +200,7 @@ impl<Pk: MiniscriptKey> Policy<Pk> {
         match (internal_key, unspendable_key) {
             (Some(ref key), _) => Ok((key.clone(), self.translate_unsatisfiable_pk(key))),
             (_, Some(key)) => Ok((key, self)),
-            _ => Err(errstr("No viable internal key found.")),
+            _ => Err(CompilerError::NoInternalKey),
         }
     }
 
@@ -222,11 +222,11 @@ impl<Pk: MiniscriptKey> Policy<Pk> {
     /// is also *cost-efficient*.
     // TODO: We might require other compile errors for Taproot.
     #[cfg(feature = "compiler")]
-    pub fn compile_tr(&self, unspendable_key: Option<Pk>) -> Result<Descriptor<Pk>, Error> {
-        self.is_valid().map_err(Error::ConcretePolicy)?;
+    pub fn compile_tr(&self, unspendable_key: Option<Pk>) -> Result<Descriptor<Pk>, CompilerError> {
+        self.is_valid().map_err(CompilerError::PolicyError)?;
         match self.is_safe_nonmalleable() {
-            (false, _) => Err(Error::from(CompilerError::TopLevelNonSafe)),
-            (_, false) => Err(Error::from(CompilerError::ImpossibleNonMalleableCompilation)),
+            (false, _) => Err(CompilerError::TopLevelNonSafe),
+            (_, false) => Err(CompilerError::ImpossibleNonMalleableCompilation),
             _ => {
                 let (internal_key, policy) = self.clone().extract_key(unspendable_key)?;
                 policy.check_num_tapleaves()?;
@@ -337,7 +337,9 @@ impl<Pk: MiniscriptKey> Policy<Pk> {
                 DescriptorCtx::Sh => Descriptor::new_sh(compiler::best_compilation(self)?),
                 DescriptorCtx::Wsh => Descriptor::new_wsh(compiler::best_compilation(self)?),
                 DescriptorCtx::ShWsh => Descriptor::new_sh_wsh(compiler::best_compilation(self)?),
-                DescriptorCtx::Tr(unspendable_key) => self.compile_tr(unspendable_key),
+                DescriptorCtx::Tr(unspendable_key) => self
+                    .compile_tr(unspendable_key)
+                    .map_err(Error::CompilerError),
             },
         }
     }
@@ -585,9 +587,10 @@ impl<Pk: MiniscriptKey> Policy<Pk> {
 
     /// Does checks on the number of `TapLeaf`s.
     #[cfg(feature = "compiler")]
-    fn check_num_tapleaves(&self) -> Result<(), Error> {
-        if self.num_tap_leaves() > MAX_COMPILATION_LEAVES {
-            return Err(errstr("Too many Tapleaves"));
+    fn check_num_tapleaves(&self) -> Result<(), CompilerError> {
+        let n = self.num_tap_leaves();
+        if n > MAX_COMPILATION_LEAVES {
+            return Err(CompilerError::TooManyTapleaves { n, max: MAX_COMPILATION_LEAVES });
         }
         Ok(())
     }