Add support for parsing Tapscript Miniscripts

Author: sanket1729

src/lib.rs

@@ -159,6 +159,14 @@ impl MiniscriptKey for bitcoin::PublicKey {
     }
 }
 
+impl MiniscriptKey for bitcoin::schnorr::PublicKey {
+    type Hash = hash160::Hash;
+
+    fn to_pubkeyhash(&self) -> Self::Hash {
+        hash160::Hash::hash(&self.serialize())
+    }
+}
+
 impl MiniscriptKey for String {
     type Hash = String;
 
@@ -197,6 +205,25 @@ impl ToPublicKey for bitcoin::PublicKey {
     }
 }
 
+impl ToPublicKey for bitcoin::schnorr::PublicKey {
+    fn to_public_key(&self) -> bitcoin::PublicKey {
+        // This code should never be used.
+        // But is implemented for completeness
+        let mut data: Vec<u8> = vec![0x02];
+        data.extend(self.serialize().iter());
+        bitcoin::PublicKey::from_slice(&data)
+            .expect("Failed to construct 33 Publickey from 0x02 appended x-only key")
+    }
+
+    fn to_x_only_pubkey(&self) -> bitcoin::schnorr::PublicKey {
+        *self
+    }
+
+    fn hash_to_hash160(hash: &hash160::Hash) -> hash160::Hash {
+        *hash
+    }
+}
+
 /// Dummy key which de/serializes to the empty string; useful sometimes for testing
 #[derive(Copy, Clone, PartialOrd, Ord, PartialEq, Eq, Debug)]
 pub struct DummyKey;
