fix: avoid blocking worker threads

crates/edr_napi/src/provider.rs

@@ -73,12 +73,14 @@ impl Provider {
                 if let Some((method_name, provider_error)) = reason.provider_error() {
                     // Ignore potential failure of logging, as returning the original error is more
                     // important
-                    if let Err(error) = provider
-                        .log_failed_deserialization(&method_name, &provider_error)
+                    let _result = runtime::Handle::current()
+                        .spawn_blocking(move || {
+                            provider.log_failed_deserialization(&method_name, &provider_error)
+                        })
                         .await
-                    {
-                        log::error!("Failed to log deserialization error: {error}");
-                    }
+                        .map_err(|error| {
+                            napi::Error::new(Status::GenericFailure, error.to_string())
+                        })?;
                 }
 
                 let data = serde_json::from_str(&json_request).ok();
@@ -105,7 +107,7 @@ impl Provider {
         };
 
         let response = runtime::Handle::current()
-            .spawn(async move { provider.handle_request(request).await })
+            .spawn_blocking(move || provider.handle_request(request))
             .await
             .map_err(|e| napi::Error::new(Status::GenericFailure, e.to_string()))?;
 

crates/edr_provider/src/lib.rs

@@ -21,7 +21,7 @@ use lazy_static::lazy_static;
 use logger::SyncLogger;
 use parking_lot::Mutex;
 use requests::{eth::handle_set_interval_mining, hardhat::rpc_types::ResetProviderConfig};
-use tokio::{runtime, sync::Mutex as AsyncMutex};
+use tokio::{runtime, sync::Mutex as AsyncMutex, task};
 
 pub use self::{
     config::*,
@@ -118,24 +118,26 @@ impl<LoggerErrorT: Debug + Send + Sync + 'static> Provider<LoggerErrorT> {
         })
     }
 
-    pub async fn handle_request(
+    /// Blocking method to handle a request.
+    pub fn handle_request(
         &self,
         request: ProviderRequest,
     ) -> Result<serde_json::Value, ProviderError<LoggerErrorT>> {
-        let mut data = self.data.lock().await;
+        let mut data = task::block_in_place(|| self.runtime.block_on(self.data.lock()));
 
         match request {
             ProviderRequest::Single(request) => self.handle_single_request(&mut data, request),
             ProviderRequest::Batch(requests) => self.handle_batch_request(&mut data, requests),
         }
     }
 
-    pub async fn log_failed_deserialization(
+    /// Blocking method to log a failed deserialization.
+    pub fn log_failed_deserialization(
         &self,
         method_name: &str,
         error: &ProviderError<LoggerErrorT>,
     ) -> Result<(), ProviderError<LoggerErrorT>> {
-        let mut data = self.data.lock().await;
+        let mut data = task::block_in_place(|| self.runtime.block_on(self.data.lock()));
         data.logger_mut()
             .print_method_logs(method_name, Some(error))
             .map_err(ProviderError::Logger)