openzeppelin_relayer/models/error/
signer.rs

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

openzeppelin_relayer/models/error/
signer.rs
