alternative

Author: drahnr

Cargo.lock

@@ -14,7 +14,6 @@ bytes = { workspace = true }
 cid = { workspace = true }
 hex = { workspace = true }
 fs-err = { workspace = true }
-futures-util = { workspace = true }
 k256 = { workspace = true }
 lazy_static = { workspace = true }
 libipld = { workspace = true }

fendermint/app/Cargo.toml

@@ -1,9 +1,7 @@
 // Copyright 2022-2024 Protocol Labs
 // SPDX-License-Identifier: Apache-2.0, MIT
 use std::future::Future;
-use std::panic::catch_unwind;
 use std::sync::Arc;
-use futures_util::FutureExt;
 
 use crate::observe::{
     BlockCommitted, BlockProposalEvaluated, BlockProposalReceived, BlockProposalSent, Message,
@@ -14,7 +12,7 @@ use crate::AppExitCode;
 use crate::BlockHeight;
 use crate::{tmconv::*, VERSION};
 use actors_custom_api::gas_market::Reading;
-use anyhow::{anyhow, bail, Context, Result};
+use anyhow::{anyhow, Context, Result};
 use async_stm::{atomically, atomically_or_err};
 use async_trait::async_trait;
 use cid::Cid;
@@ -329,32 +327,16 @@ where
     /// Update the execution state using the provided closure.
     ///
     /// Note: Deals with panics in the user provided closure as well.
-    async fn modify_exec_state<T, F, R>(&self, f: F) -> Result<T>
+    async fn modify_exec_state<T, G, F>(&self, generator: G) -> Result<T>
     where
-        F: FnOnce(&mut FvmExecState<BS>) -> R,
-        R: Future<Output = Result<(FvmExecState<BS>, T)>>,
+        G: for<'s> FnOnce(&'s mut FvmExecState<BS>) -> F,
+        F: Future<Output = Result<T>>,
+        T: 'static,
     {
         let mut guard = self.exec_state.lock().await;
-        let state = guard.take().expect("exec state empty");
-
-        let fut = catch_unwind(move || { f(state) });
-        let fut: R = match fut {
-            Ok(fut) => fut,
-            Err(err) => {
-                *guard = Some(backup);
-                bail!("Encounterd panic in `modify_exec_state` user provided future generator invocation: {err:?}")
-            }
-        };
-        let res = fut.catch_unwind().await?;
-        let (state, ret): (FvmExecState<BS>, T) = match res {
-            Ok(tup) => tup,
-            Err(err) => {
-                *guard = Some(state);
-                bail!("Encounterd panic in `modify_exec_state` user provided future generator future polling: {err:?}");
-            }
-        };
-
-        *guard = Some(state);
+        let maybe_state = guard.as_mut();
+        let state = maybe_state.expect("exec state empty");
+        let ret = generator(state).await?;
 
         Ok(ret)
     }
@@ -437,10 +419,13 @@ where
     async fn refresh_validators_cache(&self) -> Result<()> {
         // TODO: This should be read only state, but we can't use the read-only view here
         // because it hasn't been committed to state store yet.
-        self.modify_exec_state(|mut s| async {
-            let mut cache = self.validators_cache.lock().await;
-            *cache = Some(ValidatorCache::new_from_state(&mut s)?);
-            Ok((s, ()))
+        let mut cache = self.validators_cache.lock().await;
+        self.modify_exec_state(|s| {
+            let x = ValidatorCache::new_from_state(s);
+            async move {
+               *cache = Some(x?);
+                Ok(())
+            }
         })
         .await?;