Keystore overhaul (#13615)

* Remove 'supported_keys' 'sign_with_any' and 'sign_with_all' from keystore trait

* Remove the aync keystore

* Renaming:
- SyncCryptoStore -> Keystore
- SyncCryptoStorePtr -> KeystorePtr
- KeyStore -> MemoryKeystore

* Fix authority discovery worker and tests

* Rename 'insert_unknown' to 'insert'

* Remove leftover

substrate/client/rpc/src/author/mod.rs

@@ -40,7 +40,7 @@ use sc_transaction_pool_api::{
 use sp_api::ProvideRuntimeApi;
 use sp_blockchain::HeaderBackend;
 use sp_core::Bytes;
-use sp_keystore::{SyncCryptoStore, SyncCryptoStorePtr};
+use sp_keystore::{Keystore, KeystorePtr};
 use sp_runtime::{generic, traits::Block as BlockT};
 use sp_session::SessionKeys;
 
@@ -55,7 +55,7 @@ pub struct Author<P, Client> {
 	/// Transactions pool
 	pool: Arc<P>,
 	/// The key store.
-	keystore: SyncCryptoStorePtr,
+	keystore: KeystorePtr,
 	/// Whether to deny unsafe calls
 	deny_unsafe: DenyUnsafe,
 	/// Executor to spawn subscriptions.
@@ -67,7 +67,7 @@ impl<P, Client> Author<P, Client> {
 	pub fn new(
 		client: Arc<Client>,
 		pool: Arc<P>,
-		keystore: SyncCryptoStorePtr,
+		keystore: KeystorePtr,
 		deny_unsafe: DenyUnsafe,
 		executor: SubscriptionTaskExecutor,
 	) -> Self {
@@ -112,8 +112,8 @@ where
 		self.deny_unsafe.check_if_safe()?;
 
 		let key_type = key_type.as_str().try_into().map_err(|_| Error::BadKeyType)?;
-		SyncCryptoStore::insert_unknown(&*self.keystore, key_type, &suri, &public[..])
-			.map_err(|_| Error::KeyStoreUnavailable)?;
+		Keystore::insert(&*self.keystore, key_type, &suri, &public[..])
+			.map_err(|_| Error::KeystoreUnavailable)?;
 		Ok(())
 	}
 
@@ -139,14 +139,14 @@ where
 			.map_err(|e| Error::Client(Box::new(e)))?
 			.ok_or(Error::InvalidSessionKeys)?;
 
-		Ok(SyncCryptoStore::has_keys(&*self.keystore, &keys))
+		Ok(Keystore::has_keys(&*self.keystore, &keys))
 	}
 
 	fn has_key(&self, public_key: Bytes, key_type: String) -> RpcResult<bool> {
 		self.deny_unsafe.check_if_safe()?;
 
 		let key_type = key_type.as_str().try_into().map_err(|_| Error::BadKeyType)?;
-		Ok(SyncCryptoStore::has_keys(&*self.keystore, &[(public_key.to_vec(), key_type)]))
+		Ok(Keystore::has_keys(&*self.keystore, &[(public_key.to_vec(), key_type)]))
 	}
 
 	fn pending_extrinsics(&self) -> RpcResult<Vec<Bytes>> {

substrate/client/rpc/src/author/tests.rs

@@ -36,7 +36,7 @@ use sp_core::{
 	testing::{ED25519, SR25519},
 	H256,
 };
-use sp_keystore::testing::KeyStore;
+use sp_keystore::testing::MemoryKeystore;
 use std::sync::Arc;
 use substrate_test_runtime_client::{
 	self,
@@ -58,13 +58,13 @@ type FullTransactionPool = BasicPool<FullChainApi<Client<Backend>, Block>, Block
 
 struct TestSetup {
 	pub client: Arc<Client<Backend>>,
-	pub keystore: Arc<KeyStore>,
+	pub keystore: Arc<MemoryKeystore>,
 	pub pool: Arc<FullTransactionPool>,
 }
 
 impl Default for TestSetup {
 	fn default() -> Self {
-		let keystore = Arc::new(KeyStore::new());
+		let keystore = Arc::new(MemoryKeystore::new());
 		let client_builder = substrate_test_runtime_client::TestClientBuilder::new();
 		let client = Arc::new(client_builder.set_keystore(keystore.clone()).build());
 
@@ -225,7 +225,7 @@ async fn author_should_insert_key() {
 		keypair.public().0.to_vec().into(),
 	);
 	api.call::<_, ()>("author_insertKey", params).await.unwrap();
-	let pubkeys = SyncCryptoStore::keys(&*setup.keystore, ED25519).unwrap();
+	let pubkeys = Keystore::keys(&*setup.keystore, ED25519).unwrap();
 
 	assert!(
 		pubkeys.contains(&CryptoTypePublicPair(ed25519::CRYPTO_ID, keypair.public().to_raw_vec()))
@@ -240,8 +240,8 @@ async fn author_should_rotate_keys() {
 	let new_pubkeys: Bytes = api.call("author_rotateKeys", EmptyParams::new()).await.unwrap();
 	let session_keys =
 		SessionKeys::decode(&mut &new_pubkeys[..]).expect("SessionKeys decode successfully");
-	let ed25519_pubkeys = SyncCryptoStore::keys(&*setup.keystore, ED25519).unwrap();
-	let sr25519_pubkeys = SyncCryptoStore::keys(&*setup.keystore, SR25519).unwrap();
+	let ed25519_pubkeys = Keystore::keys(&*setup.keystore, ED25519).unwrap();
+	let sr25519_pubkeys = Keystore::keys(&*setup.keystore, SR25519).unwrap();
 	assert!(ed25519_pubkeys
 		.contains(&CryptoTypePublicPair(ed25519::CRYPTO_ID, session_keys.ed25519.to_raw_vec())));
 	assert!(sr25519_pubkeys