@@ -443,7 +470,7 @@ pub enum Error {
     InvalidOpcode(opcodes::All),
     /// Some opcode occurred followed by `OP_VERIFY` when it had
     /// a `VERIFY` version that should have been used instead
-    NonMinimalVerify(miniscript::lex::Token),
+    NonMinimalVerify(String),
     /// Push was illegal in some context
     InvalidPush(Vec<u8>),
     /// rust-bitcoin script error
@@ -512,6 +539,8 @@ pub enum Error {
     ImpossibleSatisfaction,
     /// Bare descriptors don't have any addresses
     BareDescriptorAddr,
+    /// PubKey invalid under current context
+    PubKeyCtxError(miniscript::decode::KeyParseError, &'static str),
 }
 
 #[doc(hidden)]
@@ -575,7 +604,7 @@ impl fmt::Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match *self {
             Error::InvalidOpcode(op) => write!(f, "invalid opcode {}", op),
-            Error::NonMinimalVerify(tok) => write!(f, "{} VERIFY", tok),
+            Error::NonMinimalVerify(ref tok) => write!(f, "{} VERIFY", tok),
             Error::InvalidPush(ref push) => write!(f, "invalid push {:?}", push), // TODO hexify this
             Error::Script(ref e) => fmt::Display::fmt(e, f),
             Error::CmsTooManyKeys(n) => write!(f, "checkmultisig with {} keys", n),
@@ -629,6 +658,9 @@ impl fmt::Display for Error {
             Error::AnalysisError(ref e) => e.fmt(f),
             Error::ImpossibleSatisfaction => write!(f, "Impossible to satisfy Miniscript"),
             Error::BareDescriptorAddr => write!(f, "Bare descriptors don't have address"),
+            Error::PubKeyCtxError(ref pk, ref ctx) => {
+                write!(f, "Pubkey error: {} under {} scriptcontext", pk, ctx)
+            }
         }
     }
 }

src/miniscript/context.rs

@@ -14,6 +14,7 @@
 
 use std::{fmt, hash};
 
+use bitcoin;
 use bitcoin::blockdata::constants::MAX_BLOCK_WEIGHT;
 use miniscript::limits::{
     MAX_OPS_PER_SCRIPT, MAX_SCRIPTSIG_SIZE, MAX_SCRIPT_ELEMENT_SIZE, MAX_SCRIPT_SIZE,
@@ -23,6 +24,8 @@ use miniscript::types;
 use util::witness_to_scriptsig;
 use Error;
 
+use super::decode::ParseableKey;
+
 use {Miniscript, MiniscriptKey, Terminal};
 
 /// Error for Script Context
@@ -129,7 +132,11 @@ impl fmt::Display for ScriptContextError {
 /// For example, disallowing uncompressed keys in Segwit context
 pub trait ScriptContext:
     fmt::Debug + Clone + Ord + PartialOrd + Eq + PartialEq + hash::Hash + private::Sealed
+where
+    Self::Key: MiniscriptKey<Hash = bitcoin::hashes::hash160::Hash>,
 {
+    /// The consensus key associated with the type. Must be a parseable key
+    type Key: ParseableKey;
     /// Depending on ScriptContext, fragments can be malleable. For Example,
     /// under Legacy context, PkH is malleable because it is possible to
     /// estimate the cost of satisfaction because of compressed keys
@@ -276,6 +283,9 @@ pub trait ScriptContext:
     /// 34/66 for Bare/Legacy based on key compressedness
     /// 34 for Segwitv0, 33 for Tap
     fn pk_len<Pk: MiniscriptKey>(pk: &Pk) -> usize;
+
+    /// Local helper function to display error messages with context
+    fn to_str() -> &'static str;
 }
 
 /// Legacy ScriptContext
@@ -286,6 +296,7 @@ pub trait ScriptContext:
 pub enum Legacy {}
 
 impl ScriptContext for Legacy {
+    type Key = bitcoin::PublicKey;
     fn check_terminal_non_malleable<Pk: MiniscriptKey, Ctx: ScriptContext>(
         frag: &Terminal<Pk, Ctx>,
     ) -> Result<(), ScriptContextError> {
@@ -358,13 +369,18 @@ impl ScriptContext for Legacy {
             34
         }
     }
+
+    fn to_str() -> &'static str {
+        "Legacy/p2sh"
+    }
 }
 
 /// Segwitv0 ScriptContext
 #[derive(Debug, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
 pub enum Segwitv0 {}
 
 impl ScriptContext for Segwitv0 {
+    type Key = bitcoin::PublicKey;
     fn check_terminal_non_malleable<Pk: MiniscriptKey, Ctx: ScriptContext>(
         _frag: &Terminal<Pk, Ctx>,
     ) -> Result<(), ScriptContextError> {
@@ -451,13 +467,18 @@ impl ScriptContext for Segwitv0 {
     fn pk_len<Pk: MiniscriptKey>(_pk: &Pk) -> usize {
         34
     }
+
+    fn to_str() -> &'static str {
+        "Segwitv0"
+    }
 }
 
 /// Tap ScriptContext
 #[derive(Debug, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
 pub enum Tap {}
 
 impl ScriptContext for Tap {
+    type Key = bitcoin::schnorr::PublicKey;
     fn check_terminal_non_malleable<Pk: MiniscriptKey, Ctx: ScriptContext>(
         _frag: &Terminal<Pk, Ctx>,
     ) -> Result<(), ScriptContextError> {
@@ -546,6 +567,10 @@ impl ScriptContext for Tap {
     fn pk_len<Pk: MiniscriptKey>(_pk: &Pk) -> usize {
         33
     }
+
+    fn to_str() -> &'static str {
+        "TapscriptCtx"
+    }
 }
 
 /// Bare ScriptContext
@@ -556,6 +581,7 @@ impl ScriptContext for Tap {
 pub enum BareCtx {}
 
 impl ScriptContext for BareCtx {
+    type Key = bitcoin::PublicKey;
     fn check_terminal_non_malleable<Pk: MiniscriptKey, Ctx: ScriptContext>(
         _frag: &Terminal<Pk, Ctx>,
     ) -> Result<(), ScriptContextError> {
@@ -615,6 +641,10 @@ impl ScriptContext for BareCtx {
             33
         }
     }
+
+    fn to_str() -> &'static str {
+        "BareCtx"
+    }
 }
 
 /// "No Checks" Context
@@ -625,6 +655,8 @@ impl ScriptContext for BareCtx {
 #[derive(Debug, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
 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, Ctx: ScriptContext>(
         _frag: &Terminal<Pk, Ctx>,
     ) -> Result<(), ScriptContextError> {
@@ -664,6 +696,11 @@ impl ScriptContext for NoChecks {
     fn pk_len<Pk: MiniscriptKey>(_pk: &Pk) -> usize {
         panic!("Tried to compute a pk len bound on a no-checks miniscript")
     }
+
+    fn to_str() -> &'static str {
+        // Internally used code
+        "NochecksCtx"
+    }
 }
 
 /// Private Mod to prevent downstream from implementing this public trait