Remove direct std usage

Author: chipshort

packages/std/Cargo.toml

@@ -14,11 +14,11 @@ features = ["abort", "stargate", "staking", "cosmwasm_1_4"]
 [features]
 default = ["iterator", "abort", "std"]
 abort = []
-# This feature is currently unused, but might be used in the future to replace internal
-# implementation details with no_std compatible ones or feature-gate functionality
-# that is only available in std environments.
-# You probably want to keep this enabled for now to avoid breaking changes later.
-std = []
+# This feature can be used in the future to provide support for no_std environments,
+# but disabling it will not provide any benefit at the moment. Even with this feature disabled,
+# we currently require an std environment.
+# You probably want to keep this enabled for now to avoid possible breaking changes later.
+std = ["serde/std", "serde-json-wasm/std"]
 # iterator allows us to iterate over all DB items in a given range
 # optional as some merkle stores (like tries) don't support this
 # given Ethereum 1.0, 2.0, Substrate, and other major projects use Tries
@@ -50,13 +50,13 @@ cosmwasm_1_4 = ["cosmwasm_1_3"]
 [dependencies]
 base64 = "0.21.0"
 cosmwasm-derive = { path = "../derive", version = "1.5.0" }
-derivative = "2"
+derivative = { version = "2", features = ["use_core"] }
 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-json-wasm = { version = "1.0.0" }
+serde-json-wasm = { version = "1.0.0", default-features = false }
 thiserror = "1.0.26"
 bnum = "0.8.0"
 static_assertions = "1.1.0"

packages/std/src/addresses.rs

@@ -9,6 +9,7 @@ use sha2::{
 };
 use thiserror::Error;
 
+use crate::prelude::*;
 use crate::{binary::Binary, forward_ref_partial_eq, HexBinary};
 
 /// A human readable address.

packages/std/src/binary.rs

@@ -6,6 +6,7 @@ use schemars::JsonSchema;
 use serde::{de, ser, Deserialize, Deserializer, Serialize};
 
 use crate::errors::{StdError, StdResult};
+use crate::prelude::*;
 
 /// Binary is a wrapper around Vec<u8> to add base64 de/serialization
 /// with serde. It also adds some helper methods to help encode inline.

packages/std/src/checksum.rs

@@ -5,6 +5,7 @@ use serde::{de, ser, Deserialize, Deserializer, Serialize};
 use sha2::{Digest, Sha256};
 use thiserror::Error;
 
+use crate::prelude::*;
 use crate::{StdError, StdResult};
 
 /// A SHA-256 checksum of a Wasm blob, used to identify a Wasm code.

packages/std/src/coin.rs

@@ -2,6 +2,7 @@ use core::{fmt, str::FromStr};
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 
+use crate::prelude::*;
 use crate::{errors::CoinFromStrError, math::Uint128};
 
 #[derive(Serialize, Deserialize, Clone, Default, PartialEq, Eq, JsonSchema)]

packages/std/src/coins.rs

@@ -2,6 +2,7 @@ use alloc::collections::BTreeMap;
 use core::fmt;
 use core::str::FromStr;
 
+use crate::prelude::*;
 use crate::{
     errors::CoinsError, Coin, OverflowError, OverflowOperation, StdError, StdResult, Uint128,
 };

packages/std/src/errors/backtrace.rs

@@ -1,5 +1,7 @@
 use core::fmt::{Debug, Display, Formatter, Result};
 
+use crate::prelude::*;
+
 /// 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`]
@@ -9,10 +11,17 @@ impl BT {
     #[track_caller]
     pub fn capture() -> Self {
         // in case of no_std, we can fill with a stub here
-        #[cfg(target_arch = "wasm32")]
-        return BT(Box::new(std::backtrace::Backtrace::disabled()));
-        #[cfg(not(target_arch = "wasm32"))]
-        return BT(Box::new(std::backtrace::Backtrace::capture()));
+        #[cfg(feature = "std")]
+        {
+            #[cfg(target_arch = "wasm32")]
+            return BT(Box::new(std::backtrace::Backtrace::disabled()));
+            #[cfg(not(target_arch = "wasm32"))]
+            return BT(Box::new(std::backtrace::Backtrace::capture()));
+        }
+        #[cfg(not(feature = "std"))]
+        {
+            BT(Box::new(Stub))
+        }
     }
 }
 
@@ -31,6 +40,23 @@ impl Display for BT {
     }
 }
 
+#[cfg(not(feature = "std"))]
+struct Stub;
+
+#[cfg(not(feature = "std"))]
+impl Debug for Stub {
+    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
+        write!(f, "<disabled>")
+    }
+}
+
+#[cfg(not(feature = "std"))]
+impl Display for Stub {
+    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
+        write!(f, "<disabled>")
+    }
+}
+
 /// 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

packages/std/src/errors/std_error.rs

@@ -4,6 +4,7 @@ use super::{impl_from_err, BT};
 use thiserror::Error;
 
 use crate::errors::{RecoverPubkeyError, VerificationError};
+use crate::prelude::*;
 
 /// Structured error type for init, execute and query.
 ///

packages/std/src/errors/system_error.rs

@@ -1,6 +1,7 @@
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 
+use crate::prelude::*;
 use crate::Binary;
 
 /// SystemError is used for errors inside the VM and is API friendly (i.e. serializable).
@@ -39,6 +40,7 @@ pub enum SystemError {
     },
 }
 
+#[cfg(feature = "std")]
 impl std::error::Error for SystemError {}
 
 impl core::fmt::Display for SystemError {

packages/std/src/hex_binary.rs

@@ -4,6 +4,7 @@ use core::ops::Deref;
 use schemars::JsonSchema;
 use serde::{de, ser, Deserialize, Deserializer, Serialize};
 
+use crate::prelude::*;
 use crate::{Binary, StdError, StdResult};
 
 /// This is a wrapper around Vec<u8> to add hex de/serialization