Remove concrete::PolicyArc

We just added `Arc` wrappers around all the `Policy` vector elements, we
no longer need the `PolicyArc` type.

Author: tcharding

src/policy/concrete.rs

@@ -84,105 +84,6 @@ where
     }
 }
 
-/// Lightweight repr of Concrete policy which corresponds directly to a
-/// Miniscript structure, and whose disjunctions are annotated with satisfaction
-/// probabilities to assist the compiler
-#[cfg(feature = "compiler")]
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
-enum PolicyArc<Pk: MiniscriptKey> {
-    /// Unsatisfiable
-    Unsatisfiable,
-    /// Trivially satisfiable
-    Trivial,
-    /// A public key which must sign to satisfy the descriptor
-    Key(Pk),
-    /// An absolute locktime restriction
-    After(AbsLockTime),
-    /// A relative locktime restriction
-    Older(u32),
-    /// A SHA256 whose preimage must be provided to satisfy the descriptor
-    Sha256(Pk::Sha256),
-    /// A SHA256d whose preimage must be provided to satisfy the descriptor
-    Hash256(Pk::Hash256),
-    /// A RIPEMD160 whose preimage must be provided to satisfy the descriptor
-    Ripemd160(Pk::Ripemd160),
-    /// A HASH160 whose preimage must be provided to satisfy the descriptor
-    Hash160(Pk::Hash160),
-    /// A list of sub-policies' references, all of which must be satisfied
-    And(Vec<Arc<PolicyArc<Pk>>>),
-    /// A list of sub-policies's references, one of which must be satisfied,
-    /// along with relative probabilities for each one
-    Or(Vec<(usize, Arc<PolicyArc<Pk>>)>),
-    /// A set of descriptors' references, satisfactions must be provided for `k` of them
-    Threshold(usize, Vec<Arc<PolicyArc<Pk>>>),
-}
-
-#[cfg(feature = "compiler")]
-impl<Pk: MiniscriptKey> From<PolicyArc<Pk>> for Policy<Pk> {
-    fn from(p: PolicyArc<Pk>) -> Self {
-        match p {
-            PolicyArc::Unsatisfiable => Policy::Unsatisfiable,
-            PolicyArc::Trivial => Policy::Trivial,
-            PolicyArc::Key(pk) => Policy::Key(pk),
-            PolicyArc::After(t) => Policy::After(t),
-            PolicyArc::Older(t) => Policy::Older(Sequence::from_consensus(t)),
-            PolicyArc::Sha256(hash) => Policy::Sha256(hash),
-            PolicyArc::Hash256(hash) => Policy::Hash256(hash),
-            PolicyArc::Ripemd160(hash) => Policy::Ripemd160(hash),
-            PolicyArc::Hash160(hash) => Policy::Hash160(hash),
-            PolicyArc::And(subs) => Policy::And(
-                subs.into_iter()
-                    .map(|pol| Self::from((*pol).clone()))
-                    .collect(),
-            ),
-            PolicyArc::Or(subs) => Policy::Or(
-                subs.into_iter()
-                    .map(|(odds, sub)| (odds, Self::from((*sub).clone())))
-                    .collect(),
-            ),
-            PolicyArc::Threshold(k, subs) => Policy::Threshold(
-                k,
-                subs.into_iter()
-                    .map(|pol| Self::from((*pol).clone()))
-                    .collect(),
-            ),
-        }
-    }
-}
-
-#[cfg(feature = "compiler")]
-impl<Pk: MiniscriptKey> From<Policy<Pk>> for PolicyArc<Pk> {
-    fn from(p: Policy<Pk>) -> Self {
-        match p {
-            Policy::Unsatisfiable => PolicyArc::Unsatisfiable,
-            Policy::Trivial => PolicyArc::Trivial,
-            Policy::Key(pk) => PolicyArc::Key(pk),
-            Policy::After(lock_time) => PolicyArc::After(lock_time),
-            Policy::Older(Sequence(t)) => PolicyArc::Older(t),
-            Policy::Sha256(hash) => PolicyArc::Sha256(hash),
-            Policy::Hash256(hash) => PolicyArc::Hash256(hash),
-            Policy::Ripemd160(hash) => PolicyArc::Ripemd160(hash),
-            Policy::Hash160(hash) => PolicyArc::Hash160(hash),
-            Policy::And(subs) => PolicyArc::And(
-                subs.iter()
-                    .map(|sub| Arc::new(Self::from(sub.clone())))
-                    .collect(),
-            ),
-            Policy::Or(subs) => PolicyArc::Or(
-                subs.iter()
-                    .map(|(odds, sub)| (*odds, Arc::new(Self::from(sub.clone()))))
-                    .collect(),
-            ),
-            Policy::Threshold(k, subs) => PolicyArc::Threshold(
-                k,
-                subs.iter()
-                    .map(|sub| Arc::new(Self::from(sub.clone())))
-                    .collect(),
-            ),
-        }
-    }
-}
-
 /// Detailed error type for concrete policies.
 #[derive(Copy, Clone, PartialEq, Eq, Debug)]
 pub enum PolicyError {
@@ -450,17 +351,12 @@ impl<Pk: MiniscriptKey> Policy<Pk> {
                     match policy {
                         Policy::Trivial => None,
                         policy => {
-                            let pol = PolicyArc::from(policy);
-                            let leaf_compilations: Vec<_> = pol
+                            let leaf_compilations: Vec<_> = policy
                                 .enumerate_policy_tree(1.0)
                                 .into_iter()
-                                .filter(|x| x.1 != Arc::new(PolicyArc::Unsatisfiable))
+                                .filter(|x| x.1 != Policy::Unsatisfiable)
                                 .map(|(prob, ref pol)| {
-                                    let converted_pol = Policy::<Pk>::from((**pol).clone());
-                                    (
-                                        OrdF64(prob),
-                                        compiler::best_compilation(&converted_pol).unwrap(),
-                                    )
+                                    (OrdF64(prob), compiler::best_compilation(&policy).unwrap())
                                 })
                                 .collect();
                             let tap_tree = with_huffman_tree::<Pk>(leaf_compilations).unwrap();
@@ -523,7 +419,7 @@ impl<Pk: MiniscriptKey> Policy<Pk> {
 }
 
 #[cfg(feature = "compiler")]
-impl<Pk: MiniscriptKey> PolicyArc<Pk> {
+impl<Pk: MiniscriptKey> Policy<Pk> {
     /// Returns a vector of policies whose disjunction is isomorphic to the initial one.
     ///
     /// This function is supposed to incrementally expand i.e. represent the policy as
@@ -532,21 +428,19 @@ impl<Pk: MiniscriptKey> PolicyArc<Pk> {
     #[cfg(feature = "compiler")]
     fn enumerate_pol(&self, prob: f64) -> Vec<(f64, Arc<Self>)> {
         match self {
-            PolicyArc::Or(subs) => {
+            Policy::Or(subs) => {
                 let total_odds = subs.iter().fold(0, |acc, x| acc + x.0);
                 subs.iter()
                     .map(|(odds, pol)| (prob * *odds as f64 / total_odds as f64, pol.clone()))
                     .collect::<Vec<_>>()
             }
-            PolicyArc::Threshold(k, subs) if *k == 1 => {
+            Policy::Threshold(k, subs) if *k == 1 => {
                 let total_odds = subs.len();
                 subs.iter()
                     .map(|pol| (prob / total_odds as f64, pol.clone()))
                     .collect::<Vec<_>>()
             }
-            PolicyArc::Threshold(k, subs) if *k != subs.len() => {
-                generate_combination(subs, prob, *k)
-            }
+            Policy::Threshold(k, subs) if *k != subs.len() => generate_combination(subs, prob, *k),
             pol => vec![(prob, Arc::new(pol.clone()))],
         }
     }
@@ -584,7 +478,7 @@ impl<Pk: MiniscriptKey> PolicyArc<Pk> {
         'outer: loop {
             //--- FIND a plausible node ---
             let mut prob: Reverse<OrdF64> = Reverse(OrdF64(0.0));
-            let mut curr_policy: Arc<Self> = Arc::new(PolicyArc::Unsatisfiable);
+            let mut curr_policy: Arc<Self> = Arc::new(Policy::Unsatisfiable);
             let mut curr_pol_replace_vec: Vec<(f64, Arc<Self>)> = vec![];
             let mut no_more_enum = false;
 
@@ -1203,22 +1097,22 @@ fn with_huffman_tree<Pk: MiniscriptKey>(
 /// any one of the conditions exclusively.
 #[cfg(feature = "compiler")]
 fn generate_combination<Pk: MiniscriptKey>(
-    policy_vec: &Vec<Arc<PolicyArc<Pk>>>,
+    policy_vec: &Vec<Arc<Policy<Pk>>>,
     prob: f64,
     k: usize,
-) -> Vec<(f64, Arc<PolicyArc<Pk>>)> {
+) -> Vec<(f64, Arc<Policy<Pk>>)> {
     debug_assert!(k <= policy_vec.len());
 
-    let mut ret: Vec<(f64, Arc<PolicyArc<Pk>>)> = vec![];
+    let mut ret: Vec<(f64, Arc<Policy<Pk>>)> = vec![];
     for i in 0..policy_vec.len() {
-        let policies: Vec<Arc<PolicyArc<Pk>>> = policy_vec
+        let policies: Vec<Arc<Policy<Pk>>> = policy_vec
             .iter()
             .enumerate()
             .filter_map(|(j, sub)| if j != i { Some(Arc::clone(sub)) } else { None })
             .collect();
         ret.push((
             prob / policy_vec.len() as f64,
-            Arc::new(PolicyArc::Threshold(k, policies)),
+            Arc::new(Policy::Threshold(k, policies)),
         ));
     }
     ret
@@ -1231,7 +1125,7 @@ mod compiler_tests {
     use sync::Arc;
 
     use super::Concrete;
-    use crate::policy::concrete::{generate_combination, PolicyArc};
+    use crate::policy::concrete::{generate_combination, Policy};
     use crate::prelude::*;
 
     #[test]
@@ -1242,46 +1136,46 @@ mod compiler_tests {
             .collect();
         let policy_vec = policies
             .into_iter()
-            .map(|pol| Arc::new(PolicyArc::from(pol)))
+            .map(|pol| Arc::new(Policy::from(pol)))
             .collect::<Vec<_>>();
 
         let combinations = generate_combination(&policy_vec, 1.0, 2);
 
-        let comb_a: Vec<Arc<PolicyArc<String>>> = vec![
+        let comb_a: Vec<Arc<Policy<String>>> = vec![
             policy_str!("pk(B)"),
             policy_str!("pk(C)"),
             policy_str!("pk(D)"),
         ]
         .into_iter()
-        .map(|pol| Arc::new(PolicyArc::from(pol)))
+        .map(|pol| Arc::new(Policy::from(pol)))
         .collect();
-        let comb_b: Vec<Arc<PolicyArc<String>>> = vec![
+        let comb_b: Vec<Arc<Policy<String>>> = vec![
             policy_str!("pk(A)"),
             policy_str!("pk(C)"),
             policy_str!("pk(D)"),
         ]
         .into_iter()
-        .map(|pol| Arc::new(PolicyArc::from(pol)))
+        .map(|pol| Arc::new(Policy::from(pol)))
         .collect();
-        let comb_c: Vec<Arc<PolicyArc<String>>> = vec![
+        let comb_c: Vec<Arc<Policy<String>>> = vec![
             policy_str!("pk(A)"),
             policy_str!("pk(B)"),
             policy_str!("pk(D)"),
         ]
         .into_iter()
-        .map(|pol| Arc::new(PolicyArc::from(pol)))
+        .map(|pol| Arc::new(Policy::from(pol)))
         .collect();
-        let comb_d: Vec<Arc<PolicyArc<String>>> = vec![
+        let comb_d: Vec<Arc<Policy<String>>> = vec![
             policy_str!("pk(A)"),
             policy_str!("pk(B)"),
             policy_str!("pk(C)"),
         ]
         .into_iter()
-        .map(|pol| Arc::new(PolicyArc::from(pol)))
+        .map(|pol| Arc::new(Policy::from(pol)))
         .collect();
         let expected_comb = vec![comb_a, comb_b, comb_c, comb_d]
             .into_iter()
-            .map(|sub_pol| (0.25, Arc::new(PolicyArc::Threshold(2, sub_pol))))
+            .map(|sub_pol| (0.25, Arc::new(Policy::Threshold(2, sub_pol))))
             .collect::<Vec<_>>();
         assert_eq!(combinations, expected_comb);
     }