Support no_std builds

Cargo.toml

@@ -14,8 +14,12 @@ categories = ["cryptography::cryptocurrencies"]
 name = "serde_utils"
 
 [dependencies]
-alloy-primitives = { version = "1.0", features = ["serde"] }
-serde = { version = "1.0.0", features = ["derive"] }
+alloy-primitives = { version = "1.0", default-features = false, features = ["serde"] }
+serde = { version = "1.0.0", default-features = false, features = ["derive", "alloc"] }
 serde_derive = "1.0.0"
-serde_json = "1.0.0"
-hex = "0.4.3"
+serde_json = { version = "1.0.0", default-features = false, features = ["alloc"] }
+hex = { version = "0.4.3", default-features = false, features = ["alloc"] }
+
+[features]
+default = ["std"]
+std = ["alloy-primitives/std", "serde/std", "serde_json/std", "hex/std"]

src/address_hex.rs

@@ -1,3 +1,7 @@
+use alloc::{
+    format,
+    string::{String, ToString},
+};
 use alloy_primitives::Address;
 use serde::de::Error;
 use serde::{Deserializer, Serializer};
@@ -9,7 +13,7 @@ where
     S: Serializer,
 {
     let mut hex_string: String = "0x".to_string();
-    hex_string.push_str(&hex::encode(&address));
+    hex_string.push_str(&hex::encode(address));
 
     serializer.serialize_str(&hex_string)
 }
