sp_keystore/
testing.rs

1// This file is part of Substrate.
2
3// Copyright (C) Parity Technologies (UK) Ltd.
4// SPDX-License-Identifier: Apache-2.0
5
6// Licensed under the Apache License, Version 2.0 (the "License");
7// you may not use this file except in compliance with the License.
8// You may obtain a copy of the License at
9//
10// 	http://www.apache.org/licenses/LICENSE-2.0
11//
12// Unless required by applicable law or agreed to in writing, software
13// distributed under the License is distributed on an "AS IS" BASIS,
14// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15// See the License for the specific language governing permissions and
16// limitations under the License.
17
18//! Types that should only be used for testing!
19
20use crate::{Error, Keystore, KeystorePtr};
21
22#[cfg(feature = "bandersnatch-experimental")]
23use sp_core::bandersnatch;
24#[cfg(feature = "bls-experimental")]
25use sp_core::{
26	bls381, ecdsa_bls381, proof_of_possession::ProofOfPossessionGenerator, KeccakHasher,
27};
28use sp_core::{
29	crypto::{ByteArray, KeyTypeId, Pair, VrfSecret},
30	ecdsa, ed25519, sr25519,
31};
32
33use parking_lot::RwLock;
34use std::{collections::HashMap, sync::Arc};
35
36/// A keystore implementation usable in tests.
37#[derive(Default, Clone)]
38pub struct MemoryKeystore {
39	/// `KeyTypeId` maps to public keys and public keys map to private keys.
40	keys: Arc<RwLock<HashMap<KeyTypeId, HashMap<Vec<u8>, String>>>>,
41}
42
43impl MemoryKeystore {
44	/// Creates a new instance of `Self`.
45	pub fn new() -> Self {
46		Self::default()
47	}
48
49	/// The pair stored under `public`, if its secret URI parses and derives `public`.
50	///
51	/// `insert` stores whatever it is given, so like `LocalKeystore` this checks the URI on lookup.
52	fn pair<T: Pair>(&self, key_type: KeyTypeId, public: &T::Public) -> Option<T> {
53		self.keys.read().get(&key_type).and_then(|inner| {
54			let pair = T::from_string(inner.get(public.as_slice())?, None).ok()?;
55			(pair.public().as_slice() == public.as_slice()).then_some(pair)
56		})
57	}
58
59	fn public_keys<T: Pair>(&self, key_type: KeyTypeId) -> Vec<T::Public> {
60		self.keys
61			.read()
62			.get(&key_type)
63			.map(|keys| {
64				keys.iter()
65					.filter_map(|(raw_pubkey, s)| {
66						let pair = T::from_string(s, None).ok()?;
67						let pubkey = pair.public();
68						(pubkey.as_slice() == raw_pubkey).then_some(pubkey)
69					})
70					.collect()
71			})
72			.unwrap_or_default()
73	}
74
75	fn generate_new<T: Pair>(
76		&self,
77		key_type: KeyTypeId,
78		seed: Option<&str>,
79	) -> Result<T::Public, Error> {
80		match seed {
81			Some(seed) => {
82				let pair = T::from_string(seed, None)
83					.map_err(|_| Error::ValidationError("Generates a pair.".to_owned()))?;
84				self.keys
85					.write()
86					.entry(key_type)
87					.or_default()
88					.insert(pair.public().to_raw_vec(), seed.into());
89				Ok(pair.public())
90			},
91			None => {
92				let (pair, phrase, _) = T::generate_with_phrase(None);
93				self.keys
94					.write()
95					.entry(key_type)
96					.or_default()
97					.insert(pair.public().to_raw_vec(), phrase);
98				Ok(pair.public())
99			},
100		}
101	}
102
103	fn sign<T: Pair>(
104		&self,
105		key_type: KeyTypeId,
106		public: &T::Public,
107		msg: &[u8],
108	) -> Result<Option<T::Signature>, Error> {
109		let sig = self.pair::<T>(key_type, public).map(|pair| pair.sign(msg));
110		Ok(sig)
111	}
112
113	fn vrf_sign<T: Pair + VrfSecret>(
114		&self,
115		key_type: KeyTypeId,
116		public: &T::Public,
117		data: &T::VrfSignData,
118	) -> Result<Option<T::VrfSignature>, Error> {
119		let sig = self.pair::<T>(key_type, public).map(|pair| pair.vrf_sign(data));
120		Ok(sig)
121	}
122
123	fn vrf_pre_output<T: Pair + VrfSecret>(
124		&self,
125		key_type: KeyTypeId,
126		public: &T::Public,
127		input: &T::VrfInput,
128	) -> Result<Option<T::VrfPreOutput>, Error> {
129		let pre_output = self.pair::<T>(key_type, public).map(|pair| pair.vrf_pre_output(input));
130		Ok(pre_output)
131	}
132
133	#[cfg(feature = "bls-experimental")]
134	fn generate_proof_of_possession<T: Pair + ProofOfPossessionGenerator>(
135		&self,
136		key_type: KeyTypeId,
137		public: &T::Public,
138		owner: &[u8],
139	) -> Result<Option<T::ProofOfPossession>, Error> {
140		let proof_of_possession = self
141			.pair::<T>(key_type, public)
142			.map(|mut pair| pair.generate_proof_of_possession(owner));
143		Ok(proof_of_possession)
144	}
145}
146
147impl Keystore for MemoryKeystore {
148	fn sr25519_public_keys(&self, key_type: KeyTypeId) -> Vec<sr25519::Public> {
149		self.public_keys::<sr25519::Pair>(key_type)
150	}
151
152	fn sr25519_generate_new(
153		&self,
154		key_type: KeyTypeId,
155		seed: Option<&str>,
156	) -> Result<sr25519::Public, Error> {
157		self.generate_new::<sr25519::Pair>(key_type, seed)
158	}
159
160	fn sr25519_sign(
161		&self,
162		key_type: KeyTypeId,
163		public: &sr25519::Public,
164		msg: &[u8],
165	) -> Result<Option<sr25519::Signature>, Error> {
166		self.sign::<sr25519::Pair>(key_type, public, msg)
167	}
168
169	fn sr25519_vrf_sign(
170		&self,
171		key_type: KeyTypeId,
172		public: &sr25519::Public,
173		data: &sr25519::vrf::VrfSignData,
174	) -> Result<Option<sr25519::vrf::VrfSignature>, Error> {
175		self.vrf_sign::<sr25519::Pair>(key_type, public, data)
176	}
177
178	fn sr25519_vrf_pre_output(
179		&self,
180		key_type: KeyTypeId,
181		public: &sr25519::Public,
182		input: &sr25519::vrf::VrfInput,
183	) -> Result<Option<sr25519::vrf::VrfPreOutput>, Error> {
184		self.vrf_pre_output::<sr25519::Pair>(key_type, public, input)
185	}
186
187	fn ed25519_public_keys(&self, key_type: KeyTypeId) -> Vec<ed25519::Public> {
188		self.public_keys::<ed25519::Pair>(key_type)
189	}
190
191	fn ed25519_generate_new(
192		&self,
193		key_type: KeyTypeId,
194		seed: Option<&str>,
195	) -> Result<ed25519::Public, Error> {
196		self.generate_new::<ed25519::Pair>(key_type, seed)
197	}
198
199	fn ed25519_sign(
200		&self,
201		key_type: KeyTypeId,
202		public: &ed25519::Public,
203		msg: &[u8],
204	) -> Result<Option<ed25519::Signature>, Error> {
205		self.sign::<ed25519::Pair>(key_type, public, msg)
206	}
207
208	fn ecdsa_public_keys(&self, key_type: KeyTypeId) -> Vec<ecdsa::Public> {
209		self.public_keys::<ecdsa::Pair>(key_type)
210	}
211
212	fn ecdsa_generate_new(
213		&self,
214		key_type: KeyTypeId,
215		seed: Option<&str>,
216	) -> Result<ecdsa::Public, Error> {
217		self.generate_new::<ecdsa::Pair>(key_type, seed)
218	}
219
220	fn ecdsa_sign(
221		&self,
222		key_type: KeyTypeId,
223		public: &ecdsa::Public,
224		msg: &[u8],
225	) -> Result<Option<ecdsa::Signature>, Error> {
226		self.sign::<ecdsa::Pair>(key_type, public, msg)
227	}
228
229	fn ecdsa_sign_prehashed(
230		&self,
231		key_type: KeyTypeId,
232		public: &ecdsa::Public,
233		msg: &[u8; 32],
234	) -> Result<Option<ecdsa::Signature>, Error> {
235		let sig = self.pair::<ecdsa::Pair>(key_type, public).map(|pair| pair.sign_prehashed(msg));
236		Ok(sig)
237	}
238
239	#[cfg(feature = "bandersnatch-experimental")]
240	fn bandersnatch_public_keys(&self, key_type: KeyTypeId) -> Vec<bandersnatch::Public> {
241		self.public_keys::<bandersnatch::Pair>(key_type)
242	}
243
244	#[cfg(feature = "bandersnatch-experimental")]
245	fn bandersnatch_generate_new(
246		&self,
247		key_type: KeyTypeId,
248		seed: Option<&str>,
249	) -> Result<bandersnatch::Public, Error> {
250		self.generate_new::<bandersnatch::Pair>(key_type, seed)
251	}
252
253	#[cfg(feature = "bandersnatch-experimental")]
254	fn bandersnatch_sign(
255		&self,
256		key_type: KeyTypeId,
257		public: &bandersnatch::Public,
258		msg: &[u8],
259	) -> Result<Option<bandersnatch::Signature>, Error> {
260		self.sign::<bandersnatch::Pair>(key_type, public, msg)
261	}
262
263	#[cfg(feature = "bandersnatch-experimental")]
264	fn bandersnatch_vrf_sign(
265		&self,
266		key_type: KeyTypeId,
267		public: &bandersnatch::Public,
268		data: &bandersnatch::vrf::VrfSignData,
269	) -> Result<Option<bandersnatch::vrf::VrfSignature>, Error> {
270		self.vrf_sign::<bandersnatch::Pair>(key_type, public, data)
271	}
272
273	#[cfg(feature = "bandersnatch-experimental")]
274	fn bandersnatch_ring_vrf_sign(
275		&self,
276		key_type: KeyTypeId,
277		public: &bandersnatch::Public,
278		data: &bandersnatch::vrf::VrfSignData,
279		prover: &bandersnatch::ring_vrf::RingProver,
280	) -> Result<Option<bandersnatch::ring_vrf::RingVrfSignature>, Error> {
281		let sig = self
282			.pair::<bandersnatch::Pair>(key_type, public)
283			.map(|pair| pair.ring_vrf_sign(data, prover));
284		Ok(sig)
285	}
286
287	#[cfg(feature = "bandersnatch-experimental")]
288	fn bandersnatch_vrf_pre_output(
289		&self,
290		key_type: KeyTypeId,
291		public: &bandersnatch::Public,
292		input: &bandersnatch::vrf::VrfInput,
293	) -> Result<Option<bandersnatch::vrf::VrfPreOutput>, Error> {
294		self.vrf_pre_output::<bandersnatch::Pair>(key_type, public, input)
295	}
296
297	#[cfg(feature = "bls-experimental")]
298	fn bls381_public_keys(&self, key_type: KeyTypeId) -> Vec<bls381::Public> {
299		self.public_keys::<bls381::Pair>(key_type)
300	}
301
302	#[cfg(feature = "bls-experimental")]
303	fn bls381_generate_new(
304		&self,
305		key_type: KeyTypeId,
306		seed: Option<&str>,
307	) -> Result<bls381::Public, Error> {
308		self.generate_new::<bls381::Pair>(key_type, seed)
309	}
310
311	#[cfg(feature = "bls-experimental")]
312	fn bls381_sign(
313		&self,
314		key_type: KeyTypeId,
315		public: &bls381::Public,
316		msg: &[u8],
317	) -> Result<Option<bls381::Signature>, Error> {
318		self.sign::<bls381::Pair>(key_type, public, msg)
319	}
320
321	#[cfg(feature = "bls-experimental")]
322	fn bls381_generate_proof_of_possession(
323		&self,
324		key_type: KeyTypeId,
325		public: &bls381::Public,
326		owner: &[u8],
327	) -> Result<Option<bls381::ProofOfPossession>, Error> {
328		self.generate_proof_of_possession::<bls381::Pair>(key_type, public, owner)
329	}
330
331	#[cfg(feature = "bls-experimental")]
332	fn ecdsa_bls381_public_keys(&self, key_type: KeyTypeId) -> Vec<ecdsa_bls381::Public> {
333		self.public_keys::<ecdsa_bls381::Pair>(key_type)
334	}
335
336	#[cfg(feature = "bls-experimental")]
337	fn ecdsa_bls381_generate_new(
338		&self,
339		key_type: KeyTypeId,
340		seed: Option<&str>,
341	) -> Result<ecdsa_bls381::Public, Error> {
342		let pubkey = self.generate_new::<ecdsa_bls381::Pair>(key_type, seed)?;
343
344		let s: String = self
345			.keys
346			.read()
347			.get(&key_type)
348			.and_then(|inner| inner.get(pubkey.as_slice()).map(|s| s.to_string()))
349			.expect("Can Retrieve Seed");
350
351		// This is done to give the keystore access to individual keys, this is necessary to avoid
352		// redundant host functions for paired keys and re-use host functions implemented for each
353		// element of the pair.
354		self.generate_new::<ecdsa::Pair>(key_type, Some(&s))
355			.expect("seed slice is valid");
356		self.generate_new::<bls381::Pair>(key_type, Some(&s))
357			.expect("seed slice is valid");
358
359		Ok(pubkey)
360	}
361
362	#[cfg(feature = "bls-experimental")]
363	fn ecdsa_bls381_sign(
364		&self,
365		key_type: KeyTypeId,
366		public: &ecdsa_bls381::Public,
367		msg: &[u8],
368	) -> Result<Option<ecdsa_bls381::Signature>, Error> {
369		self.sign::<ecdsa_bls381::Pair>(key_type, public, msg)
370	}
371
372	#[cfg(feature = "bls-experimental")]
373	fn ecdsa_bls381_sign_with_keccak256(
374		&self,
375		key_type: KeyTypeId,
376		public: &ecdsa_bls381::Public,
377		msg: &[u8],
378	) -> Result<Option<ecdsa_bls381::Signature>, Error> {
379		let sig = self
380			.pair::<ecdsa_bls381::Pair>(key_type, public)
381			.map(|pair| pair.sign_with_hasher::<KeccakHasher>(msg));
382		Ok(sig)
383	}
384
385	fn insert(&self, key_type: KeyTypeId, suri: &str, public: &[u8]) -> Result<(), ()> {
386		self.keys
387			.write()
388			.entry(key_type)
389			.or_default()
390			.insert(public.to_owned(), suri.to_string());
391		Ok(())
392	}
393
394	fn keys(&self, key_type: KeyTypeId) -> Result<Vec<Vec<u8>>, Error> {
395		let keys = self
396			.keys
397			.read()
398			.get(&key_type)
399			.map(|map| map.keys().cloned().collect())
400			.unwrap_or_default();
401		Ok(keys)
402	}
403
404	fn has_keys(&self, public_keys: &[(Vec<u8>, KeyTypeId)]) -> bool {
405		public_keys
406			.iter()
407			.all(|(k, t)| self.keys.read().get(t).and_then(|s| s.get(k)).is_some())
408	}
409}
410
411impl Into<KeystorePtr> for MemoryKeystore {
412	fn into(self) -> KeystorePtr {
413		Arc::new(self)
414	}
415}
416
417#[cfg(test)]
418mod tests {
419	use super::*;
420	use sp_core::{
421		sr25519,
422		testing::{ECDSA, ED25519, SR25519},
423	};
424
425	#[test]
426	fn store_key_and_extract() {
427		let store = MemoryKeystore::new();
428
429		let public = store.ed25519_generate_new(ED25519, None).expect("Generates key");
430
431		let public_keys = store.ed25519_public_keys(ED25519);
432
433		assert!(public_keys.contains(&public.into()));
434	}
435
436	#[test]
437	fn store_unknown_and_extract_it() {
438		let store = MemoryKeystore::new();
439
440		let secret_uri = "//Alice";
441		let key_pair = sr25519::Pair::from_string(secret_uri, None).expect("Generates key pair");
442
443		store
444			.insert(SR25519, secret_uri, key_pair.public().as_ref())
445			.expect("Inserts unknown key");
446
447		let public_keys = store.sr25519_public_keys(SR25519);
448
449		assert!(public_keys.contains(&key_pair.public().into()));
450	}
451
452	#[test]
453	fn mismatched_secret_uri_signs_nothing() {
454		let store = MemoryKeystore::new();
455		let alice = sr25519::Pair::from_string("//Alice", None).unwrap();
456		let bob = sr25519::Pair::from_string("//Bob", None).unwrap();
457
458		// Alice's public key stored with Bob's secret URI.
459		store.insert(SR25519, "//Bob", alice.public().as_ref()).unwrap();
460
461		assert_eq!(store.sr25519_sign(SR25519, &alice.public(), b"msg").unwrap(), None);
462		assert_eq!(
463			store
464				.sign_with(SR25519, sr25519::CRYPTO_ID, alice.public().as_slice(), b"msg")
465				.unwrap(),
466			None
467		);
468		let data = sr25519::vrf::VrfInput::new(b"Test", &[(b"one", &1_u64.to_le_bytes())])
469			.into_sign_data();
470		assert!(store.sr25519_vrf_sign(SR25519, &alice.public(), &data).unwrap().is_none());
471		let input = sr25519::vrf::VrfInput::new(b"Test", &[(b"one", &1_u64.to_le_bytes())]);
472		assert!(store
473			.sr25519_vrf_pre_output(SR25519, &alice.public(), &input)
474			.unwrap()
475			.is_none());
476		assert!(store.sr25519_public_keys(SR25519).is_empty());
477		// Bob's key was never stored under his own public key.
478		assert_eq!(store.sr25519_sign(SR25519, &bob.public(), b"msg").unwrap(), None);
479
480		// Stored under the right public key, the same URI signs as before.
481		store.insert(SR25519, "//Bob", bob.public().as_ref()).unwrap();
482		let sig = store.sr25519_sign(SR25519, &bob.public(), b"msg").unwrap().unwrap();
483		assert!(sr25519::Pair::verify(&sig, b"msg", &bob.public()));
484		assert_eq!(store.sr25519_public_keys(SR25519), vec![bob.public()]);
485	}
486
487	#[test]
488	fn unparseable_secret_uri_does_not_panic() {
489		let store = MemoryKeystore::new();
490		let sr = sr25519::Pair::from_string("//Alice", None).unwrap();
491		let ed = ed25519::Pair::from_string("//Alice", None).unwrap();
492		let ec = ecdsa::Pair::from_string("//Alice", None).unwrap();
493		let bad = "not a valid secret uri";
494		assert!(sr25519::Pair::from_string(bad, None).is_err());
495
496		store.insert(SR25519, bad, sr.public().as_ref()).unwrap();
497		store.insert(ED25519, bad, ed.public().as_ref()).unwrap();
498		store.insert(ECDSA, bad, ec.public().as_ref()).unwrap();
499
500		assert_eq!(store.sr25519_sign(SR25519, &sr.public(), b"msg").unwrap(), None);
501		let data = sr25519::vrf::VrfInput::new(b"Test", &[(b"one", &1_u64.to_le_bytes())])
502			.into_sign_data();
503		assert!(store.sr25519_vrf_sign(SR25519, &sr.public(), &data).unwrap().is_none());
504		let input = sr25519::vrf::VrfInput::new(b"Test", &[(b"one", &1_u64.to_le_bytes())]);
505		assert!(store.sr25519_vrf_pre_output(SR25519, &sr.public(), &input).unwrap().is_none());
506		assert_eq!(store.ed25519_sign(ED25519, &ed.public(), b"msg").unwrap(), None);
507		assert_eq!(store.ecdsa_sign(ECDSA, &ec.public(), b"msg").unwrap(), None);
508		assert_eq!(store.ecdsa_sign_prehashed(ECDSA, &ec.public(), &[0u8; 32]).unwrap(), None);
509		assert_eq!(
510			store
511				.sign_with(ED25519, ed25519::CRYPTO_ID, ed.public().as_slice(), b"msg")
512				.unwrap(),
513			None
514		);
515
516		assert!(store.sr25519_public_keys(SR25519).is_empty());
517		assert!(store.ed25519_public_keys(ED25519).is_empty());
518		assert!(store.ecdsa_public_keys(ECDSA).is_empty());
519	}
520
521	#[test]
522	fn sr25519_vrf_sign() {
523		let store = MemoryKeystore::new();
524
525		let secret_uri = "//Alice";
526		let key_pair = sr25519::Pair::from_string(secret_uri, None).expect("Generates key pair");
527
528		let data = sr25519::vrf::VrfInput::new(
529			b"Test",
530			&[
531				(b"one", &1_u64.to_le_bytes()),
532				(b"two", &2_u64.to_le_bytes()),
533				(b"three", "test".as_bytes()),
534			],
535		)
536		.into_sign_data();
537
538		let result = store.sr25519_vrf_sign(SR25519, &key_pair.public(), &data);
539		assert!(result.unwrap().is_none());
540
541		store
542			.insert(SR25519, secret_uri, key_pair.public().as_ref())
543			.expect("Inserts unknown key");
544
545		let result = store.sr25519_vrf_sign(SR25519, &key_pair.public(), &data);
546
547		assert!(result.unwrap().is_some());
548	}
549
550	#[test]
551	fn sr25519_vrf_pre_output() {
552		let store = MemoryKeystore::new();
553
554		let secret_uri = "//Alice";
555		let pair = sr25519::Pair::from_string(secret_uri, None).expect("Generates key pair");
556
557		let input = sr25519::vrf::VrfInput::new(
558			b"Test",
559			&[
560				(b"one", &1_u64.to_le_bytes()),
561				(b"two", &2_u64.to_le_bytes()),
562				(b"three", "test".as_bytes()),
563			],
564		);
565
566		let result = store.sr25519_vrf_pre_output(SR25519, &pair.public(), &input);
567		assert!(result.unwrap().is_none());
568
569		store
570			.insert(SR25519, secret_uri, pair.public().as_ref())
571			.expect("Inserts unknown key");
572
573		let pre_output =
574			store.sr25519_vrf_pre_output(SR25519, &pair.public(), &input).unwrap().unwrap();
575
576		let result = pre_output.make_bytes::<32>(b"rand", &input, &pair.public());
577		assert!(result.is_ok());
578	}
579
580	#[test]
581	fn ecdsa_sign_prehashed_works() {
582		let store = MemoryKeystore::new();
583
584		let suri = "//Alice";
585		let pair = ecdsa::Pair::from_string(suri, None).unwrap();
586
587		// Let's pretend this to be the hash output as content doesn't really matter here.
588		let hash = [0xff; 32];
589
590		// no key in key store
591		let res = store.ecdsa_sign_prehashed(ECDSA, &pair.public(), &hash).unwrap();
592		assert!(res.is_none());
593
594		// insert key, sign again
595		store.insert(ECDSA, suri, pair.public().as_ref()).unwrap();
596
597		let res = store.ecdsa_sign_prehashed(ECDSA, &pair.public(), &hash).unwrap();
598		assert!(res.is_some());
599	}
600
601	#[test]
602	#[cfg(feature = "bls-experimental")]
603	fn ecdsa_bls381_sign_with_keccak_works() {
604		use sp_core::testing::ECDSA_BLS377;
605
606		let store = MemoryKeystore::new();
607
608		let suri = "//Alice";
609		let pair = ecdsa_bls381::Pair::from_string(suri, None).unwrap();
610
611		let msg = b"this should be a normal unhashed message not a hash of a message because bls scheme comes with its own hashing";
612
613		// insert key, sign again
614		store.insert(ECDSA_BLS377, suri, pair.public().as_ref()).unwrap();
615
616		let res = store
617			.ecdsa_bls381_sign_with_keccak256(ECDSA_BLS377, &pair.public(), &msg[..])
618			.unwrap();
619
620		assert!(res.is_some());
621
622		// does not verify with default out-of-the-box verification
623		assert!(!ecdsa_bls381::Pair::verify(&res.unwrap(), &msg[..], &pair.public()));
624
625		// should verify using keccak256 as hasher
626		assert!(ecdsa_bls381::Pair::verify_with_hasher::<KeccakHasher>(
627			&res.unwrap(),
628			msg,
629			&pair.public()
630		));
631	}
632
633	#[test]
634	#[cfg(feature = "bls-experimental")]
635	fn ecdsa_bls381_generate_with_none_works() {
636		use sp_core::testing::ECDSA_BLS381;
637
638		let store = MemoryKeystore::new();
639		let ecdsa_bls381_key =
640			store.ecdsa_bls381_generate_new(ECDSA_BLS381, None).expect("Can generate key..");
641
642		let ecdsa_keys = store.ecdsa_public_keys(ECDSA_BLS381);
643		let bls381_keys = store.bls381_public_keys(ECDSA_BLS381);
644		let ecdsa_bls381_keys = store.ecdsa_bls381_public_keys(ECDSA_BLS381);
645
646		assert_eq!(ecdsa_keys.len(), 1);
647		assert_eq!(bls381_keys.len(), 1);
648		assert_eq!(ecdsa_bls381_keys.len(), 1);
649
650		let ecdsa_key = ecdsa_keys[0];
651		let bls381_key = bls381_keys[0];
652
653		let mut combined_key_raw = [0u8; ecdsa_bls381::PUBLIC_KEY_LEN];
654		combined_key_raw[..ecdsa::PUBLIC_KEY_SERIALIZED_SIZE].copy_from_slice(ecdsa_key.as_ref());
655		combined_key_raw[ecdsa::PUBLIC_KEY_SERIALIZED_SIZE..].copy_from_slice(bls381_key.as_ref());
656		let combined_key = ecdsa_bls381::Public::from_raw(combined_key_raw);
657
658		assert_eq!(combined_key, ecdsa_bls381_key);
659	}
660
661	#[test]
662	#[cfg(feature = "bls-experimental")]
663	fn ecdsa_bls381_generate_with_seed_works() {
664		use sp_core::testing::ECDSA_BLS381;
665
666		let store = MemoryKeystore::new();
667		let ecdsa_bls381_key = store
668			.ecdsa_bls381_generate_new(ECDSA_BLS381, Some("//Alice"))
669			.expect("Can generate key..");
670
671		let ecdsa_keys = store.ecdsa_public_keys(ECDSA_BLS381);
672		let bls381_keys = store.bls381_public_keys(ECDSA_BLS381);
673		let ecdsa_bls381_keys = store.ecdsa_bls381_public_keys(ECDSA_BLS381);
674
675		assert_eq!(ecdsa_keys.len(), 1);
676		assert_eq!(bls381_keys.len(), 1);
677		assert_eq!(ecdsa_bls381_keys.len(), 1);
678
679		let ecdsa_key = ecdsa_keys[0];
680		let bls381_key = bls381_keys[0];
681
682		let mut combined_key_raw = [0u8; ecdsa_bls381::PUBLIC_KEY_LEN];
683		combined_key_raw[..ecdsa::PUBLIC_KEY_SERIALIZED_SIZE].copy_from_slice(ecdsa_key.as_ref());
684		combined_key_raw[ecdsa::PUBLIC_KEY_SERIALIZED_SIZE..].copy_from_slice(bls381_key.as_ref());
685		let combined_key = ecdsa_bls381::Public::from_raw(combined_key_raw);
686
687		assert_eq!(combined_key, ecdsa_bls381_key);
688	}
689
690	#[test]
691	#[cfg(feature = "bandersnatch-experimental")]
692	fn bandersnatch_vrf_sign() {
693		use sp_core::testing::BANDERSNATCH;
694
695		let store = MemoryKeystore::new();
696
697		let secret_uri = "//Alice";
698		let key_pair =
699			bandersnatch::Pair::from_string(secret_uri, None).expect("Generates key pair");
700		let sign_data = bandersnatch::vrf::VrfSignData::new(b"vrf_input", b"aux_data");
701
702		let result = store.bandersnatch_vrf_sign(BANDERSNATCH, &key_pair.public(), &sign_data);
703		assert!(result.unwrap().is_none());
704
705		store
706			.insert(BANDERSNATCH, secret_uri, key_pair.public().as_ref())
707			.expect("Inserts unknown key");
708
709		let result = store.bandersnatch_vrf_sign(BANDERSNATCH, &key_pair.public(), &sign_data);
710
711		assert!(result.unwrap().is_some());
712	}
713
714	#[test]
715	#[cfg(feature = "bandersnatch-experimental")]
716	fn bandersnatch_ring_vrf_sign() {
717		use sp_core::testing::BANDERSNATCH;
718
719		let store = MemoryKeystore::new();
720
721		let ring_ctx = bandersnatch::ring_vrf::RingContext::<1024>::new_testing();
722
723		let mut pks: Vec<_> = (0..16)
724			.map(|i| bandersnatch::Pair::from_seed(&[i as u8; 32]).public())
725			.collect();
726
727		let prover_idx = 3;
728		let prover = ring_ctx.prover(&pks, prover_idx);
729
730		let secret_uri = "//Alice";
731		let pair = bandersnatch::Pair::from_string(secret_uri, None).expect("Generates key pair");
732		pks[prover_idx] = pair.public();
733
734		let sign_data = bandersnatch::vrf::VrfSignData::new(b"vrf_input", b"aux_data");
735
736		let result =
737			store.bandersnatch_ring_vrf_sign(BANDERSNATCH, &pair.public(), &sign_data, &prover);
738		assert!(result.unwrap().is_none());
739
740		store
741			.insert(BANDERSNATCH, secret_uri, pair.public().as_ref())
742			.expect("Inserts unknown key");
743
744		let result =
745			store.bandersnatch_ring_vrf_sign(BANDERSNATCH, &pair.public(), &sign_data, &prover);
746
747		assert!(result.unwrap().is_some());
748	}
749}
sp_keystore/testing.rs

sp_keystore/
testing.rs
