From f6548aee31153df576d31820d23bbefca2a5eee4 Mon Sep 17 00:00:00 2001
From: Michal Kucharczyk <1728078+michalkucharczyk@users.noreply.github.com>
Date: Mon, 11 Dec 2023 15:21:20 +0100
Subject: [PATCH] `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>
---
Cargo.lock | 1 -
.../primitives/core/src/const_hex2array.rs | 162 ++++++++++++++++++
substrate/primitives/core/src/lib.rs | 1 +
substrate/primitives/keyring/Cargo.toml | 1 -
.../primitives/keyring/src/bandersnatch.rs | 69 +++-----
substrate/primitives/keyring/src/ed25519.rs | 78 ++++-----
substrate/primitives/keyring/src/sr25519.rs | 76 ++++----
7 files changed, 266 insertions(+), 122 deletions(-)
create mode 100644 substrate/primitives/core/src/const_hex2array.rs
diff --git a/Cargo.lock b/Cargo.lock
index baaa561bb80..a55223b4bcd 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -17687,7 +17687,6 @@ dependencies = [
name = "sp-keyring"
version = "24.0.0"
dependencies = [
- "lazy_static",
"sp-core",
"sp-runtime",
"strum",
diff --git a/substrate/primitives/core/src/const_hex2array.rs b/substrate/primitives/core/src/const_hex2array.rs
new file mode 100644
index 00000000000..cd6071028e6
--- /dev/null
+++ b/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");
+ }
+}
diff --git a/substrate/primitives/core/src/lib.rs b/substrate/primitives/core/src/lib.rs
index 4873d1a2112..c7232563cb7 100644
--- a/substrate/primitives/core/src/lib.rs
+++ b/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;
diff --git a/substrate/primitives/keyring/Cargo.toml b/substrate/primitives/keyring/Cargo.toml
index a504cda756e..5b58a4f97ca 100644
--- a/substrate/primitives/keyring/Cargo.toml
+++ b/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" }
diff --git a/substrate/primitives/keyring/src/bandersnatch.rs b/substrate/primitives/keyring/src/bandersnatch.rs
index 8de6786a6fb..eb60f856327 100644
--- a/substrate/primitives/keyring/src/bandersnatch.rs
+++ b/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) }));
+ }
}
diff --git a/substrate/primitives/keyring/src/ed25519.rs b/substrate/primitives/keyring/src/ed25519.rs
index 3060bfb1ad9..ade42b29494 100644
--- a/substrate/primitives/keyring/src/ed25519.rs
+++ b/substrate/primitives/keyring/src/ed25519.rs
@@ -17,14 +17,12 @@
//! Support code for the runtime. A set of test accounts.
-use lazy_static::lazy_static;
pub use sp_core::ed25519;
use sp_core::{
ed25519::{Pair, Public, Signature},
- ByteArray, Pair as PairT, H256,
+ hex2array, ByteArray, Pair as PairT, H256,
};
use sp_runtime::AccountId32;
-use std::{collections::HashMap, ops::Deref};
/// Set of test accounts.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, strum::Display, strum::EnumIter)]
@@ -93,7 +91,7 @@ impl Keyring {
}
pub fn public(self) -> Public {
- self.pair().public()
+ Public::from(self)
}
pub fn to_seed(self) -> String {
@@ -128,16 +126,9 @@ impl From<Keyring> for sp_runtime::MultiSigner {
}
}
-lazy_static! {
- static ref PRIVATE_KEYS: HashMap<Keyring, Pair> =
- Keyring::iter().map(|i| (i, i.pair())).collect();
- static ref PUBLIC_KEYS: HashMap<Keyring, Public> =
- PRIVATE_KEYS.iter().map(|(&name, pair)| (name, pair.public())).collect();
-}
-
impl From<Keyring> for Public {
fn from(k: Keyring) -> Self {
- *(*PUBLIC_KEYS).get(&k).unwrap()
+ Public::from_raw(k.into())
}
}
@@ -155,38 +146,42 @@ impl From<Keyring> for Pair {
impl From<Keyring> for [u8; 32] {
fn from(k: Keyring) -> Self {
- *(*PUBLIC_KEYS).get(&k).unwrap().as_array_ref()
+ match k {
+ Keyring::Alice =>
+ hex2array!("88dc3417d5058ec4b4503e0c12ea1a0a89be200fe98922423d4334014fa6b0ee"),
+ Keyring::Bob =>
+ hex2array!("d17c2d7823ebf260fd138f2d7e27d114c0145d968b5ff5006125f2414fadae69"),
+ Keyring::Charlie =>
+ hex2array!("439660b36c6c03afafca027b910b4fecf99801834c62a5e6006f27d978de234f"),
+ Keyring::Dave =>
+ hex2array!("5e639b43e0052c47447dac87d6fd2b6ec50bdd4d0f614e4299c665249bbd09d9"),
+ Keyring::Eve =>
+ hex2array!("1dfe3e22cc0d45c70779c1095f7489a8ef3cf52d62fbd8c2fa38c9f1723502b5"),
+ Keyring::Ferdie =>
+ hex2array!("568cb4a574c6d178feb39c27dfc8b3f789e5f5423e19c71633c748b9acf086b5"),
+ Keyring::AliceStash =>
+ hex2array!("451781cd0c5504504f69ceec484cc66e4c22a2b6a9d20fb1a426d91ad074a2a8"),
+ Keyring::BobStash =>
+ hex2array!("292684abbb28def63807c5f6e84e9e8689769eb37b1ab130d79dbfbf1b9a0d44"),
+ Keyring::CharlieStash =>
+ hex2array!("dd6a6118b6c11c9c9e5a4f34ed3d545e2c74190f90365c60c230fa82e9423bb9"),
+ Keyring::DaveStash =>
+ hex2array!("1d0432d75331ab299065bee79cdb1bdc2497c597a3087b4d955c67e3c000c1e2"),
+ Keyring::EveStash =>
+ hex2array!("c833bdd2e1a7a18acc1c11f8596e2e697bb9b42d6b6051e474091a1d43a294d7"),
+ Keyring::FerdieStash =>
+ hex2array!("199d749dbf4b8135cb1f3c8fd697a390fc0679881a8a110c1d06375b3b62cd09"),
+ Keyring::One =>
+ hex2array!("16f97016bbea8f7b45ae6757b49efc1080accc175d8f018f9ba719b60b0815e4"),
+ Keyring::Two =>
+ hex2array!("5079bcd20fd97d7d2f752c4607012600b401950260a91821f73e692071c82bf5"),
+ }
}
}
impl From<Keyring> for H256 {
fn from(k: Keyring) -> Self {
- (*PUBLIC_KEYS).get(&k).unwrap().as_array_ref().into()
- }
-}
-
-impl From<Keyring> for &'static [u8; 32] {
- fn from(k: Keyring) -> Self {
- (*PUBLIC_KEYS).get(&k).unwrap().as_array_ref()
- }
-}
-
-impl AsRef<[u8; 32]> for Keyring {
- fn as_ref(&self) -> &[u8; 32] {
- (*PUBLIC_KEYS).get(self).unwrap().as_array_ref()
- }
-}
-
-impl AsRef<Public> for Keyring {
- fn as_ref(&self) -> &Public {
- (*PUBLIC_KEYS).get(self).unwrap()
- }
-}
-
-impl Deref for Keyring {
- type Target = [u8; 32];
- fn deref(&self) -> &[u8; 32] {
- (*PUBLIC_KEYS).get(self).unwrap().as_array_ref()
+ k.into()
}
}
@@ -213,4 +208,9 @@ mod tests {
&Keyring::Bob.public(),
));
}
+
+ #[test]
+ fn verify_static_public_keys() {
+ assert!(Keyring::iter().all(|k| { k.pair().public().as_ref() == <[u8; 32]>::from(k) }));
+ }
}
diff --git a/substrate/primitives/keyring/src/sr25519.rs b/substrate/primitives/keyring/src/sr25519.rs
index 914a66b4d83..1c2a2526efb 100644
--- a/substrate/primitives/keyring/src/sr25519.rs
+++ b/substrate/primitives/keyring/src/sr25519.rs
@@ -17,14 +17,13 @@
//! Support code for the runtime. A set of test accounts.
-use lazy_static::lazy_static;
pub use sp_core::sr25519;
use sp_core::{
+ hex2array,
sr25519::{Pair, Public, Signature},
ByteArray, Pair as PairT, H256,
};
use sp_runtime::AccountId32;
-use std::{collections::HashMap, ops::Deref};
/// Set of test accounts.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, strum::Display, strum::EnumIter)]
@@ -93,7 +92,7 @@ impl Keyring {
}
pub fn public(self) -> Public {
- self.pair().public()
+ Public::from(self)
}
pub fn to_seed(self) -> String {
@@ -165,13 +164,6 @@ impl std::str::FromStr for Keyring {
}
}
-lazy_static! {
- static ref PRIVATE_KEYS: HashMap<Keyring, Pair> =
- Keyring::iter().map(|i| (i, i.pair())).collect();
- static ref PUBLIC_KEYS: HashMap<Keyring, Public> =
- PRIVATE_KEYS.iter().map(|(&name, pair)| (name, pair.public())).collect();
-}
-
impl From<Keyring> for AccountId32 {
fn from(k: Keyring) -> Self {
k.to_account_id()
@@ -180,7 +172,7 @@ impl From<Keyring> for AccountId32 {
impl From<Keyring> for Public {
fn from(k: Keyring) -> Self {
- *(*PUBLIC_KEYS).get(&k).unwrap()
+ Public::from_raw(k.into())
}
}
@@ -192,38 +184,42 @@ impl From<Keyring> for Pair {
impl From<Keyring> for [u8; 32] {
fn from(k: Keyring) -> Self {
- *(*PUBLIC_KEYS).get(&k).unwrap().as_array_ref()
+ match k {
+ Keyring::Alice =>
+ hex2array!("d43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d"),
+ Keyring::Bob =>
+ hex2array!("8eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a48"),
+ Keyring::Charlie =>
+ hex2array!("90b5ab205c6974c9ea841be688864633dc9ca8a357843eeacf2314649965fe22"),
+ Keyring::Dave =>
+ hex2array!("306721211d5404bd9da88e0204360a1a9ab8b87c66c1bc2fcdd37f3c2222cc20"),
+ Keyring::Eve =>
+ hex2array!("e659a7a1628cdd93febc04a4e0646ea20e9f5f0ce097d9a05290d4a9e054df4e"),
+ Keyring::Ferdie =>
+ hex2array!("1cbd2d43530a44705ad088af313e18f80b53ef16b36177cd4b77b846f2a5f07c"),
+ Keyring::AliceStash =>
+ hex2array!("be5ddb1579b72e84524fc29e78609e3caf42e85aa118ebfe0b0ad404b5bdd25f"),
+ Keyring::BobStash =>
+ hex2array!("fe65717dad0447d715f660a0a58411de509b42e6efb8375f562f58a554d5860e"),
+ Keyring::CharlieStash =>
+ hex2array!("1e07379407fecc4b89eb7dbd287c2c781cfb1907a96947a3eb18e4f8e7198625"),
+ Keyring::DaveStash =>
+ hex2array!("e860f1b1c7227f7c22602f53f15af80747814dffd839719731ee3bba6edc126c"),
+ Keyring::EveStash =>
+ hex2array!("8ac59e11963af19174d0b94d5d78041c233f55d2e19324665bafdfb62925af2d"),
+ Keyring::FerdieStash =>
+ hex2array!("101191192fc877c24d725b337120fa3edc63d227bbc92705db1e2cb65f56981a"),
+ Keyring::One =>
+ hex2array!("ac859f8a216eeb1b320b4c76d118da3d7407fa523484d0a980126d3b4d0d220a"),
+ Keyring::Two =>
+ hex2array!("1254f7017f0b8347ce7ab14f96d818802e7e9e0c0d1b7c9acb3c726b080e7a03"),
+ }
}
}
impl From<Keyring> for H256 {
fn from(k: Keyring) -> Self {
- (*PUBLIC_KEYS).get(&k).unwrap().as_array_ref().into()
- }
-}
-
-impl From<Keyring> for &'static [u8; 32] {
- fn from(k: Keyring) -> Self {
- (*PUBLIC_KEYS).get(&k).unwrap().as_array_ref()
- }
-}
-
-impl AsRef<[u8; 32]> for Keyring {
- fn as_ref(&self) -> &[u8; 32] {
- (*PUBLIC_KEYS).get(self).unwrap().as_array_ref()
- }
-}
-
-impl AsRef<Public> for Keyring {
- fn as_ref(&self) -> &Public {
- (*PUBLIC_KEYS).get(self).unwrap()
- }
-}
-
-impl Deref for Keyring {
- type Target = [u8; 32];
- fn deref(&self) -> &[u8; 32] {
- (*PUBLIC_KEYS).get(self).unwrap().as_array_ref()
+ k.into()
}
}
@@ -250,4 +246,8 @@ mod tests {
&Keyring::Bob.public(),
));
}
+ #[test]
+ fn verify_static_public_keys() {
+ assert!(Keyring::iter().all(|k| { k.pair().public().as_ref() == <[u8; 32]>::from(k) }));
+ }
}
--
GitLab