mirror of
https://github.com/pezkuwichain/pezkuwi-subxt.git
synced 2026-04-27 23:18:01 +00:00
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>
This commit is contained in:
Michal Kucharczyk
committed by
GitHub
GitHub
parent
1e878780a5
commit
f6548aee31
Generated
-1
@@ -17687,7 +17687,6 @@ dependencies = [
|
||||
name = "sp-keyring"
|
||||
version = "24.0.0"
|
||||
dependencies = [
|
||||
"lazy_static",
|
||||
"sp-core",
|
||||
"sp-runtime",
|
||||
"strum",
|
||||
|
||||
@@ -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");
|
||||
}
|
||||
}
|
||||
@@ -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;
|
||||
|
||||
@@ -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" }
|
||||
|
||||
@@ -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) }));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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) }));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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) }));
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user