switch to try_lock to prevent deadlocks

crates/cheatcodes/src/evm.rs

@@ -65,7 +65,7 @@ impl Cheatcode for getNonce_0Call {
         let Self { account } = self;
 
         let strategy = ccx.state.strategy.clone();
-        let mut guard = strategy.lock().expect("failed acquiring strategy");
+        let mut guard = strategy.try_lock().expect("failed acquiring strategy");
         guard.cheatcode_get_nonce(ccx, *account)
     }
 }
@@ -353,7 +353,7 @@ impl Cheatcode for rollCall {
     fn apply_stateful(&self, ccx: &mut CheatsCtxt) -> Result {
         let Self { newHeight } = self;
         let strategy = ccx.state.strategy.clone();
-        let mut guard = strategy.lock().expect("failed acquiring strategy");
+        let mut guard = strategy.try_lock().expect("failed acquiring strategy");
         guard.cheatcode_roll(ccx, *newHeight)
     }
 }
@@ -377,7 +377,7 @@ impl Cheatcode for warpCall {
     fn apply_stateful(&self, ccx: &mut CheatsCtxt) -> Result {
         let Self { newTimestamp } = self;
         let strategy = ccx.state.strategy.clone();
-        let mut guard = strategy.lock().expect("failed acquiring strategy");
+        let mut guard = strategy.try_lock().expect("failed acquiring strategy");
         guard.cheatcode_warp(ccx, *newTimestamp)
     }
 }
@@ -414,7 +414,7 @@ impl Cheatcode for dealCall {
         let Self { account: address, newBalance: new_balance } = *self;
 
         let strategy = ccx.state.strategy.clone();
-        let mut guard = strategy.lock().expect("failed acquiring strategy");
+        let mut guard = strategy.try_lock().expect("failed acquiring strategy");
         guard.cheatcode_deal(ccx, address, new_balance)
     }
 }
@@ -424,7 +424,7 @@ impl Cheatcode for etchCall {
         let Self { target, newRuntimeBytecode } = self;
 
         let strategy = ccx.state.strategy.clone();
-        let mut guard = strategy.lock().expect("failed acquiring strategy");
+        let mut guard = strategy.try_lock().expect("failed acquiring strategy");
         guard.cheatcode_etch(ccx, *target, newRuntimeBytecode)
     }
 }
@@ -433,7 +433,7 @@ impl Cheatcode for resetNonceCall {
     fn apply_stateful(&self, ccx: &mut CheatsCtxt) -> Result {
         let Self { account } = self;
         let strategy = ccx.state.strategy.clone();
-        let mut guard = strategy.lock().expect("failed acquiring strategy");
+        let mut guard = strategy.try_lock().expect("failed acquiring strategy");
         guard.cheatcode_reset_nonce(ccx, *account)
     }
 }
@@ -443,7 +443,7 @@ impl Cheatcode for setNonceCall {
         let Self { account, newNonce } = *self;
 
         let strategy = ccx.state.strategy.clone();
-        let mut guard = strategy.lock().expect("failed acquiring strategy");
+        let mut guard = strategy.try_lock().expect("failed acquiring strategy");
         guard.cheatcode_set_nonce(ccx, account, newNonce)
     }
 }
@@ -453,7 +453,7 @@ impl Cheatcode for setNonceUnsafeCall {
         let Self { account, newNonce } = *self;
 
         let strategy = ccx.state.strategy.clone();
-        let mut guard = strategy.lock().expect("failed acquiring strategy");
+        let mut guard = strategy.try_lock().expect("failed acquiring strategy");
         guard.cheatcode_set_nonce_unsafe(ccx, account, newNonce)
     }
 }

crates/cheatcodes/src/evm/mock.rs

@@ -16,7 +16,7 @@ impl Cheatcode for mockCall_0Call {
     fn apply_stateful(&self, ccx: &mut CheatsCtxt) -> Result {
         let Self { callee, data, returnData } = self;
         let strategy = ccx.state.strategy.clone();
-        let mut guard = strategy.lock().expect("failed acquiring strategy");
+        let mut guard = strategy.try_lock().expect("failed acquiring strategy");
         guard.mock_call(ccx, *callee, data, returnData)
     }
 }
