Merge pull request #138 from JeremyRubin/add-trivial-unsat-concrete

Add Trivial and Unsatisfiable types to Concrete Policy

Author: apoelstra

src/policy/compiler.rs

@@ -161,8 +161,11 @@ struct CompilerExtData {
 
 impl Property for CompilerExtData {
     fn from_true() -> Self {
-        // only used in casts. should never be computed directly
-        unreachable!();
+        CompilerExtData {
+            branch_prob: None,
+            sat_cost: 0.0,
+            dissat_cost: None,
+        }
     }
 
     fn from_false() -> Self {
@@ -811,6 +814,12 @@ where
     }
 
     match *policy {
+        Concrete::Unsatisfiable => {
+            insert_wrap!(AstElemExt::terminal(Terminal::False));
+        }
+        Concrete::Trivial => {
+            insert_wrap!(AstElemExt::terminal(Terminal::True));
+        }
         Concrete::Key(ref pk) => {
             insert_wrap!(AstElemExt::terminal(Terminal::PkH(
                 pk.to_pubkeyhash().clone()

src/policy/concrete.rs

@@ -37,6 +37,10 @@ use {Error, MiniscriptKey};
 /// to assist the compiler
 #[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub enum Policy<Pk: MiniscriptKey> {
+    /// Unsatisfiable
+    Unsatisfiable,
+    /// Trivially satisfiable
+    Trivial,
     /// A public key which must sign to satisfy the descriptor
     Key(Pk),
     /// An absolute locktime restriction
@@ -147,6 +151,8 @@ impl<Pk: MiniscriptKey> Policy<Pk> {
         Q: MiniscriptKey,
     {
         match *self {
+            Policy::Unsatisfiable => Ok(Policy::Unsatisfiable),
+            Policy::Trivial => Ok(Policy::Trivial),
             Policy::Key(ref pk) => translatefpk(pk).map(Policy::Key),
             Policy::Sha256(ref h) => Ok(Policy::Sha256(h.clone())),
             Policy::Hash256(ref h) => Ok(Policy::Hash256(h.clone())),
@@ -192,7 +198,9 @@ impl<Pk: MiniscriptKey> Policy<Pk> {
     fn check_timelocks_helper(&self) -> TimeLockInfo {
         // timelocks[csv_h, csv_t, cltv_h, cltv_t, combination]
         match *self {
-            Policy::Key(_)
+            Policy::Unsatisfiable
+            | Policy::Trivial
+            | Policy::Key(_)
             | Policy::Sha256(_)
             | Policy::Hash256(_)
             | Policy::Ripemd160(_)
@@ -284,6 +292,7 @@ impl<Pk: MiniscriptKey> Policy<Pk> {
     ///
     pub fn is_safe_nonmalleable(&self) -> (bool, bool) {
         match *self {
+            Policy::Unsatisfiable | Policy::Trivial => (true, true),
             Policy::Key(_) => (true, true),
             Policy::Sha256(_)
             | Policy::Hash256(_)
@@ -330,6 +339,8 @@ impl<Pk: MiniscriptKey> Policy<Pk> {
 impl<Pk: MiniscriptKey> fmt::Debug for Policy<Pk> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match *self {
+            Policy::Unsatisfiable => f.write_str("UNSATISFIABLE()"),
+            Policy::Trivial => f.write_str("TRIVIAL()"),
             Policy::Key(ref pk) => write!(f, "pk({:?})", pk),
             Policy::After(n) => write!(f, "after({})", n),
             Policy::Older(n) => write!(f, "older({})", n),
@@ -371,6 +382,8 @@ impl<Pk: MiniscriptKey> fmt::Debug for Policy<Pk> {
 impl<Pk: MiniscriptKey> fmt::Display for Policy<Pk> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match *self {
+            Policy::Unsatisfiable => f.write_str("UNSATISFIABLE"),
+            Policy::Trivial => f.write_str("TRIVIAL"),
             Policy::Key(ref pk) => write!(f, "pk({})", pk),
             Policy::After(n) => write!(f, "after({})", n),
             Policy::Older(n) => write!(f, "older({})", n),
@@ -468,6 +481,8 @@ where
             }
         }
         match (frag_name, top.args.len() as u32) {
+            ("UNSATISFIABLE", 0) => Ok(Policy::Unsatisfiable),
+            ("TRIVIAL", 0) => Ok(Policy::Trivial),
             ("pk", 1) => expression::terminal(&top.args[0], |pk| Pk::from_str(pk).map(Policy::Key)),
             ("after", 1) => {
                 let num = expression::terminal(&top.args[0], |x| expression::parse_num(x))?;

src/policy/mod.rs

@@ -141,6 +141,8 @@ impl<Pk: MiniscriptKey> Liftable<Pk> for Concrete<Pk> {
         // involving combination of timelocks and heightlocks
         self.check_timelocks()?;
         let ret = match *self {
+            Concrete::Unsatisfiable => Semantic::Unsatisfiable,
+            Concrete::Trivial => Semantic::Trivial,
             Concrete::Key(ref pk) => Semantic::KeyHash(pk.to_pubkeyhash()),
             Concrete::After(t) => Semantic::After(t),
             Concrete::Older(t) => Semantic::Older(t),