Use array-bytes for array/bytes/hex operations

.github/workflows/ci.yml

@@ -66,7 +66,7 @@ jobs:
           args: -p uint --all-features
 
       - name: Test fixed-hash no_std
-        run: cargo test -p fixed-hash --no-default-features --features='byteorder,rustc-hex'
+        run: cargo test -p fixed-hash --no-default-features --features='array-bytes,byteorder'
 
       - name: Test fixed-hash all-features
         uses: actions-rs/cargo@v1
@@ -114,16 +114,16 @@ jobs:
           command: test
           args: -p parity-util-mem --target=aarch64-linux-android
 
-      - name: Test parity-util-mem estimate-heapsize 
+      - name: Test parity-util-mem estimate-heapsize
         run: cargo test -p parity-util-mem --features='estimate-heapsize'
 
-      - name: Test parity-util-mem jemalloc-global 
+      - name: Test parity-util-mem jemalloc-global
         run: cargo test -p parity-util-mem --features='jemalloc-global'
 
-      - name: Test parity-util-mem mimalloc-global 
+      - name: Test parity-util-mem mimalloc-global
         run: cargo test -p parity-util-mem --features='mimalloc-global'
 
-      - name: Test parity-util-mem dlmalloc-global 
+      - name: Test parity-util-mem dlmalloc-global
         run: cargo test -p parity-util-mem --no-default-features --features='dlmalloc-global'
 
   test_windows:

ethbloom/Cargo.toml