@@ -86,7 +86,7 @@ impl Cheatcode for mockCallRevert_0Call {
     fn apply_stateful(&self, ccx: &mut CheatsCtxt) -> Result {
         let Self { callee, data, revertData } = self;
         let strategy = ccx.state.strategy.clone();
-        let mut guard = strategy.lock().expect("failed acquiring strategy");
+        let mut guard = strategy.try_lock().expect("failed acquiring strategy");
         guard.mock_call_revert(ccx, *callee, data, revertData)
     }
 }

crates/cheatcodes/src/fs.rs

@@ -284,7 +284,7 @@ impl Cheatcode for getCodeCall {
     fn apply(&self, state: &mut Cheatcodes) -> Result {
         let Self { artifactPath: path } = self;
         let strategy = state.strategy.clone();
-        let guard = strategy.lock().expect("failed acquiring strategy");
+        let guard = strategy.try_lock().expect("failed acquiring strategy");
         guard.get_artifact_code(state, path, false)
     }
 }

crates/cheatcodes/src/inspector.rs

@@ -762,7 +762,7 @@ impl Cheatcodes {
         }
 
         let strategy = self.strategy.clone();
-        let mut guard = strategy.lock().expect("failed acquiring strategy");
+        let mut guard = strategy.try_lock().expect("failed acquiring strategy");
         if let Some(result) = guard.zksync_try_create(self, ecx, &input, executor) {
             return Some(result);
         }
@@ -1181,7 +1181,7 @@ where {
         }
 
         let strategy = self.strategy.clone();
-        let mut guard = strategy.lock().expect("failed acquiring strategy");
+        let mut guard = strategy.try_lock().expect("failed acquiring strategy");
         if let Some(result) = guard.zksync_try_call(self, ecx, &call, executor) {
             return Some(result);
         }
