Remove NoChecksSchnorr

This was a mistake. In the new API, we never decode/encode from
NoChecks. We don't need a tag to know whether we want to parse 32/33
byte keys. We parse script with the correct context and then create
another instance NoChecks

Author: sanket1729

src/interpreter/inner.rs

@@ -21,7 +21,7 @@ use bitcoin::util::taproot::{ControlBlock, TAPROOT_ANNEX_PREFIX};
 use {BareCtx, Legacy, Segwitv0, Tap};
 
 use super::{stack, BitcoinKey, Error, Stack, TaggedHash160};
-use miniscript::context::{NoChecksEcdsa, ScriptContext};
+use miniscript::context::{NoChecks, ScriptContext};
 use {Miniscript, MiniscriptKey};
 
 /// Attempts to parse a slice as a Bitcoin public key, checking compressedness
@@ -95,7 +95,7 @@ pub(super) enum Inner {
     // that only appropriate outputs are created
     PublicKey(super::BitcoinKey, PubkeyType),
     /// The script being evaluated is an actual script
-    Script(Miniscript<super::BitcoinKey, NoChecksEcdsa>, ScriptType),
+    Script(Miniscript<super::BitcoinKey, NoChecks>, ScriptType),
 }
 
 // The `Script` returned by this method is always generated/cloned ... when
