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	fn pair<T: Pair>(&self, key_type: KeyTypeId, public: &T::Public) -> Option<T> {
50		self.keys.read().get(&key_type).and_then(|inner| {
51			inner
52				.get(public.as_slice())
53				.map(|s| T::from_string(s, None).expect("seed slice is valid"))
54		})
55	}
56
57	fn public_keys<T: Pair>(&self, key_type: KeyTypeId) -> Vec<T::Public> {
58		self.keys
59			.read()
60			.get(&key_type)
61			.map(|keys| {
62				keys.iter()
63					.filter_map(|(raw_pubkey, s)| {
64						let pair = T::from_string(s, None).expect("seed slice is valid");
65						let pubkey = pair.public();
66						(pubkey.as_slice() == raw_pubkey).then_some(pubkey)
67					})
68					.collect()
69			})
70			.unwrap_or_default()
71	}
72
73	fn generate_new<T: Pair>(
74		&self,
75		key_type: KeyTypeId,
76		seed: Option<&str>,
77	) -> Result<T::Public, Error> {
78		match seed {
79			Some(seed) => {
80				let pair = T::from_string(seed, None)
81					.map_err(|_| Error::ValidationError("Generates a pair.".to_owned()))?;
82				self.keys
83					.write()
84					.entry(key_type)
85					.or_default()
86					.insert(pair.public().to_raw_vec(), seed.into());
87				Ok(pair.public())
88			},
89			None => {
90				let (pair, phrase, _) = T::generate_with_phrase(None);
91				self.keys
92					.write()
93					.entry(key_type)
94					.or_default()
95					.insert(pair.public().to_raw_vec(), phrase);
96				Ok(pair.public())
97			},
98		}
99	}
100
101	fn sign<T: Pair>(
102		&self,
103		key_type: KeyTypeId,
104		public: &T::Public,
105		msg: &[u8],
106	) -> Result<Option<T::Signature>, Error> {
107		let sig = self.pair::<T>(key_type, public).map(|pair| pair.sign(msg));
108		Ok(sig)
109	}
110
111	fn vrf_sign<T: Pair + VrfSecret>(
112		&self,
113		key_type: KeyTypeId,
114		public: &T::Public,
115		data: &T::VrfSignData,
116	) -> Result<Option<T::VrfSignature>, Error> {
117		let sig = self.pair::<T>(key_type, public).map(|pair| pair.vrf_sign(data));
118		Ok(sig)
119	}
120
121	fn vrf_pre_output<T: Pair + VrfSecret>(
122		&self,
123		key_type: KeyTypeId,
124		public: &T::Public,
125		input: &T::VrfInput,
126	) -> Result<Option<T::VrfPreOutput>, Error> {
127		let pre_output = self.pair::<T>(key_type, public).map(|pair| pair.vrf_pre_output(input));
128		Ok(pre_output)
129	}
130
131	#[cfg(feature = "bls-experimental")]
132	fn generate_proof_of_possession<T: Pair + ProofOfPossessionGenerator>(
133		&self,
134		key_type: KeyTypeId,
135		public: &T::Public,
136		owner: &[u8],
137	) -> Result<Option<T::ProofOfPossession>, Error> {
138		let proof_of_possession = self
139			.pair::<T>(key_type, public)
140			.map(|mut pair| pair.generate_proof_of_possession(owner));
141		Ok(proof_of_possession)
142	}
143}
144
145impl Keystore for MemoryKeystore {
146	fn sr25519_public_keys(&self, key_type: KeyTypeId) -> Vec<sr25519::Public> {
147		self.public_keys::<sr25519::Pair>(key_type)
148	}
149
150	fn sr25519_generate_new(
151		&self,
152		key_type: KeyTypeId,
153		seed: Option<&str>,
154	) -> Result<sr25519::Public, Error> {
155		self.generate_new::<sr25519::Pair>(key_type, seed)
156	}
157
158	fn sr25519_sign(
159		&self,
160		key_type: KeyTypeId,
161		public: &sr25519::Public,
162		msg: &[u8],
163	) -> Result<Option<sr25519::Signature>, Error> {
164		self.sign::<sr25519::Pair>(key_type, public, msg)
165	}
166
167	fn sr25519_vrf_sign(
168		&self,
169		key_type: KeyTypeId,
170		public: &sr25519::Public,
171		data: &sr25519::vrf::VrfSignData,
172	) -> Result<Option<sr25519::vrf::VrfSignature>, Error> {
173		self.vrf_sign::<sr25519::Pair>(key_type, public, data)
174	}
175
176	fn sr25519_vrf_pre_output(
177		&self,
178		key_type: KeyTypeId,
179		public: &sr25519::Public,
180		input: &sr25519::vrf::VrfInput,
181	) -> Result<Option<sr25519::vrf::VrfPreOutput>, Error> {
182		self.vrf_pre_output::<sr25519::Pair>(key_type, public, input)
183	}
184
185	fn ed25519_public_keys(&self, key_type: KeyTypeId) -> Vec<ed25519::Public> {
186		self.public_keys::<ed25519::Pair>(key_type)
187	}
188
189	fn ed25519_generate_new(
190		&self,
191		key_type: KeyTypeId,
192		seed: Option<&str>,
193	) -> Result<ed25519::Public, Error> {
194		self.generate_new::<ed25519::Pair>(key_type, seed)
195	}
196
197	fn ed25519_sign(
198		&self,
199		key_type: KeyTypeId,
200		public: &ed25519::Public,
201		msg: &[u8],
202	) -> Result<Option<ed25519::Signature>, Error> {
203		self.sign::<ed25519::Pair>(key_type, public, msg)
204	}
205
206	fn ecdsa_public_keys(&self, key_type: KeyTypeId) -> Vec<ecdsa::Public> {
207		self.public_keys::<ecdsa::Pair>(key_type)
208	}
209
210	fn ecdsa_generate_new(
211		&self,
212		key_type: KeyTypeId,
213		seed: Option<&str>,
214	) -> Result<ecdsa::Public, Error> {
215		self.generate_new::<ecdsa::Pair>(key_type, seed)
216	}
217
218	fn ecdsa_sign(
219		&self,
220		key_type: KeyTypeId,
221		public: &ecdsa::Public,
222		msg: &[u8],
223	) -> Result<Option<ecdsa::Signature>, Error> {
224		self.sign::<ecdsa::Pair>(key_type, public, msg)
225	}
226
227	fn ecdsa_sign_prehashed(
228		&self,
229		key_type: KeyTypeId,
230		public: &ecdsa::Public,
231		msg: &[u8; 32],
232	) -> Result<Option<ecdsa::Signature>, Error> {
233		let sig = self.pair::<ecdsa::Pair>(key_type, public).map(|pair| pair.sign_prehashed(msg));
234		Ok(sig)
235	}
236
237	#[cfg(feature = "bandersnatch-experimental")]
238	fn bandersnatch_public_keys(&self, key_type: KeyTypeId) -> Vec<bandersnatch::Public> {
239		self.public_keys::<bandersnatch::Pair>(key_type)
240	}
241
242	#[cfg(feature = "bandersnatch-experimental")]
243	fn bandersnatch_generate_new(
244		&self,
245		key_type: KeyTypeId,
246		seed: Option<&str>,
247	) -> Result<bandersnatch::Public, Error> {
248		self.generate_new::<bandersnatch::Pair>(key_type, seed)
249	}
250
251	#[cfg(feature = "bandersnatch-experimental")]
252	fn bandersnatch_sign(
253		&self,
254		key_type: KeyTypeId,
255		public: &bandersnatch::Public,
256		msg: &[u8],
257	) -> Result<Option<bandersnatch::Signature>, Error> {
258		self.sign::<bandersnatch::Pair>(key_type, public, msg)
259	}
260
261	#[cfg(feature = "bandersnatch-experimental")]
262	fn bandersnatch_vrf_sign(
263		&self,
264		key_type: KeyTypeId,
265		public: &bandersnatch::Public,
266		data: &bandersnatch::vrf::VrfSignData,
267	) -> Result<Option<bandersnatch::vrf::VrfSignature>, Error> {
268		self.vrf_sign::<bandersnatch::Pair>(key_type, public, data)
269	}
270
271	#[cfg(feature = "bandersnatch-experimental")]
272	fn bandersnatch_ring_vrf_sign(
273		&self,
274		key_type: KeyTypeId,
275		public: &bandersnatch::Public,
276		data: &bandersnatch::vrf::VrfSignData,
277		prover: &bandersnatch::ring_vrf::RingProver,
278	) -> Result<Option<bandersnatch::ring_vrf::RingVrfSignature>, Error> {
279		let sig = self
280			.pair::<bandersnatch::Pair>(key_type, public)
281			.map(|pair| pair.ring_vrf_sign(data, prover));
282		Ok(sig)
283	}
284
285	#[cfg(feature = "bandersnatch-experimental")]
286	fn bandersnatch_vrf_pre_output(
287		&self,
288		key_type: KeyTypeId,
289		public: &bandersnatch::Public,
290		input: &bandersnatch::vrf::VrfInput,
291	) -> Result<Option<bandersnatch::vrf::VrfPreOutput>, Error> {
292		self.vrf_pre_output::<bandersnatch::Pair>(key_type, public, input)
293	}
294
295	#[cfg(feature = "bls-experimental")]
296	fn bls381_public_keys(&self, key_type: KeyTypeId) -> Vec<bls381::Public> {
297		self.public_keys::<bls381::Pair>(key_type)
298	}
299
300	#[cfg(feature = "bls-experimental")]
301	fn bls381_generate_new(
302		&self,
303		key_type: KeyTypeId,
304		seed: Option<&str>,
305	) -> Result<bls381::Public, Error> {
306		self.generate_new::<bls381::Pair>(key_type, seed)
307	}
308
309	#[cfg(feature = "bls-experimental")]
310	fn bls381_sign(
311		&self,
312		key_type: KeyTypeId,
313		public: &bls381::Public,
314		msg: &[u8],
315	) -> Result<Option<bls381::Signature>, Error> {
316		self.sign::<bls381::Pair>(key_type, public, msg)
317	}
318
319	#[cfg(feature = "bls-experimental")]
320	fn bls381_generate_proof_of_possession(
321		&self,
322		key_type: KeyTypeId,
323		public: &bls381::Public,
324		owner: &[u8],
325	) -> Result<Option<bls381::ProofOfPossession>, Error> {
326		self.generate_proof_of_possession::<bls381::Pair>(key_type, public, owner)
327	}
328
329	#[cfg(feature = "bls-experimental")]
330	fn ecdsa_bls381_public_keys(&self, key_type: KeyTypeId) -> Vec<ecdsa_bls381::Public> {
331		self.public_keys::<ecdsa_bls381::Pair>(key_type)
332	}
333
334	#[cfg(feature = "bls-experimental")]
335	fn ecdsa_bls381_generate_new(
336		&self,
337		key_type: KeyTypeId,
338		seed: Option<&str>,
339	) -> Result<ecdsa_bls381::Public, Error> {
340		let pubkey = self.generate_new::<ecdsa_bls381::Pair>(key_type, seed)?;
341
342		let s: String = self
343			.keys
344			.read()
345			.get(&key_type)
346			.and_then(|inner| inner.get(pubkey.as_slice()).map(|s| s.to_string()))
347			.expect("Can Retrieve Seed");
348
349		// This is done to give the keystore access to individual keys, this is necessary to avoid
350		// redundant host functions for paired keys and re-use host functions implemented for each
351		// element of the pair.
352		self.generate_new::<ecdsa::Pair>(key_type, Some(&s))
353			.expect("seed slice is valid");
354		self.generate_new::<bls381::Pair>(key_type, Some(&s))
355			.expect("seed slice is valid");
356
357		Ok(pubkey)
358	}
359
360	#[cfg(feature = "bls-experimental")]
361	fn ecdsa_bls381_sign(
362		&self,
363		key_type: KeyTypeId,
364		public: &ecdsa_bls381::Public,
365		msg: &[u8],
366	) -> Result<Option<ecdsa_bls381::Signature>, Error> {
367		self.sign::<ecdsa_bls381::Pair>(key_type, public, msg)
368	}
369
370	#[cfg(feature = "bls-experimental")]
371	fn ecdsa_bls381_sign_with_keccak256(
372		&self,
373		key_type: KeyTypeId,
374		public: &ecdsa_bls381::Public,
375		msg: &[u8],
376	) -> Result<Option<ecdsa_bls381::Signature>, Error> {
377		let sig = self
378			.pair::<ecdsa_bls381::Pair>(key_type, public)
379			.map(|pair| pair.sign_with_hasher::<KeccakHasher>(msg));
380		Ok(sig)
381	}
382
383	fn insert(&self, key_type: KeyTypeId, suri: &str, public: &[u8]) -> Result<(), ()> {
384		self.keys
385			.write()
386			.entry(key_type)
387			.or_default()
388			.insert(public.to_owned(), suri.to_string());
389		Ok(())
390	}
391
392	fn keys(&self, key_type: KeyTypeId) -> Result<Vec<Vec<u8>>, Error> {
393		let keys = self
394			.keys
395			.read()
396			.get(&key_type)
397			.map(|map| map.keys().cloned().collect())
398			.unwrap_or_default();
399		Ok(keys)
400	}
401
402	fn has_keys(&self, public_keys: &[(Vec<u8>, KeyTypeId)]) -> bool {
403		public_keys
404			.iter()
405			.all(|(k, t)| self.keys.read().get(t).and_then(|s| s.get(k)).is_some())
406	}
407}
408
409impl Into<KeystorePtr> for MemoryKeystore {
410	fn into(self) -> KeystorePtr {
411		Arc::new(self)
412	}
413}
414
415#[cfg(test)]
416mod tests {
417	use super::*;
418	use sp_core::{
419		sr25519,
420		testing::{ECDSA, ED25519, SR25519},
421	};
422
423	#[test]
424	fn store_key_and_extract() {
425		let store = MemoryKeystore::new();
426
427		let public = store.ed25519_generate_new(ED25519, None).expect("Generates key");
428
429		let public_keys = store.ed25519_public_keys(ED25519);
430
431		assert!(public_keys.contains(&public.into()));
432	}
433
434	#[test]
435	fn store_unknown_and_extract_it() {
436		let store = MemoryKeystore::new();
437
438		let secret_uri = "//Alice";
439		let key_pair = sr25519::Pair::from_string(secret_uri, None).expect("Generates key pair");
440
441		store
442			.insert(SR25519, secret_uri, key_pair.public().as_ref())
443			.expect("Inserts unknown key");
444
445		let public_keys = store.sr25519_public_keys(SR25519);
446
447		assert!(public_keys.contains(&key_pair.public().into()));
448	}
449
450	#[test]
451	fn sr25519_vrf_sign() {
452		let store = MemoryKeystore::new();
453
454		let secret_uri = "//Alice";
455		let key_pair = sr25519::Pair::from_string(secret_uri, None).expect("Generates key pair");
456
457		let data = sr25519::vrf::VrfInput::new(
458			b"Test",
459			&[
460				(b"one", &1_u64.to_le_bytes()),
461				(b"two", &2_u64.to_le_bytes()),
462				(b"three", "test".as_bytes()),
463			],
464		)
465		.into_sign_data();
466
467		let result = store.sr25519_vrf_sign(SR25519, &key_pair.public(), &data);
468		assert!(result.unwrap().is_none());
469
470		store
471			.insert(SR25519, secret_uri, key_pair.public().as_ref())
472			.expect("Inserts unknown key");
473
474		let result = store.sr25519_vrf_sign(SR25519, &key_pair.public(), &data);
475
476		assert!(result.unwrap().is_some());
477	}
478
479	#[test]
480	fn sr25519_vrf_pre_output() {
481		let store = MemoryKeystore::new();
482
483		let secret_uri = "//Alice";
484		let pair = sr25519::Pair::from_string(secret_uri, None).expect("Generates key pair");
485
486		let input = sr25519::vrf::VrfInput::new(
487			b"Test",
488			&[
489				(b"one", &1_u64.to_le_bytes()),
490				(b"two", &2_u64.to_le_bytes()),
491				(b"three", "test".as_bytes()),
492			],
493		);
494
495		let result = store.sr25519_vrf_pre_output(SR25519, &pair.public(), &input);
496		assert!(result.unwrap().is_none());
497
498		store
499			.insert(SR25519, secret_uri, pair.public().as_ref())
500			.expect("Inserts unknown key");
501
502		let pre_output =
503			store.sr25519_vrf_pre_output(SR25519, &pair.public(), &input).unwrap().unwrap();
504
505		let result = pre_output.make_bytes::<32>(b"rand", &input, &pair.public());
506		assert!(result.is_ok());
507	}
508
509	#[test]
510	fn ecdsa_sign_prehashed_works() {
511		let store = MemoryKeystore::new();
512
513		let suri = "//Alice";
514		let pair = ecdsa::Pair::from_string(suri, None).unwrap();
515
516		// Let's pretend this to be the hash output as content doesn't really matter here.
517		let hash = [0xff; 32];
518
519		// no key in key store
520		let res = store.ecdsa_sign_prehashed(ECDSA, &pair.public(), &hash).unwrap();
521		assert!(res.is_none());
522
523		// insert key, sign again
524		store.insert(ECDSA, suri, pair.public().as_ref()).unwrap();
525
526		let res = store.ecdsa_sign_prehashed(ECDSA, &pair.public(), &hash).unwrap();
527		assert!(res.is_some());
528	}
529
530	#[test]
531	#[cfg(feature = "bls-experimental")]
532	fn ecdsa_bls381_sign_with_keccak_works() {
533		use sp_core::testing::ECDSA_BLS377;
534
535		let store = MemoryKeystore::new();
536
537		let suri = "//Alice";
538		let pair = ecdsa_bls381::Pair::from_string(suri, None).unwrap();
539
540		let msg = b"this should be a normal unhashed message not a hash of a message because bls scheme comes with its own hashing";
541
542		// insert key, sign again
543		store.insert(ECDSA_BLS377, suri, pair.public().as_ref()).unwrap();
544
545		let res = store
546			.ecdsa_bls381_sign_with_keccak256(ECDSA_BLS377, &pair.public(), &msg[..])
547			.unwrap();
548
549		assert!(res.is_some());
550
551		// does not verify with default out-of-the-box verification
552		assert!(!ecdsa_bls381::Pair::verify(&res.unwrap(), &msg[..], &pair.public()));
553
554		// should verify using keccak256 as hasher
555		assert!(ecdsa_bls381::Pair::verify_with_hasher::<KeccakHasher>(
556			&res.unwrap(),
557			msg,
558			&pair.public()
559		));
560	}
561
562	#[test]
563	#[cfg(feature = "bls-experimental")]
564	fn ecdsa_bls381_generate_with_none_works() {
565		use sp_core::testing::ECDSA_BLS381;
566
567		let store = MemoryKeystore::new();
568		let ecdsa_bls381_key =
569			store.ecdsa_bls381_generate_new(ECDSA_BLS381, None).expect("Can generate key..");
570
571		let ecdsa_keys = store.ecdsa_public_keys(ECDSA_BLS381);
572		let bls381_keys = store.bls381_public_keys(ECDSA_BLS381);
573		let ecdsa_bls381_keys = store.ecdsa_bls381_public_keys(ECDSA_BLS381);
574
575		assert_eq!(ecdsa_keys.len(), 1);
576		assert_eq!(bls381_keys.len(), 1);
577		assert_eq!(ecdsa_bls381_keys.len(), 1);
578
579		let ecdsa_key = ecdsa_keys[0];
580		let bls381_key = bls381_keys[0];
581
582		let mut combined_key_raw = [0u8; ecdsa_bls381::PUBLIC_KEY_LEN];
583		combined_key_raw[..ecdsa::PUBLIC_KEY_SERIALIZED_SIZE].copy_from_slice(ecdsa_key.as_ref());
584		combined_key_raw[ecdsa::PUBLIC_KEY_SERIALIZED_SIZE..].copy_from_slice(bls381_key.as_ref());
585		let combined_key = ecdsa_bls381::Public::from_raw(combined_key_raw);
586
587		assert_eq!(combined_key, ecdsa_bls381_key);
588	}
589
590	#[test]
591	#[cfg(feature = "bls-experimental")]
592	fn ecdsa_bls381_generate_with_seed_works() {
593		use sp_core::testing::ECDSA_BLS381;
594
595		let store = MemoryKeystore::new();
596		let ecdsa_bls381_key = store
597			.ecdsa_bls381_generate_new(ECDSA_BLS381, Some("//Alice"))
598			.expect("Can generate key..");
599
600		let ecdsa_keys = store.ecdsa_public_keys(ECDSA_BLS381);
601		let bls381_keys = store.bls381_public_keys(ECDSA_BLS381);
602		let ecdsa_bls381_keys = store.ecdsa_bls381_public_keys(ECDSA_BLS381);
603
604		assert_eq!(ecdsa_keys.len(), 1);
605		assert_eq!(bls381_keys.len(), 1);
606		assert_eq!(ecdsa_bls381_keys.len(), 1);
607
608		let ecdsa_key = ecdsa_keys[0];
609		let bls381_key = bls381_keys[0];
610
611		let mut combined_key_raw = [0u8; ecdsa_bls381::PUBLIC_KEY_LEN];
612		combined_key_raw[..ecdsa::PUBLIC_KEY_SERIALIZED_SIZE].copy_from_slice(ecdsa_key.as_ref());
613		combined_key_raw[ecdsa::PUBLIC_KEY_SERIALIZED_SIZE..].copy_from_slice(bls381_key.as_ref());
614		let combined_key = ecdsa_bls381::Public::from_raw(combined_key_raw);
615
616		assert_eq!(combined_key, ecdsa_bls381_key);
617	}
618
619	#[test]
620	#[cfg(feature = "bandersnatch-experimental")]
621	fn bandersnatch_vrf_sign() {
622		use sp_core::testing::BANDERSNATCH;
623
624		let store = MemoryKeystore::new();
625
626		let secret_uri = "//Alice";
627		let key_pair =
628			bandersnatch::Pair::from_string(secret_uri, None).expect("Generates key pair");
629		let sign_data = bandersnatch::vrf::VrfSignData::new(b"vrf_input", b"aux_data");
630
631		let result = store.bandersnatch_vrf_sign(BANDERSNATCH, &key_pair.public(), &sign_data);
632		assert!(result.unwrap().is_none());
633
634		store
635			.insert(BANDERSNATCH, secret_uri, key_pair.public().as_ref())
636			.expect("Inserts unknown key");
637
638		let result = store.bandersnatch_vrf_sign(BANDERSNATCH, &key_pair.public(), &sign_data);
639
640		assert!(result.unwrap().is_some());
641	}
642
643	#[test]
644	#[cfg(feature = "bandersnatch-experimental")]
645	fn bandersnatch_ring_vrf_sign() {
646		use sp_core::testing::BANDERSNATCH;
647
648		let store = MemoryKeystore::new();
649
650		let ring_ctx = bandersnatch::ring_vrf::RingContext::<1024>::new_testing();
651
652		let mut pks: Vec<_> = (0..16)
653			.map(|i| bandersnatch::Pair::from_seed(&[i as u8; 32]).public())
654			.collect();
655
656		let prover_idx = 3;
657		let prover = ring_ctx.prover(&pks, prover_idx);
658
659		let secret_uri = "//Alice";
660		let pair = bandersnatch::Pair::from_string(secret_uri, None).expect("Generates key pair");
661		pks[prover_idx] = pair.public();
662
663		let sign_data = bandersnatch::vrf::VrfSignData::new(b"vrf_input", b"aux_data");
664
665		let result =
666			store.bandersnatch_ring_vrf_sign(BANDERSNATCH, &pair.public(), &sign_data, &prover);
667		assert!(result.unwrap().is_none());
668
669		store
670			.insert(BANDERSNATCH, secret_uri, pair.public().as_ref())
671			.expect("Inserts unknown key");
672
673		let result =
674			store.bandersnatch_ring_vrf_sign(BANDERSNATCH, &pair.public(), &sign_data, &prover);
675
676		assert!(result.unwrap().is_some());
677	}
678}
sp_keystore/testing.rs

sp_keystore/
testing.rs
