feat: use const-hex instead of hex

Cargo.toml

@@ -43,7 +43,7 @@ syn = "2.0"
 arbitrary = { version = "1.3", default-features = false }
 arrayvec = { version = "0.7.2", default-features = false }
 bytes = { version = "1.4", default-features = false }
-hex = { version = "0.4", default-features = false }
+hex = { package = "const-hex", version = "1.2", default-features = false, features = ["hex"] }
 hex-literal = "0.4"
 proptest = { version = "1.1", default-features = false }
 proptest-derive = "0.3"

abi/Cargo.toml

@@ -20,13 +20,12 @@ sol-type-parser.workspace = true
 hex = { workspace = true, features = ["alloc"] }
 
 thiserror = { workspace = true, optional = true }
-serde = { workspace = true, optional = true }
+serde = { workspace = true, optional = true, features = ["derive"] }
 
 [dev-dependencies]
 hex-literal.workspace = true
 
 [features]
 default = ["std", "hex/alloc"]
 std = ["ethers-primitives/std", "hex/std", "serde?/std", "thiserror"]
-# TODO: Can we remove std from here?
-eip712-serde = ["std", "dep:serde"]
+eip712-serde = ["dep:serde", "serde?/alloc", "ethers-primitives/serde"]

abi/src/coder/token.rs

