chore: Resolve conflicts with main

Author: shahnami

docs/modules/ROOT/pages/error.adoc

@@ -160,6 +160,12 @@ a|* `NotFound` - Resource not found errors
 * `ExecutionError` - Trigger execution failures
 * `ConfigurationError` - Trigger configuration issues
 * `Other` - Unclassified errors
+
+|Monitor Executor
+|`MonitorExecutionError`
+a|* `NotFound` - Resource not found errors
+* `ExecutionError` - Monitor execution failures
+* `Other` - Unclassified errors
 |===
 
 == Error Handling Guidelines

docs/modules/ROOT/pages/rpc.adoc

@@ -153,8 +153,8 @@ This architecture ensures:
 3. Both clients maintain efficiency by sharing the same connection pool
 
 
-*Transport Level*: Each transport client may define its own retry policy:
-+
+Each transport client may define its own retry policy:
+
 [source,rust]
 ----
 

docs/modules/ROOT/pages/structure.adoc

@@ -46,6 +46,7 @@ The main source code directory contains the core implementation files organized
 ** `expression`: Expression evaluation
 ** `logging/`: Logging utilities
 ** `metrics/`: Metrics utilities
+** `monitor/`: Monitor configuration test utilities
 
 == Configuration and Data
 

src/main.rs

