Polished version

Author: ElijahVlasov

Cargo.toml

@@ -14,7 +14,7 @@ std = [
     "serde_json/std",
     "indexmap/std",
     "starknet-crypto/std",
-    "thiserror"
+    "thiserror-no-std/std"
 ]
 testing = ["std"]
 
@@ -37,9 +37,7 @@ starknet-crypto = { version = "0.5.1", default-features = false, features = [
 ] }
 strum = "0.24.1"
 strum_macros = "0.24.3"
-thiserror = { version = "1.0.31", optional = true}
 thiserror-no-std = { version = "2.0.2", default-features = false }
-cfg-if = "1.0.0"
 
 [dev-dependencies]
 assert_matches = "1.5.0"

src/block.rs

@@ -2,15 +2,13 @@
 #[path = "block_test.rs"]
 mod block_test;
 
-#[cfg(not(feature = "std"))]
-use alloc::vec::Vec;
-
 use derive_more::Display;
 use serde::{Deserialize, Serialize};
 
 use crate::core::{ContractAddress, GlobalRoot};
 use crate::hash::StarkHash;
 use crate::serde_utils::{BytesAsHex, PrefixedBytesAsHex};
+use crate::stdlib::vec::Vec;
 use crate::transaction::{Transaction, TransactionHash, TransactionOutput};
 
 /// A block.

src/core.rs

@@ -2,19 +2,6 @@
 #[path = "core_test.rs"]
 mod core_test;
 
-cfg_if::cfg_if! {
-    if #[cfg(not(feature = "std"))] {
-        use alloc::format;
-        use alloc::fmt;
-        use alloc::fmt::Debug;
-        use alloc::string::String;
-        use alloc::string::ToString;
-    } else {
-        use std::fmt;
-        use std::fmt::Debug;
-    }
-}
-
 use derive_more::Display;
 use once_cell::sync::Lazy;
 use primitive_types::H160;
@@ -23,6 +10,9 @@ use starknet_crypto::FieldElement;
 
 use crate::hash::{pedersen_hash_array, StarkFelt, StarkHash};
 use crate::serde_utils::{BytesAsHex, PrefixedBytesAsHex};
+use crate::stdlib::fmt::Debug;
+use crate::stdlib::string::{String, ToString};
+use crate::stdlib::{fmt, format, mem};
 use crate::transaction::{Calldata, ContractAddressSalt};
 use crate::{impl_from_through_intermediate, StarknetApiError};
 
