Remove sanity_check from DescriptorTrait

In preparation for removing the `DescriptorTrait` move the
`sanity_check` trait methods onto each individual descriptor.

Author: heap-coder

src/descriptor/bare.rs

@@ -60,6 +60,12 @@ impl<Pk: MiniscriptKey> Bare<Pk> {
     pub fn as_inner(&self) -> &Miniscript<Pk, BareCtx> {
         &self.ms
     }
+
+    /// Checks whether the descriptor is safe.
+    pub fn sanity_check(&self) -> Result<(), Error> {
+        self.ms.sanity_check()?;
+        Ok(())
+    }
 }
 
 impl<Pk: MiniscriptKey + ToPublicKey> Bare<Pk> {
@@ -133,11 +139,6 @@ where
 }
 
 impl<Pk: MiniscriptKey> DescriptorTrait<Pk> for Bare<Pk> {
-    fn sanity_check(&self) -> Result<(), Error> {
-        self.ms.sanity_check()?;
-        Ok(())
-    }
-
     fn address(&self, _network: Network) -> Result<Address, Error>
     where
         Pk: ToPublicKey,
@@ -340,10 +341,6 @@ where
 }
 
 impl<Pk: MiniscriptKey> DescriptorTrait<Pk> for Pkh<Pk> {
-    fn sanity_check(&self) -> Result<(), Error> {
-        Ok(())
-    }
-
     fn address(&self, network: Network) -> Result<Address, Error>
     where
         Pk: ToPublicKey,

src/descriptor/mod.rs

@@ -76,16 +76,6 @@ pub type KeyMap = HashMap<DescriptorPublicKey, DescriptorSecretKey>;
 // because of traits cannot know underlying generic of Self.
 // Thus, we must implement additional trait for translate function
 pub trait DescriptorTrait<Pk: MiniscriptKey> {
-    /// Whether the descriptor is safe
-    /// Checks whether all the spend paths in the descriptor are possible
-    /// on the bitcoin network under the current standardness and consensus rules
-    /// Also checks whether the descriptor requires signauture on all spend paths
-    /// And whether the script is malleable.
-    /// In general, all the guarantees of miniscript hold only for safe scripts.
-    /// All the analysis guarantees of miniscript only hold safe scripts.
-    /// The signer may not be able to find satisfactions even if one exists
-    fn sanity_check(&self) -> Result<(), Error>;
-
     /// Computes the Bitcoin address of the descriptor, if one exists
     /// Some descriptors like pk() don't have any address.
     /// Errors:
@@ -395,6 +385,26 @@ impl<Pk: MiniscriptKey> Descriptor<Pk> {
             Descriptor::Tr(ref _tr) => DescriptorType::Tr,
         }
     }
+
+    /// Checks whether the descriptor is safe.
+    ///
+    /// Checks whether all the spend paths in the descriptor are possible on the
+    /// bitcoin network under the current standardness and consensus rules. Also
+    /// checks whether the descriptor requires signatures on all spend paths and
+    /// whether the script is malleable.
+    ///
+    /// In general, all the guarantees of miniscript hold only for safe scripts.
+    /// The signer may not be able to find satisfactions even if one exists.
+    pub fn sanity_check(&self) -> Result<(), Error> {
+        match *self {
+            Descriptor::Bare(ref bare) => bare.sanity_check(),
+            Descriptor::Pkh(_) => Ok(()),
+            Descriptor::Wpkh(ref wpkh) => wpkh.sanity_check(),
+            Descriptor::Wsh(ref wsh) => wsh.sanity_check(),
+            Descriptor::Sh(ref sh) => sh.sanity_check(),
+            Descriptor::Tr(ref tr) => tr.sanity_check(),
+        }
+    }
 }
 
 impl<P, Q> TranslatePk<P, Q> for Descriptor<P>
@@ -428,24 +438,6 @@ where
 }
 
 impl<Pk: MiniscriptKey> DescriptorTrait<Pk> for Descriptor<Pk> {
-    /// Whether the descriptor is safe
-    /// Checks whether all the spend paths in the descriptor are possible
-    /// on the bitcoin network under the current standardness and consensus rules
-    /// Also checks whether the descriptor requires signauture on all spend paths
-    /// And whether the script is malleable.
-    /// In general, all the guarantees of miniscript hold only for safe scripts.
-    /// All the analysis guarantees of miniscript only hold safe scripts.
-    /// The signer may not be able to find satisfactions even if one exists
-    fn sanity_check(&self) -> Result<(), Error> {
-        match *self {
-            Descriptor::Bare(ref bare) => bare.sanity_check(),
-            Descriptor::Pkh(ref pkh) => pkh.sanity_check(),
-            Descriptor::Wpkh(ref wpkh) => wpkh.sanity_check(),
-            Descriptor::Wsh(ref wsh) => wsh.sanity_check(),
-            Descriptor::Sh(ref sh) => sh.sanity_check(),
-            Descriptor::Tr(ref tr) => tr.sanity_check(),
-        }
-    }
     /// Computes the Bitcoin address of the descriptor, if one exists
     fn address(&self, network: Network) -> Result<Address, Error>
     where

src/descriptor/segwitv0.rs

@@ -74,6 +74,15 @@ impl<Pk: MiniscriptKey> Wsh<Pk> {
             WshInner::Ms(ref ms) => format!("wsh({})", ms),
         }
     }