@@ -158,7 +158,9 @@ async fn test_monitor_execution(
 
 									tracing::info!(
 										"Network: {}",
-										details.get("network_slug").unwrap()
+										details
+											.get("network_slug")
+											.unwrap_or(&serde_json::Value::Null)
 									);
 
 									// Get transaction details based on network type
@@ -459,8 +461,11 @@ async fn main() -> Result<()> {
 	let should_test_monitor_execution = monitor_path.is_some();
 	// If monitor path is provided, test monitor execution else start the service
 	if should_test_monitor_execution {
+		let monitor_path = monitor_path.ok_or(anyhow::anyhow!(
+			"monitor_path must be defined when testing monitor execution"
+		))?;
 		return test_monitor_execution(
-			monitor_path.unwrap(),
+			monitor_path,
 			network_slug,
 			block_number,
 			monitor_service,

src/services/blockchain/transports/endpoint_manager.rs

@@ -57,6 +57,14 @@ impl EndpointManager {
 		self.client = client;
 	}
 
+	/// Updates the retry policy for the client
+	///
+	/// Constructs a new client with the given retry policy and strategy
+	/// and updates the endpoint manager with the new client
+	///
+	/// # Arguments
+	/// * `retry_policy` - The new retry policy to use for the client
+	/// * `retry_strategy` - The new retry strategy to use for the client
 	pub fn set_retry_policy<R: RetryableStrategy + Send + Sync + 'static>(
 		&mut self,
 		retry_policy: ExponentialBackoff,

src/services/blockchain/transports/mod.rs

@@ -21,9 +21,9 @@ pub use endpoint_manager::EndpointManager;
 pub use evm::http::EVMTransportClient;
 pub use http::HttpTransportClient;
 pub use midnight::http::MidnightTransportClient;
-use reqwest_middleware::ClientWithMiddleware;
 pub use stellar::http::StellarTransportClient;
 
+use reqwest_middleware::ClientWithMiddleware;
 use reqwest_retry::{
 	default_on_request_failure, default_on_request_success, policies::ExponentialBackoff,
 	Retryable, RetryableStrategy,

tests/integration/blockchain/transports/endpoint_manager.rs

@@ -1,6 +1,6 @@
 use mockito::Server;
 use reqwest_middleware::{ClientBuilder, ClientWithMiddleware};
-use reqwest_retry::policies::ExponentialBackoff;
+use reqwest_retry::{policies::ExponentialBackoff, RetryTransientMiddleware};
 use serde::Serialize;
 use serde_json::{json, Value};
 use std::sync::Arc;
@@ -333,3 +333,169 @@ async fn test_rotate_url_connection_failure() {
 		&vec![invalid_url.to_string()]
 	);
 }
+
+#[tokio::test]
+async fn test_update_client() {
+	let mut server = Server::new_async().await;
+
+	// Set up two different responses to differentiate between clients
+	let initial_mock = server
+		.mock("POST", "/")
+		.with_status(200)
+		.with_header("content-type", "application/json")
+		.with_body(r#"{"jsonrpc": "2.0", "result": "initial_client", "id": 1}"#)
+		.expect(1)
+		.create_async()
+		.await;
+
+	let mut manager =
+		EndpointManager::new(get_mock_client_builder(), server.url().as_ref(), vec![]);
+
+	// Test initial client
+	let transport = MockTransport::new();
+	let initial_result = manager
+		.send_raw_request(&transport, "test_method", Some(json!(["param1"])))
+		.await
+		.unwrap();
+	assert_eq!(initial_result["result"], "initial_client");
+	initial_mock.assert();
+
+	// Set up mock for new client
+	let updated_mock = server
+		.mock("POST", "/")
+		.with_status(200)
+		.with_header("content-type", "application/json")
+		.with_body(r#"{"jsonrpc": "2.0", "result": "updated_client", "id": 1}"#)
+		.expect(1)
+		.create_async()
+		.await;
+
+	// Create and update to new client with different configuration
+	let new_client = ClientBuilder::new(reqwest::Client::new())
+		.with(RetryTransientMiddleware::new_with_policy(
+			ExponentialBackoff::builder().build_with_max_retries(3),
+		))
+		.build();
+	manager.update_client(new_client);
+
+	// Test updated client
+	let updated_result = manager
+		.send_raw_request(&transport, "test_method", Some(json!(["param1"])))
+		.await
+		.unwrap();
+	assert_eq!(updated_result["result"], "updated_client");
+	updated_mock.assert();
+}
+
+#[tokio::test]
+async fn test_set_retry_policy() {
+	let mut server = Server::new_async().await;
+
+	// Set up a sequence of responses to test retry behavior
+	let retry_mock = server
+		.mock("POST", "/")
+		.with_status(429) // Too Many Requests
+		.with_body("Rate limited")
+		.expect(2) // Expect 2 retries
+		.create_async()
+		.await;
+
+	let success_mock = server
+		.mock("POST", "/")
+		.with_status(200)
+		.with_header("content-type", "application/json")
+		.with_body(r#"{"jsonrpc": "2.0", "result": "success_after_retry", "id": 1}"#)
+		.expect(1)
+		.create_async()
+		.await;
+
+	let mut manager = EndpointManager::new(
+		get_mock_client_builder(), // Initial client with no retry policy
+		server.url().as_ref(),
+		vec![],
+	);
+
+	// Set a custom retry policy with exactly 2 retries
+	let retry_policy = ExponentialBackoff::builder().build_with_max_retries(2);
+
+	manager.set_retry_policy(retry_policy, TransientErrorRetryStrategy);
+
+	// Make request that should trigger retries
+	let transport = MockTransport::new();
+	let result = manager
+		.send_raw_request(&transport, "test_method", Some(json!(["param1"])))
+		.await
+		.unwrap();
+
+	// Verify that we got the successful response after retries
+	assert_eq!(result["result"], "success_after_retry");
+
+	// Verify that both mocks were called the expected number of times
+	retry_mock.assert();
+	success_mock.assert();
+}
+
+#[tokio::test]
+async fn test_send_raw_request_network_error() {
+	// Set up with an invalid primary URL that will cause a network error
+	let invalid_url = "http://invalid-domain-that-will-fail:12345";
+	let mut valid_server = Server::new_async().await;
+
+	// Set up mock for fallback server
+	let success_mock = valid_server
+		.mock("POST", "/")
+		.with_status(200)
+		.with_header("content-type", "application/json")
+		.with_body(r#"{"jsonrpc": "2.0", "result": "success", "id": 1}"#)
+		.expect(1)
+		.create_async()
+		.await;
+
+	let manager = EndpointManager::new(
+		get_mock_client_builder(),
+		invalid_url,
+		vec![valid_server.url()], // Add valid fallback URL
+	);
+	let transport = MockTransport::new();
+
+	// Send request - should fail first with network error, then rotate and succeed
+	let result = manager
+		.send_raw_request(&transport, "test_method", Some(json!(["param1"])))
+		.await;
+
+	// Verify success after rotation
+	assert!(result.is_ok());
+	let response = result.unwrap();
+	assert_eq!(response["result"], "success");
+	success_mock.assert();
+
+	// Verify URL rotation occurred
+	assert_eq!(&*manager.active_url.read().await, &valid_server.url());
+}
+
+#[tokio::test]
+async fn test_send_raw_request_network_error_no_fallback() {
+	// Set up with an invalid URL and no fallbacks
+	let invalid_url = "http://invalid-domain-that-will-fail:12345";
+	let manager = EndpointManager::new(
+		get_mock_client_builder(),
+		invalid_url,
+		vec![], // No fallback URLs
+	);
+	let transport = MockTransport::new();
+
+	// Send request - should fail with network error and no rotation possible
+	let result = manager
+		.send_raw_request(&transport, "test_method", Some(json!(["param1"])))
+		.await;
+
+	// Verify error
+	assert!(result.is_err());
+	assert!(result
+		.unwrap_err()
+		.to_string()
+		.contains("Failed to send request"));
+
+	// Verify URL didn't change
+	assert_eq!(&*manager.active_url.read().await, invalid_url);
+}

tests/integration/blockchain/transports/evm/http.rs

@@ -1,7 +1,9 @@
 use mockito::Server;
 use openzeppelin_monitor::services::blockchain::{
-	BlockchainTransport, EVMTransportClient, RotatingTransport,
+	BlockchainTransport, EVMTransportClient, RotatingTransport, TransientErrorRetryStrategy,
 };
+use reqwest_middleware::ClientBuilder;
+use reqwest_retry::{policies::ExponentialBackoff, RetryTransientMiddleware};
 use serde_json::{json, Value};
 
 use crate::integration::mocks::{
@@ -161,3 +163,108 @@ async fn test_send_raw_request() {
 	assert_eq!(response["result"]["data"], "success");
 	no_params_mock.assert();
 }
+
+#[tokio::test]
+async fn test_set_retry_policy() {
+	let mut server = Server::new_async().await;
+	let mock = create_evm_valid_server_mock_network_response(&mut server);
+
+	let network = create_evm_test_network_with_urls(vec![&server.url()]);
+	let mut client = EVMTransportClient::new(&network).await.unwrap();
+
+	// Set up a sequence of responses to test retry behavior
+	let retry_mock = server
+		.mock("POST", "/")
+		.with_status(429) // Too Many Requests
+		.with_body("Rate limited")
+		.expect(2) // Expect 2 retries
+		.create_async()
+		.await;
+
+	let success_mock = server
+		.mock("POST", "/")
+		.with_status(200)
+		.with_header("content-type", "application/json")
+		.with_body(r#"{"jsonrpc": "2.0", "result": "success_after_retry", "id": 1}"#)
+		.expect(1)
+		.create_async()
+		.await;
+
+	// Set a custom retry policy with exactly 2 retries
+	let retry_policy = ExponentialBackoff::builder().build_with_max_retries(2);
+	let result = client.set_retry_policy(retry_policy, Some(TransientErrorRetryStrategy));
+	assert!(result.is_ok());
+
+	// Make request that should trigger retries
+	let result = client
+		.send_raw_request("test_method", Some(json!(["param1"])))
+		.await;
+
+	// Verify success after retries
+	assert!(result.is_ok());
+	let response = result.unwrap();
+	assert_eq!(response["result"], "success_after_retry");
+
+	// Verify all mocks were called
+	mock.assert();
+	retry_mock.assert();
+	success_mock.assert();
+}
+
+#[tokio::test]
+async fn test_update_endpoint_manager_client() {
+	let mut server = Server::new_async().await;
+
+	// Set up initial response
+	let initial_mock = create_evm_valid_server_mock_network_response(&mut server);
+	let initial_request_mock = server
+		.mock("POST", "/")
+		.with_status(200)
+		.with_header("content-type", "application/json")
+		.with_body(r#"{"jsonrpc": "2.0", "result": "initial_client", "id": 1}"#)
+		.expect(1)
+		.create_async()
+		.await;
+
+	let network = create_evm_test_network_with_urls(vec![&server.url()]);
+	let mut client = EVMTransportClient::new(&network).await.unwrap();
+
+	// Test initial client
+	let result = client
+		.send_raw_request("test_method", Some(json!(["param1"])))
+		.await
+		.unwrap();
+	assert_eq!(result["result"], "initial_client");
+
+	// Set up mock for updated client
+	let updated_mock = server
+		.mock("POST", "/")
+		.with_status(200)
+		.with_header("content-type", "application/json")
+		.with_body(r#"{"jsonrpc": "2.0", "result": "updated_client", "id": 1}"#)
+		.expect(1)
+		.create_async()
+		.await;
+
+	// Create and update to new client
+	let new_client = ClientBuilder::new(reqwest::Client::new())
+		.with(RetryTransientMiddleware::new_with_policy(
+			ExponentialBackoff::builder().build_with_max_retries(3),
+		))
+		.build();
+
+	let result = client.update_endpoint_manager_client(new_client);
+	assert!(result.is_ok());
+
+	// Test updated client
+	let result = client
+		.send_raw_request("test_method", Some(json!(["param1"])))
+		.await
+		.unwrap();
+	assert_eq!(result["result"], "updated_client");
+
+	// Verify all mocks were called
+	initial_mock.assert();
+	initial_request_mock.assert();
+	updated_mock.assert();
+}