Introduce errors for byte parsing and verification

diff --git a/crypto/src/ecdsa.rs b/crypto/src/ecdsa.rs
index 7668859f..b1f04351 100644
--- a/crypto/src/ecdsa.rs
+++ b/crypto/src/ecdsa.rs
@@ -32,7 +32,7 @@ use crate::sighash::EcdsaSighashType;
 
 #[rustfmt::skip]                // Keep public re-exports separate.
 #[doc(no_inline)]
-pub use self::error::DecodeError;
+pub use self::error::{DecodeError, InvalidDerError};
 #[cfg(feature = "hex")]
 #[doc(no_inline)]
 pub use self::error::ParseSignatureError;
@@ -314,6 +314,27 @@ pub mod error {
         }
     }
 
+    /// The DER encoding of an ECDSA signature is not valid.
+    #[derive(Debug, Clone, PartialEq, Eq)]
+    #[non_exhaustive]
+    pub struct InvalidDerError;
+
+    impl From<Infallible> for InvalidDerError {
+        fn from(never: Infallible) -> Self { match never {} }
+    }
+
+    impl fmt::Display for InvalidDerError {
+        fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "invalid DER encoding") }
+    }
+
+    #[cfg(feature = "std")]
+    impl std::error::Error for InvalidDerError {
+        fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+            let Self {} = self;
+            None
+        }
+    }
+
     /// Error encountered while parsing an ECDSA signature from a string.
     #[derive(Debug, Clone, PartialEq, Eq)]
     #[non_exhaustive]
diff --git a/crypto/src/key.rs b/crypto/src/key.rs
index e0a6ff36..eddee3b5 100644
--- a/crypto/src/key.rs
+++ b/crypto/src/key.rs
@@ -36,8 +36,9 @@ use crate::hex::{self, DecodeFixedLengthBytesError};
 pub use secp256k1::{constants, Parity, Verification};
 #[doc(no_inline)]
 pub use self::error::{
-    FromSliceError, InvalidAddressVersionError, InvalidBase58PayloadLengthError, ParseKeypairError,
-    ParseXOnlyPublicKeyError, TweakXOnlyPublicKeyError, UncompressedPublicKeyError,
+    FromSecretBytesError, FromSliceError, InvalidAddressVersionError,
+    InvalidBase58PayloadLengthError, InvalidPublicKeyError, ParseKeypairError,
+    ParseXOnlyPublicKeyError, TweakXOnlyPublicKeyError, UncompressedPublicKeyError, VerifyError,
 };
 #[cfg(feature = "alloc")]
 #[doc(no_inline)]
@@ -1981,6 +1982,91 @@ pub mod error {
             }
         }
     }
+
+    /// The bytes do not represent a valid secp256k1 public key.
+    #[derive(Debug, Clone, PartialEq, Eq)]
+    #[non_exhaustive]
+    pub struct InvalidPublicKeyError;
+
+    impl From<Infallible> for InvalidPublicKeyError {
+        #[inline]
+        fn from(never: Infallible) -> Self { match never {} }
+    }
+
+    impl fmt::Display for InvalidPublicKeyError {
+        #[inline]
+        fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "invalid public key") }
+    }
+
+    #[cfg(feature = "std")]
+    impl std::error::Error for InvalidPublicKeyError {
+        fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+            let Self {} = self;
+            None
+        }
+    }
+
+    /// Error that can occur when parsing a [`PrivateKey`] from a byte array.
+    ///
+    /// [`PrivateKey`]: super::PrivateKey
+    #[derive(Debug, Clone, PartialEq, Eq)]
+    pub struct FromSecretBytesError(pub(super) FromSecretBytesErrorInner);
+
+    impl From<Infallible> for FromSecretBytesError {
+        #[inline]
+        fn from(never: Infallible) -> Self { match never {} }
+    }
+
+    impl fmt::Display for FromSecretBytesError {
+        #[inline]
+        fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+            match self.0 {
+                FromSecretBytesErrorInner::InvalidSecretKey => write!(f, "invalid secret key"),
+            }
+        }
+    }
+
+    #[cfg(feature = "std")]
+    impl std::error::Error for FromSecretBytesError {
+        #[inline]
+        fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+            match self.0 {
+                FromSecretBytesErrorInner::InvalidSecretKey => None,
+            }
+        }
+    }
+
+    #[derive(Debug, Clone, PartialEq, Eq)]
+    #[non_exhaustive]
+    pub(super) enum FromSecretBytesErrorInner {
+        /// The bytes represent an invalid secp256k1 secret key.
+        InvalidSecretKey,
+    }
+
+    /// Signature verification failed for the given message and key.
+    #[derive(Debug, Clone, PartialEq, Eq)]
+    #[non_exhaustive]
+    pub struct VerifyError;
+
+    impl From<Infallible> for VerifyError {
+        #[inline]
+        fn from(never: Infallible) -> Self { match never {} }
+    }
+
+    impl fmt::Display for VerifyError {
+        #[inline]
+        fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+            write!(f, "signature verification failed")
+        }
+    }
+
+    #[cfg(feature = "std")]
+    impl std::error::Error for VerifyError {
+        fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+            let Self {} = self;
+            None
+        }
+    }
 }
 
 #[cfg(feature = "arbitrary")]