+
+    /// Checks whether the descriptor is safe.
+    pub fn sanity_check(&self) -> Result<(), Error> {
+        match self.inner {
+            WshInner::SortedMulti(ref smv) => smv.sanity_check()?,
+            WshInner::Ms(ref ms) => ms.sanity_check()?,
+        }
+        Ok(())
+    }
 }
 
 impl<Pk: MiniscriptKey + ToPublicKey> Wsh<Pk> {
@@ -189,14 +198,6 @@ where
 }
 
 impl<Pk: MiniscriptKey> DescriptorTrait<Pk> for Wsh<Pk> {
-    fn sanity_check(&self) -> Result<(), Error> {
-        match self.inner {
-            WshInner::SortedMulti(ref smv) => smv.sanity_check()?,
-            WshInner::Ms(ref ms) => ms.sanity_check()?,
-        }
-        Ok(())
-    }
-
     fn address(&self, network: Network) -> Result<Address, Error>
     where
         Pk: ToPublicKey,
@@ -349,6 +350,17 @@ impl<Pk: MiniscriptKey> Wpkh<Pk> {
     pub fn to_string_no_checksum(&self) -> String {
         format!("wpkh({})", self.pk)
     }
+
+    /// Checks whether the descriptor is safe.
+    pub fn sanity_check(&self) -> Result<(), Error> {
+        if self.pk.is_uncompressed() {
+            Err(Error::ContextError(ScriptContextError::CompressedOnly(
+                self.pk.to_string(),
+            )))
+        } else {
+            Ok(())
+        }
+    }
 }
 
 impl<Pk: MiniscriptKey + ToPublicKey> Wpkh<Pk> {
@@ -444,16 +456,6 @@ where
 }
 
 impl<Pk: MiniscriptKey> DescriptorTrait<Pk> for Wpkh<Pk> {
-    fn sanity_check(&self) -> Result<(), Error> {
-        if self.pk.is_uncompressed() {
-            Err(Error::ContextError(ScriptContextError::CompressedOnly(
-                self.pk.to_string(),
-            )))
-        } else {
-            Ok(())
-        }
-    }
-
     fn address(&self, network: Network) -> Result<Address, Error>
     where
         Pk: ToPublicKey,

src/descriptor/sh.rs

@@ -180,6 +180,17 @@ impl<Pk: MiniscriptKey> Sh<Pk> {
         }
     }
 
+    /// Checks whether the descriptor is safe.
+    pub fn sanity_check(&self) -> Result<(), Error> {
+        match self.inner {
+            ShInner::Wsh(ref wsh) => wsh.sanity_check()?,
+            ShInner::Wpkh(ref wpkh) => wpkh.sanity_check()?,
+            ShInner::SortedMulti(ref smv) => smv.sanity_check()?,
+            ShInner::Ms(ref ms) => ms.sanity_check()?,
+        }
+        Ok(())
+    }
+
     /// Create a new p2sh wrapped wsh sortedmulti descriptor from threshold
     /// `k` and Vec of `pks`
     pub fn new_wsh_sortedmulti(k: usize, pks: Vec<Pk>) -> Result<Self, Error> {
@@ -263,16 +274,6 @@ impl<Pk: MiniscriptKey + ToPublicKey> Sh<Pk> {
 }
 
 impl<Pk: MiniscriptKey> DescriptorTrait<Pk> for Sh<Pk> {
-    fn sanity_check(&self) -> Result<(), Error> {
-        match self.inner {
-            ShInner::Wsh(ref wsh) => wsh.sanity_check()?,
-            ShInner::Wpkh(ref wpkh) => wpkh.sanity_check()?,
-            ShInner::SortedMulti(ref smv) => smv.sanity_check()?,
-            ShInner::Ms(ref ms) => ms.sanity_check()?,
-        }
-        Ok(())
-    }
-
     fn address(&self, network: Network) -> Result<Address, Error>
     where
         Pk: ToPublicKey,

src/descriptor/tr.rs

@@ -270,6 +270,14 @@ impl<Pk: MiniscriptKey> Tr<Pk> {
         *self.spend_info.lock().expect("Lock poisoned") = Some(Arc::clone(&spend_info));
         spend_info
     }
+
+    /// Checks whether the descriptor is safe.
+    pub fn sanity_check(&self) -> Result<(), Error> {
+        for (_depth, ms) in self.iter_scripts() {
+            ms.sanity_check()?;
+        }
+        Ok(())
+    }
 }
 
 impl<Pk: MiniscriptKey + ToPublicKey> Tr<Pk> {
@@ -548,13 +556,6 @@ impl<Pk: MiniscriptKey> Liftable<Pk> for Tr<Pk> {
 }
 
 impl<Pk: MiniscriptKey> DescriptorTrait<Pk> for Tr<Pk> {
-    fn sanity_check(&self) -> Result<(), Error> {
-        for (_depth, ms) in self.iter_scripts() {
-            ms.sanity_check()?;
-        }
-        Ok(())
-    }
-
     fn address(&self, network: Network) -> Result<Address, Error>
     where
         Pk: ToPublicKey,