Use array-bytes for All Array/Bytes/Hex Operations (#12190)

* Use `array-bytes` for All Array/Bytes/Hex Operations

Signed-off-by: Xavier Lau <xavier@inv.cafe>

* Reorder

* Self Review

* Format

* Fix Tests

* Bump `array-bytes`

* Optimize large test res

Signed-off-by: Xavier Lau <xavier@inv.cafe>
Co-authored-by: parity-processbot <>

substrate/primitives/beefy/Cargo.toml

@@ -22,8 +22,7 @@ sp-runtime = { version = "6.0.0", default-features = false, path = "../runtime"
 sp-std = { version = "4.0.0", default-features = false, path = "../std" }
 
 [dev-dependencies]
-hex = "0.4.3"
-hex-literal = "0.3"
+array-bytes = "4.1"
 sp-keystore = { version = "0.12.0", path = "../keystore" }
 
 [features]

substrate/primitives/beefy/src/witness.rs

@@ -148,12 +148,14 @@ mod tests {
 		assert_eq!(decoded, Ok(witness));
 		assert_eq!(
 			encoded,
-			hex_literal::hex!(
-				"046d683048656c6c6f20576f726c642105000000000000000000000000000000000000000000000010
-				0000010110000001558455ad81279df0795cc985580e4fb75d72d948d1107b2ac80a09abed4da8480c
-				746cc321f2319a5e99a830e314d10dd3cd68ce3dc0c33c86e99bcb7816f9ba01012d6e1f8105c337a86
-				cdd9aaacdc496577f3db8c55ef9e6fd48f2c5c05a2274707491635d8ba3df64f324575b7b2a34487bc
-				a2324b6a0046395a71681be3d0c2a00"
+			array_bytes::hex2bytes_unchecked(
+				"\
+				046d683048656c6c6f20576f726c642105000000000000000000000000000000000000000000000010\
+				0000010110000001558455ad81279df0795cc985580e4fb75d72d948d1107b2ac80a09abed4da8480c\
+				746cc321f2319a5e99a830e314d10dd3cd68ce3dc0c33c86e99bcb7816f9ba01012d6e1f8105c337a8\
+				6cdd9aaacdc496577f3db8c55ef9e6fd48f2c5c05a2274707491635d8ba3df64f324575b7b2a34487b\
+				ca2324b6a0046395a71681be3d0c2a00\
+			"
 			)
 		);
 	}

substrate/primitives/core/Cargo.toml

@@ -47,13 +47,13 @@ thiserror = { version = "1.0.30", optional = true }
 bitflags = "1.3"
 
 # full crypto
+array-bytes = { version = "4.1", optional = true }
 ed25519-zebra = { version = "3.0.0", default-features = false, optional = true}
 blake2 = { version = "0.10.4", default-features = false, optional = true }
 schnorrkel = { version = "0.9.1", features = [
 	"preaudit_deprecated",
 	"u64_backend",
 ], default-features = false, optional = true }
-hex = { version = "0.4", default-features = false, optional = true }
 libsecp256k1 = { version = "0.7", default-features = false, features = ["static-context"], optional = true }
 merlin = { version = "2.0", default-features = false, optional = true }
 secp256k1 = { version = "0.24.0", default-features = false, features = ["recovery", "alloc"], optional = true }
@@ -63,7 +63,6 @@ sp-runtime-interface = { version = "6.0.0", default-features = false, path = "..
 
 [dev-dependencies]
 sp-serializer = { version = "4.0.0-dev", path = "../serializer" }
-hex-literal = "0.3.4"
 rand = "0.7.2"
 criterion = "0.3.3"
 serde_json = "1.0"
@@ -99,8 +98,8 @@ std = [
 	"sp-std/std",
 	"serde",
 	"blake2/std",
+	"array-bytes",
 	"ed25519-zebra",
-	"hex/std",
 	"base58",
 	"substrate-bip39",
 	"tiny-bip39",
@@ -129,10 +128,10 @@ std = [
 # or Intel SGX.
 # For the regular wasm runtime builds this should not be used.
 full_crypto = [
+	"array-bytes",
 	"ed25519-zebra",
 	"blake2",
 	"schnorrkel",
-	"hex",
 	"libsecp256k1",
 	"secp256k1",
 	"sp-core-hashing",

substrate/primitives/core/src/crypto.rs

@@ -421,7 +421,7 @@ impl<T: Sized + AsMut<[u8]> + AsRef<[u8]> + Public + Derive> Ss58Codec for T {
 		let cap = SS58_REGEX.captures(s).ok_or(PublicError::InvalidFormat)?;
 		let s = cap.name("ss58").map(|r| r.as_str()).unwrap_or(DEV_ADDRESS);
 		let addr = if let Some(stripped) = s.strip_prefix("0x") {
-			let d = hex::decode(stripped).map_err(|_| PublicError::InvalidFormat)?;
+			let d = array_bytes::hex2bytes(stripped).map_err(|_| PublicError::InvalidFormat)?;
 			Self::from_slice(&d).map_err(|()| PublicError::BadLength)?
 		} else {
 			Self::from_ss58check(s)?
@@ -614,10 +614,7 @@ impl sp_std::str::FromStr for AccountId32 {
 	fn from_str(s: &str) -> Result<Self, Self::Err> {
 		let hex_or_ss58_without_prefix = s.trim_start_matches("0x");
 		if hex_or_ss58_without_prefix.len() == 64 {
-			let mut bytes = [0u8; 32];
-			hex::decode_to_slice(hex_or_ss58_without_prefix, &mut bytes)
-				.map_err(|_| "invalid hex address.")
-				.map(|_| Self::from(bytes))
+			array_bytes::hex_n_into(hex_or_ss58_without_prefix).map_err(|_| "invalid hex address.")
 		} else {
 			Self::from_ss58check(s).map_err(|_| "invalid ss58 address.")
 		}
@@ -943,7 +940,7 @@ pub trait Pair: CryptoType + Sized + Clone + Send + Sync + 'static {
 			password_override.or_else(|| password.as_ref().map(|p| p.expose_secret().as_str()));
 
 		let (root, seed) = if let Some(stripped) = phrase.expose_secret().strip_prefix("0x") {
-			hex::decode(stripped)
+			array_bytes::hex2bytes(stripped)
 				.ok()
 				.and_then(|seed_vec| {
 					let mut seed = Self::Seed::default();
@@ -1127,7 +1124,6 @@ pub mod key_types {
 mod tests {
 	use super::*;
 	use crate::DeriveJunction;
-	use hex_literal::hex;
 
 	#[derive(Clone, Eq, PartialEq, Debug)]
 	enum TestPair {
@@ -1269,7 +1265,7 @@ mod tests {
 	fn interpret_std_seed_should_work() {
 		assert_eq!(
 			TestPair::from_string("0x0123456789abcdef", None),
-			Ok(TestPair::Seed(hex!["0123456789abcdef"][..].to_owned()))
+			Ok(TestPair::Seed(array_bytes::hex2bytes_unchecked("0123456789abcdef")))
 		);
 	}
 

substrate/primitives/core/src/ecdsa.rs

@@ -229,7 +229,7 @@ impl Serialize for Signature {
 	where
 		S: Serializer,
 	{
-		serializer.serialize_str(&hex::encode(self))
+		serializer.serialize_str(&array_bytes::bytes2hex("", self.as_ref()))
 	}
 }
 
@@ -239,7 +239,7 @@ impl<'de> Deserialize<'de> for Signature {
 	where
 		D: Deserializer<'de>,
 	{
-		let signature_hex = hex::decode(&String::deserialize(deserializer)?)
+		let signature_hex = array_bytes::hex2bytes(&String::deserialize(deserializer)?)
 			.map_err(|e| de::Error::custom(format!("{:?}", e)))?;
 		Signature::try_from(signature_hex.as_ref())
 			.map_err(|e| de::Error::custom(format!("{:?}", e)))
@@ -597,7 +597,6 @@ mod test {
 		set_default_ss58_version, PublicError, Ss58AddressFormat, Ss58AddressFormatRegistry,
 		DEV_PHRASE,
 	};
-	use hex_literal::hex;
 	use serde_json;
 
 	#[test]
@@ -612,31 +611,35 @@ mod test {
 
 	#[test]
 	fn seed_and_derive_should_work() {
-		let seed = hex!("9d61b19deffd5a60ba844af492ec2cc44449c5697b326919703bac031cae7f60");
+		let seed = array_bytes::hex2array_unchecked(
+			"9d61b19deffd5a60ba844af492ec2cc44449c5697b326919703bac031cae7f60",
+		);
 		let pair = Pair::from_seed(&seed);
 		assert_eq!(pair.seed(), seed);
 		let path = vec![DeriveJunction::Hard([0u8; 32])];
 		let derived = pair.derive(path.into_iter(), None).ok().unwrap();
 		assert_eq!(
 			derived.0.seed(),
-			hex!("b8eefc4937200a8382d00050e050ced2d4ab72cc2ef1b061477afb51564fdd61")
+			array_bytes::hex2array_unchecked::<32>(
+				"b8eefc4937200a8382d00050e050ced2d4ab72cc2ef1b061477afb51564fdd61"
+			)
 		);
 	}
 
 	#[test]
 	fn test_vector_should_work() {
-		let pair = Pair::from_seed(&hex!(
-			"9d61b19deffd5a60ba844af492ec2cc44449c5697b326919703bac031cae7f60"
+		let pair = Pair::from_seed(&array_bytes::hex2array_unchecked(
+			"9d61b19deffd5a60ba844af492ec2cc44449c5697b326919703bac031cae7f60",
 		));
 		let public = pair.public();
 		assert_eq!(
 			public,
 			Public::from_full(
-				&hex!("8db55b05db86c0b1786ca49f095d76344c9e6056b2f02701a7e7f3c20aabfd913ebbe148dd17c56551a52952371071a6c604b3f3abe8f2c8fa742158ea6dd7d4")[..],
+				&array_bytes::hex2bytes_unchecked("8db55b05db86c0b1786ca49f095d76344c9e6056b2f02701a7e7f3c20aabfd913ebbe148dd17c56551a52952371071a6c604b3f3abe8f2c8fa742158ea6dd7d4"),
 			).unwrap(),
 		);
 		let message = b"";
-		let signature = hex!("3dde91174bd9359027be59a428b8146513df80a2a3c7eda2194f64de04a69ab97b753169e94db6ffd50921a2668a48b94ca11e3d32c1ff19cfe88890aa7e8f3c00");
+		let signature = array_bytes::hex2array_unchecked("3dde91174bd9359027be59a428b8146513df80a2a3c7eda2194f64de04a69ab97b753169e94db6ffd50921a2668a48b94ca11e3d32c1ff19cfe88890aa7e8f3c00");
 		let signature = Signature::from_raw(signature);
 		assert!(pair.sign(&message[..]) == signature);
 		assert!(Pair::verify(&signature, &message[..], &public));
@@ -653,11 +656,11 @@ mod test {
 		assert_eq!(
 			public,
 			Public::from_full(
-				&hex!("8db55b05db86c0b1786ca49f095d76344c9e6056b2f02701a7e7f3c20aabfd913ebbe148dd17c56551a52952371071a6c604b3f3abe8f2c8fa742158ea6dd7d4")[..],
+				&array_bytes::hex2bytes_unchecked("8db55b05db86c0b1786ca49f095d76344c9e6056b2f02701a7e7f3c20aabfd913ebbe148dd17c56551a52952371071a6c604b3f3abe8f2c8fa742158ea6dd7d4"),
 			).unwrap(),
 		);
 		let message = b"";
-		let signature = hex!("3dde91174bd9359027be59a428b8146513df80a2a3c7eda2194f64de04a69ab97b753169e94db6ffd50921a2668a48b94ca11e3d32c1ff19cfe88890aa7e8f3c00");
+		let signature = array_bytes::hex2array_unchecked("3dde91174bd9359027be59a428b8146513df80a2a3c7eda2194f64de04a69ab97b753169e94db6ffd50921a2668a48b94ca11e3d32c1ff19cfe88890aa7e8f3c00");
 		let signature = Signature::from_raw(signature);
 		assert!(pair.sign(&message[..]) == signature);
 		assert!(Pair::verify(&signature, &message[..], &public));
@@ -680,10 +683,10 @@ mod test {
 		assert_eq!(
 			public,
 			Public::from_full(
-				&hex!("5676109c54b9a16d271abeb4954316a40a32bcce023ac14c8e26e958aa68fba995840f3de562156558efbfdac3f16af0065e5f66795f4dd8262a228ef8c6d813")[..],
+				&array_bytes::hex2bytes_unchecked("5676109c54b9a16d271abeb4954316a40a32bcce023ac14c8e26e958aa68fba995840f3de562156558efbfdac3f16af0065e5f66795f4dd8262a228ef8c6d813"),
 			).unwrap(),
 		);
-		let message = hex!("2f8c6129d816cf51c374bc7f08c3e63ed156cf78aefb4a6550d97b87997977ee00000000000000000200d75a980182b10ab7d54bfed3c964073a0ee172f3daa62325af021a68f707511a4500000000000000");
+		let message = array_bytes::hex2bytes_unchecked("2f8c6129d816cf51c374bc7f08c3e63ed156cf78aefb4a6550d97b87997977ee00000000000000000200d75a980182b10ab7d54bfed3c964073a0ee172f3daa62325af021a68f707511a4500000000000000");
 		let signature = pair.sign(&message[..]);
 		println!("Correct signature: {:?}", signature);
 		assert!(Pair::verify(&signature, &message[..], &public));

substrate/primitives/core/src/ed25519.rs

@@ -228,7 +228,7 @@ impl Serialize for Signature {
 	where
 		S: Serializer,
 	{
-		serializer.serialize_str(&hex::encode(self))
+		serializer.serialize_str(&array_bytes::bytes2hex("", self.as_ref()))
 	}
 }
 
@@ -238,7 +238,7 @@ impl<'de> Deserialize<'de> for Signature {
 	where
 		D: Deserializer<'de>,
 	{
-		let signature_hex = hex::decode(&String::deserialize(deserializer)?)
+		let signature_hex = array_bytes::hex2bytes(&String::deserialize(deserializer)?)
 			.map_err(|e| de::Error::custom(format!("{:?}", e)))?;
 		Signature::try_from(signature_hex.as_ref())
 			.map_err(|e| de::Error::custom(format!("{:?}", e)))
@@ -551,7 +551,6 @@ impl CryptoType for Pair {
 mod test {
 	use super::*;
 	use crate::crypto::DEV_PHRASE;
-	use hex_literal::hex;
 	use serde_json;
 
 	#[test]
@@ -566,31 +565,35 @@ mod test {
 
 	#[test]
 	fn seed_and_derive_should_work() {
-		let seed = hex!("9d61b19deffd5a60ba844af492ec2cc44449c5697b326919703bac031cae7f60");
+		let seed = array_bytes::hex2array_unchecked(
+			"9d61b19deffd5a60ba844af492ec2cc44449c5697b326919703bac031cae7f60",
+		);
 		let pair = Pair::from_seed(&seed);
 		assert_eq!(pair.seed(), seed);
 		let path = vec![DeriveJunction::Hard([0u8; 32])];
 		let derived = pair.derive(path.into_iter(), None).ok().unwrap().0;
 		assert_eq!(
 			derived.seed(),
-			hex!("ede3354e133f9c8e337ddd6ee5415ed4b4ffe5fc7d21e933f4930a3730e5b21c")
+			array_bytes::hex2array_unchecked::<32>(
+				"ede3354e133f9c8e337ddd6ee5415ed4b4ffe5fc7d21e933f4930a3730e5b21c"
+			)
 		);
 	}
 
 	#[test]
 	fn test_vector_should_work() {
-		let pair = Pair::from_seed(&hex!(
-			"9d61b19deffd5a60ba844af492ec2cc44449c5697b326919703bac031cae7f60"
+		let pair = Pair::from_seed(&array_bytes::hex2array_unchecked(
+			"9d61b19deffd5a60ba844af492ec2cc44449c5697b326919703bac031cae7f60",
 		));
 		let public = pair.public();
 		assert_eq!(
 			public,
-			Public::from_raw(hex!(
+			Public::from_raw(array_bytes::hex2array_unchecked(
 				"d75a980182b10ab7d54bfed3c964073a0ee172f3daa62325af021a68f707511a"
 			))
 		);
 		let message = b"";
-		let signature = hex!("e5564300c360ac729086e2cc806e828a84877f1eb8e5d974d873e065224901555fb8821590a33bacc61e39701cf9b46bd25bf5f0595bbe24655141438e7a100b");
+		let signature = array_bytes::hex2array_unchecked("e5564300c360ac729086e2cc806e828a84877f1eb8e5d974d873e065224901555fb8821590a33bacc61e39701cf9b46bd25bf5f0595bbe24655141438e7a100b");
 		let signature = Signature::from_raw(signature);
 		assert!(pair.sign(&message[..]) == signature);
 		assert!(Pair::verify(&signature, &message[..], &public));
@@ -606,12 +609,12 @@ mod test {
 		let public = pair.public();
 		assert_eq!(
 			public,
-			Public::from_raw(hex!(
+			Public::from_raw(array_bytes::hex2array_unchecked(
 				"d75a980182b10ab7d54bfed3c964073a0ee172f3daa62325af021a68f707511a"
 			))
 		);
 		let message = b"";
-		let signature = hex!("e5564300c360ac729086e2cc806e828a84877f1eb8e5d974d873e065224901555fb8821590a33bacc61e39701cf9b46bd25bf5f0595bbe24655141438e7a100b");
+		let signature = array_bytes::hex2array_unchecked("e5564300c360ac729086e2cc806e828a84877f1eb8e5d974d873e065224901555fb8821590a33bacc61e39701cf9b46bd25bf5f0595bbe24655141438e7a100b");
 		let signature = Signature::from_raw(signature);
 		assert!(pair.sign(&message[..]) == signature);
 		assert!(Pair::verify(&signature, &message[..], &public));
@@ -633,11 +636,11 @@ mod test {
 		let public = pair.public();
 		assert_eq!(
 			public,
-			Public::from_raw(hex!(
+			Public::from_raw(array_bytes::hex2array_unchecked(
 				"2f8c6129d816cf51c374bc7f08c3e63ed156cf78aefb4a6550d97b87997977ee"
 			))
 		);
-		let message = hex!("2f8c6129d816cf51c374bc7f08c3e63ed156cf78aefb4a6550d97b87997977ee00000000000000000200d75a980182b10ab7d54bfed3c964073a0ee172f3daa62325af021a68f707511a4500000000000000");
+		let message = array_bytes::hex2bytes_unchecked("2f8c6129d816cf51c374bc7f08c3e63ed156cf78aefb4a6550d97b87997977ee00000000000000000200d75a980182b10ab7d54bfed3c964073a0ee172f3daa62325af021a68f707511a4500000000000000");
 		let signature = pair.sign(&message[..]);
 		println!("Correct signature: {:?}", signature);
 		assert!(Pair::verify(&signature, &message[..], &public));

substrate/primitives/core/src/sr25519.rs

@@ -233,7 +233,7 @@ impl Serialize for Signature {
 	where
 		S: Serializer,
 	{
-		serializer.serialize_str(&hex::encode(self))
+		serializer.serialize_str(&array_bytes::bytes2hex("", self.as_ref()))
 	}
 }
 
@@ -243,7 +243,7 @@ impl<'de> Deserialize<'de> for Signature {
 	where
 		D: Deserializer<'de>,
 	{
-		let signature_hex = hex::decode(&String::deserialize(deserializer)?)
+		let signature_hex = array_bytes::hex2bytes(&String::deserialize(deserializer)?)
 			.map_err(|e| de::Error::custom(format!("{:?}", e)))?;
 		Signature::try_from(signature_hex.as_ref())
 			.map_err(|e| de::Error::custom(format!("{:?}", e)))
@@ -664,7 +664,6 @@ pub fn verify_batch(
 mod compatibility_test {
 	use super::*;
 	use crate::crypto::DEV_PHRASE;
-	use hex_literal::hex;
 
 	// NOTE: tests to ensure addresses that are created with the `0.1.x` version (pre-audit) are
 	// still functional.
@@ -673,7 +672,9 @@ mod compatibility_test {
 	fn derive_soft_known_pair_should_work() {
 		let pair = Pair::from_string(&format!("{}/Alice", DEV_PHRASE), None).unwrap();
 		// known address of DEV_PHRASE with 1.1
-		let known = hex!("d6c71059dbbe9ad2b0ed3f289738b800836eb425544ce694825285b958ca755e");
+		let known = array_bytes::hex2bytes_unchecked(
+			"d6c71059dbbe9ad2b0ed3f289738b800836eb425544ce694825285b958ca755e",
+		);
 		assert_eq!(pair.public().to_raw_vec(), known);
 	}
 
@@ -681,17 +682,19 @@ mod compatibility_test {
 	fn derive_hard_known_pair_should_work() {
 		let pair = Pair::from_string(&format!("{}//Alice", DEV_PHRASE), None).unwrap();
 		// known address of DEV_PHRASE with 1.1
-		let known = hex!("d43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d");
+		let known = array_bytes::hex2bytes_unchecked(
+			"d43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d",
+		);
 		assert_eq!(pair.public().to_raw_vec(), known);
 	}
 
 	#[test]
 	fn verify_known_old_message_should_work() {
-		let public = Public::from_raw(hex!(
-			"b4bfa1f7a5166695eb75299fd1c4c03ea212871c342f2c5dfea0902b2c246918"
+		let public = Public::from_raw(array_bytes::hex2array_unchecked(
+			"b4bfa1f7a5166695eb75299fd1c4c03ea212871c342f2c5dfea0902b2c246918",
 		));
 		// signature generated by the 1.1 version with the same ^^ public key.
-		let signature = Signature::from_raw(hex!(
+		let signature = Signature::from_raw(array_bytes::hex2array_unchecked(
 			"5a9755f069939f45d96aaf125cf5ce7ba1db998686f87f2fb3cbdea922078741a73891ba265f70c31436e18a9acd14d189d73c12317ab6c313285cd938453202"
 		));
 		let message = b"Verifying that I am the owner of 5G9hQLdsKQswNPgB499DeA5PkFBbgkLPJWkkS6FAM6xGQ8xD. Hash: 221455a3\n";
@@ -704,7 +707,6 @@ mod compatibility_test {
 mod test {
 	use super::*;
 	use crate::crypto::{Ss58Codec, DEV_ADDRESS, DEV_PHRASE};
-	use hex_literal::hex;
 	use serde_json;
 
 	#[test]
@@ -745,8 +747,8 @@ mod test {
 
 	#[test]
 	fn derive_soft_should_work() {
-		let pair = Pair::from_seed(&hex!(
-			"9d61b19deffd5a60ba844af492ec2cc44449c5697b326919703bac031cae7f60"
+		let pair = Pair::from_seed(&array_bytes::hex2array_unchecked(
+			"9d61b19deffd5a60ba844af492ec2cc44449c5697b326919703bac031cae7f60",
 		));
 		let derive_1 = pair.derive(Some(DeriveJunction::soft(1)).into_iter(), None).unwrap().0;
 		let derive_1b = pair.derive(Some(DeriveJunction::soft(1)).into_iter(), None).unwrap().0;
@@ -757,8 +759,8 @@ mod test {
 
 	#[test]
 	fn derive_hard_should_work() {
-		let pair = Pair::from_seed(&hex!(
-			"9d61b19deffd5a60ba844af492ec2cc44449c5697b326919703bac031cae7f60"
+		let pair = Pair::from_seed(&array_bytes::hex2array_unchecked(
+			"9d61b19deffd5a60ba844af492ec2cc44449c5697b326919703bac031cae7f60",
 		));
 		let derive_1 = pair.derive(Some(DeriveJunction::hard(1)).into_iter(), None).unwrap().0;
 		let derive_1b = pair.derive(Some(DeriveJunction::hard(1)).into_iter(), None).unwrap().0;
@@ -769,8 +771,8 @@ mod test {
 
 	#[test]
 	fn derive_soft_public_should_work() {
-		let pair = Pair::from_seed(&hex!(
-			"9d61b19deffd5a60ba844af492ec2cc44449c5697b326919703bac031cae7f60"
+		let pair = Pair::from_seed(&array_bytes::hex2array_unchecked(
+			"9d61b19deffd5a60ba844af492ec2cc44449c5697b326919703bac031cae7f60",
 		));
 		let path = Some(DeriveJunction::soft(1));
 		let pair_1 = pair.derive(path.into_iter(), None).unwrap().0;
@@ -780,8 +782,8 @@ mod test {
 
 	#[test]
 	fn derive_hard_public_should_fail() {
-		let pair = Pair::from_seed(&hex!(
-			"9d61b19deffd5a60ba844af492ec2cc44449c5697b326919703bac031cae7f60"
+		let pair = Pair::from_seed(&array_bytes::hex2array_unchecked(
+			"9d61b19deffd5a60ba844af492ec2cc44449c5697b326919703bac031cae7f60",
 		));
 		let path = Some(DeriveJunction::hard(1));
 		assert!(pair.public().derive(path.into_iter()).is_none());
@@ -789,13 +791,13 @@ mod test {
 
 	#[test]
 	fn sr_test_vector_should_work() {
-		let pair = Pair::from_seed(&hex!(
-			"9d61b19deffd5a60ba844af492ec2cc44449c5697b326919703bac031cae7f60"
+		let pair = Pair::from_seed(&array_bytes::hex2array_unchecked(
+			"9d61b19deffd5a60ba844af492ec2cc44449c5697b326919703bac031cae7f60",
 		));
 		let public = pair.public();
 		assert_eq!(
 			public,
-			Public::from_raw(hex!(
+			Public::from_raw(array_bytes::hex2array_unchecked(
 				"44a996beb1eef7bdcab976ab6d2ca26104834164ecf28fb375600576fcc6eb0f"
 			))
 		);
@@ -840,11 +842,11 @@ mod test {
 		let public = pair.public();
 		assert_eq!(
 			public,
-			Public::from_raw(hex!(
+			Public::from_raw(array_bytes::hex2array_unchecked(
 				"741c08a06f41c596608f6774259bd9043304adfa5d3eea62760bd9be97634d63"
 			))
 		);
-		let message = hex!("2f8c6129d816cf51c374bc7f08c3e63ed156cf78aefb4a6550d97b87997977ee00000000000000000200d75a980182b10ab7d54bfed3c964073a0ee172f3daa62325af021a68f707511a4500000000000000");
+		let message = array_bytes::hex2bytes_unchecked("2f8c6129d816cf51c374bc7f08c3e63ed156cf78aefb4a6550d97b87997977ee00000000000000000200d75a980182b10ab7d54bfed3c964073a0ee172f3daa62325af021a68f707511a4500000000000000");
 		let signature = pair.sign(&message[..]);
 		assert!(Pair::verify(&signature, &message[..], &public));
 	}
@@ -865,11 +867,11 @@ mod test {
 		// schnorrkel-js.
 		//
 		// This is to make sure that the wasm library is compatible.
-		let pk = Pair::from_seed(&hex!(
-			"0000000000000000000000000000000000000000000000000000000000000000"
+		let pk = Pair::from_seed(&array_bytes::hex2array_unchecked(
+			"0000000000000000000000000000000000000000000000000000000000000000",
 		));
 		let public = pk.public();
-		let js_signature = Signature::from_raw(hex!(
+		let js_signature = Signature::from_raw(array_bytes::hex2array_unchecked(
 			"28a854d54903e056f89581c691c1f7d2ff39f8f896c9e9c22475e60902cc2b3547199e0e91fa32902028f2ca2355e8cdd16cfe19ba5e8b658c94aa80f3b81a00"
 		));
 		assert!(Pair::verify_deprecated(&js_signature, b"SUBSTRATE", &public));

substrate/primitives/merkle-mountain-range/Cargo.toml

@@ -22,7 +22,7 @@ sp-runtime = { version = "6.0.0", default-features = false, path = "../runtime"
 sp-std = { version = "4.0.0", default-features = false, path = "../std" }
 
 [dev-dependencies]
-hex-literal = "0.3"
+array-bytes = "4.1"
 
 [features]
 default = ["std"]

substrate/primitives/merkle-mountain-range/src/lib.rs

@@ -535,11 +535,16 @@ mod tests {
 			cases.into_iter().map(Result::<_, codec::Error>::Ok).collect::<Vec<_>>()
 		);
 		// check encoding correctness
-		assert_eq!(&encoded[0], &hex_literal::hex!("00343048656c6c6f20576f726c6421"));
+		assert_eq!(
+			&encoded[0],
+			&array_bytes::hex2bytes_unchecked("00343048656c6c6f20576f726c6421")
+		);
 		assert_eq!(
 			encoded[1].as_slice(),
-			hex_literal::hex!("01c3e7ba6b511162fead58f2c8b5764ce869ed1118011ac37392522ed16720bbcd")
-				.as_ref()
+			array_bytes::hex2bytes_unchecked(
+				"01c3e7ba6b511162fead58f2c8b5764ce869ed1118011ac37392522ed16720bbcd"
+			)
+			.as_slice()
 		);
 	}
 

substrate/primitives/state-machine/Cargo.toml

@@ -31,7 +31,7 @@ sp-std = { version = "4.0.0", default-features = false, path = "../std" }
 sp-trie = { version = "6.0.0", default-features = false, path = "../trie" }
 
 [dev-dependencies]
-hex-literal = "0.3.4"
+array-bytes = "4.1"
 pretty_assertions = "1.2.1"
 rand = "0.7.2"
 sp-runtime = { version = "6.0.0", path = "../runtime" }

substrate/primitives/state-machine/src/basic.rs

@@ -356,7 +356,6 @@ impl sp_externalities::ExtensionStore for BasicExternalities {
 #[cfg(test)]
 mod tests {
 	use super::*;
-	use hex_literal::hex;
 	use sp_core::{
 		map,
 		storage::{well_known_keys::CODE, Storage, StorageChild},
@@ -368,10 +367,11 @@ mod tests {
 		ext.set_storage(b"doe".to_vec(), b"reindeer".to_vec());
 		ext.set_storage(b"dog".to_vec(), b"puppy".to_vec());
 		ext.set_storage(b"dogglesworth".to_vec(), b"cat".to_vec());
-		const ROOT: [u8; 32] =
-			hex!("39245109cef3758c2eed2ccba8d9b370a917850af3824bc8348d505df2c298fa");
+		let root = array_bytes::hex2bytes_unchecked(
+			"39245109cef3758c2eed2ccba8d9b370a917850af3824bc8348d505df2c298fa",
+		);
 
-		assert_eq!(&ext.storage_root(StateVersion::default())[..], &ROOT);
+		assert_eq!(&ext.storage_root(StateVersion::default())[..], &root);
 	}
 
 	#[test]

substrate/primitives/state-machine/src/overlayed_changes/mod.rs

@@ -743,7 +743,6 @@ impl<'a> OverlayedExtensions<'a> {
 mod tests {
 	use super::*;
 	use crate::{ext::Ext, InMemoryBackend};
-	use hex_literal::hex;
 	use sp_core::{traits::Externalities, Blake2Hasher};
 	use std::collections::BTreeMap;
 
@@ -870,10 +869,11 @@ mod tests {
 
 		let mut cache = StorageTransactionCache::default();
 		let mut ext = Ext::new(&mut overlay, &mut cache, &backend, None);
-		const ROOT: [u8; 32] =
-			hex!("39245109cef3758c2eed2ccba8d9b370a917850af3824bc8348d505df2c298fa");
+		let root = array_bytes::hex2bytes_unchecked(
+			"39245109cef3758c2eed2ccba8d9b370a917850af3824bc8348d505df2c298fa",
+		);
 
-		assert_eq!(&ext.storage_root(state_version)[..], &ROOT);
+		assert_eq!(&ext.storage_root(state_version)[..], &root);
 	}
 
 	#[test]

substrate/primitives/state-machine/src/testing.rs

@@ -334,7 +334,6 @@ where
 #[cfg(test)]
 mod tests {
 	use super::*;
-	use hex_literal::hex;
 	use sp_core::{storage::ChildInfo, traits::Externalities, H256};
 	use sp_runtime::traits::BlakeTwo256;
 
@@ -346,8 +345,9 @@ mod tests {
 		ext.set_storage(b"doe".to_vec(), b"reindeer".to_vec());
 		ext.set_storage(b"dog".to_vec(), b"puppy".to_vec());
 		ext.set_storage(b"dogglesworth".to_vec(), b"cat".to_vec());
-		let root =
-			H256::from(hex!("ed4d8c799d996add422395a6abd7545491d40bd838d738afafa1b8a4de625489"));
+		let root = array_bytes::hex_n_into_unchecked::<H256, 32>(
+			"ed4d8c799d996add422395a6abd7545491d40bd838d738afafa1b8a4de625489",
+		);
 		assert_eq!(H256::from_slice(ext.storage_root(Default::default()).as_slice()), root);
 	}
 

substrate/primitives/trie/Cargo.toml

@@ -36,8 +36,8 @@ sp-core = { version = "6.0.0", default-features = false, path = "../core" }
 sp-std = { version = "4.0.0", default-features = false, path = "../std" }
 
 [dev-dependencies]
+array-bytes = "4.1"
 criterion = "0.3.3"
-hex-literal = "0.3.4"
 trie-bench = "0.31.0"
 trie-standardmap = "0.15.2"
 sp-runtime = { version = "6.0.0", path = "../runtime" }

substrate/primitives/trie/src/lib.rs

@@ -542,7 +542,6 @@ mod tests {
 	use super::*;
 	use codec::{Compact, Decode, Encode};
 	use hash_db::{HashDB, Hasher};
-	use hex_literal::hex;
 	use sp_core::Blake2Hasher;
 	use trie_db::{DBValue, NodeCodec as NodeCodecT, Trie, TrieMut};
 	use trie_standardmap::{Alphabet, StandardMap, ValueMode};
@@ -845,8 +844,14 @@ mod tests {
 	}
 	fn iterator_works_inner<Layout: TrieConfiguration>() {
 		let pairs = vec![
-			(hex!("0103000000000000000464").to_vec(), hex!("0400000000").to_vec()),
-			(hex!("0103000000000000000469").to_vec(), hex!("0401000000").to_vec()),
+			(
+				array_bytes::hex2bytes_unchecked("0103000000000000000464"),
+				array_bytes::hex2bytes_unchecked("0400000000"),
+			),
+			(
+				array_bytes::hex2bytes_unchecked("0103000000000000000469"),
+				array_bytes::hex2bytes_unchecked("0401000000"),
+			),
 		];
 
 		let mut mdb = MemoryDB::default();
@@ -859,7 +864,7 @@ mod tests {
 		let mut iter_pairs = Vec::new();
 		for pair in iter {
 			let (key, value) = pair.unwrap();
-			iter_pairs.push((key, value.to_vec()));
+			iter_pairs.push((key, value));
 		}
 
 		assert_eq!(pairs, iter_pairs);
@@ -868,15 +873,15 @@ mod tests {
 	#[test]
 	fn proof_non_inclusion_works() {
 		let pairs = vec![
-			(hex!("0102").to_vec(), hex!("01").to_vec()),
-			(hex!("0203").to_vec(), hex!("0405").to_vec()),
+			(array_bytes::hex2bytes_unchecked("0102"), array_bytes::hex2bytes_unchecked("01")),
+			(array_bytes::hex2bytes_unchecked("0203"), array_bytes::hex2bytes_unchecked("0405")),
 		];
 
 		let mut memdb = MemoryDB::default();
 		let mut root = Default::default();
 		populate_trie::<LayoutV1>(&mut memdb, &mut root, &pairs);
 
-		let non_included_key: Vec<u8> = hex!("0909").to_vec();
+		let non_included_key: Vec<u8> = array_bytes::hex2bytes_unchecked("0909");
 		let proof =
 			generate_trie_proof::<LayoutV1, _, _, _>(&memdb, root, &[non_included_key.clone()])
 				.unwrap();
@@ -893,7 +898,7 @@ mod tests {
 		assert!(verify_trie_proof::<LayoutV1, _, _, Vec<u8>>(
 			&root,
 			&proof,
-			&[(non_included_key, Some(hex!("1010").to_vec()))],
+			&[(non_included_key, Some(array_bytes::hex2bytes_unchecked("1010")))],
 		)
 		.is_err());
 	}
@@ -901,8 +906,8 @@ mod tests {
 	#[test]
 	fn proof_inclusion_works() {
 		let pairs = vec![
-			(hex!("0102").to_vec(), hex!("01").to_vec()),
-			(hex!("0203").to_vec(), hex!("0405").to_vec()),
+			(array_bytes::hex2bytes_unchecked("0102"), array_bytes::hex2bytes_unchecked("01")),
+			(array_bytes::hex2bytes_unchecked("0203"), array_bytes::hex2bytes_unchecked("0405")),
 		];
 
 		let mut memdb = MemoryDB::default();
@@ -932,7 +937,7 @@ mod tests {
 		assert!(verify_trie_proof::<LayoutV1, _, _, _>(
 			&root,
 			&proof,
-			&[(hex!("4242").to_vec(), Some(pairs[0].1.clone()))]
+			&[(array_bytes::hex2bytes_unchecked("4242"), Some(pairs[0].1.clone()))]
 		)
 		.is_err());