@@ -35,7 +39,7 @@ where
 
 #[cfg(test)]
 mod test {
-    use std::str::FromStr;
+    use core::str::FromStr;
 
     use alloy_primitives::Address;
     use serde::{Deserialize, Serialize};

src/b256_hex.rs

@@ -1,3 +1,7 @@
+use alloc::{
+    format,
+    string::{String, ToString},
+};
 use alloy_primitives::B256;
 use serde::de::Error;
 use serde::{Deserializer, Serializer};
@@ -9,7 +13,7 @@ where
     S: Serializer,
 {
     let mut hex_string: String = "0x".to_string();
-    hex_string.push_str(&hex::encode(&hash));
+    hex_string.push_str(&hex::encode(hash));
 
     serializer.serialize_str(&hex_string)
 }

src/fixed_bytes_hex.rs

@@ -3,6 +3,10 @@
 //! E.g., `[0, 1, 2, 3]` serializes as `"0x00010203"`.
 
 use crate::hex::PrefixedHexVisitor;
+use alloc::{
+    format,
+    string::{String, ToString},
+};
 use serde::de::Error;
 use serde::{Deserializer, Serializer};
 

src/hex.rs

@@ -1,7 +1,12 @@
 //! Provides utilities for parsing 0x-prefixed hex strings.
 
+use alloc::{
+    format,
+    string::{String, ToString},
+    vec::Vec,
+};
+use core::fmt;
 use serde::de::{self, Visitor};
-use std::fmt;
 
 /// Encode `data` as a 0x-prefixed hex string.
 pub fn encode<T: AsRef<[u8]>>(data: T) -> String {

src/hex_vec.rs

@@ -3,6 +3,10 @@
 //! E.g., `vec![0, 1, 2, 3]` serializes as `"0x00010203"`.
 
 use crate::hex::PrefixedHexVisitor;
+use alloc::{
+    string::{String, ToString},
+    vec::Vec,
+};
 use serde::{Deserializer, Serializer};
 
 pub fn serialize<S>(bytes: &[u8], serializer: S) -> Result<S::Ok, S::Error>

src/json_str.rs

@@ -1,4 +1,5 @@
 //! Serialize a datatype as a JSON-blob within a single string.
+use alloc::string::String;
 use serde::{
     de::{DeserializeOwned, Error as _},
     ser::Error as _,

src/lib.rs

@@ -1,3 +1,8 @@
+#![cfg_attr(not(feature = "std"), no_std)]
+
+#[macro_use]
+extern crate alloc;
+
 mod quoted_int;
 
 pub mod address_hex;

src/list_of_bytes_lists.rs

@@ -5,14 +5,15 @@
 //! Quotes can be optional during decoding.
 
 use crate::hex;
+use alloc::{string::String, vec::Vec};
 use serde::ser::SerializeSeq;
 use serde::{de, Deserializer, Serializer};
 
 pub struct ListOfBytesListVisitor;
 impl<'a> serde::de::Visitor<'a> for ListOfBytesListVisitor {
     type Value = Vec<Vec<u8>>;
 
-    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn expecting(&self, formatter: &mut core::fmt::Formatter) -> core::fmt::Result {
         write!(formatter, "a list of 0x-prefixed byte lists")
     }
 

src/quoted_int.rs

@@ -4,11 +4,12 @@
 //!
 //! Quotes can be optional during decoding.
 
+use alloc::format;
 use alloy_primitives::U256;
+use core::convert::TryFrom;
+use core::marker::PhantomData;
 use serde::{Deserializer, Serializer};
 use serde_derive::{Deserialize, Serialize};
-use std::convert::TryFrom;
-use std::marker::PhantomData;
 
 macro_rules! define_mod {
     ($int: ty) => {
@@ -26,7 +27,7 @@ macro_rules! define_mod {
         {
             type Value = T;
 
-            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+            fn expecting(&self, formatter: &mut core::fmt::Formatter) -> core::fmt::Result {
                 if self.require_quotes {
                     write!(formatter, "a quoted integer")
                 } else {
@@ -169,7 +170,7 @@ pub mod quoted_u256 {
     impl<'de> serde::de::Visitor<'de> for U256Visitor {
         type Value = U256;
 
-        fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+        fn expecting(&self, formatter: &mut core::fmt::Formatter) -> core::fmt::Result {
             formatter.write_str("a quoted U256 integer")
         }
 

src/quoted_u64_vec.rs

@@ -4,6 +4,7 @@
 //!
 //! Quotes can be optional during decoding.
 
+use alloc::vec::Vec;
 use serde::ser::SerializeSeq;
 use serde::{Deserializer, Serializer};
 use serde_derive::{Deserialize, Serialize};
@@ -19,7 +20,7 @@ pub struct QuotedIntVecVisitor;
 impl<'a> serde::de::Visitor<'a> for QuotedIntVecVisitor {
     type Value = Vec<u64>;
 
-    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn expecting(&self, formatter: &mut core::fmt::Formatter) -> core::fmt::Result {
         write!(formatter, "a list of quoted or unquoted integers")
     }
 

src/u256_dec.rs

@@ -1,3 +1,7 @@
+use alloc::{
+    format,
+    string::{String, ToString},
+};
 use alloy_primitives::U256;
 use serde::{de, Deserialize, Deserializer, Serialize, Serializer};
 

src/u256_hex_be.rs

@@ -1,8 +1,12 @@
+use alloc::{
+    format,
+    string::{String, ToString},
+};
 use alloy_primitives::U256;
+use core::fmt;
+use core::str::FromStr;
 use serde::de::Visitor;
 use serde::{de, Deserializer, Serialize, Serializer};
-use std::fmt;
-use std::str::FromStr;
 
 pub fn serialize<S>(num: &U256, serializer: S) -> Result<S::Ok, S::Error>
 where

src/u32_hex.rs

@@ -3,6 +3,7 @@
 //! E.g., `0` serializes as `"0x00000000"`.
 
 use crate::bytes_4_hex;
+use alloc::format;
 use serde::{Deserializer, Serializer};
 
 pub fn serialize<S>(num: &u32, serializer: S) -> Result<S::Ok, S::Error>

src/u64_hex_be.rs

@@ -2,9 +2,10 @@
 //!
 //! E.g., `0` serializes as `"0x0000000000000000"`.
 
+use alloc::{format, vec::Vec};
+use core::fmt;
 use serde::de::{self, Error, Visitor};
 use serde::{Deserializer, Serializer};
-use std::fmt;
 
 const BYTES_LEN: usize = 8;
 
@@ -35,7 +36,7 @@ impl<'de> Visitor<'de> for QuantityVisitor {
             Ok(vec![0])
         } else if stripped.starts_with('0') {
             Err(de::Error::custom("cannot have leading zero"))
-        } else if stripped.len() % 2 != 0 {
+        } else if !stripped.len().is_multiple_of(2) {
             hex::decode(format!("0{}", stripped))
                 .map_err(|e| de::Error::custom(format!("invalid hex ({:?})", e)))
         } else {

src/u8_hex.rs

@@ -3,6 +3,7 @@
 //! E.g., `0` serializes as `"0x00"`.
 
 use crate::hex::PrefixedHexVisitor;
+use alloc::format;
 use serde::de::Error;
 use serde::{Deserializer, Serializer};