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

openzeppelin_relayer/models/error/
signer.rs
