use core::fmt;
use internals::write_err;
pub use secp256k1::{self, constants, Keypair, Parity, Secp256k1, Verification, XOnlyPublicKey};
use crate::prelude::*;
use crate::sighash::{InvalidSighashTypeError, TapSighashType};
#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "serde", serde(crate = "actual_serde"))]
pub struct Signature {
pub sig: secp256k1::schnorr::Signature,
pub hash_ty: TapSighashType,
}
impl Signature {
pub fn from_slice(sl: &[u8]) -> Result<Self, SigFromSliceError> {
match sl.len() {
64 => {
let sig = secp256k1::schnorr::Signature::from_slice(sl)?;
Ok(Signature { sig, hash_ty: TapSighashType::Default })
}
65 => {
let (hash_ty, sig) = sl.split_last().expect("Slice len checked == 65");
let hash_ty = TapSighashType::from_consensus_u8(*hash_ty)?;
let sig = secp256k1::schnorr::Signature::from_slice(sig)?;
Ok(Signature { sig, hash_ty })
}
len => Err(SigFromSliceError::InvalidSignatureSize(len)),
}
}
pub fn to_vec(self) -> Vec<u8> {
let mut ser_sig = self.sig.as_ref().to_vec();
if self.hash_ty == TapSighashType::Default {
} else {
ser_sig.push(self.hash_ty as u8);
}
ser_sig
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub enum SigFromSliceError {
SighashType(InvalidSighashTypeError),
Secp256k1(secp256k1::Error),
InvalidSignatureSize(usize),
}
impl fmt::Display for SigFromSliceError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
use SigFromSliceError::*;
match *self {
SighashType(ref e) => write_err!(f, "sighash"; e),
Secp256k1(ref e) => write_err!(f, "secp256k1"; e),
InvalidSignatureSize(sz) => write!(f, "invalid taproot signature size: {}", sz),
}
}
}
#[cfg(feature = "std")]
impl std::error::Error for SigFromSliceError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
use SigFromSliceError::*;
match *self {
Secp256k1(ref e) => Some(e),
SighashType(ref e) => Some(e),
InvalidSignatureSize(_) => None,
}
}
}
impl From<secp256k1::Error> for SigFromSliceError {
fn from(e: secp256k1::Error) -> Self { Self::Secp256k1(e) }
}
impl From<InvalidSighashTypeError> for SigFromSliceError {
fn from(err: InvalidSighashTypeError) -> Self { Self::SighashType(err) }
}