@@ -1291,7 +1291,12 @@ impl Inspector<&mut dyn DatabaseExt> for Cheatcodes {
 
     #[inline]
     fn step_end(&mut self, interpreter: &mut Interpreter, ecx: Ecx) {
-        if self.strategy.lock().expect("failed acquiring strategy").pre_step_end(interpreter, ecx) {
+        if self
+            .strategy
+            .try_lock()
+            .expect("failed acquiring strategy")
+            .pre_step_end(interpreter, ecx)
+        {
             return;
         }
 

crates/cheatcodes/src/test.rs

@@ -27,7 +27,11 @@ impl Cheatcode for zkVmCall {
 
 impl Cheatcode for zkVmSkipCall {
     fn apply_stateful(&self, ccx: &mut CheatsCtxt) -> Result {
-        ccx.state.strategy.lock().expect("failed acquiring strategy").zksync_cheatcode_skip_zkvm()
+        ccx.state
+            .strategy
+            .try_lock()
+            .expect("failed acquiring strategy")
+            .zksync_cheatcode_skip_zkvm()
     }
 }
 

crates/evm/core/src/backend/mod.rs

@@ -1156,7 +1156,7 @@ impl DatabaseExt for Backend {
                 caller_account.into()
             });
 
-            self.strategy.lock().expect("failed acquiring strategy").update_fork_db(
+            self.strategy.try_lock().expect("failed acquiring strategy").update_fork_db(
                 BackendStrategyForkInfo {
                     active_fork: self.active_fork(),
                     active_type: current_fork_type,
@@ -1810,7 +1810,7 @@ impl BackendInner {
             // we initialize a _new_ `ForkDB` but keep the state of persistent accounts
             let mut new_db = ForkDB::new(backend);
             for addr in self.persistent_accounts.iter().copied() {
-                strategy.lock().expect("failed acquiring strategy").merge_db_account_data(
+                strategy.try_lock().expect("failed acquiring strategy").merge_db_account_data(
                     addr,
                     &active.db,
                     &mut new_db,

crates/evm/evm/src/executors/mod.rs

@@ -208,7 +208,7 @@ impl Executor {
     pub fn set_balance(&mut self, address: Address, amount: U256) -> BackendResult<()> {
         trace!(?address, ?amount, "setting account balance");
         let strategy = self.strategy.clone();
-        let mut guard = strategy.lock().expect("failed acquiring strategy");
+        let mut guard = strategy.try_lock().expect("failed acquiring strategy");
         guard.set_balance(self, address, amount)
     }
 
@@ -220,7 +220,7 @@ impl Executor {
     /// Set the nonce of an account.
     pub fn set_nonce(&mut self, address: Address, nonce: u64) -> BackendResult<()> {
         let strategy = self.strategy.clone();
-        let mut guard = strategy.lock().expect("failed acquiring strategy");
+        let mut guard = strategy.try_lock().expect("failed acquiring strategy");
         guard.set_nonce(self, address, nonce)
     }
 
@@ -254,7 +254,10 @@ impl Executor {
 
     #[inline]
     pub fn set_transaction_other_fields(&mut self, other_fields: OtherFields) {
-        self.strategy.lock().expect("failed acquiring strategy").set_inspect_context(other_fields);
+        self.strategy
+            .try_lock()
+            .expect("failed acquiring strategy")
+            .set_inspect_context(other_fields);
     }
 
     /// Deploys a contract and commits the new state to the underlying database.
@@ -437,7 +440,7 @@ impl Executor {
         backend.is_initialized = false;
         backend.spec_id = env.spec_id();
 
-        let result = self.strategy.lock().expect("failed acquiring strategy").call_inspect(
+        let result = self.strategy.try_lock().expect("failed acquiring strategy").call_inspect(
             &mut backend,
             &mut env,
             &mut inspector,

crates/evm/evm/src/executors/trace.rs

@@ -28,7 +28,7 @@ impl TracingExecutor {
     ) -> Self {
         let db = Backend::spawn(
             fork,
-            strategy.lock().expect("failed acquiring strategy").new_backend_strategy(),
+            strategy.try_lock().expect("failed acquiring strategy").new_backend_strategy(),
         );
         let trace_mode =
             TraceMode::Call.with_debug(debug).with_decode_internal(if decode_internal {

crates/forge/src/multi_runner.rs

@@ -180,7 +180,7 @@ impl MultiContractRunner {
         // The DB backend that serves all the data.
         let db = Backend::spawn(
             self.fork.take(),
-            self.strategy.lock().expect("failed acquiring strategy").new_backend_strategy(),
+            self.strategy.try_lock().expect("failed acquiring strategy").new_backend_strategy(),
         );
 
         let find_timer = Instant::now();

crates/forge/src/runner.rs

@@ -151,7 +151,11 @@ impl ContractRunner<'_> {
         // nonce.
         if let Some(cheatcodes) = &mut self.executor.inspector.cheatcodes {
             debug!("test contract deployed");
-            cheatcodes.strategy.lock().expect("failed acquiring strategy").base_contract_deployed();
+            cheatcodes
+                .strategy
+                .try_lock()
+                .expect("failed acquiring strategy")
+                .base_contract_deployed();
         }
 
         // Optionally call the `setUp` function

crates/script/src/lib.rs

@@ -600,7 +600,10 @@ impl ScriptConfig {
                     let fork = self.evm_opts.get_fork(&self.config, env.clone());
                     let backend = Backend::spawn(
                         fork,
-                        strategy.lock().expect("failed acquiring strategy").new_backend_strategy(),
+                        strategy
+                            .try_lock()
+                            .expect("failed acquiring strategy")
+                            .new_backend_strategy(),
                     );
                     self.backends.insert(fork_url.clone(), backend.clone());
                     backend
@@ -612,7 +615,7 @@ impl ScriptConfig {
             // to cache the backend for.
             Backend::spawn(
                 None,
-                strategy.lock().expect("failed acquiring strategy").new_backend_strategy(),
+                strategy.try_lock().expect("failed acquiring strategy").new_backend_strategy(),
             )
         };
 

crates/script/src/runner.rs

@@ -174,7 +174,11 @@ impl ScriptRunner {
         // nonce.
         if let Some(cheatcodes) = &mut self.executor.inspector.cheatcodes {
             debug!("script deployed");
-            cheatcodes.strategy.lock().expect("failed acquiring strategy").base_contract_deployed();
+            cheatcodes
+                .strategy
+                .try_lock()
+                .expect("failed acquiring strategy")
+                .base_contract_deployed();
         }
 
         // Optionally call the `setUp` function