cosmwasm_std/errors/
verification_error.rs

1use core::fmt::Debug;
2#[cfg(feature = "backtraces")]
3use std::backtrace::Backtrace;
4use thiserror::Error;
5
6#[cfg(not(target_arch = "wasm32"))]
7use cosmwasm_crypto::CryptoError;
8
9#[derive(Error, Debug)]
10pub enum VerificationError {
11    #[error("Batch error")]
12    BatchErr,
13    #[error("Generic error")]
14    GenericErr,
15    #[error("Invalid hash format")]
16    InvalidHashFormat,
17    #[error("Invalid signature format")]
18    InvalidSignatureFormat,
19    #[error("Invalid public key format")]
20    InvalidPubkeyFormat,
21    #[error("Invalid recovery parameter. Supported values: 0 and 1.")]
22    InvalidRecoveryParam,
23    #[error("Unknown error: {error_code}")]
24    UnknownErr {
25        error_code: u32,
26        #[cfg(feature = "backtraces")]
27        backtrace: Backtrace,
28    },
29}
30
31impl VerificationError {
32    pub fn unknown_err(error_code: u32) -> Self {
33        VerificationError::UnknownErr {
34            error_code,
35            #[cfg(feature = "backtraces")]
36            backtrace: Backtrace::capture(),
37        }
38    }
39}
40
41impl PartialEq<VerificationError> for VerificationError {
42    fn eq(&self, rhs: &VerificationError) -> bool {
43        match self {
44            VerificationError::BatchErr => matches!(rhs, VerificationError::BatchErr),
45            VerificationError::GenericErr => matches!(rhs, VerificationError::GenericErr),
46            VerificationError::InvalidHashFormat => {
47                matches!(rhs, VerificationError::InvalidHashFormat)
48            }
49            VerificationError::InvalidPubkeyFormat => {
50                matches!(rhs, VerificationError::InvalidPubkeyFormat)
51            }
52            VerificationError::InvalidSignatureFormat => {
53                matches!(rhs, VerificationError::InvalidSignatureFormat)
54            }
55            VerificationError::InvalidRecoveryParam => {
56                matches!(rhs, VerificationError::InvalidRecoveryParam)
57            }
58            VerificationError::UnknownErr { error_code, .. } => {
59                if let VerificationError::UnknownErr {
60                    error_code: rhs_error_code,
61                    ..
62                } = rhs
63                {
64                    error_code == rhs_error_code
65                } else {
66                    false
67                }
68            }
69        }
70    }
71}
72
73#[cfg(not(target_arch = "wasm32"))]
74impl From<CryptoError> for VerificationError {
75    fn from(original: CryptoError) -> Self {
76        match original {
77            CryptoError::InvalidHashFormat { .. } => VerificationError::InvalidHashFormat,
78            CryptoError::InvalidPubkeyFormat { .. } => VerificationError::InvalidPubkeyFormat,
79            CryptoError::InvalidSignatureFormat { .. } => VerificationError::InvalidSignatureFormat,
80            CryptoError::GenericErr { .. } => VerificationError::GenericErr,
81            CryptoError::InvalidRecoveryParam { .. } => VerificationError::InvalidRecoveryParam,
82            CryptoError::BatchErr { .. } => VerificationError::BatchErr,
83        }
84    }
85}
86
87#[cfg(test)]
88mod tests {
89    use super::*;
90
91    // constructors
92    #[test]
93    fn unknown_err_works() {
94        let error = VerificationError::unknown_err(123);
95        match error {
96            VerificationError::UnknownErr { error_code, .. } => assert_eq!(error_code, 123),
97            _ => panic!("wrong error type!"),
98        }
99    }
100}