openzeppelin_relayer/models/error/
signer.rs

1use serde::Serialize;
2use thiserror::Error;
3
4use crate::services::{AwsKmsError, CdpError, GoogleCloudKmsError, TurnkeyError, VaultError};
5
6use super::TransactionError;
7
8#[derive(Error, Debug, Serialize)]
9#[allow(clippy::enum_variant_names)]
10pub enum SignerError {
11    #[error("Failed to sign transaction: {0}")]
12    SigningError(String),
13
14    #[error("Invalid key format: {0}")]
15    KeyError(String),
16
17    #[error("Provider error: {0}")]
18    ProviderError(String),
19
20    #[error("Unsupported signer type: {0}")]
21    UnsupportedTypeError(String),
22
23    #[error("Invalid transaction: {0}")]
24    InvalidTransaction(#[from] TransactionError),
25
26    #[error("Vault error: {0}")]
27    VaultError(#[from] VaultError),
28
29    #[error("Turnkey error: {0}")]
30    TurnkeyError(#[from] TurnkeyError),
31
32    #[error("CDP error: {0}")]
33    CdpError(#[from] CdpError),
34
35    #[error("AWS KMS error: {0}")]
36    AwsKmsError(#[from] AwsKmsError),
37
38    #[error("Google Cloud KMS error: {0}")]
39    GoogleCloudKmsError(#[from] GoogleCloudKmsError),
40
41    #[error("Not implemented: {0}")]
42    NotImplemented(String),
43
44    #[error("Invalid configuration: {0}")]
45    ConfigError(String),
46
47    #[error("Network error: {0}")]
48    NetworkError(String),
49
50    #[error("Authentication error: {0}")]
51    AuthenticationError(String),
52
53    #[error("Parse error: {0}")]
54    ParseError(String),
55
56    #[error("Invalid configuration: {0}")]
57    Configuration(String),
58
59    #[error("Transaction conversion error: {0}")]
60    ConversionError(String),
61}
62
63#[derive(Error, Debug, Serialize)]
64pub enum SignerFactoryError {
65    #[error("Invalid configuration: {0}")]
66    InvalidConfig(String),
67    #[error("Signer creation failed: {0}")]
68    CreationFailed(String),
69    #[error("Unsupported signer type: {0}")]
70    UnsupportedType(String),
71    #[error("Signer error: {0}")]
72    SignerError(#[from] SignerError),
73}
74
75#[cfg(test)]
76mod tests {
77    use super::*;
78
79    #[test]
80    fn test_signer_error_display() {
81        let test_cases = vec![
82            (
83                SignerError::SigningError("failed to sign".to_string()),
84                "Failed to sign transaction: failed to sign",
85            ),
86            (
87                SignerError::KeyError("invalid key".to_string()),
88                "Invalid key format: invalid key",
89            ),
90            (
91                SignerError::ProviderError("connection failed".to_string()),
92                "Provider error: connection failed",
93            ),
94            (
95                SignerError::UnsupportedTypeError("unknown type".to_string()),
96                "Unsupported signer type: unknown type",
97            ),
98            (
99                SignerError::NotImplemented("feature not ready".to_string()),
100                "Not implemented: feature not ready",
101            ),
102            (
103                SignerError::Configuration("missing parameter".to_string()),
104                "Invalid configuration: missing parameter",
105            ),
106            (
107                SignerError::ConversionError("conversion failed".to_string()),
108                "Transaction conversion error: conversion failed",
109            ),
110        ];
111
112        for (error, expected_message) in test_cases {
113            assert_eq!(error.to_string(), expected_message);
114        }
115    }
116
117    #[test]
118    fn test_signer_error_from_transaction_error() {
119        let tx_error = TransactionError::ValidationError("bad format".to_string());
120        let signer_error = SignerError::from(tx_error);
121
122        match signer_error {
123            SignerError::InvalidTransaction(e) => {
124                assert_eq!(e.to_string(), "Transaction validation error: bad format");
125            }
126            _ => panic!("Expected SignerError::InvalidTransaction"),
127        }
128    }
129
130    #[test]
131    fn test_signer_error_from_vault_error() {
132        let vault_error = VaultError::AuthenticationFailed("no permission".to_string());
133        let signer_error = SignerError::from(vault_error);
134
135        match signer_error {
136            SignerError::VaultError(e) => {
137                assert_eq!(e.to_string(), "Authentication failed: no permission");
138            }
139            _ => panic!("Expected SignerError::VaultError"),
140        }
141    }
142
143    #[test]
144    fn test_signer_error_from_google_cloud_kms_error() {
145        let gcp_error = GoogleCloudKmsError::ApiError("authentication failed".to_string());
146        let signer_error = SignerError::from(gcp_error);
147
148        match signer_error {
149            SignerError::GoogleCloudKmsError(e) => {
150                assert_eq!(e.to_string(), "KMS API error: authentication failed");
151            }
152            _ => panic!("Expected SignerError::GoogleCloudKmsError"),
153        }
154    }
155
156    #[test]
157    fn test_signer_error_from_turnkey_error() {
158        let turnkey_error = TurnkeyError::AuthenticationFailed("api failure".to_string());
159        let signer_error = SignerError::from(turnkey_error);
160
161        match signer_error {
162            SignerError::TurnkeyError(e) => {
163                assert_eq!(e.to_string(), "Authentication failed: api failure");
164            }
165            _ => panic!("Expected SignerError::TurnkeyError"),
166        }
167    }
168
169    #[test]
170    fn test_signer_error_from_aws_kms_error() {
171        let aws_error = AwsKmsError::ConfigError("invalid credentials".to_string());
172        let signer_error = SignerError::from(aws_error);
173
174        match signer_error {
175            SignerError::AwsKmsError(e) => {
176                assert_eq!(e.to_string(), "AWS KMS config error: invalid credentials");
177            }
178            _ => panic!("Expected SignerError::AwsKmsError"),
179        }
180    }
181
182    #[test]
183    fn test_signer_factory_error_display() {
184        let test_cases = vec![
185            (
186                SignerFactoryError::InvalidConfig("missing key".to_string()),
187                "Invalid configuration: missing key",
188            ),
189            (
190                SignerFactoryError::CreationFailed("initialization error".to_string()),
191                "Signer creation failed: initialization error",
192            ),
193            (
194                SignerFactoryError::UnsupportedType("unknown signer".to_string()),
195                "Unsupported signer type: unknown signer",
196            ),
197        ];
198
199        for (error, expected_message) in test_cases {
200            assert_eq!(error.to_string(), expected_message);
201        }
202    }
203
204    #[test]
205    fn test_signer_factory_error_from_signer_error() {
206        let signer_error = SignerError::KeyError("invalid key format".to_string());
207        let factory_error = SignerFactoryError::from(signer_error);
208
209        match factory_error {
210            SignerFactoryError::SignerError(e) => {
211                assert_eq!(e.to_string(), "Invalid key format: invalid key format");
212            }
213            _ => panic!("Expected SignerFactoryError::SignerError"),
214        }
215    }
216}
openzeppelin_relayer/models/error/signer.rs

openzeppelin_relayer/models/error/
signer.rs
