Always add backtrace to cosmwasm-std

Author: chipshort

packages/std/Cargo.toml

@@ -23,10 +23,6 @@ iterator = []
 # CosmosMsg types, and new QueryRequest types. This should only be enabled on contracts
 # that require these types, so other contracts can be used on systems with eg. PoA consensus
 staking = []
-# 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 = []
 # stargate enables stargate-dependent messages and queries, like raw protobuf messages
 # as well as ibc-related functionality
 stargate = []
@@ -54,10 +50,7 @@ forward_ref = "1"
 hex = "0.4"
 schemars = "0.8.3"
 sha2 = "0.10.3"
-serde = { version = "1.0.103", default-features = false, features = [
-  "derive",
-  "alloc",
-] }
+serde = { version = "1.0.103", default-features = false, features = ["derive", "alloc"] }
 serde-json-wasm = { version = "1.0.0" }
 thiserror = "1.0.26"
 bnum = "0.8.0"
@@ -70,10 +63,7 @@ cosmwasm-crypto = { path = "../crypto", version = "1.5.0" }
 [dev-dependencies]
 cosmwasm-schema = { path = "../schema" }
 # The chrono dependency is only used in an example, which Rust compiles for us. If this causes trouble, remove it.
-chrono = { version = "0.4", default-features = false, features = [
-  "alloc",
-  "std",
-] }
+chrono = { version = "0.4", default-features = false, features = ["alloc", "std"] }
 crc32fast = "1.3.2"
 hex-literal = "0.3.1"
 serde_json = "1.0.81"

packages/std/src/binary.rs

@@ -335,7 +335,7 @@ mod tests {
             ("cmFuZ", "Encoded text cannot have a 6-bit remainder."),
         ] {
             match Binary::from_base64(invalid_base64) {
-                Err(StdError::InvalidBase64 { msg }) => assert_eq!(want, msg),
+                Err(StdError::InvalidBase64 { msg, .. }) => assert_eq!(want, msg),
                 result => panic!("Unexpected result: {result:?}"),
             }
         }

packages/std/src/errors/backtrace.rs

@@ -0,0 +1,48 @@
+use core::fmt::{Debug, Display, Formatter, Result};
+use thiserror::Error;
+
+/// 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`]
+#[derive(Error)]
+pub struct BT(Box<dyn Printable>);
+
+impl BT {
+    #[track_caller]
+    pub fn capture() -> Self {
+        BT(Box::new(std::backtrace::Backtrace::capture()))
+    }
+}
+
+trait Printable: Debug + Display {}
+impl<T> Printable for T where T: Debug + Display {}
+
+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/std/src/errors/mod.rs

@@ -1,8 +1,10 @@
+mod backtrace;
 mod recover_pubkey_error;
 mod std_error;
 mod system_error;
 mod verification_error;
 
+pub(crate) use backtrace::{impl_from_err, BT};
 pub use recover_pubkey_error::RecoverPubkeyError;
 pub use std_error::{
     CheckedFromRatioError, CheckedMultiplyFractionError, CheckedMultiplyRatioError,

packages/std/src/errors/recover_pubkey_error.rs

@@ -1,8 +1,8 @@
 use core::fmt::Debug;
 #[cfg(not(target_arch = "wasm32"))]
 use cosmwasm_crypto::CryptoError;
-#[cfg(feature = "backtraces")]
-use std::backtrace::Backtrace;
+
+use super::BT;
 use thiserror::Error;
 
 #[derive(Error, Debug)]
@@ -14,19 +14,15 @@ pub enum RecoverPubkeyError {
     #[error("Invalid recovery parameter. Supported values: 0 and 1.")]
     InvalidRecoveryParam,
     #[error("Unknown error: {error_code}")]
-    UnknownErr {
-        error_code: u32,
-        #[cfg(feature = "backtraces")]
-        backtrace: Backtrace,
-    },
+    UnknownErr { error_code: u32, backtrace: BT },
 }
 
 impl RecoverPubkeyError {
     pub fn unknown_err(error_code: u32) -> Self {
         RecoverPubkeyError::UnknownErr {
             error_code,
-            #[cfg(feature = "backtraces")]
-            backtrace: Backtrace::capture(),
+
+            backtrace: BT::capture(),
         }
     }
 }