Renable assertion

Redo all correctness and malleablity properties for Covenant fragments.
Minsicript fragments were designed only to consider inputs from stack
for satisfaction/dissatisfaction.
Traditional fragments can only be dissatified from stack inputs, but
covenant fragments can be dissatisfied by changing the transaction
components. We do not consider these malleabilities in the extensions
and only deal with script witness malleability.

I also needed to remove the test that used now incorrectly typed
miniscript.

src/descriptor/csfs_cov/mod.rs

@@ -94,7 +94,7 @@ mod tests {
         string_rtt("elcovwsh(A,or_i(pk(B),pk(C)))");
         string_rtt("elcovwsh(A,multi(2,B,C,D))");
         string_rtt("elcovwsh(A,and_v(v:pk(B),pk(C)))");
-        string_rtt("elcovwsh(A,thresh(2,ver_eq(1),s:pk(C),s:pk(B)))");
+        string_rtt("elcovwsh(A,thresh(2,l:ver_eq(1),s:pk(C),s:pk(B)))");
         string_rtt("elcovwsh(A,outputs_pref(01020304))");
     }
 

src/descriptor/mod.rs

@@ -2109,4 +2109,9 @@ pk(03f28773c2d975288bc7d1d205c3748651b075fbc6610e58cddeeddf8f19405aa8))";
             "eltr(020000000000000000000000000000000000000000000000000000000000000002)",
         );
     }
+
+    #[test]
+    fn test_regression_29() {
+        let _ = Descriptor::<String>::from_str("eltr(,thresh(1,spk_eq(,00)))");
+    }
 }

src/extensions/arith.rs

@@ -811,16 +811,16 @@ impl Extension for Arith {
     fn corr_prop(&self) -> Correctness {
         Correctness {
             base: Base::B,
-            input: Input::Zero, // No input from stack
-            dissatisfiable: true,
+            input: Input::Zero,    // No input from stack
+            dissatisfiable: false, // No dissatisfactions from stack
             unit: true,
         }
     }
 
     fn mall_prop(&self) -> Malleability {
         Malleability {
-            dissat: Dissat::Unknown, // many dissatisfactions possible
-            safe: false,             // Unsafe as a top fragment
+            dissat: Dissat::None, // No dissatisfactions from stack inputs
+            safe: false,          // Unsafe as a top fragment
             non_malleable: true, // There can exist multiple satisfactions for expressions. inp_v(0) = out_v(0), but
                                  // we only deal with script satisfactions here.
         }

src/extensions/introspect_ops.rs

@@ -418,16 +418,16 @@ impl<T: ExtParam> Extension for CovOps<T> {
     fn corr_prop(&self) -> Correctness {
         Correctness {
             base: Base::B,
-            input: Input::Zero, // No input from stack
-            dissatisfiable: true,
+            input: Input::Zero,    // No input from stack
+            dissatisfiable: false, // No dissatisfactions possible from stack inputs
             unit: true,
         }
     }
 
     fn mall_prop(&self) -> Malleability {
         Malleability {
-            dissat: Dissat::Unknown, // many dissatisfactions possible
-            safe: false,             // Unsafe as a top fragment
+            dissat: Dissat::None, // No dissatisfactions from stack inputs
+            safe: false,          // Unsafe as a top fragment
             non_malleable: true, // Script satisfaction is non-malleable, whole fragment tx could be malleable
         }
     }

src/extensions/tx_ver.rs

@@ -48,14 +48,14 @@ impl Extension for LegacyVerEq {
         Correctness {
             base: Base::B,
             input: Input::Zero,
-            dissatisfiable: true,
+            dissatisfiable: false, // No dissat from stack inputs
             unit: true,
         }
     }
 
     fn mall_prop(&self) -> Malleability {
         Malleability {
-            dissat: Dissat::Unknown, // multi-dissat
+            dissat: Dissat::None, // No dissatisfactions from stack inputs
             safe: false,
             non_malleable: true,
         }

src/miniscript/types/mod.rs

@@ -554,8 +554,7 @@ impl Property for Type {
         debug_assert!(!self.corr.dissatisfiable || self.mall.dissat != Dissat::None);
         debug_assert!(self.mall.dissat == Dissat::None || self.corr.base != Base::V);
         debug_assert!(self.mall.safe || self.corr.base != Base::K);
-        // Not true for covenant scripts. Covenant scripts have zero inputs, but are still malleable
-        // debug_assert!(self.mall.non_malleable || self.corr.input != Input::Zero);
+        debug_assert!(self.mall.non_malleable || self.corr.input != Input::Zero);
     }
 
     fn from_true() -> Self {