miniscript: add constants for 1 and 0

These are fairly common leaf nodes and throughout the codebase we tend
to reconstruct and typecheck them. It is faster and clearer to just have
constants.

Author: heap-coder

src/miniscript/mod.rs

@@ -64,6 +64,22 @@ pub struct Miniscript<Pk: MiniscriptKey, Ctx: ScriptContext> {
 }
 
 impl<Pk: MiniscriptKey, Ctx: ScriptContext> Miniscript<Pk, Ctx> {
+    /// The `1` combinator.
+    pub const TRUE: Self = Miniscript {
+        node: Terminal::True,
+        ty: types::Type::TRUE,
+        ext: types::extra_props::ExtData::TRUE,
+        phantom: PhantomData,
+    };
+
+    /// The `0` combinator.
+    pub const FALSE: Self = Miniscript {
+        node: Terminal::False,
+        ty: types::Type::FALSE,
+        ext: types::extra_props::ExtData::FALSE,
+        phantom: PhantomData,
+    };
+
     /// Add type information(Type and Extdata) to Miniscript based on
     /// `AstElem` fragment. Dependent on display and clone because of Error
     /// Display code of type_check.

src/miniscript/types/correctness.rs

@@ -83,6 +83,14 @@ pub struct Correctness {
 }
 
 impl Correctness {
+    /// Correctness data for the `1` combinator
+    pub const TRUE: Self =
+        Correctness { base: Base::B, input: Input::Zero, dissatisfiable: false, unit: true };
+
+    /// Correctness data for the `0` combinator
+    pub const FALSE: Self =
+        Correctness { base: Base::B, input: Input::Zero, dissatisfiable: true, unit: true };
+
     /// Check whether the `self` is a subtype of `other` argument .
     /// This checks whether the argument `other` has attributes which are present
     /// in the given `Type`. This returns `true` on same arguments
@@ -113,13 +121,9 @@ impl Property for Correctness {
         }
     }
 
-    fn from_true() -> Self {
-        Correctness { base: Base::B, input: Input::Zero, dissatisfiable: false, unit: true }
-    }
+    fn from_true() -> Self { Self::TRUE }
 
-    fn from_false() -> Self {
-        Correctness { base: Base::B, input: Input::Zero, dissatisfiable: true, unit: true }
-    }
+    fn from_false() -> Self { Self::FALSE }
 
     fn from_pk_k<Ctx: ScriptContext>() -> Self {
         Correctness { base: Base::K, input: Input::OneNonZero, dissatisfiable: true, unit: true }

src/miniscript/types/extra_props.rs

@@ -42,7 +42,7 @@ pub struct OpLimits {
 
 impl OpLimits {
     /// Creates a new instance of [`OpLimits`]
-    pub fn new(op_static: usize, op_sat: Option<usize>, op_nsat: Option<usize>) -> Self {
+    pub const fn new(op_static: usize, op_sat: Option<usize>, op_nsat: Option<usize>) -> Self {
         OpLimits { count: op_static, sat: op_sat, nsat: op_nsat }
     }
 
@@ -51,6 +51,17 @@ impl OpLimits {
 }
 
 impl TimelockInfo {
+    /// Creates a new `TimelockInfo` with all fields set to false.
+    pub const fn new() -> Self {
+        TimelockInfo {
+            csv_with_height: false,
+            csv_with_time: false,
+            cltv_with_height: false,
+            cltv_with_time: false,
+            contains_combination: false,
+        }
+    }
+
     /// Returns true if the current `TimelockInfo` contains any possible unspendable paths.
     pub fn contains_unspendable_path(self) -> bool { self.contains_combination }
 
@@ -133,6 +144,36 @@ pub struct ExtData {
     pub exec_stack_elem_count_dissat: Option<usize>,
 }
 
+impl ExtData {
+    /// Extra data for the `0` combinator
+    pub const FALSE: Self = ExtData {
+        pk_cost: 1,
+        has_free_verify: false,
+        ops: OpLimits::new(0, None, Some(0)),
+        stack_elem_count_sat: None,
+        stack_elem_count_dissat: Some(0),
+        max_sat_size: None,
+        max_dissat_size: Some((0, 0)),
+        timelock_info: TimelockInfo::new(),
+        exec_stack_elem_count_sat: None,
+        exec_stack_elem_count_dissat: Some(1),
+    };
+
+    /// Extra data for the `1` combinator
+    pub const TRUE: Self = ExtData {
+        pk_cost: 1,
+        has_free_verify: false,
+        ops: OpLimits::new(0, Some(0), None),
+        stack_elem_count_sat: Some(0),
+        stack_elem_count_dissat: None,
+        max_sat_size: Some((0, 0)),
+        max_dissat_size: None,
+        timelock_info: TimelockInfo::new(),
+        exec_stack_elem_count_sat: Some(1),
+        exec_stack_elem_count_dissat: None,
+    };
+}
+
 impl Property for ExtData {
     fn sanity_checks(&self) {
         debug_assert_eq!(
@@ -145,35 +186,9 @@ impl Property for ExtData {
         );
     }
 
-    fn from_true() -> Self {
-        ExtData {
-            pk_cost: 1,
-            has_free_verify: false,
-            ops: OpLimits::new(0, Some(0), None),
-            stack_elem_count_sat: Some(0),
-            stack_elem_count_dissat: None,
-            max_sat_size: Some((0, 0)),
-            max_dissat_size: None,
-            timelock_info: TimelockInfo::default(),
-            exec_stack_elem_count_sat: Some(1),
-            exec_stack_elem_count_dissat: None,
-        }
-    }
+    fn from_true() -> Self { Self::TRUE }
 
-    fn from_false() -> Self {
-        ExtData {
-            pk_cost: 1,
-            has_free_verify: false,
-            ops: OpLimits::new(0, None, Some(0)),
-            stack_elem_count_sat: None,
-            stack_elem_count_dissat: Some(0),
-            max_sat_size: None,
-            max_dissat_size: Some((0, 0)),
-            timelock_info: TimelockInfo::default(),
-            exec_stack_elem_count_sat: None,
-            exec_stack_elem_count_dissat: Some(1),
-        }
-    }
+    fn from_false() -> Self { Self::FALSE }
 
     fn from_pk_k<Ctx: ScriptContext>() -> Self {
         ExtData {

src/miniscript/types/malleability.rs

@@ -55,6 +55,13 @@ pub struct Malleability {
 }
 
 impl Malleability {
+    /// Malleability data for the `1` combinator
+    pub const TRUE: Self = Malleability { dissat: Dissat::None, safe: false, non_malleable: true };
+
+    /// Malleability data for the `0` combinator
+    pub const FALSE: Self =
+        Malleability { dissat: Dissat::Unique, safe: true, non_malleable: true };
+
     /// Check whether the `self` is a subtype of `other` argument .
     /// This checks whether the argument `other` has attributes which are present
     /// in the given `Type`. This returns `true` on same arguments

src/miniscript/types/mod.rs

@@ -216,6 +216,12 @@ pub struct Type {
 }
 
 impl Type {
+    /// Type of the `0` combinator
+    pub const TRUE: Self = Type { corr: Correctness::TRUE, mall: Malleability::TRUE };
+
+    /// Type of the `0` combinator
+    pub const FALSE: Self = Type { corr: Correctness::FALSE, mall: Malleability::FALSE };
+
     /// Check whether the `self` is a subtype of `other` argument .
     /// This checks whether the argument `other` has attributes which are present
     /// in the given `Type`. This returns `true` on same arguments