Rework Interpreter: Prepare of tap support

I realize that introducing NoChecksEcdsa/NoChecksSchnorr was the wrong
way to go.
- Remove lifetimes from return types
- Change script from Script to Option<Script>
- Makes all the awkward hacks non-public
- This makes the tests for internal non-exposed types really ackward with
.into() etc, but I don't think this matters much as it is not a public
API

Author: sanket1729

Cargo.toml

@@ -33,8 +33,9 @@ name = "parse"
 [[example]]
 name = "sign_multisig"
 
-[[example]]
-name = "verify_tx"
+# TODO: Re-enable in future commit after API re-design
+# [[example]]
+# name = "verify_tx"
 
 [[example]]
 name = "psbt"

src/interpreter/error.rs

@@ -16,13 +16,22 @@ use bitcoin::hashes::{hash160, hex::ToHex};
 use bitcoin::{self, secp256k1};
 use std::{error, fmt};
 
+use super::BitcoinKey;
+
 /// Detailed Error type for Interpreter
 #[derive(Debug)]
 pub enum Error {
     /// Could not satisfy, absolute locktime not met
     AbsoluteLocktimeNotMet(u32),
+    /// Cannot Infer a taproot descriptor
+    /// Key spends cannot infer the internal key of the descriptor
+    /// Inferring script spends is possible, but is hidden nodes are currently
+    /// not supported in descriptor spec
+    CannotInferTrDescriptors,
     /// General Interpreter error.
     CouldNotEvaluate,
+    /// EcdsaSig related error
+    EcdsaSig(bitcoin::EcdsaSigError),
     /// We expected a push (including a `OP_1` but no other numeric pushes)
     ExpectedPush,
     /// The preimage to the hash function must be exactly 32 bytes.
@@ -39,8 +48,10 @@ pub enum Error {
     InsufficientSignaturesMultiSig,
     /// Invalid Sighash type
     InvalidSchnorrSigHashType(Vec<u8>),
+    /// ecdsa Signature failed to verify
+    InvalidEcdsaSignature(bitcoin::PublicKey),
     /// Signature failed to verify
-    InvalidSignature(bitcoin::PublicKey),
+    InvalidSchnorrSignature(bitcoin::XOnlyPublicKey),
     /// Last byte of this signature isn't a standard sighash type
     NonStandardSigHash(Vec<u8>),
     /// Miniscript error
@@ -60,19 +71,25 @@ pub enum Error {
     /// Any input witness apart from sat(sig) or nsat(0) leads to
     /// this error. This is network standardness assumption and miniscript only
     /// supports standard scripts
-    PkEvaluationError(bitcoin::PublicKey),
+    // note that BitcoinKey is not exported, create a data structure to convey the same
+    // information in error
+    PkEvaluationError(PkEvalErrInner),
     /// The Public Key hash check for the given pubkey. This occurs in `PkH`
     /// node when the given key does not match to Hash in script.
     PkHashVerifyFail(hash160::Hash),
     /// Parse Error while parsing a `stack::Element::Push` as a Pubkey. Both
     /// 33 byte and 65 bytes are supported.
     PubkeyParseError,
+    /// Parse Error while parsing a `stack::Element::Push` as a XOnlyPublicKey (32 bytes)
+    XOnlyPublicKeyParseError,
     /// Could not satisfy, relative locktime not met
     RelativeLocktimeNotMet(u32),
     /// Forward-secp related errors
     Secp(secp256k1::Error),
     /// Miniscript requires the entire top level script to be satisfied.
     ScriptSatisfactionError,
+    /// Schnorr Signature error
+    SchnorrSig(bitcoin::SchnorrSigError),
     /// Errors in signature hash calculations
     SighashError(bitcoin::util::sighash::Error),
     /// An uncompressed public key was encountered in a context where it is
@@ -92,6 +109,34 @@ pub enum Error {
     VerifyFailed,
 }
 
+/// A type of representing which keys errored during interpreter checksig evaluation
+// Note that we can't use BitcoinKey because it is not public
+#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum PkEvalErrInner {
+    /// Full Key
+    FullKey(bitcoin::PublicKey),
+    /// XOnly Key
+    XOnlyKey(bitcoin::XOnlyPublicKey),
+}
+
+impl From<BitcoinKey> for PkEvalErrInner {
+    fn from(pk: BitcoinKey) -> Self {
+        match pk {
+            BitcoinKey::Fullkey(pk) => PkEvalErrInner::FullKey(pk),
+            BitcoinKey::XOnlyPublicKey(xpk) => PkEvalErrInner::XOnlyKey(xpk),
+        }
+    }
+}
+
+impl fmt::Display for PkEvalErrInner {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            PkEvalErrInner::FullKey(pk) => pk.fmt(f),
+            PkEvalErrInner::XOnlyKey(xpk) => xpk.fmt(f),
+        }
+    }
+}
+
 #[doc(hidden)]
 impl From<secp256k1::Error> for Error {
     fn from(e: secp256k1::Error) -> Error {
@@ -106,6 +151,20 @@ impl From<bitcoin::util::sighash::Error> for Error {
     }
 }
 
+#[doc(hidden)]
+impl From<bitcoin::EcdsaSigError> for Error {
+    fn from(e: bitcoin::EcdsaSigError) -> Error {
+        Error::EcdsaSig(e)
+    }
+}
+
+#[doc(hidden)]
+impl From<bitcoin::SchnorrSigError> for Error {
+    fn from(e: bitcoin::SchnorrSigError) -> Error {
+        Error::SchnorrSig(e)
+    }
+}
+
 #[doc(hidden)]
 impl From<::Error> for Error {
     fn from(e: ::Error) -> Error {
@@ -130,6 +189,8 @@ impl fmt::Display for Error {
                 "required absolute locktime CLTV of {} blocks, not met",
                 n
             ),
+            Error::CannotInferTrDescriptors => write!(f, "Cannot infer taproot descriptors"),
+            Error::EcdsaSig(ref s) => write!(f, "Ecdsa sig error: {}", s),
             Error::ExpectedPush => f.write_str("expected push in script"),
             Error::CouldNotEvaluate => f.write_str("Interpreter Error: Could not evaluate"),
             Error::HashPreimageLengthMismatch => f.write_str("Hash preimage should be 32 bytes"),
@@ -147,7 +208,8 @@ impl fmt::Display for Error {
                     sig.to_hex()
                 )
             }
-            Error::InvalidSignature(pk) => write!(f, "bad signature with pk {}", pk),
+            Error::InvalidEcdsaSignature(pk) => write!(f, "bad ecdsa signature with pk {}", pk),
+            Error::InvalidSchnorrSignature(pk) => write!(f, "bad schnorr signature with pk {}", pk),
             Error::NonStandardSigHash(ref sig) => {
                 write!(
                     f,
@@ -165,11 +227,13 @@ impl fmt::Display for Error {
             Error::PkEvaluationError(ref key) => write!(f, "Incorrect Signature for pk {}", key),
             Error::PkHashVerifyFail(ref hash) => write!(f, "Pubkey Hash check failed {}", hash),
             Error::PubkeyParseError => f.write_str("could not parse pubkey"),
+            Error::XOnlyPublicKeyParseError => f.write_str("could not parse x-only pubkey"),
             Error::RelativeLocktimeNotMet(n) => {
                 write!(f, "required relative locktime CSV of {} blocks, not met", n)
             }
             Error::ScriptSatisfactionError => f.write_str("Top level script must be satisfied"),
             Error::Secp(ref e) => fmt::Display::fmt(e, f),
+            Error::SchnorrSig(ref s) => write!(f, "Schnorr sig error: {}", s),
             Error::SighashError(ref e) => fmt::Display::fmt(e, f),
             Error::UncompressedPubkey => {
                 f.write_str("uncompressed pubkey in non-legacy descriptor")