@@ -20,18 +20,27 @@ impl-codec = { version = "0.6.0", path = "../primitive-types/impls/codec", defau
 scale-info = { version = ">=1.0, <3", features = ["derive"], default-features = false, optional = true }
 
 [dev-dependencies]
+array-bytes = "4.2"
 criterion = "0.4.0"
 rand = "0.8.0"
-hex-literal = "0.3.1"
 
 [features]
-default = ["std", "rlp", "serialize", "rustc-hex"]
-std = ["fixed-hash/std", "crunchy/std"]
-serialize = ["impl-serde"]
-rustc-hex = ["fixed-hash/rustc-hex"]
+default = [
+	"std",
+	"array-bytes",
+	"rlp",
+	"serialize",
+]
+std = [
+	"crunchy/std",
+	"fixed-hash/std",
+]
+
 arbitrary = ["fixed-hash/arbitrary"]
-rlp = ["impl-rlp"]
+array-bytes = ["fixed-hash/array-bytes"]
 codec = ["impl-codec", "scale-info"]
+rlp = ["impl-rlp"]
+serialize = ["impl-serde"]
 
 [[bench]]
 name = "bloom"

ethbloom/src/lib.rs

@@ -273,9 +273,11 @@ impl<'a> From<&'a Bloom> for BloomRef<'a> {
 
 #[cfg(test)]
 mod tests {
-	use super::{Bloom, Input};
 	use core::str::FromStr;
-	use hex_literal::hex;
+
+	use super::{Bloom, Input};
+
+	use array_bytes::hex2bytes_unchecked;
 
 	#[test]
 	#[rustfmt::skip]
@@ -298,8 +300,8 @@ mod tests {
 			 00000000000000000000000000000000\
 			 00000000000000000000000000000000",
 		).unwrap();
-		let address = hex!("ef2d6d194084c2de36e0dabfce45d046b37d1106");
-		let topic = hex!("02c69be41d0b7e40352fc85be1cd65eb03d40ef8427a0ca4596b1ead9a00e9fc");
+		let address = hex2bytes_unchecked("ef2d6d194084c2de36e0dabfce45d046b37d1106");
+		let topic = hex2bytes_unchecked("02c69be41d0b7e40352fc85be1cd65eb03d40ef8427a0ca4596b1ead9a00e9fc");
 
 		let mut my_bloom = Bloom::default();
 		assert!(!my_bloom.contains_input(Input::Raw(&address)));

ethereum-types/Cargo.toml

@@ -10,9 +10,9 @@ rust-version = "1.60.0"
 
 [dependencies]
 ethbloom = { path = "../ethbloom", version = "0.13", optional = true, default-features = false }
-fixed-hash = { path = "../fixed-hash", version = "0.8", default-features = false, features = ["byteorder", "rustc-hex"] }
+fixed-hash = { path = "../fixed-hash", version = "0.8", default-features = false, features = ["array-bytes", "byteorder"] }
 uint-crate = { path = "../uint", package = "uint", version = "0.9", default-features = false }
-primitive-types = { path = "../primitive-types", version = "0.12", features = ["byteorder", "rustc-hex"], default-features = false }
+primitive-types = { path = "../primitive-types", version = "0.12", features = ["array-bytes", "byteorder"], default-features = false }
 impl-serde = { path = "../primitive-types/impls/serde", version = "0.4.0", default-features = false, optional = true }
 impl-rlp = { path = "../primitive-types/impls/rlp", version = "0.3", default-features = false, optional = true }
 impl-codec = { version = "0.6.0", path = "../primitive-types/impls/codec", default-features = false, optional = true }

fixed-hash/Cargo.toml

@@ -15,21 +15,29 @@ rust-version = "1.56.1"
 features = ["quickcheck", "api-dummy"]
 
 [dependencies]
+arbitrary = { version = "1.0", optional = true }
+array-bytes = { version = "4.2", optional = true }
 byteorder = { version = "1.4.2", optional = true, default-features = false }
 quickcheck = { version = "1", optional = true }
 rand = { version = "0.8.0", optional = true, default-features = false }
-rustc-hex = { version = "2.0.1", optional = true, default-features = false }
 static_assertions = "1.0.0"
-arbitrary = { version = "1.0", optional = true }
 
 [dev-dependencies]
-rand_xorshift = "0.3.0"
 criterion = "0.4.0"
 rand = { version = "0.8.0", default-features = false, features = ["std_rng"] }
+rand_xorshift = "0.3.0"
 
 [features]
-default = ["std", "rand", "rustc-hex", "byteorder"]
-std = ["rustc-hex/std", "rand/std", "byteorder/std"]
+default = [
+	"std",
+	"array-bytes",
+	"byteorder",
+	"rand",
+]
+std = [
+	"byteorder/std",
+	"rand/std",
+]
 
 api-dummy = [] # Feature used by docs.rs to display documentation of hash types
 

fixed-hash/README.md

@@ -39,7 +39,7 @@ construct_fixed_hash!{
 
 ## Features
 
-By default this is an standard library depending crate.  
+By default this is an standard library depending crate.
 For a `#[no_std]` environment use it as follows:
 
 ```
@@ -50,7 +50,6 @@ fixed-hash = { version = "0.3", default-features = false }
 
 - `std`: Use the standard library instead of the core library.
 	- Using this feature enables the following features
-		- `rustc-hex/std`
 		- `rand/std`
 		- `byteorder/std`
     - Enabled by default.

fixed-hash/src/hash.rs

@@ -547,34 +547,34 @@ macro_rules! impl_cmp_for_fixed_hash {
 	};
 }
 
-// Implementation for disabled rustc-hex crate support.
+// Implementation for disabled array-bytes crate support.
 //
 // # Note
 //
 // Feature guarded macro definitions instead of feature guarded impl blocks
-// to work around the problems of introducing `rustc-hex` crate feature in
+// to work around the problems of introducing `array-bytes` crate feature in
 // a user crate.
-#[cfg(not(feature = "rustc-hex"))]
+#[cfg(not(feature = "array-bytes"))]
 #[macro_export]
 #[doc(hidden)]
 macro_rules! impl_rustc_hex_for_fixed_hash {
 	( $name:ident ) => {};
 }
 
-// Implementation for enabled rustc-hex crate support.
+// Implementation for enabled array-bytes crate support.
 //
 // # Note
 //
 // Feature guarded macro definitions instead of feature guarded impl blocks
-// to work around the problems of introducing `rustc-hex` crate feature in
+// to work around the problems of introducing `array-bytes` crate feature in
 // a user crate.
-#[cfg(feature = "rustc-hex")]
+#[cfg(feature = "array-bytes")]
 #[macro_export]
 #[doc(hidden)]
 macro_rules! impl_rustc_hex_for_fixed_hash {
 	( $name:ident ) => {
 		impl $crate::core_::str::FromStr for $name {
-			type Err = $crate::rustc_hex::FromHexError;
+			type Err = $crate::array_bytes::Error;
 
 			/// Creates a hash type instance from the given string.
 			///
@@ -586,17 +586,8 @@ macro_rules! impl_rustc_hex_for_fixed_hash {
 			///
 			/// - When encountering invalid non hex-digits
 			/// - Upon empty string input or invalid input length in general
-			fn from_str(input: &str) -> $crate::core_::result::Result<$name, $crate::rustc_hex::FromHexError> {
-				let input = input.strip_prefix("0x").unwrap_or(input);
-				let mut iter = $crate::rustc_hex::FromHexIter::new(input);
-				let mut result = Self::zero();
-				for byte in result.as_mut() {
-					*byte = iter.next().ok_or(Self::Err::InvalidHexLength)??;
-				}
-				if iter.next().is_some() {
-					return Err(Self::Err::InvalidHexLength)
-				}
-				Ok(result)
+			fn from_str(input: &str) -> $crate::core_::result::Result<$name, $crate::array_bytes::Error> {
+				$crate::array_bytes::hex_n_into::<Self, { Self::len_bytes() }>(input)
 			}
 		}
 	};

fixed-hash/src/lib.rs

@@ -34,9 +34,9 @@ pub use static_assertions::const_assert;
 #[doc(hidden)]
 pub use byteorder;
 
-#[cfg(feature = "rustc-hex")]
+#[cfg(feature = "array-bytes")]
 #[doc(hidden)]
-pub use rustc_hex;
+pub use array_bytes;
 
 #[cfg(feature = "rand")]
 #[doc(hidden)]

fixed-hash/src/tests.rs

@@ -249,7 +249,7 @@ mod rand {
 	}
 }
 
-#[cfg(feature = "rustc-hex")]
+#[cfg(feature = "array-bytes")]
 mod from_str {
 	use super::*;
 

primitive-types/Cargo.toml

@@ -20,16 +20,17 @@ scale-info-crate = { package = "scale-info", version = ">=0.9, <3", features = [
 [features]
 default = ["std"]
 std = ["uint/std", "fixed-hash/std", "impl-codec?/std"]
+
+arbitrary = ["fixed-hash/arbitrary", "uint/arbitrary"]
+array-bytes = ["fixed-hash/array-bytes"]
 byteorder = ["fixed-hash/byteorder"]
-rustc-hex = ["fixed-hash/rustc-hex"]
-serde = ["std", "impl-serde", "impl-serde/std"]
-serde_no_std = ["impl-serde"]
 codec = ["impl-codec"]
 scale-info = ["codec", "scale-info-crate"]
-rlp = ["impl-rlp"]
-arbitrary = ["fixed-hash/arbitrary", "uint/arbitrary"]
 fp-conversion = ["std"]
 num-traits = ["impl-num-traits"]
+rlp = ["impl-rlp"]
+serde = ["std", "impl-serde", "impl-serde/std"]
+serde_no_std = ["impl-serde"]
 
 [[test]]
 name = "scale_info"

rlp/Cargo.toml

@@ -9,18 +9,18 @@ edition = "2021"
 rust-version = "1.56.1"
 
 [dependencies]
+array-bytes = { version = "4.2" }
 bytes = { version = "1", default-features = false }
-rustc-hex = { version = "2.0.1", default-features = false }
 rlp-derive = { version = "0.1", path = "../rlp-derive", optional = true }
 
 [dev-dependencies]
 criterion = "0.4.0"
-hex-literal = "0.3.1"
 primitive-types = { path = "../primitive-types", version = "0.12", features = ["impl-rlp"] }
 
 [features]
 default = ["std"]
-std = ["bytes/std", "rustc-hex/std"]
+std = ["bytes/std"]
+
 derive = ["rlp-derive"]
 
 [[bench]]

rlp/src/rlpin.rs

@@ -10,8 +10,6 @@
 use alloc::{string::String, vec::Vec};
 use core::{cell::Cell, fmt};
 
-use rustc_hex::ToHex;
-
 use crate::{error::DecoderError, impls::decode_usize, traits::Decodable};
 
 /// rlp offset
@@ -110,7 +108,7 @@ impl<'a> fmt::Display for Rlp<'a> {
 	fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
 		match self.prototype() {
 			Ok(Prototype::Null) => write!(f, "null"),
-			Ok(Prototype::Data(_)) => write!(f, "\"0x{}\"", self.data().unwrap().to_hex::<String>()),
+			Ok(Prototype::Data(_)) => write!(f, "\"{}\"", array_bytes::bytes2hex("0x", self.data().unwrap())),
 			Ok(Prototype::List(len)) => {
 				write!(f, "[")?;
 				for i in 0..len - 1 {