Merge branch 'master' into feat-new-allocator

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;

substrate/primitives/keyring/Cargo.toml

@@ -14,7 +14,6 @@ readme = "README.md"
 targets = ["x86_64-unknown-linux-gnu"]
 
 [dependencies]
-lazy_static = "1.4.0"
 strum = { version = "0.24.1", features = ["derive"], default-features = false }
 sp-core = { path = "../core" }
 sp-runtime = { path = "../runtime" }

substrate/primitives/keyring/src/bandersnatch.rs

@@ -21,12 +21,9 @@ pub use sp_core::bandersnatch;
 use sp_core::{
 	bandersnatch::{Pair, Public, Signature},
 	crypto::UncheckedFrom,
-	ByteArray, Pair as PairT,
+	hex2array, ByteArray, Pair as PairT,
 };
 
-use lazy_static::lazy_static;
-use std::{collections::HashMap, ops::Deref, sync::Mutex};
-
 /// Set of test accounts.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, strum::Display, strum::EnumIter)]
 pub enum Keyring {
@@ -74,7 +71,7 @@ impl Keyring {
 	}
 
 	pub fn public(self) -> Public {
-		self.pair().public()
+		Public::from(self)
 	}
 
 	pub fn to_seed(self) -> String {
@@ -129,20 +126,9 @@ impl std::str::FromStr for Keyring {
 	}
 }
 
-lazy_static! {
-	static ref PRIVATE_KEYS: Mutex<HashMap<Keyring, Pair>> =
-		Mutex::new(Keyring::iter().map(|who| (who, who.pair())).collect());
-	static ref PUBLIC_KEYS: HashMap<Keyring, Public> = PRIVATE_KEYS
-		.lock()
-		.unwrap()
-		.iter()
-		.map(|(&who, pair)| (who, pair.public()))
-		.collect();
-}
-
 impl From<Keyring> for Public {
 	fn from(k: Keyring) -> Self {
-		*(*PUBLIC_KEYS).get(&k).unwrap()
+		Public::unchecked_from(<[u8; PUBLIC_RAW_LEN]>::from(k))
 	}
 }
 
@@ -154,32 +140,24 @@ impl From<Keyring> for Pair {
 
 impl From<Keyring> for [u8; PUBLIC_RAW_LEN] {
 	fn from(k: Keyring) -> Self {
-		*(*PUBLIC_KEYS).get(&k).unwrap().as_ref()
-	}
-}
-
-impl From<Keyring> for &'static [u8; PUBLIC_RAW_LEN] {
-	fn from(k: Keyring) -> Self {
-		PUBLIC_KEYS.get(&k).unwrap().as_ref()
-	}
-}
-
-impl AsRef<[u8; PUBLIC_RAW_LEN]> for Keyring {
-	fn as_ref(&self) -> &[u8; PUBLIC_RAW_LEN] {
-		PUBLIC_KEYS.get(self).unwrap().as_ref()
-	}
-}
-
-impl AsRef<Public> for Keyring {
-	fn as_ref(&self) -> &Public {
-		PUBLIC_KEYS.get(self).unwrap()
-	}
-}
-
-impl Deref for Keyring {
-	type Target = [u8; PUBLIC_RAW_LEN];
-	fn deref(&self) -> &[u8; PUBLIC_RAW_LEN] {
-		PUBLIC_KEYS.get(self).unwrap().as_ref()
+		match k {
+			Keyring::Alice =>
+				hex2array!("9c8af77d3a4e3f6f076853922985b9e6724fc9675329087f47aff1ceaaae772180"),
+			Keyring::Bob =>
+				hex2array!("1abfbb76dc8374a1a6d93d59a5c81f07c18835f4681a6258aa0f514d363bff4780"),
+			Keyring::Charlie =>
+				hex2array!("0f4a9990aca3d39a7cd8bf187e2e81a9ea6f9cedb2db405f2fffff384c5dd02680"),
+			Keyring::Dave =>
+				hex2array!("bd7a87d4dfa89926a408b5acbed554ae3b053fa3532531053295cbabf07d337000"),
+			Keyring::Eve =>
+				hex2array!("f992d5b8eac8fc004d521bee6edc1174cfa7fae3a1baec8262511ee351f9f85e00"),
+			Keyring::Ferdie =>
+				hex2array!("1ce2613e89bc5c8e358aad884099cfb576a61176f2f9968cd0d486a04457245180"),
+			Keyring::One =>
+				hex2array!("a29e03ac273e521274d8e501a6242abd2ab393d7e197221a9113bdf8e2e5b34d00"),
+			Keyring::Two =>
+				hex2array!("f968d47e819ddb18a9d0f2ebd16501680b1a3f07ee375c6f81310e5f99a04f4d00"),
+		}
 	}
 }
 
@@ -206,4 +184,9 @@ mod tests {
 			&Keyring::Bob.public(),
 		));
 	}
+	#[test]
+	fn verify_static_public_keys() {
+		assert!(Keyring::iter()
+			.all(|k| { k.pair().public().as_ref() == <[u8; PUBLIC_RAW_LEN]>::from(k) }));
+	}
 }