@@ -605,12 +605,9 @@ impl TokenSeq for () {
 
 #[cfg(test)]
 mod tests {
-    use ethers_primitives::B256;
-
     use super::*;
-    #[cfg(not(feature = "std"))]
-    use crate::no_std_prelude::*;
     use crate::{sol_data, SolType};
+    use ethers_primitives::B256;
 
     macro_rules! assert_type_check {
         ($sol:ty, $token:expr $(,)?) => {

abi/src/util.rs

@@ -71,31 +71,30 @@ pub(crate) use serde_helper::*;
 
 #[cfg(feature = "eip712-serde")]
 mod serde_helper {
+    use alloc::string::{String, ToString};
     use ethers_primitives::U256;
     use serde::{Deserialize, Deserializer};
 
     /// Helper type to parse numeric strings, `u64` and `U256`
     #[derive(Deserialize, Debug, Clone)]
     #[serde(untagged)]
     pub(crate) enum StringifiedNumeric {
-        String(String),
-        U256(U256),
         Num(u64),
+        U256(U256),
+        String(String),
     }
 
     impl TryFrom<StringifiedNumeric> for U256 {
         type Error = String;
 
         fn try_from(value: StringifiedNumeric) -> Result<Self, Self::Error> {
             match value {
-                StringifiedNumeric::U256(n) => Ok(n),
                 StringifiedNumeric::Num(n) => Ok(U256::from(n)),
+                StringifiedNumeric::U256(n) => Ok(n),
+                // TODO: this is probably unreachable, due to ruint U256 deserializing from a string
                 StringifiedNumeric::String(s) => {
-                    if let Ok(val) = s.parse::<u128>() {
-                        Ok(U256::from(val))
-                    } else if s.starts_with("0x") {
-                        U256::from_str_radix(s.strip_prefix("0x").unwrap(), 16)
-                            .map_err(|err| err.to_string())
+                    if let Some(s) = s.strip_prefix("0x") {
+                        U256::from_str_radix(s, 16).map_err(|err| err.to_string())
                     } else {
                         U256::from_str_radix(&s, 10).map_err(|err| err.to_string())
                     }

dyn-abi/src/eip712/typed_data.rs

@@ -110,6 +110,7 @@ impl<'de> Deserialize<'de> for TypedData {
         D: serde::de::Deserializer<'de>,
     {
         #[derive(Deserialize)]
+        #[allow(missing_debug_implementations)]
         struct TypedDataHelper {
             #[serde(default)]
             domain: Eip712Domain,

primitives/Cargo.toml

@@ -20,11 +20,10 @@ ruint = { workspace = true, features = ["rlp", "serde"] }
 # utility
 derive_more = "0.99"
 tiny-keccak = { workspace = true, features = ["keccak"] }
-hex = { workspace = true, default-features = false }
+hex.workspace = true
 
 # optional
 serde = { workspace = true, features = ["derive"], optional = true }
-thiserror = { workspace = true, optional = true }
 
 # rlp support
 ethers-rlp = { workspace = true, optional = true }
@@ -37,8 +36,13 @@ proptest-derive = { workspace = true, optional = true }
 
 [features]
 default = ["std", "rlp", "serde", "hex/std"]
-std = ["serde/std", "ethers-rlp?/std", "bytes?/std", "proptest?/std", "dep:thiserror"]
+std = ["serde/std", "ethers-rlp?/std", "bytes?/std", "proptest?/std"]
 rlp = ["dep:ethers-rlp", "dep:bytes"]
 serde = ["dep:serde", "ruint/serde"]
-arbitrary = ["ruint/arbitrary", "ruint/proptest", "dep:arbitrary", "dep:proptest", "dep:proptest-derive"]
-
+arbitrary = [
+    "ruint/arbitrary",
+    "ruint/proptest",
+    "dep:arbitrary",
+    "dep:proptest",
+    "dep:proptest-derive",
+]

primitives/src/bits/address.rs

@@ -1,15 +1,9 @@
-#[cfg(feature = "std")]
-use std::borrow::Borrow;
-
-#[cfg(not(feature = "std"))]
+use crate::{utils::keccak256, wrap_fixed_bytes, FixedBytes};
 use alloc::{
     borrow::Borrow,
-    format,
     string::{String, ToString},
 };
 
-use crate::{utils::keccak256, wrap_fixed_bytes, FixedBytes};
-
 /// Error type for address checksum validation
 #[derive(Debug, Copy, Clone)]
 pub enum AddressError {
@@ -157,6 +151,7 @@ impl Address {
 #[cfg(test)]
 mod test {
     use super::Address;
+    use alloc::string::String;
 
     #[test]
     fn it_parses() {

primitives/src/bits/fixed.rs

@@ -1,5 +1,4 @@
 use core::{fmt, ops};
-
 use derive_more::{AsMut, AsRef, Deref, DerefMut, From, Index, IndexMut};
 
 /// A bytearray of fixed length.
@@ -65,23 +64,20 @@ impl<'a, const N: usize> From<&'a mut [u8; N]> for FixedBytes<N> {
 
 impl<const N: usize> From<FixedBytes<N>> for [u8; N] {
     #[inline]
-    #[track_caller]
     fn from(s: FixedBytes<N>) -> Self {
         s.0
     }
 }
 
 impl<const N: usize> AsRef<[u8]> for FixedBytes<N> {
     #[inline]
-    #[track_caller]
     fn as_ref(&self) -> &[u8] {
         self.as_bytes()
     }
 }
 
 impl<const N: usize> AsMut<[u8]> for FixedBytes<N> {
     #[inline]
-    #[track_caller]
     fn as_mut(&mut self) -> &mut [u8] {
         self.as_bytes_mut()
     }
@@ -371,10 +367,7 @@ impl<const N: usize> core::str::FromStr for FixedBytes<N> {
         let s = s.strip_prefix("0x").unwrap_or(s);
 
         let mut buf = [0u8; N];
-        hex::decode_to_slice(s, buf.as_mut())?;
+        hex::decode_to_slice(s, &mut buf)?;
         Ok(Self(buf))
     }
 }
-
-#[cfg(test)]
-mod test {}

primitives/src/bits/macros.rs

@@ -70,31 +70,27 @@ macro_rules! wrap_fixed_bytes {
 
         impl<'a> From<[u8; $n]> for $name {
             #[inline]
-            #[track_caller]
             fn from(bytes: [u8; $n]) -> Self {
                 Self(bytes.into())
             }
         }
 
         impl<'a> From<&'a [u8; $n]> for $name {
             #[inline]
-            #[track_caller]
             fn from(bytes: &'a [u8; $n]) -> Self {
                 Self(bytes.into())
             }
         }
 
         impl AsRef<[u8]> for $name {
             #[inline]
-            #[track_caller]
             fn as_ref(&self) -> &[u8] {
                 self.as_bytes()
             }
         }
 
         impl AsMut<[u8]> for $name {
             #[inline]
-            #[track_caller]
             fn as_mut(&mut self) -> &mut [u8] {
                 self.as_bytes_mut()
             }

primitives/src/bits/mod.rs

@@ -6,8 +6,6 @@ pub use fixed::FixedBytes;
 
 mod macros;
 
-// pub(self) mod hex;
-
 // code stolen from: https://docs.rs/impl-serde/0.4.0/impl_serde/
 #[cfg(feature = "serde")]
 mod serialize;

primitives/src/bits/rlp.rs

@@ -1,6 +1,5 @@
-use ethers_rlp::{Decodable, Encodable};
-
 use super::FixedBytes;
+use ethers_rlp::{Decodable, Encodable};
 
 impl<const N: usize> Decodable for FixedBytes<N> {
     fn decode(buf: &mut &[u8]) -> Result<Self, ethers_rlp::DecodeError> {

primitives/src/bits/serialize.rs

@@ -1,6 +1,6 @@
-use core::result::Result;
-
 use super::FixedBytes;
+use alloc::string::String;
+use core::result::Result;
 
 impl<const N: usize> serde::Serialize for FixedBytes<N> {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

primitives/src/lib.rs

@@ -14,7 +14,7 @@
 
 #![cfg_attr(not(feature = "std"), no_std)]
 
-#[cfg(not(feature = "std"))]
+#[macro_use]
 extern crate alloc;
 
 mod bits;

primitives/src/signed/errors.rs

@@ -1,16 +1,14 @@
+use core::fmt;
 use ruint::BaseConvertError;
 
 /// The error type that is returned when parsing a signed integer.
 #[derive(Clone, Copy, Debug, PartialEq)]
-#[cfg_attr(feature = "std", derive(thiserror::Error))]
 pub enum ParseSignedError {
     /// Error that occurs when an invalid digit is encountered while parsing.
-    #[cfg_attr(feature = "std", error("Parsing Error: {0}"))]
     Ruint(ruint::ParseError),
 
     /// Error that occurs when the number is too large or too small (negative)
     /// and does not fit in the target signed integer.
-    #[cfg_attr(feature = "std", error("number does not fit in the integer size"))]
     IntegerOverflow,
 }
 
@@ -27,8 +25,27 @@ impl From<ruint::ParseError> for ParseSignedError {
     }
 }
 
+#[cfg(feature = "std")]
+impl std::error::Error for ParseSignedError {}
+
+impl fmt::Display for ParseSignedError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Ruint(err) => write!(f, "Parsing Error: {err}"),
+            Self::IntegerOverflow => f.write_str("number does not fit in the integer size"),
+        }
+    }
+}
+
 /// The error type that is returned when conversion to or from a integer fails.
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
-#[cfg_attr(feature = "std", derive(thiserror::Error))]
-#[cfg_attr(feature = "std", error("output of range integer conversion attempted"))]
 pub struct BigIntConversionError;
+
+#[cfg(feature = "std")]
+impl std::error::Error for BigIntConversionError {}
+
+impl fmt::Display for BigIntConversionError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str("output of range integer conversion attempted")
+    }
+}

primitives/src/signed/int.rs

@@ -1,11 +1,8 @@
+use super::{errors, utils::*, Sign};
+use alloc::string::{String, ToString};
 use core::fmt;
 use ruint::Uint;
 
-#[cfg(not(feature = "std"))]
-use alloc::{format, string::String};
-
-use super::{errors, utils::*, Sign};
-
 /// Signed integer wrapping a `ruint::Uint`.
 ///
 /// This signed integer implementation is fully abstract across the number of

primitives/src/signed/ops.rs

@@ -1,11 +1,9 @@
-use ruint::Uint;
-
-use core::{cmp, iter, ops};
-
 use super::{
     utils::{handle_overflow, twos_complement},
     Sign, Signed,
 };
+use core::{cmp, iter, ops};
+use ruint::Uint;
 
 // ops impl
 impl<const BITS: usize, const LIMBS: usize> Signed<BITS, LIMBS> {

primitives/src/utils.rs

@@ -1,8 +1,8 @@
-pub use tiny_keccak::{Hasher, Keccak};
-
 use crate::bits::FixedBytes;
 
-/// Simple interface to keccak256 hash function
+pub use tiny_keccak::{Hasher, Keccak};
+
+/// Simple interface to the `keccak256` hash function.
 pub fn keccak256(bytes: impl AsRef<[u8]>) -> FixedBytes<32> {
     let mut output = [0u8; 32];
     let mut hasher = Keccak::v256();