trustless-protocol 0.2.3

Protocol utilities for trustless
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

mod backend;
mod blob_check;
mod certificate;
#[cfg(feature = "encrypted-key")]
mod encrypted_key;

pub use backend::*;
pub use blob_check::*;
pub use certificate::*;
#[cfg(feature = "encrypted-key")]
pub use encrypted_key::*;

/// Error type for provider helper operations.
#[derive(Debug, thiserror::Error)]
pub enum ProviderHelperError {
    #[error("failed to parse PEM: {0}")]
    PemParse(String),

    #[error("failed to parse X.509 certificate: {0}")]
    X509Parse(String),

    #[error("failed to parse signing key: {0}")]
    KeyParse(String),

    #[error("certificate not found: {0}")]
    CertificateNotFound(String),

    #[error("unsupported signature scheme: {0}")]
    UnsupportedScheme(String),

    #[error("blob check failed: {0}")]
    BlobCheckFailed(String),

    #[error("signing failed: {0}")]
    SigningFailed(String),

    #[error("key decryption error: {0}")]
    KeyDecryption(String),
}

impl From<ProviderHelperError> for crate::message::ErrorCode {
    fn from(e: ProviderHelperError) -> Self {
        match e {
            ProviderHelperError::CertificateNotFound(m) => {
                crate::message::ErrorCode::CertificateNotFound(m)
            }
            ProviderHelperError::UnsupportedScheme(m) => {
                crate::message::ErrorCode::UnsupportedScheme(m)
            }
            ProviderHelperError::BlobCheckFailed(m)
            | ProviderHelperError::SigningFailed(m)
            | ProviderHelperError::KeyDecryption(m) => crate::message::ErrorCode::SigningFailed(m),
            other => crate::message::ErrorCode::SigningFailed(other.to_string()),
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn error_to_error_code() {
        let cert_err: crate::message::ErrorCode =
            ProviderHelperError::CertificateNotFound("x".to_owned()).into();
        assert!(matches!(
            cert_err,
            crate::message::ErrorCode::CertificateNotFound(_)
        ));

        let scheme_err: crate::message::ErrorCode =
            ProviderHelperError::UnsupportedScheme("x".to_owned()).into();
        assert!(matches!(
            scheme_err,
            crate::message::ErrorCode::UnsupportedScheme(_)
        ));

        let sign_err: crate::message::ErrorCode =
            ProviderHelperError::SigningFailed("x".to_owned()).into();
        assert!(matches!(
            sign_err,
            crate::message::ErrorCode::SigningFailed(_)
        ));
    }
}