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

openzeppelin_relayer/models/error/
relayer.rs