@@ -262,7 +252,7 @@ pub struct EthAddress(pub H160);
 impl TryFrom<StarkFelt> for EthAddress {
     type Error = StarknetApiError;
     fn try_from(felt: StarkFelt) -> Result<Self, Self::Error> {
-        const COMPLIMENT_OF_H160: usize = core::mem::size_of::<StarkFelt>() - H160::len_bytes();
+        const COMPLIMENT_OF_H160: usize = mem::size_of::<StarkFelt>() - H160::len_bytes();
 
         let (rest, h160_bytes) = felt.bytes().split_at(COMPLIMENT_OF_H160);
         if rest != [0u8; COMPLIMENT_OF_H160] {

src/data_availability.rs

@@ -1,9 +1,7 @@
-#[cfg(not(feature = "std"))]
-use alloc::format;
-
 use serde::{Deserialize, Serialize};
 
 use crate::hash::StarkFelt;
+use crate::stdlib::format;
 use crate::StarknetApiError;
 
 #[derive(Clone, Copy, Debug, Deserialize, Eq, Hash, Ord, PartialEq, PartialOrd, Serialize)]

src/deprecated_contract_class.rs

@@ -1,25 +1,14 @@
-cfg_if::cfg_if! {
-    if #[cfg(feature = "std")] {
-        use std::collections::HashMap;
-        use std::num;
-    } else {
-        use alloc::format;
-        use alloc::vec::Vec;
-        use alloc::string::String;
-
-        use core::num;
-
-        use hashbrown::HashMap;
-    }
-}
-
 use cairo_lang_starknet::casm_contract_class::CasmContractEntryPoint;
 use serde::de::Error as DeserializationError;
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 use serde_json::Value;
 
 use crate::core::EntryPointSelector;
 use crate::serde_utils::deserialize_optional_contract_class_abi_entry_vector;
+use crate::stdlib::collections::HashMap;
+use crate::stdlib::string::String;
+use crate::stdlib::vec::Vec;
+use crate::stdlib::{format, num};
 use crate::StarknetApiError;
 
 /// A deprecated contract class.

src/hash.rs

@@ -2,23 +2,16 @@
 #[path = "hash_test.rs"]
 mod hash_test;
 
-cfg_if::cfg_if! {
-    if #[cfg(feature = "std")] {
-        use std::fmt;
-        use std::fmt::{Debug, Display};
-        use std::io::Error;
-    } else {
-        use alloc::fmt;
-        use alloc::fmt::{Debug, Display};
-        use alloc::format;
-        use alloc::string::ToString;
-    }
-}
+#[cfg(feature = "std")]
+use std::io::Error;
 
 use serde::{Deserialize, Serialize};
 use starknet_crypto::{pedersen_hash as starknet_crypto_pedersen_hash, FieldElement};
 
 use crate::serde_utils::{bytes_from_hex_str, hex_str_from_bytes, BytesAsHex, PrefixedBytesAsHex};
+use crate::stdlib::fmt::{Debug, Display};
+use crate::stdlib::string::ToString;
+use crate::stdlib::{fmt, format, mem};
 use crate::{impl_from_through_intermediate, StarknetApiError};
 
 /// Genesis state hash.
@@ -215,8 +208,7 @@ impl From<StarkFelt> for PrefixedBytesAsHex<32_usize> {
 impl TryFrom<StarkFelt> for usize {
     type Error = StarknetApiError;
     fn try_from(felt: StarkFelt) -> Result<Self, Self::Error> {
-        const COMPLIMENT_OF_USIZE: usize =
-            core::mem::size_of::<StarkFelt>() - core::mem::size_of::<usize>();
+        const COMPLIMENT_OF_USIZE: usize = mem::size_of::<StarkFelt>() - mem::size_of::<usize>();
 
         let (rest, usize_bytes) = felt.bytes().split_at(COMPLIMENT_OF_USIZE);
         if rest != [0u8; COMPLIMENT_OF_USIZE] {

src/lib.rs

@@ -4,11 +4,11 @@
 
 #![cfg_attr(not(feature = "std"), no_std)]
 
-#[cfg(not(features = "std"))]
-extern crate alloc;
+#[cfg(feature = "std")]
+include!("./with_std.rs");
 
-#[cfg(not(features = "std"))]
-extern crate thiserror_no_std as thiserror;
+#[cfg(not(feature = "std"))]
+include!("./without_std.rs");
 
 pub mod block;
 pub mod core;
@@ -20,21 +20,29 @@ pub mod state;
 pub mod transaction;
 pub mod type_utils;
 
-mod api_error {
-
-    cfg_if::cfg_if! {
-        if #[cfg(feature = "std")] {
-            use std::num;
-        } else {
-            use core::num;
-            use alloc::string::String;
-        }
+pub mod stdlib {
+    pub mod collections {
+        #[cfg(feature = "std")]
+        pub use crate::with_std::collections::*;
+        #[cfg(not(feature = "std"))]
+        pub use crate::without_std::collections::*;
     }
 
+    #[cfg(feature = "std")]
+    pub use crate::with_std::*;
+    #[cfg(not(feature = "std"))]
+    pub use crate::without_std::*;
+}
+
+mod api_error {
+    use thiserror_no_std::Error;
+
     use crate::serde_utils::InnerDeserializationError;
+    use crate::stdlib::num;
+    use crate::stdlib::string::String;
 
     /// The error type returned by StarknetApi.
-    #[derive(thiserror::Error, Clone, Debug)]
+    #[derive(Error, Clone, Debug)]
     pub enum StarknetApiError {
         /// Error in the inner deserialization of the node.
         #[error(transparent)]

src/serde_utils.rs

@@ -3,25 +3,16 @@
 #[path = "serde_utils_test.rs"]
 mod serde_utils_test;
 
-cfg_if::cfg_if! {
-    if #[cfg(not(feature = "std"))] {
-        use alloc::borrow::ToOwned;
-        use alloc::fmt;
-        use alloc::format;
-        use alloc::string::String;
-        use alloc::string::ToString;
-        use alloc::vec;
-        use alloc::vec::Vec;
-    } else {
-        use std::fmt;
-    }
-}
-
 use serde::de::{Deserialize, Visitor};
 use serde::ser::{Serialize, SerializeTuple};
 use serde::Deserializer;
+use thiserror_no_std::Error;
 
 use crate::deprecated_contract_class::ContractClassAbiEntry;
+use crate::stdlib::borrow::ToOwned;
+use crate::stdlib::string::{String, ToString};
+use crate::stdlib::vec::Vec;
+use crate::stdlib::{fmt, format, vec};
 
 /// A [BytesAsHex](`crate::serde_utils::BytesAsHex`) prefixed with '0x'.
 pub type PrefixedBytesAsHex<const N: usize> = BytesAsHex<N, true>;
@@ -90,7 +81,7 @@ impl<const N: usize, const PREFIXED: bool> Serialize for BytesAsHex<N, PREFIXED>
 }
 
 /// The error type returned by the inner deserialization.
-#[derive(thiserror::Error, Clone, Debug)]
+#[derive(Error, Clone, Debug)]
 pub enum InnerDeserializationError {
     /// Error parsing the hex string.
     #[error(transparent)]

src/state.rs

@@ -2,18 +2,6 @@
 #[path = "state_test.rs"]
 mod state_test;
 
-cfg_if::cfg_if! {
-    if #[cfg(features = "std")] {
-        use std::collections::HashMap;
-    } else {
-        use alloc::fmt::Debug;
-        use alloc::string::String;
-        use alloc::vec::Vec;
-
-        use hashbrown::HashMap;
-    }
-}
-
 use indexmap::IndexMap;
 use serde::{Deserialize, Serialize};
 
@@ -24,6 +12,10 @@ use crate::core::{
 };
 use crate::deprecated_contract_class::ContractClass as DeprecatedContractClass;
 use crate::hash::{StarkFelt, StarkHash};
+use crate::stdlib::collections::HashMap;
+use crate::stdlib::fmt::Debug;
+use crate::stdlib::string::String;
+use crate::stdlib::vec::Vec;
 use crate::{impl_from_through_intermediate, StarknetApiError};
 
 pub type DeclaredClasses = IndexMap<ClassHash, ContractClass>;

src/state_test.rs

@@ -1,8 +1,7 @@
-use std::collections::HashMap;
-
 use serde_json::json;
 
 use crate::deprecated_contract_class::EntryPointOffset;
+use crate::stdlib::collections::HashMap;
 
 #[test]
 fn entry_point_offset_from_json_str() {

src/transaction.rs

@@ -1,22 +1,3 @@
-cfg_if::cfg_if! {
-    if #[cfg(features = "std")] {
-        use std::collections::{BTreeMap, HashMap, HashSet};
-        use std::fmt;
-        use std::fmt::Display;
-        use std::sync::Arc;
-    } else {
-        use alloc::collections::BTreeMap;
-        use alloc::fmt;
-        use alloc::fmt::Display;
-        use alloc::format;
-        use alloc::string::String;
-        use alloc::sync::Arc;
-        use alloc::vec::Vec;
-
-        use hashbrown::{HashMap, HashSet};
-    }
-}
-
 use derive_more::From;
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 use strum::IntoEnumIterator;
@@ -29,6 +10,12 @@ use crate::core::{
 use crate::data_availability::DataAvailabilityMode;
 use crate::hash::{StarkFelt, StarkHash};
 use crate::serde_utils::PrefixedBytesAsHex;
+use crate::stdlib::collections::{BTreeMap, HashMap, HashSet};
+use crate::stdlib::fmt;
+use crate::stdlib::fmt::Display;
+use crate::stdlib::string::String;
+use crate::stdlib::sync::Arc;
+use crate::stdlib::vec::Vec;
 use crate::StarknetApiError;
 
 /// A transaction.

src/with_std.rs

@@ -0,0 +1,15 @@
+pub mod with_std {
+    pub use std::borrow;
+    pub use std::fmt;
+    pub use std::format;
+    pub use std::mem;
+    pub use std::num;
+
+    pub use std::string;
+    pub use std::sync;
+    pub use std::vec;
+
+    pub mod collections {
+        pub use std::collections::{BTreeMap, HashMap, HashSet};
+    }
+}

src/without_std.rs

@@ -0,0 +1,26 @@
+#[macro_use]
+pub extern crate alloc;
+
+pub mod without_std {
+    pub use core::fmt;
+    pub use core::hash;
+    pub use core::mem;
+    pub use core::num;
+
+    pub use alloc::boxed;
+    pub use alloc::format;
+    pub use alloc::rc;
+    pub use alloc::string;
+    pub use alloc::sync;
+    pub use alloc::vec;
+
+    pub mod collections {
+        pub use alloc::collections::BTreeMap;
+        pub use hashbrown::{HashMap, HashSet};
+    }
+
+    pub mod borrow {
+        pub use alloc::borrow::*;
+        pub use core::borrow::*;
+    }
+}