x

Author: drahnr

Cargo.lock

@@ -14,6 +14,7 @@ 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,7 +1,9 @@
 // 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,
@@ -12,7 +14,7 @@ use crate::AppExitCode;
 use crate::BlockHeight;
 use crate::{tmconv::*, VERSION};
 use actors_custom_api::gas_market::Reading;
-use anyhow::{anyhow, Context, Result};
+use anyhow::{anyhow, bail, Context, Result};
 use async_stm::{atomically, atomically_or_err};
 use async_trait::async_trait;
 use cid::Cid;
@@ -324,16 +326,33 @@ where
         guard.take().expect("exec state empty")
     }
 
-    /// Take the execution state, update it, put it back, return the output.
+    /// 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>
     where
-        F: FnOnce(FvmExecState<BS>) -> R,
+        F: FnOnce(&mut FvmExecState<BS>) -> R,
         R: Future<Output = Result<(FvmExecState<BS>, T)>>,
     {
         let mut guard = self.exec_state.lock().await;
         let state = guard.take().expect("exec state empty");
 
-        let (state, ret) = f(state).await?;
+        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);
 

fendermint/app/src/app.rs

@@ -43,6 +43,7 @@ struct Actor {
     state: ActorState,
 }
 
+/// Interprets messages as received from the ABCI layer
 #[derive(Clone)]
 pub struct FvmMessagesInterpreter<DB, C>
 where
@@ -107,19 +108,16 @@ where
         state: &FvmExecState<ReadOnlyBlockstore<DB>>,
         msg: &FvmMessage,
     ) -> Result<CheckResponse> {
-        let Actor {
+        let Some(Actor {
             id: _,
             state: actor,
-        } = match self.lookup_actor(state, &msg.from)? {
-            Some(actor) => actor,
-            None => {
-                return Ok(CheckResponse::new(
-                    msg,
-                    ExitCode::SYS_SENDER_INVALID,
-                    None,
-                    None,
-                ))
-            }
+        }) = self.lookup_actor(state, &msg.from)? else  {
+            return Ok(CheckResponse::new(
+                msg,
+                ExitCode::SYS_SENDER_INVALID,
+                None,
+                None,
+            ))
         };
 
         let balance_needed = msg.gas_fee_cap.clone() * msg.gas_limit;