Added miniscript check_safety

Author: sanket1729

src/lib.rs

@@ -350,6 +350,8 @@ pub enum Error {
     /// Anything but c:pk(key) (P2PK), c:pk_h(key) (P2PKH), and thresh_m(k,...)
     /// up to n=3 is invalid by standardness (bare)
     NonStandardBareScript,
+    /// Analysis Error
+    AnalysisError(miniscript::analyzable::AnalysisError),
 }
 
 #[doc(hidden)]
@@ -370,6 +372,13 @@ impl From<miniscript::context::ScriptContextError> for Error {
     }
 }
 
+#[doc(hidden)]
+impl From<miniscript::analyzable::AnalysisError> for Error {
+    fn from(e: miniscript::analyzable::AnalysisError) -> Error {
+        Error::AnalysisError(e)
+    }
+}
+
 #[doc(hidden)]
 impl From<bitcoin::secp256k1::Error> for Error {
     fn from(e: bitcoin::secp256k1::Error) -> Error {
@@ -467,6 +476,7 @@ impl fmt::Display for Error {
                 up to n=3 is invalid by standardness (bare).
                 "
             ),
+            Error::AnalysisError(ref e) => e.fmt(f),
         }
     }
 }

src/miniscript/analyzable.rs

@@ -0,0 +1,151 @@
+// Miniscript Analysis
+// Written in 2018 by
+//     Andrew Poelstra <apoelstra@wpsoftware.net>
+//
+// To the extent possible under law, the author(s) have dedicated all
+// copyright and related and neighboring rights to this software to
+// the public domain worldwide. This software is distributed without
+// any warranty.
+//
+// You should have received a copy of the CC0 Public Domain Dedication
+// along with this software.
+// If not, see <http://creativecommons.org/publicdomain/zero/1.0/>.
+//
+
+//!  Miniscript Analysis
+//!
+//! Tools for determining whether the gurantees offered by the library
+//! actually hold.
+
+use error;
+use miniscript::iter::PkPkh;
+use std::collections::HashSet;
+use std::fmt;
+use {Miniscript, MiniscriptKey, ScriptContext};
+/// Possible reasons Miniscript guarantees can fail
+/// We currently mark Miniscript as Non-Analyzable if
+/// 1. It is unsafe(does not require a digital signature to spend it)
+/// 2. It contains a unspendable path because of either
+///     a. Resource limitations
+///     b. Timelock Mixing
+/// 3. The script is malleable and thereby some of satisfaction weight
+///    gurantees are not satisfied.
+/// 4. It has repeated publickeys
+#[derive(Debug)]
+pub enum AnalysisError {
+    /// Top level is not safe.
+    TopLevelNonSafe,
+    /// Repeated Pubkeys
+    RepeatedPubkeys,
+    /// Miniscript contains atleast one path that exceeds resource limits
+    ResourceLimitsExceeded,
+    /// Contains a combination of heightlock and timelock
+    HeightTimeLockCombination,
+    /// Malleable script
+    Malleable,
+}
+
+impl fmt::Display for AnalysisError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match *self {
+            AnalysisError::TopLevelNonSafe => {
+                f.write_str("All spend paths must require a signature")
+            }
+            AnalysisError::RepeatedPubkeys => {
+                f.write_str("Miniscript contains repeated pubkeys or pubkeyhashes")
+            }
+            AnalysisError::ResourceLimitsExceeded => {
+                f.write_str("Atleast one spend path exceeds the resource limits(stack depth/satisfaction size..)")
+            }
+            AnalysisError::HeightTimeLockCombination => {
+                f.write_str("Contains a combination of heightlock and timelock")
+            }
+            AnalysisError::Malleable => f.write_str("Miniscript is malleable")
+        }
+    }
+}
+
+impl error::Error for AnalysisError {
+    fn description(&self) -> &str {
+        ""
+    }
+    fn cause(&self) -> Option<&error::Error> {
+        None
+    }
+}
+
+impl<Pk: MiniscriptKey, Ctx: ScriptContext> Miniscript<Pk, Ctx> {
+    /// Whether all spend paths of miniscript require a signature
+    pub fn requires_sig(&self) -> bool {
+        self.ty.mall.safe
+    }
+
+    /// Whether the miniscript is malleable
+    pub fn is_non_malleable(&self) -> bool {
+        self.ty.mall.non_malleable
+    }
+
+    /// Whether the miniscript can exceed the resource limits(Opcodes, Stack limit etc)
+    // It maybe possible to return a detail error type containing why the miniscript
+    // failed. But doing so may require returning a collection of errors
+    pub fn within_resource_limits(&self) -> bool {
+        match Ctx::check_satisfaction_rules(&self) {
+            Ok(_) => true,
+            Err(_) => false,
+        }
+    }
+
+    /// Whether the miniscript contains a combination of timelocks
+    pub fn has_mixed_timelocks(&self) -> bool {
+        self.ext.timelock_info.contains_unspendable_path()
+    }
+
+    /// Whether the miniscript has repeated Pk or Pkh
+    pub fn has_repeated_keys(&self) -> bool {
+        // Simple way to check whether all of these are correct is
+        // to have an iterator
+        let all_pkhs_len = self
+            .iter_pk_pkh()
+            .map(|pk_pkh| match pk_pkh {
+                PkPkh::PlainPubkey(pk) => pk.to_pubkeyhash(),
+                PkPkh::HashedPubkey(h) => h,
+            })
+            .count();
+
+        let unique_pkhs_len = self
+            .iter_pk_pkh()
+            .map(|pk_pkh| match pk_pkh {
+                PkPkh::PlainPubkey(pk) => pk.to_pubkeyhash(),
+                PkPkh::HashedPubkey(h) => h,
+            })
+            .collect::<HashSet<_>>()
+            .len();
+
+        unique_pkhs_len != all_pkhs_len
+    }
+
+    /// Check whether the underlying Miniscript is safe under the current context
+    /// Lifting these polices would create a semantic representation that does
+    /// not represent the underlying semantics when miniscript is spent.
+    /// Signing logic may not find satisfaction even if one exists.  
+    ///
+    /// For most cases, users should be dealing with safe scripts.
+    /// Use this function to check whether the guarantees of library hold.
+    /// Most functions of the library like would still
+    /// work, but results cannot be relied upon
+    pub fn check_safety(&self) -> Result<(), AnalysisError> {
+        if !self.requires_sig() {
+            Err(AnalysisError::TopLevelNonSafe)
+        } else if !self.is_non_malleable() {
+            Err(AnalysisError::Malleable)
+        } else if !self.within_resource_limits() {
+            Err(AnalysisError::ResourceLimitsExceeded)
+        } else if self.has_repeated_keys() {
+            Err(AnalysisError::RepeatedPubkeys)
+        } else if self.has_mixed_timelocks() {
+            Err(AnalysisError::HeightTimeLockCombination)
+        } else {
+            Ok(())
+        }
+    }
+}

src/miniscript/mod.rs

@@ -32,6 +32,7 @@ use bitcoin::blockdata::script;
 
 pub use self::context::{Bare, Legacy, Segwitv0};
 
+pub mod analyzable;
 pub mod astelem;
 pub(crate) mod context;
 pub mod decode;