fix Cause#FatalCause formatting.

Author: raulk

fvm/src/call_manager/backtrace.rs

@@ -112,10 +112,8 @@ pub struct SyscallCause {
 
 #[derive(Clone, Debug)]
 pub struct FatalCause {
-    /// The error message from the error.
+    /// The alternate-formatted message from the anyhow error.
     pub error_msg: String,
-    /// The original cause that initiated the error chain.
-    pub root_cause: String,
     /// The backtrace, captured if the relevant
     /// [environment variables](https://doc.rust-lang.org/std/backtrace/index.html#environment-variables) are enabled.
     pub backtrace: String,
@@ -144,8 +142,7 @@ impl Cause {
     /// Records a fatal error as the cause of a backtrace.
     pub fn from_fatal(err: anyhow::Error) -> Self {
         Self::Fatal(FatalCause {
-            error_msg: err.to_string(),
-            root_cause: err.root_cause().to_string(),
+            error_msg: format!("{:#}", err),
             backtrace: err.backtrace().to_string(),
         })
     }
@@ -164,8 +161,8 @@ impl Display for Cause {
             Cause::Fatal(msg) => {
                 write!(
                     f,
-                    "[FATAL] Root cause: {}, Stacktrace: {}",
-                    msg.root_cause, msg.backtrace
+                    "[FATAL] Error: {}, Backtrace:\n{}",
+                    msg.error_msg, msg.backtrace
                 )
             }
         }

fvm/src/executor/default.rs

@@ -138,21 +138,23 @@ where
                 }
             }
             Err(ExecutionError::Fatal(err)) => {
-                // // Annotate the error with the message context.
-                // let err = {
-                //     let backtrace = String::from("foo"); //e.backtrace().to_string();
-                //                                          // e.context(format!(
-                //                                          //     "[from={}, to={}, seq={}, m={}, h={}] fatal error; backtrace: {}",
-                //                                          //     msg.from,
-                //                                          //     msg.to,
-                //                                          //     msg.sequence,
-                //                                          //     msg.method_num,
-                //                                          //     self.context().epoch,
-                //                                          //     backtrace,
-                //                                          // ))
-                // };
+                // We produce a receipt with SYS_ASSERTION_FAILED exit code, and
+                // we consume the full gas amount so that, in case of a network-
+                // wide fatal errors, all nodes behave deterministically.
+                //
+                // We set the backtrace from the fatal error to aid diagnosis.
+                // Note that we use backtrace#set_cause instead of backtrace#begin
+                // because we want to retain the propagation chain that we've
+                // accumulated on the way out.
+                let err = err.context(format!(
+                    "[from={}, to={}, seq={}, m={}, h={}]",
+                    msg.from,
+                    msg.to,
+                    msg.sequence,
+                    msg.method_num,
+                    self.context().epoch,
+                ));
                 backtrace.set_cause(backtrace::Cause::from_fatal(err));
-                // Produce a receipt that consumes the full gas amount.
                 Receipt {
                     exit_code: ExitCode::SYS_ASSERTION_FAILED,
                     return_data: Default::default(),