Add comment to decoding x-only keys

Fixup: remove xor check

Author: sanket1729

src/miniscript/decode.rs

@@ -301,6 +301,15 @@ pub fn parse<Ctx: ScriptContext>(
                     // Note this does not collide with hash32 because they always followed by equal
                     // and would be parsed in different branch. If we get a naked Bytes32, it must be
                     // a x-only key
+                    // In miniscript spec, bytes32 only occurs at three places.
+                    // - during parsing XOnly keys in Pk fragment
+                    // - during parsing XOnly keys in MultiA fragment
+                    // - checking for 32 bytes hashlocks (sha256/hash256)
+                    // The second case(MultiA) is disambiguated using NumEqual which is not used anywhere in miniscript
+                    // The third case can only occur hashlocks is disambiguated because hashlocks start from equal, and
+                    // it is impossible for any K type fragment to be followed by EQUAL in miniscript spec. Thus, EQUAL
+                    // after bytes32 means bytes32 is in a hashlock
+                    // Finally for the first case, K being parsed as a solo expression is a Pk type
                     Tk::Bytes32(pk) => {
                         let ret = Ctx::Key::from_slice(pk).map_err(|e| Error::PubKeyCtxError(e, Ctx::name_str()))?;
                         term.reduce0(Terminal::PkK(ret))?

src/miniscript/types/extra_props.rs

@@ -133,20 +133,14 @@ pub struct ExtData {
 
 impl Property for ExtData {
     fn sanity_checks(&self) {
-        fn xor<T>(a: Option<T>, b: Option<T>) -> bool {
-            match (a, b) {
-                (Some(_), Some(_)) | (None, None) => false,
-                _ => true,
-            }
-        }
-        debug_assert!(!xor(
-            self.stack_elem_count_sat,
-            self.exec_stack_elem_count_sat
-        ));
-        debug_assert!(!xor(
-            self.stack_elem_count_dissat,
-            self.exec_stack_elem_count_dissat
-        ));
+        debug_assert_eq!(
+            self.stack_elem_count_sat.is_some(),
+            self.exec_stack_elem_count_sat.is_some()
+        );
+        debug_assert_eq!(
+            self.stack_elem_count_dissat.is_some(),
+            self.exec_stack_elem_count_dissat.is_some()
+        );
     }
 
     fn from_true() -> Self {