@@ -367,7 +367,7 @@ pub(super) fn from_txdata<'txin>(
 // we need to know whether to parse the public key provided in witness as x-only or full
 pub(super) fn pre_taproot_to_no_checks<Ctx: ScriptContext>(
     ms: &Miniscript<bitcoin::PublicKey, Ctx>,
-) -> Miniscript<BitcoinKey, NoChecksEcdsa> {
+) -> Miniscript<BitcoinKey, NoChecks> {
     // specify the () error type as this cannot error
     ms.real_translate_pk::<_, _, _, (), _>(&mut |pk| Ok(BitcoinKey::Fullkey(*pk)), &mut |pkh| {
         Ok(TaggedHash160::FullKey(*pkh))
@@ -379,7 +379,7 @@ pub(super) fn pre_taproot_to_no_checks<Ctx: ScriptContext>(
 #[allow(dead_code)]
 pub(super) fn taproot_to_no_checks<Ctx: ScriptContext>(
     ms: &Miniscript<bitcoin::XOnlyPublicKey, Ctx>,
-) -> Miniscript<BitcoinKey, NoChecksEcdsa> {
+) -> Miniscript<BitcoinKey, NoChecks> {
     // specify the () error type as this cannot error
     ms.real_translate_pk::<_, _, _, (), _>(
         &mut |xpk| Ok(BitcoinKey::XOnlyPublicKey(*xpk)),
@@ -734,7 +734,7 @@ mod tests {
         assert_eq!(script_code, Some(comp.pkh_spk.clone()));
     }
 
-    fn ms_inner_script(ms: &str) -> (Miniscript<BitcoinKey, NoChecksEcdsa>, bitcoin::Script) {
+    fn ms_inner_script(ms: &str) -> (Miniscript<BitcoinKey, NoChecks>, bitcoin::Script) {
         let ms = Miniscript::<bitcoin::PublicKey, Segwitv0>::from_str_insane(ms).unwrap();
         let spk = ms.encode();
         let miniscript = pre_taproot_to_no_checks(&ms);

src/interpreter/mod.rs

@@ -28,7 +28,7 @@ use bitcoin::hashes::{hash160, ripemd160, sha256, sha256d};
 // use bitcoin::util::sighash;
 #[allow(unused_imports)]
 use bitcoin::{self, secp256k1};
-use miniscript::context::NoChecksEcdsa;
+use miniscript::context::NoChecks;
 use miniscript::ScriptContext;
 use Miniscript;
 use Terminal;
@@ -486,7 +486,7 @@ pub enum SatisfiedConstraint {
 ///depending on evaluation of the children.
 struct NodeEvaluationState<'intp> {
     ///The node which is being evaluated
-    node: &'intp Miniscript<BitcoinKey, NoChecksEcdsa>,
+    node: &'intp Miniscript<BitcoinKey, NoChecks>,
     ///number of children evaluated
     n_evaluated: usize,
     ///number of children satisfied
@@ -517,7 +517,7 @@ pub struct Iter<'intp, 'txin: 'intp> {
 ///Iterator for Iter
 impl<'intp, 'txin: 'intp> Iterator for Iter<'intp, 'txin>
 where
-    NoChecksEcdsa: ScriptContext,
+    NoChecks: ScriptContext,
 {
     type Item = Result<SatisfiedConstraint, Error>;
 
@@ -537,12 +537,12 @@ where
 
 impl<'intp, 'txin: 'intp> Iter<'intp, 'txin>
 where
-    NoChecksEcdsa: ScriptContext,
+    NoChecks: ScriptContext,
 {
     /// Helper function to push a NodeEvaluationState on state stack
     fn push_evaluation_state(
         &mut self,
-        node: &'intp Miniscript<BitcoinKey, NoChecksEcdsa>,
+        node: &'intp Miniscript<BitcoinKey, NoChecks>,
         n_evaluated: usize,
         n_satisfied: usize,
     ) -> () {
@@ -973,7 +973,7 @@ mod tests {
     use bitcoin;
     use bitcoin::hashes::{hash160, ripemd160, sha256, sha256d, Hash};
     use bitcoin::secp256k1::{self, Secp256k1, VerifyOnly};
-    use miniscript::context::NoChecksEcdsa;
+    use miniscript::context::NoChecks;
     use Miniscript;
     use MiniscriptKey;
     use ToPublicKey;
@@ -1034,7 +1034,7 @@ mod tests {
         fn from_stack<'txin, 'elem>(
             verify_fn: Box<dyn FnMut(&KeySigPair) -> bool + 'elem>,
             stack: Stack<'txin>,
-            ms: &'elem Miniscript<BitcoinKey, NoChecksEcdsa>,
+            ms: &'elem Miniscript<BitcoinKey, NoChecks>,
         ) -> Iter<'elem, 'txin> {
             Iter {
                 verify_sig: verify_fn,
@@ -1438,8 +1438,8 @@ mod tests {
 
     // By design there is no support for parse a miniscript with BitcoinKey
     // because it does not implement FromStr
-    fn no_checks_ms(ms: &str) -> Miniscript<BitcoinKey, NoChecksEcdsa> {
-        let elem: Miniscript<bitcoin::PublicKey, NoChecksEcdsa> =
+    fn no_checks_ms(ms: &str) -> Miniscript<BitcoinKey, NoChecks> {
+        let elem: Miniscript<bitcoin::PublicKey, NoChecks> =
             Miniscript::from_str_insane(ms).unwrap();
         inner::pre_taproot_to_no_checks(&elem)
     }

src/miniscript/context.rs

@@ -760,8 +760,8 @@ impl ScriptContext for BareCtx {
 /// scripts off of the blockchain without doing any sanity checks on them.
 /// This context should *NOT* be used unless you know what you are doing.
 #[derive(Debug, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
-pub enum NoChecksEcdsa {}
-impl ScriptContext for NoChecksEcdsa {
+pub enum NoChecks {}
+impl ScriptContext for NoChecks {
     // todo: When adding support for interpreter, we need a enum with all supported keys here
     type Key = bitcoin::PublicKey;
     fn check_terminal_non_malleable<Pk: MiniscriptKey>(
@@ -853,108 +853,9 @@ impl ScriptContext for NoChecksEcdsa {
     }
 }
 
-/// "No Checks Schnorr" Context
-///
-/// Used by the "satisified constraints" iterator, which is intended to read
-/// scripts off of the blockchain without doing any sanity checks on them.
-/// This context should *NOT* be used unless you know what you are doing.
-#[derive(Debug, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
-pub enum NoChecksSchnorr {}
-impl ScriptContext for NoChecksSchnorr {
-    // todo: When adding support for interpreter, we need a enum with all supported keys here
-    type Key = bitcoin::secp256k1::XOnlyPublicKey;
-    fn check_terminal_non_malleable<Pk: MiniscriptKey>(
-        _frag: &Terminal<Pk, Self>,
-    ) -> Result<(), ScriptContextError> {
-        Ok(())
-    }
-
-    fn check_global_policy_validity<Pk: MiniscriptKey>(
-        _ms: &Miniscript<Pk, Self>,
-    ) -> Result<(), ScriptContextError> {
-        Ok(())
-    }
-
-    fn check_global_consensus_validity<Pk: MiniscriptKey>(
-        _ms: &Miniscript<Pk, Self>,
-    ) -> Result<(), ScriptContextError> {
-        Ok(())
-    }
-
-    fn check_local_policy_validity<Pk: MiniscriptKey>(
-        _ms: &Miniscript<Pk, Self>,
-    ) -> Result<(), ScriptContextError> {
-        Ok(())
-    }
-
-    fn check_local_consensus_validity<Pk: MiniscriptKey>(
-        _ms: &Miniscript<Pk, Self>,
-    ) -> Result<(), ScriptContextError> {
-        Ok(())
-    }
-
-    fn max_satisfaction_size<Pk: MiniscriptKey>(_ms: &Miniscript<Pk, Self>) -> Option<usize> {
-        panic!("Tried to compute a satisfaction size bound on a no-checks schnorr miniscript")
-    }
-
-    fn pk_len<Pk: MiniscriptKey>(_pk: &Pk) -> usize {
-        panic!("Tried to compute a pk len bound on a no-checks schnorr miniscript")
-    }
-
-    fn name_str() -> &'static str {
-        // Internally used code
-        "NochecksSchnorr"
-    }
-
-    fn check_witness<Pk: MiniscriptKey>(_witness: &[Vec<u8>]) -> Result<(), ScriptContextError> {
-        // Only really need to do this for segwitv0 and legacy
-        // Bare is already restrcited by standardness rules
-        // and would reach these limits.
-        Ok(())
-    }
-
-    fn check_global_validity<Pk: MiniscriptKey>(
-        ms: &Miniscript<Pk, Self>,
-    ) -> Result<(), ScriptContextError> {
-        Self::check_global_consensus_validity(ms)?;
-        Self::check_global_policy_validity(ms)?;
-        Ok(())
-    }
-
-    fn check_local_validity<Pk: MiniscriptKey>(
-        ms: &Miniscript<Pk, Self>,
-    ) -> Result<(), ScriptContextError> {
-        Self::check_global_consensus_validity(ms)?;
-        Self::check_global_policy_validity(ms)?;
-        Self::check_local_consensus_validity(ms)?;
-        Self::check_local_policy_validity(ms)?;
-        Ok(())
-    }
-
-    fn top_level_type_check<Pk: MiniscriptKey>(ms: &Miniscript<Pk, Self>) -> Result<(), Error> {
-        if ms.ty.corr.base != types::Base::B {
-            return Err(Error::NonTopLevel(format!("{:?}", ms)));
-        }
-        Ok(())
-    }
-
-    fn other_top_level_checks<Pk: MiniscriptKey>(_ms: &Miniscript<Pk, Self>) -> Result<(), Error> {
-        Ok(())
-    }
-
-    fn top_level_checks<Pk: MiniscriptKey>(ms: &Miniscript<Pk, Self>) -> Result<(), Error> {
-        Self::top_level_type_check(ms)?;
-        Self::other_top_level_checks(ms)
-    }
-
-    fn sig_type() -> SigType {
-        SigType::Schnorr
-    }
-}
-
 /// Private Mod to prevent downstream from implementing this public trait
 mod private {
-    use super::{BareCtx, Legacy, NoChecksEcdsa, NoChecksSchnorr, Segwitv0, Tap};
+    use super::{BareCtx, Legacy, NoChecks, Segwitv0, Tap};
 
     pub trait Sealed {}
 
@@ -963,6 +864,5 @@ mod private {
     impl Sealed for Legacy {}
     impl Sealed for Segwitv0 {}
     impl Sealed for Tap {}
-    impl Sealed for NoChecksEcdsa {}
-    impl Sealed for NoChecksSchnorr {}
+    impl Sealed for NoChecks {}
 }