Add Taproot compiler private-version

Author: SarcasticNastik

src/policy/concrete.rs

@@ -195,19 +195,6 @@ impl<Pk: MiniscriptKey> Policy<Pk> {
         }
     }
 
-    /// Compile [`Policy::Or`] and [`Policy::Threshold`] according to odds
-    #[cfg(feature = "compiler")]
-    fn compile_tr_policy(&self) -> Result<TapTree<Pk>, Error> {
-        let leaf_compilations: Vec<_> = self
-            .to_tapleaf_prob_vec(1.0)
-            .into_iter()
-            .filter(|x| x.1 != Policy::Unsatisfiable)
-            .map(|(prob, ref policy)| (OrdF64(prob), compiler::best_compilation(policy).unwrap()))
-            .collect();
-        let taptree = Self::with_huffman_tree(leaf_compilations, |x| x).unwrap();
-        Ok(taptree)
-    }
-
     /// Extract the internal_key from policy tree.
     #[cfg(feature = "compiler")]
     fn extract_key(self, unspendable_key: Option<Pk>) -> Result<(Pk, Policy<Pk>), Error> {
@@ -252,10 +239,15 @@ impl<Pk: MiniscriptKey> Policy<Pk> {
         }
     }
 
-    /// Compile the [`Tr`] descriptor into optimized [`TapTree`] implementation
-    // TODO: We might require other compile errors for Taproot. Will discuss and update.
+    /// Compile [`Policy`] into a [`TapTree Descriptor`][`Descriptor::Tr`]
+    ///
+    /// We recursively expand the policy tree w.r.t root-level [`Policy::Or`]s and
+    /// [`Policy::Threshold`](1, ...) to obtain (sub)-policies. For example,
+    /// `thresh(1,and(or(A,B),C),or(or(D, E),and(F, G)),H)` is split into the list
+    /// [and(or(A,B),C), D,E, and(F, G), H] which are used for generating miniscript compilations
+    /// required for generating [`TapTree`].
     #[cfg(feature = "compiler")]
-    pub fn compile_tr(&self, unspendable_key: Option<Pk>) -> Result<Descriptor<Pk>, Error> {
+    pub fn compile_tr_private(&self, unspendable_key: Option<Pk>) -> Result<Descriptor<Pk>, Error> {
         self.is_valid()?; // Check for validity
         match self.is_safe_nonmalleable() {
             (false, _) => Err(Error::from(CompilerError::TopLevelNonSafe)),
@@ -268,7 +260,19 @@ impl<Pk: MiniscriptKey> Policy<Pk> {
                     internal_key,
                     match policy {
                         Policy::Trivial => None,
-                        policy => Some(policy.compile_tr_policy()?),
+                        policy => {
+                            let leaf_compilations: Vec<_> = policy
+                                .to_tapleaf_prob_vec(1.0)
+                                .into_iter()
+                                .filter(|x| x.1 != Policy::Unsatisfiable)
+                                .map(|(prob, ref pol)| {
+                                    (OrdF64(prob), compiler::best_compilation(pol).unwrap())
+                                })
+                                .collect();
+                            let taptree =
+                                Self::with_huffman_tree(leaf_compilations, |x| x).unwrap();
+                            Some(taptree)
+                        }
                     },
                 )?;
                 Ok(tree)

src/policy/mod.rs

@@ -382,7 +382,9 @@ mod tests {
         let unspendable_key: String = "UNSPENDABLE".to_string();
         {
             let policy: Concrete<String> = policy_str!("thresh(2,pk(A),pk(B),pk(C),pk(D))");
-            let descriptor = policy.compile_tr(Some(unspendable_key.clone())).unwrap();
+            let descriptor = policy
+                .compile_tr_private(Some(unspendable_key.clone()))
+                .unwrap();
 
             let ms_compilation: Miniscript<String, Tap> = ms_str!("multi_a(2,A,B,C,D)");
             let tree: TapTree<String> = TapTree::Leaf(Arc::new(ms_compilation));
@@ -394,7 +396,9 @@ mod tests {
         // Trivial multi-node compilation
         {
             let policy: Concrete<String> = policy_str!("or(and(pk(A),pk(B)),and(pk(C),pk(D)))");
-            let descriptor = policy.compile_tr(Some(unspendable_key.clone())).unwrap();
+            let descriptor = policy
+                .compile_tr_private(Some(unspendable_key.clone()))
+                .unwrap();
 
             let left_ms_compilation: Arc<Miniscript<String, Tap>> =
                 Arc::new(ms_str!("and_v(v:pk(C),pk(D))"));
@@ -411,7 +415,7 @@ mod tests {
         {
             // Invalid policy compilation (Duplicate PubKeys)
             let policy: Concrete<String> = policy_str!("or(and(pk(A),pk(B)),and(pk(A),pk(D)))");
-            let descriptor = policy.compile_tr(Some(unspendable_key.clone()));
+            let descriptor = policy.compile_tr_private(Some(unspendable_key.clone()));
 
             assert_eq!(
                 descriptor.unwrap_err().to_string(),
@@ -448,7 +452,9 @@ mod tests {
                     node_policies[6]
                 )
             );
-            let descriptor = policy.compile_tr(Some(unspendable_key.clone())).unwrap();
+            let descriptor = policy
+                .compile_tr_private(Some(unspendable_key.clone()))
+                .unwrap();
 
             let mut sorted_policy_prob = node_policies
                 .into_iter()