Always add backtrace to cosmwasm-vm

Author: chipshort

packages/vm/Cargo.toml

@@ -9,10 +9,6 @@ license = "Apache-2.0"
 
 [features]
 default = ["staking", "iterator"]
-# backtraces provides much better context at runtime errors (in non-wasm code)
-# at the cost of a bit of code size and performance.
-# This feature requires Rust nightly because it depends on the unstable backtrace feature.
-backtraces = []
 # iterator allows us to iterate over all DB items in a given range
 # this must be enabled to support cosmwasm contracts compiled with the 'iterator' feature
 # optional as some merkle stores (like tries) don't support this

packages/vm/src/cache.rs

@@ -1287,7 +1287,7 @@ mod tests {
         // removing again fails
 
         match remove_wasm_from_disk(path, &checksum).unwrap_err() {
-            VmError::CacheErr { msg } => assert_eq!(msg, "Wasm file does not exist"),
+            VmError::CacheErr { msg, .. } => assert_eq!(msg, "Wasm file does not exist"),
             err => panic!("Unexpected error: {err:?}"),
         }
     }

packages/vm/src/calls.rs

@@ -669,7 +669,7 @@ mod tests {
         let msg = br#"{"cpu_loop":{}}"#;
         let err =
             call_execute::<_, _, _, Empty>(&mut instance, &mock_env(), &info, msg).unwrap_err();
-        assert!(matches!(err, VmError::GasDepletion {}));
+        assert!(matches!(err, VmError::GasDepletion { .. }));
     }
 
     #[test]
@@ -687,7 +687,7 @@ mod tests {
         let err =
             call_execute::<_, _, _, Empty>(&mut instance, &mock_env(), &info, msg).unwrap_err();
         match err {
-            VmError::RuntimeErr { msg } => {
+            VmError::RuntimeErr { msg, .. } => {
                 assert!(msg.contains(
                     "RuntimeError: Aborted: panicked at 'This page intentionally faulted'"
                 ))
@@ -711,7 +711,7 @@ mod tests {
         let err =
             call_execute::<_, _, _, Empty>(&mut instance, &mock_env(), &info, msg).unwrap_err();
         match err {
-            VmError::RuntimeErr { msg } => {
+            VmError::RuntimeErr { msg, .. } => {
                 assert!(msg.contains("RuntimeError: unreachable"))
             }
             err => panic!("Unexpected error: {err:?}"),

packages/vm/src/errors/backtrace.rs

@@ -0,0 +1,44 @@
+use core::fmt::{Debug, Display, Formatter, Result};
+use std::backtrace::Backtrace;
+
+/// This wraps an actual backtrace to achieve two things:
+/// - being able to fill this with a stub implementation in `no_std` environments
+/// - being able to use this in conjunction with [`thiserror::Error`]
+pub struct BT(Backtrace);
+
+impl BT {
+    #[track_caller]
+    pub fn capture() -> Self {
+        BT(Backtrace::capture())
+    }
+}
+
+impl Debug for BT {
+    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
+        Debug::fmt(&self.0, f)
+    }
+}
+
+impl Display for BT {
+    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
+        Display::fmt(&self.0, f)
+    }
+}
+
+/// This macro implements `From` for a given error type to a given error type where
+/// the target error has a `backtrace` field.
+/// This is meant as a replacement for `thiserror`'s `#[from]` attribute, which does not
+/// work with our custom backtrace wrapper.
+macro_rules! impl_from_err {
+    ($from:ty, $to:ty, $map:path) => {
+        impl From<$from> for $to {
+            fn from(err: $from) -> Self {
+                $map {
+                    source: err,
+                    backtrace: $crate::errors::backtrace::BT::capture(),
+                }
+            }
+        }
+    };
+}
+pub(crate) use impl_from_err;

packages/vm/src/errors/mod.rs

@@ -1,7 +1,9 @@
+mod backtrace;
 mod communication_error;
 mod region_validation_error;
 mod vm_error;
 
+pub(crate) use backtrace::{impl_from_err, BT};
 pub use communication_error::CommunicationError;
 pub use region_validation_error::RegionValidationError;
 pub use vm_error::VmError;