openzeppelin_relayer/models/error/
relayer.rs

1use crate::{
2    models::{SignerError, SignerFactoryError},
3    repositories::TransactionCounterError,
4    services::{ProviderError, SolanaProviderError},
5};
6
7use super::{ApiError, RepositoryError};
8use crate::models::NetworkError;
9use serde::Serialize;
10use thiserror::Error;
11
12#[derive(Error, Debug, Serialize)]
13pub enum RelayerError {
14    #[error("Network configuration error: {0}")]
15    NetworkConfiguration(String),
16    #[error("Provider error: {0}")]
17    ProviderError(String),
18    #[error("Underlying provider error: {0}")]
19    UnderlyingProvider(#[from] ProviderError),
20    #[error("Underlying Solana provider error: {0}")]
21    UnderlyingSolanaProvider(#[from] SolanaProviderError),
22    #[error("Queue error: {0}")]
23    QueueError(String),
24    #[error("Signer factory error: {0}")]
25    SignerFactoryError(#[from] SignerFactoryError),
26    #[error("Signer error: {0}")]
27    SignerError(#[from] SignerError),
28    #[error("Not supported: {0}")]
29    NotSupported(String),
30    #[error("Relayer is disabled")]
31    RelayerDisabled,
32    #[error("Relayer is paused")]
33    RelayerPaused,
34    #[error("Transaction sequence error: {0}")]
35    TransactionSequenceError(#[from] TransactionCounterError),
36    #[error("Insufficient balance error: {0}")]
37    InsufficientBalanceError(String),
38    #[error("Relayer Policy configuration error: {0}")]
39    PolicyConfigurationError(String),
40    #[error("Invalid Dex name : {0}")]
41    InvalidDexName(String),
42    #[error("Dex error : {0}")]
43    DexError(String),
44    #[error("Transaction validation error: {0}")]
45    ValidationError(String),
46}
47
48impl From<RelayerError> for ApiError {
49    fn from(error: RelayerError) -> Self {
50        match error {
51            RelayerError::NetworkConfiguration(msg) => ApiError::InternalError(msg),
52            RelayerError::ProviderError(msg) => ApiError::InternalError(msg),
53            RelayerError::QueueError(msg) => ApiError::InternalError(msg),
54            RelayerError::SignerError(err) => ApiError::InternalError(err.to_string()),
55            RelayerError::SignerFactoryError(err) => ApiError::InternalError(err.to_string()),
56            RelayerError::NotSupported(msg) => ApiError::BadRequest(msg),
57            RelayerError::RelayerDisabled => {
58                ApiError::ForbiddenError("Relayer disabled".to_string())
59            }
60            RelayerError::RelayerPaused => ApiError::ForbiddenError("Relayer paused".to_string()),
61            RelayerError::TransactionSequenceError(err) => ApiError::InternalError(err.to_string()),
62            RelayerError::InsufficientBalanceError(msg) => ApiError::BadRequest(msg),
63            RelayerError::UnderlyingProvider(err) => ApiError::InternalError(err.to_string()),
64            RelayerError::UnderlyingSolanaProvider(err) => ApiError::InternalError(err.to_string()),
65            RelayerError::PolicyConfigurationError(msg) => ApiError::InternalError(msg),
66            RelayerError::InvalidDexName(msg) => ApiError::InternalError(msg),
67            RelayerError::DexError(msg) => ApiError::InternalError(msg),
68            RelayerError::ValidationError(msg) => ApiError::BadRequest(msg),
69        }
70    }
71}
72
73impl From<RepositoryError> for RelayerError {
74    fn from(error: RepositoryError) -> Self {
75        RelayerError::NetworkConfiguration(error.to_string())
76    }
77}
78
79impl From<NetworkError> for RelayerError {
80    fn from(err: NetworkError) -> Self {
81        RelayerError::NetworkConfiguration(err.to_string())
82    }
83}
84
85#[cfg(test)]
86mod tests {
87    use super::*;
88    use crate::models::SignerError;
89    use crate::repositories::TransactionCounterError;
90    use crate::services::{ProviderError, SolanaProviderError};
91
92    #[test]
93    fn test_relayer_error_variants() {
94        let network_error = RelayerError::NetworkConfiguration("Invalid network".to_string());
95        assert_eq!(
96            network_error.to_string(),
97            "Network configuration error: Invalid network"
98        );
99
100        let provider_error = RelayerError::ProviderError("Connection failed".to_string());
101        assert_eq!(
102            provider_error.to_string(),
103            "Provider error: Connection failed"
104        );
105
106        let queue_error = RelayerError::QueueError("Queue full".to_string());
107        assert_eq!(queue_error.to_string(), "Queue error: Queue full");
108
109        let not_supported = RelayerError::NotSupported("Feature unavailable".to_string());
110        assert_eq!(
111            not_supported.to_string(),
112            "Not supported: Feature unavailable"
113        );
114
115        let disabled = RelayerError::RelayerDisabled;
116        assert_eq!(disabled.to_string(), "Relayer is disabled");
117
118        let paused = RelayerError::RelayerPaused;
119        assert_eq!(paused.to_string(), "Relayer is paused");
120
121        let insufficient_balance =
122            RelayerError::InsufficientBalanceError("Not enough ETH".to_string());
123        assert_eq!(
124            insufficient_balance.to_string(),
125            "Insufficient balance error: Not enough ETH"
126        );
127
128        let policy_error = RelayerError::PolicyConfigurationError("Invalid policy".to_string());
129        assert_eq!(
130            policy_error.to_string(),
131            "Relayer Policy configuration error: Invalid policy"
132        );
133    }
134
135    #[test]
136    fn test_from_provider_error() {
137        let provider_error = ProviderError::NetworkConfiguration("RPC timeout".to_string());
138        let relayer_error: RelayerError = provider_error.into();
139
140        assert!(matches!(relayer_error, RelayerError::UnderlyingProvider(_)));
141        assert!(relayer_error.to_string().contains("RPC timeout"));
142    }
143
144    #[test]
145    fn test_from_solana_provider_error() {
146        let solana_error = SolanaProviderError::RpcError("Solana RPC down".to_string());
147        let relayer_error: RelayerError = solana_error.into();
148
149        assert!(matches!(
150            relayer_error,
151            RelayerError::UnderlyingSolanaProvider(_)
152        ));
153        assert!(relayer_error.to_string().contains("Solana RPC down"));
154    }
155
156    #[test]
157    fn test_from_signer_factory_error() {
158        let factory_error = SignerFactoryError::InvalidConfig("Unknown chain".to_string());
159        let relayer_error: RelayerError = factory_error.into();
160
161        assert!(matches!(relayer_error, RelayerError::SignerFactoryError(_)));
162        assert!(relayer_error.to_string().contains("Unknown chain"));
163    }
164
165    #[test]
166    fn test_from_signer_error() {
167        let signer_error = SignerError::SigningError("Invalid key".to_string());
168        let relayer_error: RelayerError = signer_error.into();
169
170        assert!(matches!(relayer_error, RelayerError::SignerError(_)));
171        assert!(relayer_error.to_string().contains("Invalid key"));
172    }
173
174    #[test]
175    fn test_from_transaction_counter_error() {
176        let counter_error = TransactionCounterError::NotFound("Nonce not found".to_string());
177        let relayer_error: RelayerError = counter_error.into();
178
179        assert!(matches!(
180            relayer_error,
181            RelayerError::TransactionSequenceError(_)
182        ));
183        assert!(relayer_error.to_string().contains("Nonce not found"));
184    }
185
186    #[test]
187    fn test_conversion_to_api_error() {
188        let network_error = RelayerError::NetworkConfiguration("Invalid network".to_string());
189        let api_error: ApiError = network_error.into();
190        assert!(matches!(api_error, ApiError::InternalError(_)));
191
192        let not_supported = RelayerError::NotSupported("Feature unavailable".to_string());
193        let api_error: ApiError = not_supported.into();
194        assert!(matches!(api_error, ApiError::BadRequest(_)));
195
196        let disabled = RelayerError::RelayerDisabled;
197        let api_error: ApiError = disabled.into();
198        assert!(matches!(api_error, ApiError::ForbiddenError(_)));
199        assert_eq!(api_error.to_string(), "Forbidden: Relayer disabled");
200
201        let insufficient = RelayerError::InsufficientBalanceError("Not enough funds".to_string());
202        let api_error: ApiError = insufficient.into();
203        assert!(matches!(api_error, ApiError::BadRequest(_)));
204    }
205
206    #[test]
207    fn test_from_repository_error() {
208        let repo_error = RepositoryError::ConnectionError("Connection failed".to_string());
209        let relayer_error: RelayerError = repo_error.into();
210
211        assert!(matches!(
212            relayer_error,
213            RelayerError::NetworkConfiguration(_)
214        ));
215        assert!(relayer_error.to_string().contains("Connection failed"));
216    }
217}
openzeppelin_relayer/models/error/relayer.rs

openzeppelin_relayer/models/error/
relayer.rs
