keyring: remove lazy_static public keys hash maps (#2387)

The `lazy_static` package does not work well in `no-std`: it requires
`spin_no_std` feature, which also will propagate into `std` if enabled.
This is not what we want.

This PR removes public/private key hash-maps and replaces them with
simple static byte arrays.

`&T` versions of `AsRef/Deref/From` traits implementation were removed.

Little const helper for converting hex strings into array during compile
time was also added. (somewhat similar to _hex_literal_).

---------

Co-authored-by: command-bot <>
Co-authored-by: Koute <koute@users.noreply.github.com>

substrate/primitives/core/src/const_hex2array.rs

@@ -0,0 +1,162 @@
+// This file is part of Substrate.
+
+// Copyright (C) Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! Provides a const function for converting a hex string to a `u8` array at compile time, when used
+//! in the proper context.
+
+/// Provides a const array from given string literal.
+///
+/// Valid characters are `[0-9a-fA-F]`, and the hex string should not start
+/// with the `0x` prefix.
+#[macro_export]
+macro_rules! hex2array {
+	($input:expr) => {{
+		const BYTES: [u8; $input.len() / 2] = $crate::const_hex2array::private_hex2array($input);
+		BYTES
+	}};
+}
+
+/// Generates array from (static) string literal.
+///
+/// Valid characters are `[0-9a-fA-F]`, and the hex string should not start
+/// with the `0x` prefix.
+///
+/// # Panics
+///
+/// The function will panic at compile time when used in a const context if:
+/// - The given hex string has an invalid length.
+/// - It contains invalid characters.
+///
+/// The function will panic at runtime when used in a non-const context if the above conditions are
+/// met.
+#[doc(hidden)]
+pub const fn private_hex2array<const N: usize>(hex: &str) -> [u8; N] {
+	const fn c2b(c: u8) -> u8 {
+		match c as char {
+			'0'..='9' => c - b'0',
+			'a'..='f' => c - (b'a' - 10),
+			'A'..='F' => c - (b'A' - 10),
+			_ => panic!("hex string contains invalid character"),
+		}
+	}
+	let mut output = [0; N];
+	let mut i = 0;
+	if hex.len() != 2 * N {
+		panic!("hex string length is not valid");
+	}
+	while i < N {
+		output[i] = 16 * c2b(hex.as_bytes()[2 * i]) + c2b(hex.as_bytes()[2 * i + 1]);
+		i += 1;
+	}
+	output
+}
+
+#[cfg(test)]
+mod testh2b {
+	use super::private_hex2array;
+
+	#[test]
+	fn t00() {
+		const T0: [u8; 0] = private_hex2array("");
+		const EMPTY: [u8; 0] = [];
+		assert_eq!(T0, EMPTY);
+	}
+
+	macro_rules! test_byte {
+		($a:expr, $b:expr) => {{
+			const X: [u8; 1] = private_hex2array($a);
+			assert_eq!(X, [$b]);
+		}};
+	}
+
+	#[test]
+	fn t01() {
+		test_byte!("00", 0);
+		test_byte!("01", 1);
+		test_byte!("02", 2);
+		test_byte!("03", 3);
+		test_byte!("04", 4);
+		test_byte!("05", 5);
+		test_byte!("06", 6);
+		test_byte!("07", 7);
+		test_byte!("08", 8);
+		test_byte!("09", 9);
+		test_byte!("0a", 10);
+		test_byte!("0A", 10);
+		test_byte!("0b", 11);
+		test_byte!("0B", 11);
+		test_byte!("0c", 12);
+		test_byte!("0C", 12);
+		test_byte!("0d", 13);
+		test_byte!("0D", 13);
+		test_byte!("0e", 14);
+		test_byte!("0E", 14);
+		test_byte!("0f", 15);
+		test_byte!("0F", 15);
+	}
+
+	#[test]
+	fn t02() {
+		const T0: [u8; 2] = private_hex2array("0a10");
+		assert_eq!(T0, [10, 16]);
+		const T1: [u8; 2] = private_hex2array("4545");
+		assert_eq!(T1, [69, 69]);
+	}
+
+	#[test]
+	fn t02m() {
+		assert_eq!(hex2array!("0a10"), [10, 16]);
+		assert_eq!(hex2array!("4545"), [69, 69]);
+		assert_eq!(
+			hex2array!("000102030405060708090a0b0c0d0e0f"),
+			[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
+		);
+	}
+
+	#[test]
+	fn t16() {
+		const T16: [u8; 16] = private_hex2array("000102030405060708090a0b0c0d0e0f");
+
+		assert_eq!(T16, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]);
+	}
+
+	#[test]
+	fn t33() {
+		const T33: [u8; 33] =
+			private_hex2array("9c8af77d3a4e3f6f076853922985b9e6724fc9675329087f47aff1ceaaae772180");
+
+		assert_eq!(
+			T33,
+			[
+				156, 138, 247, 125, 58, 78, 63, 111, 7, 104, 83, 146, 41, 133, 185, 230, 114, 79,
+				201, 103, 83, 41, 8, 127, 71, 175, 241, 206, 170, 174, 119, 33, 128
+			]
+		);
+	}
+
+	#[test]
+	#[should_panic = "hex string length is not valid"]
+	fn t_panic_incorrect_length2() {
+		let _ = private_hex2array::<2>("454");
+	}
+
+	#[test]
+	#[should_panic = "hex string contains invalid character"]
+	fn t_panic_invalid_character() {
+		let _ = private_hex2array::<2>("45ag");
+	}
+}

substrate/primitives/core/src/lib.rs

@@ -51,6 +51,7 @@ pub mod hashing;
 
 #[cfg(feature = "full_crypto")]
 pub use hashing::{blake2_128, blake2_256, keccak_256, twox_128, twox_256, twox_64};
+pub mod const_hex2array;
 pub mod crypto;
 pub mod hexdisplay;
 pub use paste;