Cleanup context code with SigType enum

Author: sanket1729

src/miniscript/astelem.rs

@@ -29,6 +29,7 @@ use bitcoin::hashes::{hash160, ripemd160, sha256, sha256d, Hash};
 
 use errstr;
 use expression;
+use miniscript::context::SigType;
 use miniscript::types::{self, Property};
 use miniscript::ScriptContext;
 use script_num_size;
@@ -761,7 +762,7 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> Terminal<Pk, Ctx> {
                     .push_opcode(opcodes::all::OP_EQUAL)
             }
             Terminal::Multi(k, ref keys) => {
-                debug_assert!(!Ctx::is_tap());
+                debug_assert!(Ctx::sig_type() == SigType::Ecdsa);
                 builder = builder.push_int(k as i64);
                 for pk in keys {
                     builder = builder.push_key(&pk.to_public_key());
@@ -771,7 +772,7 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> Terminal<Pk, Ctx> {
                     .push_opcode(opcodes::all::OP_CHECKMULTISIG)
             }
             Terminal::MultiA(k, ref keys) => {
-                debug_assert!(Ctx::is_tap());
+                debug_assert!(Ctx::sig_type() == SigType::Schnorr);
                 // keys must be atleast len 1 here, guaranteed by typing rules
                 builder = builder.push_ms_key::<_, Ctx>(&keys[0]);
                 builder = builder.push_opcode(opcodes::all::OP_CHECKSIG);

src/miniscript/context.rs

@@ -74,6 +74,14 @@ pub enum ScriptContextError {
     MultiANotAllowed,
 }
 
+#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)]
+pub enum SigType {
+    /// Ecdsa signature
+    Ecdsa,
+    /// Schnorr Signature
+    Schnorr,
+}
+
 impl fmt::Display for ScriptContextError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match *self {
@@ -285,12 +293,10 @@ where
         Self::other_top_level_checks(ms)
     }
 
-    /// Reverse lookup to store whether the context is tapscript.
-    /// pk(33-byte key) is a valid under both tapscript context and segwitv0 context
-    /// We need to context decide whether the serialize pk to 33 byte or 32 bytes.
-    fn is_tap() -> bool {
-        return false;
-    }
+    /// The type of signature required for satisfaction
+    // We need to context decide whether the serialize pk to 33 byte or 32 bytes.
+    // And to decide which type of signatures to look for during satisfaction
+    fn sig_type() -> SigType;
 
     /// Get the len of public key when serialized based on context
     /// Note that this includes the serialization prefix. Returns
@@ -395,6 +401,10 @@ impl ScriptContext for Legacy {
     fn name_str() -> &'static str {
         "Legacy/p2sh"
     }
+
+    fn sig_type() -> SigType {
+        SigType::Ecdsa
+    }
 }
 
 /// Segwitv0 ScriptContext
@@ -503,6 +513,10 @@ impl ScriptContext for Segwitv0 {
     fn name_str() -> &'static str {
         "Segwitv0"
     }
+
+    fn sig_type() -> SigType {
+        SigType::Ecdsa
+    }
 }
 
 /// Tap ScriptContext
@@ -600,8 +614,8 @@ impl ScriptContext for Tap {
         ms.ext.max_sat_size.map(|x| x.0)
     }
 
-    fn is_tap() -> bool {
-        true
+    fn sig_type() -> SigType {
+        SigType::Schnorr
     }
 
     fn pk_len<Pk: MiniscriptKey>(_pk: &Pk) -> usize {
@@ -684,6 +698,10 @@ impl ScriptContext for BareCtx {
     fn name_str() -> &'static str {
         "BareCtx"
     }
+
+    fn sig_type() -> SigType {
+        SigType::Ecdsa
+    }
 }
 
 /// "No Checks" Context
@@ -738,6 +756,51 @@ impl ScriptContext for NoChecks {
         // Internally used code
         "Nochecks"
     }
+
+    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 {
+        unreachable!("Tried to call sig type on no-checks Miniscript")
+    }
 }
 
 /// Private Mod to prevent downstream from implementing this public trait

src/miniscript/satisfy.rs

@@ -489,18 +489,17 @@ impl Ord for Witness {
 impl Witness {
     /// Turn a signature into (part of) a satisfaction
     fn signature<Pk: ToPublicKey, S: Satisfier<Pk>, Ctx: ScriptContext>(sat: S, pk: &Pk) -> Self {
-        if Ctx::is_tap() {
-            match sat.lookup_schnorr_sig(pk) {
+        match Ctx::sig_type() {
+            super::context::SigType::Ecdsa => match sat.lookup_ecdsa_sig(pk) {
                 Some(sig) => Witness::Stack(vec![sig.to_vec()]),
                 // Signatures cannot be forged
                 None => Witness::Impossible,
-            }
-        } else {
-            match sat.lookup_ecdsa_sig(pk) {
+            },
+            super::context::SigType::Schnorr => match sat.lookup_schnorr_sig(pk) {
                 Some(sig) => Witness::Stack(vec![sig.to_vec()]),
                 // Signatures cannot be forged
                 None => Witness::Impossible,
-            }
+            },
         }
     }
 

src/util.rs

@@ -1,6 +1,7 @@
 use bitcoin;
 use bitcoin::blockdata::script;
 use bitcoin::Script;
+use miniscript::context;
 
 use {ScriptContext, ToPublicKey};
 pub(crate) fn varint_len(n: usize) -> usize {
@@ -39,10 +40,9 @@ impl MsKeyBuilder for script::Builder {
         Pk: ToPublicKey,
         Ctx: ScriptContext,
     {
-        if Ctx::is_tap() {
-            self.push_slice(&key.to_x_only_pubkey().serialize())
-        } else {
-            self.push_key(&key.to_public_key())
+        match Ctx::sig_type() {
+            context::SigType::Ecdsa => self.push_key(&key.to_public_key()),
+            context::SigType::Schnorr => self.push_slice(&key.to_x_only_pubkey().serialize()),
         }
     }
 }