[Companion #13615] Keystore overhaul (#6892)

* Remove not required async calls

* Fixed missing renaming

* make_keystore can be sync

* More fixes

* Trivial nitpicks

* Cherry pick test fix from master

* Fixes after master merge

* update lockfile for {"substrate"}

---------

Co-authored-by: parity-processbot <>

polkadot/node/core/approval-voting/src/criteria.rs

@@ -557,17 +557,14 @@ mod tests {
 	use sp_application_crypto::sr25519;
 	use sp_core::crypto::Pair as PairT;
 	use sp_keyring::sr25519::Keyring as Sr25519Keyring;
-	use sp_keystore::CryptoStore;
+	use sp_keystore::Keystore;
 
 	// sets up a keystore with the given keyring accounts.
-	async fn make_keystore(accounts: &[Sr25519Keyring]) -> LocalKeystore {
+	fn make_keystore(accounts: &[Sr25519Keyring]) -> LocalKeystore {
 		let store = LocalKeystore::in_memory();
 
 		for s in accounts.iter().copied().map(|k| k.to_seed()) {
-			store
-				.sr25519_generate_new(ASSIGNMENT_KEY_TYPE_ID, Some(s.as_str()))
-				.await
-				.unwrap();
+			store.sr25519_generate_new(ASSIGNMENT_KEY_TYPE_ID, Some(s.as_str())).unwrap();
 		}
 
 		store
@@ -620,7 +617,7 @@ mod tests {
 
 	#[test]
 	fn assignments_produced_for_non_backing() {
-		let keystore = futures::executor::block_on(make_keystore(&[Sr25519Keyring::Alice]));
+		let keystore = make_keystore(&[Sr25519Keyring::Alice]);
 
 		let c_a = CandidateHash(Hash::repeat_byte(0));
 		let c_b = CandidateHash(Hash::repeat_byte(1));
@@ -655,7 +652,7 @@ mod tests {
 
 	#[test]
 	fn assign_to_nonzero_core() {
-		let keystore = futures::executor::block_on(make_keystore(&[Sr25519Keyring::Alice]));
+		let keystore = make_keystore(&[Sr25519Keyring::Alice]);
 
 		let c_a = CandidateHash(Hash::repeat_byte(0));
 		let c_b = CandidateHash(Hash::repeat_byte(1));
@@ -688,7 +685,7 @@ mod tests {
 
 	#[test]
 	fn succeeds_empty_for_0_cores() {
-		let keystore = futures::executor::block_on(make_keystore(&[Sr25519Keyring::Alice]));
+		let keystore = make_keystore(&[Sr25519Keyring::Alice]);
 
 		let relay_vrf_story = RelayVRFStory([42u8; 32]);
 		let assignments = compute_assignments(
@@ -728,7 +725,7 @@ mod tests {
 		rotation_offset: usize,
 		f: impl Fn(&mut MutatedAssignment) -> Option<bool>, // None = skip
 	) {
-		let keystore = futures::executor::block_on(make_keystore(&[Sr25519Keyring::Alice]));
+		let keystore = make_keystore(&[Sr25519Keyring::Alice]);
 
 		let group_for_core = |i| GroupIndex(((i + rotation_offset) % n_cores) as _);
 

polkadot/node/core/approval-voting/src/tests.rs

@@ -43,7 +43,7 @@ use assert_matches::assert_matches;
 use async_trait::async_trait;
 use parking_lot::Mutex;
 use sp_keyring::sr25519::Keyring as Sr25519Keyring;
-use sp_keystore::SyncCryptoStore;
+use sp_keystore::Keystore;
 use std::{
 	pin::Pin,
 	sync::{
@@ -2312,12 +2312,8 @@ fn subsystem_validate_approvals_cache() {
 	let store = config.backend();
 
 	test_harness(config, |test_harness| async move {
-		let TestHarness {
-			mut virtual_overseer,
-			clock,
-			sync_oracle_handle: _sync_oracle_handle,
-			..
-		} = test_harness;
+		let TestHarness { mut virtual_overseer, clock, sync_oracle_handle: _sync_oracle_handle } =
+			test_harness;
 
 		assert_matches!(
 			overseer_recv(&mut virtual_overseer).await,
@@ -2399,7 +2395,7 @@ fn subsystem_validate_approvals_cache() {
 }
 
 /// Ensure that when two assignments are imported, only one triggers the Approval Checking work
-pub async fn handle_double_assignment_import(
+async fn handle_double_assignment_import(
 	virtual_overseer: &mut VirtualOverseer,
 	candidate_index: CandidateIndex,
 ) {

polkadot/node/core/backing/src/lib.rs

@@ -52,7 +52,7 @@ use polkadot_primitives::{
 	CommittedCandidateReceipt, CoreIndex, CoreState, Hash, Id as ParaId, PvfExecTimeoutKind,
 	SigningContext, ValidatorId, ValidatorIndex, ValidatorSignature, ValidityAttestation,
 };
-use sp_keystore::SyncCryptoStorePtr;
+use sp_keystore::KeystorePtr;
 use statement_table::{
 	generic::AttestedCandidate as TableAttestedCandidate,
 	v2::{
@@ -118,13 +118,13 @@ impl ValidatedCandidateCommand {
 
 /// The candidate backing subsystem.
 pub struct CandidateBackingSubsystem {
-	keystore: SyncCryptoStorePtr,
+	keystore: KeystorePtr,
 	metrics: Metrics,
 }
 
 impl CandidateBackingSubsystem {
 	/// Create a new instance of the `CandidateBackingSubsystem`.
-	pub fn new(keystore: SyncCryptoStorePtr, metrics: Metrics) -> Self {
+	pub fn new(keystore: KeystorePtr, metrics: Metrics) -> Self {
 		Self { keystore, metrics }
 	}
 }
@@ -149,7 +149,7 @@ where
 #[overseer::contextbounds(CandidateBacking, prefix = self::overseer)]
 async fn run<Context>(
 	mut ctx: Context,
-	keystore: SyncCryptoStorePtr,
+	keystore: KeystorePtr,
 	metrics: Metrics,
 ) -> FatalResult<()> {
 	let (background_validation_tx, mut background_validation_rx) = mpsc::channel(16);
@@ -178,7 +178,7 @@ async fn run<Context>(
 #[overseer::contextbounds(CandidateBacking, prefix = self::overseer)]
 async fn run_iteration<Context>(
 	ctx: &mut Context,
-	keystore: SyncCryptoStorePtr,
+	keystore: KeystorePtr,
 	metrics: &Metrics,
 	jobs: &mut HashMap<Hash, JobAndSpan<Context>>,
 	background_validation_tx: mpsc::Sender<(Hash, ValidatedCandidateCommand)>,
@@ -265,7 +265,7 @@ async fn handle_active_leaves_update<Context>(
 	ctx: &mut Context,
 	update: ActiveLeavesUpdate,
 	jobs: &mut HashMap<Hash, JobAndSpan<Context>>,
-	keystore: &SyncCryptoStorePtr,
+	keystore: &KeystorePtr,
 	background_validation_tx: &mpsc::Sender<(Hash, ValidatedCandidateCommand)>,
 	metrics: &Metrics,
 ) -> Result<(), Error> {
@@ -323,7 +323,7 @@ async fn handle_active_leaves_update<Context>(
 
 	let signing_context = SigningContext { parent_hash: parent, session_index };
 	let validator =
-		match Validator::construct(&validators, signing_context.clone(), keystore.clone()).await {
+		match Validator::construct(&validators, signing_context.clone(), keystore.clone()) {
 			Ok(v) => Some(v),
 			Err(util::Error::NotAValidator) => None,
 			Err(e) => {
@@ -426,7 +426,7 @@ struct CandidateBackingJob<Context> {
 	/// The candidates that are includable, by hash. Each entry here indicates
 	/// that we've sent the provisioner the backed candidate.
 	backed: HashSet<CandidateHash>,
-	keystore: SyncCryptoStorePtr,
+	keystore: KeystorePtr,
 	table: Table<TableContext>,
 	table_context: TableContext,
 	background_validation_tx: mpsc::Sender<(Hash, ValidatedCandidateCommand)>,
@@ -814,8 +814,7 @@ impl<Context> CandidateBackingJob<Context> {
 								commitments,
 							});
 							if let Some(stmt) = self
-								.sign_import_and_distribute_statement(ctx, statement, root_span)
-								.await?
+								.sign_import_and_distribute_statement(ctx, statement, root_span)?
 							{
 								// Break cycle - bounded as there is only one candidate to
 								// second per block.
@@ -843,8 +842,7 @@ impl<Context> CandidateBackingJob<Context> {
 				if !self.issued_statements.contains(&candidate_hash) {
 					if res.is_ok() {
 						let statement = Statement::Valid(candidate_hash);
-						self.sign_import_and_distribute_statement(ctx, statement, &root_span)
-							.await?;
+						self.sign_import_and_distribute_statement(ctx, statement, &root_span)?;
 					}
 					self.issued_statements.insert(candidate_hash);
 				}
@@ -966,14 +964,14 @@ impl<Context> CandidateBackingJob<Context> {
 		Ok(())
 	}
 
-	async fn sign_import_and_distribute_statement(
+	fn sign_import_and_distribute_statement(
 		&mut self,
 		ctx: &mut Context,
 		statement: Statement,
 		root_span: &jaeger::Span,
 	) -> Result<Option<SignedFullStatement>, Error> {
-		if let Some(signed_statement) = self.sign_statement(statement).await {
-			self.import_statement(ctx, &signed_statement, root_span).await?;
+		if let Some(signed_statement) = self.sign_statement(statement) {
+			self.import_statement(ctx, &signed_statement, root_span)?;
 			let smsg = StatementDistributionMessage::Share(self.parent, signed_statement.clone());
 			ctx.send_unbounded_message(smsg);
 
@@ -1001,7 +999,7 @@ impl<Context> CandidateBackingJob<Context> {
 	}
 
 	/// Import a statement into the statement table and return the summary of the import.
-	async fn import_statement(
+	fn import_statement(
 		&mut self,
 		ctx: &mut Context,
 		statement: &SignedFullStatement,
@@ -1222,7 +1220,7 @@ impl<Context> CandidateBackingJob<Context> {
 		ctx: &mut Context,
 		statement: SignedFullStatement,
 	) -> Result<(), Error> {
-		if let Some(summary) = self.import_statement(ctx, &statement, root_span).await? {
+		if let Some(summary) = self.import_statement(ctx, &statement, root_span)? {
 			if Some(summary.group_id) != self.assignment {
 				return Ok(())
 			}
@@ -1277,13 +1275,12 @@ impl<Context> CandidateBackingJob<Context> {
 		Ok(())
 	}
 
-	async fn sign_statement(&mut self, statement: Statement) -> Option<SignedFullStatement> {
+	fn sign_statement(&mut self, statement: Statement) -> Option<SignedFullStatement> {
 		let signed = self
 			.table_context
 			.validator
 			.as_ref()?
 			.sign(self.keystore.clone(), statement)
-			.await
 			.ok()
 			.flatten()?;
 		self.metrics.on_statement_signed();

polkadot/node/core/backing/src/tests.rs

@@ -36,7 +36,7 @@ use polkadot_primitives::{
 };
 use sp_application_crypto::AppKey;
 use sp_keyring::Sr25519Keyring;
-use sp_keystore::{CryptoStore, SyncCryptoStore};
+use sp_keystore::Keystore;
 use sp_tracing as _;
 use statement_table::v2::Misbehavior;
 use std::collections::HashMap;
@@ -55,7 +55,7 @@ fn table_statement_to_primitive(statement: TableStatement) -> Statement {
 
 struct TestState {
 	chain_ids: Vec<ParaId>,
-	keystore: SyncCryptoStorePtr,
+	keystore: KeystorePtr,
 	validators: Vec<Sr25519Keyring>,
 	validator_public: Vec<ValidatorId>,
 	validation_data: PersistedValidationData,
@@ -85,12 +85,8 @@ impl Default for TestState {
 
 		let keystore = Arc::new(sc_keystore::LocalKeystore::in_memory());
 		// Make sure `Alice` key is in the keystore, so this mocked node will be a parachain validator.
-		SyncCryptoStore::sr25519_generate_new(
-			&*keystore,
-			ValidatorId::ID,
-			Some(&validators[0].to_seed()),
-		)
-		.expect("Insert key into keystore");
+		Keystore::sr25519_generate_new(&*keystore, ValidatorId::ID, Some(&validators[0].to_seed()))
+			.expect("Insert key into keystore");
 
 		let validator_public = validator_pubkeys(&validators);
 
@@ -143,7 +139,7 @@ impl Default for TestState {
 type VirtualOverseer = test_helpers::TestSubsystemContextHandle<CandidateBackingMessage>;
 
 fn test_harness<T: Future<Output = VirtualOverseer>>(
-	keystore: SyncCryptoStorePtr,
+	keystore: KeystorePtr,
 	test: impl FnOnce(VirtualOverseer) -> T,
 ) {
 	let pool = sp_core::testing::TaskExecutor::new();
@@ -383,19 +379,17 @@ fn backing_works() {
 		let candidate_a_hash = candidate_a.hash();
 		let candidate_a_commitments_hash = candidate_a.commitments.hash();
 
-		let public1 = CryptoStore::sr25519_generate_new(
+		let public1 = Keystore::sr25519_generate_new(
 			&*test_state.keystore,
 			ValidatorId::ID,
 			Some(&test_state.validators[5].to_seed()),
 		)
-		.await
 		.expect("Insert key into keystore");
-		let public2 = CryptoStore::sr25519_generate_new(
+		let public2 = Keystore::sr25519_generate_new(
 			&*test_state.keystore,
 			ValidatorId::ID,
 			Some(&test_state.validators[2].to_seed()),
 		)
-		.await
 		.expect("Insert key into keystore");
 
 		let signed_a = SignedFullStatement::sign(
@@ -405,7 +399,6 @@ fn backing_works() {
 			ValidatorIndex(2),
 			&public2.into(),
 		)
-		.await
 		.ok()
 		.flatten()
 		.expect("should be signed");
@@ -417,7 +410,6 @@ fn backing_works() {
 			ValidatorIndex(5),
 			&public1.into(),
 		)
-		.await
 		.ok()
 		.flatten()
 		.expect("should be signed");
@@ -536,26 +528,23 @@ fn backing_works_while_validation_ongoing() {
 		let candidate_a_hash = candidate_a.hash();
 		let candidate_a_commitments_hash = candidate_a.commitments.hash();
 
-		let public1 = CryptoStore::sr25519_generate_new(
+		let public1 = Keystore::sr25519_generate_new(
 			&*test_state.keystore,
 			ValidatorId::ID,
 			Some(&test_state.validators[5].to_seed()),
 		)
-		.await
 		.expect("Insert key into keystore");
-		let public2 = CryptoStore::sr25519_generate_new(
+		let public2 = Keystore::sr25519_generate_new(
 			&*test_state.keystore,
 			ValidatorId::ID,
 			Some(&test_state.validators[2].to_seed()),
 		)
-		.await
 		.expect("Insert key into keystore");
-		let public3 = CryptoStore::sr25519_generate_new(
+		let public3 = Keystore::sr25519_generate_new(
 			&*test_state.keystore,
 			ValidatorId::ID,
 			Some(&test_state.validators[3].to_seed()),
 		)
-		.await
 		.expect("Insert key into keystore");
 
 		let signed_a = SignedFullStatement::sign(
@@ -565,7 +554,6 @@ fn backing_works_while_validation_ongoing() {
 			ValidatorIndex(2),
 			&public2.into(),
 		)
-		.await
 		.ok()
 		.flatten()
 		.expect("should be signed");
@@ -577,7 +565,6 @@ fn backing_works_while_validation_ongoing() {
 			ValidatorIndex(5),
 			&public1.into(),
 		)
-		.await
 		.ok()
 		.flatten()
 		.expect("should be signed");
@@ -589,7 +576,6 @@ fn backing_works_while_validation_ongoing() {
 			ValidatorIndex(3),
 			&public3.into(),
 		)
-		.await
 		.ok()
 		.flatten()
 		.expect("should be signed");
@@ -719,12 +705,11 @@ fn backing_misbehavior_works() {
 		let candidate_a_hash = candidate_a.hash();
 		let candidate_a_commitments_hash = candidate_a.commitments.hash();
 
-		let public2 = CryptoStore::sr25519_generate_new(
+		let public2 = Keystore::sr25519_generate_new(
 			&*test_state.keystore,
 			ValidatorId::ID,
 			Some(&test_state.validators[2].to_seed()),
 		)
-		.await
 		.expect("Insert key into keystore");
 		let seconded_2 = SignedFullStatement::sign(
 			&test_state.keystore,
@@ -733,7 +718,6 @@ fn backing_misbehavior_works() {
 			ValidatorIndex(2),
 			&public2.into(),
 		)
-		.await
 		.ok()
 		.flatten()
 		.expect("should be signed");
@@ -745,7 +729,6 @@ fn backing_misbehavior_works() {
 			ValidatorIndex(2),
 			&public2.into(),
 		)
-		.await
 		.ok()
 		.flatten()
 		.expect("should be signed");
@@ -1015,12 +998,11 @@ fn backing_second_after_first_fails_works() {
 		}
 		.build();
 
-		let validator2 = CryptoStore::sr25519_generate_new(
+		let validator2 = Keystore::sr25519_generate_new(
 			&*test_state.keystore,
 			ValidatorId::ID,
 			Some(&test_state.validators[2].to_seed()),
 		)
-		.await
 		.expect("Insert key into keystore");
 
 		let signed_a = SignedFullStatement::sign(
@@ -1030,7 +1012,6 @@ fn backing_second_after_first_fails_works() {
 			ValidatorIndex(2),
 			&validator2.into(),
 		)
-		.await
 		.ok()
 		.flatten()
 		.expect("should be signed");
@@ -1142,12 +1123,11 @@ fn backing_works_after_failed_validation() {
 		}
 		.build();
 
-		let public2 = CryptoStore::sr25519_generate_new(
+		let public2 = Keystore::sr25519_generate_new(
 			&*test_state.keystore,
 			ValidatorId::ID,
 			Some(&test_state.validators[2].to_seed()),
 		)
-		.await
 		.expect("Insert key into keystore");
 		let signed_a = SignedFullStatement::sign(
 			&test_state.keystore,
@@ -1156,7 +1136,6 @@ fn backing_works_after_failed_validation() {
 			ValidatorIndex(2),
 			&public2.into(),
 		)
-		.await
 		.ok()
 		.flatten()
 		.expect("should be signed");
@@ -1291,12 +1270,11 @@ fn validation_work_ignores_wrong_collator() {
 		}
 		.build();
 
-		let public2 = CryptoStore::sr25519_generate_new(
+		let public2 = Keystore::sr25519_generate_new(
 			&*test_state.keystore,
 			ValidatorId::ID,
 			Some(&test_state.validators[2].to_seed()),
 		)
-		.await
 		.expect("Insert key into keystore");
 		let seconding = SignedFullStatement::sign(
 			&test_state.keystore,
@@ -1305,7 +1283,6 @@ fn validation_work_ignores_wrong_collator() {
 			ValidatorIndex(2),
 			&public2.into(),
 		)
-		.await
 		.ok()
 		.flatten()
 		.expect("should be signed");
@@ -1417,26 +1394,23 @@ fn retry_works() {
 		}
 		.build();
 
-		let public2 = CryptoStore::sr25519_generate_new(
+		let public2 = Keystore::sr25519_generate_new(
 			&*test_state.keystore,
 			ValidatorId::ID,
 			Some(&test_state.validators[2].to_seed()),
 		)
-		.await
 		.expect("Insert key into keystore");
-		let public3 = CryptoStore::sr25519_generate_new(
+		let public3 = Keystore::sr25519_generate_new(
 			&*test_state.keystore,
 			ValidatorId::ID,
 			Some(&test_state.validators[3].to_seed()),
 		)
-		.await
 		.expect("Insert key into keystore");
-		let public5 = CryptoStore::sr25519_generate_new(
+		let public5 = Keystore::sr25519_generate_new(
 			&*test_state.keystore,
 			ValidatorId::ID,
 			Some(&test_state.validators[5].to_seed()),
 		)
-		.await
 		.expect("Insert key into keystore");
 		let signed_a = SignedFullStatement::sign(
 			&test_state.keystore,
@@ -1445,7 +1419,6 @@ fn retry_works() {
 			ValidatorIndex(2),
 			&public2.into(),
 		)
-		.await
 		.ok()
 		.flatten()
 		.expect("should be signed");
@@ -1456,7 +1429,6 @@ fn retry_works() {
 			ValidatorIndex(3),
 			&public3.into(),
 		)
-		.await
 		.ok()
 		.flatten()
 		.expect("should be signed");
@@ -1467,7 +1439,6 @@ fn retry_works() {
 			ValidatorIndex(5),
 			&public5.into(),
 		)
-		.await
 		.ok()
 		.flatten()
 		.expect("should be signed");
@@ -1574,26 +1545,23 @@ fn observes_backing_even_if_not_validator() {
 		.build();
 
 		let candidate_a_hash = candidate_a.hash();
-		let public0 = CryptoStore::sr25519_generate_new(
+		let public0 = Keystore::sr25519_generate_new(
 			&*test_state.keystore,
 			ValidatorId::ID,
 			Some(&test_state.validators[0].to_seed()),
 		)
-		.await
 		.expect("Insert key into keystore");
-		let public1 = CryptoStore::sr25519_generate_new(
+		let public1 = Keystore::sr25519_generate_new(
 			&*test_state.keystore,
 			ValidatorId::ID,
 			Some(&test_state.validators[5].to_seed()),
 		)
-		.await
 		.expect("Insert key into keystore");
-		let public2 = CryptoStore::sr25519_generate_new(
+		let public2 = Keystore::sr25519_generate_new(
 			&*test_state.keystore,
 			ValidatorId::ID,
 			Some(&test_state.validators[2].to_seed()),
 		)
-		.await
 		.expect("Insert key into keystore");
 
 		// Produce a 3-of-5 quorum on the candidate.
@@ -1605,7 +1573,6 @@ fn observes_backing_even_if_not_validator() {
 			ValidatorIndex(0),
 			&public0.into(),
 		)
-		.await
 		.ok()
 		.flatten()
 		.expect("should be signed");
@@ -1617,7 +1584,6 @@ fn observes_backing_even_if_not_validator() {
 			ValidatorIndex(5),
 			&public1.into(),
 		)
-		.await
 		.ok()
 		.flatten()
 		.expect("should be signed");
@@ -1629,7 +1595,6 @@ fn observes_backing_even_if_not_validator() {
 			ValidatorIndex(2),
 			&public2.into(),
 		)
-		.await
 		.ok()
 		.flatten()
 		.expect("should be signed");

polkadot/node/core/bitfield-signing/src/lib.rs

@@ -37,7 +37,7 @@ use polkadot_node_subsystem::{
 };
 use polkadot_node_subsystem_util::{self as util, Validator};
 use polkadot_primitives::{AvailabilityBitfield, CoreState, Hash, ValidatorIndex};
-use sp_keystore::{Error as KeystoreError, SyncCryptoStorePtr};
+use sp_keystore::{Error as KeystoreError, KeystorePtr};
 use std::{collections::HashMap, iter::FromIterator, time::Duration};
 use wasm_timer::{Delay, Instant};
 
@@ -181,13 +181,13 @@ async fn construct_availability_bitfield(
 
 /// The bitfield signing subsystem.
 pub struct BitfieldSigningSubsystem {
-	keystore: SyncCryptoStorePtr,
+	keystore: KeystorePtr,
 	metrics: Metrics,
 }
 
 impl BitfieldSigningSubsystem {
 	/// Create a new instance of the `BitfieldSigningSubsystem`.
-	pub fn new(keystore: SyncCryptoStorePtr, metrics: Metrics) -> Self {
+	pub fn new(keystore: KeystorePtr, metrics: Metrics) -> Self {
 		Self { keystore, metrics }
 	}
 }
@@ -209,7 +209,7 @@ impl<Context> BitfieldSigningSubsystem {
 #[overseer::contextbounds(BitfieldSigning, prefix = self::overseer)]
 async fn run<Context>(
 	mut ctx: Context,
-	keystore: SyncCryptoStorePtr,
+	keystore: KeystorePtr,
 	metrics: Metrics,
 ) -> SubsystemResult<()> {
 	// Track spawned jobs per active leaf.
@@ -251,7 +251,7 @@ async fn run<Context>(
 async fn handle_active_leaves_update<Sender>(
 	mut sender: Sender,
 	leaf: ActivatedLeaf,
-	keystore: SyncCryptoStorePtr,
+	keystore: KeystorePtr,
 	metrics: Metrics,
 ) -> Result<(), Error>
 where
@@ -310,7 +310,7 @@ where
 	let span_signing = span.child("signing");
 
 	let signed_bitfield =
-		match validator.sign(keystore, bitfield).await.map_err(|e| Error::Keystore(e))? {
+		match validator.sign(keystore, bitfield).map_err(|e| Error::Keystore(e))? {
 			Some(b) => b,
 			None => {
 				gum::error!(

polkadot/node/core/dispute-coordinator/src/initialized.rs

@@ -1168,8 +1168,7 @@ impl Initialized {
 					.get(*index)
 					.expect("`controlled_indices` are derived from `validators`; qed")
 					.clone(),
-			)
-			.await;
+			);
 
 			match res {
 				Ok(Some(signed_dispute_statement)) => {

polkadot/node/core/dispute-coordinator/src/tests.rs

@@ -48,7 +48,7 @@ use sc_keystore::LocalKeystore;
 use sp_application_crypto::AppKey;
 use sp_core::{sr25519::Pair, testing::TaskExecutor, Pair as PairT};
 use sp_keyring::Sr25519Keyring;
-use sp_keystore::{SyncCryptoStore, SyncCryptoStorePtr};
+use sp_keystore::{Keystore, KeystorePtr};
 
 use ::test_helpers::{dummy_candidate_receipt_bad_sig, dummy_digest, dummy_hash};
 use polkadot_node_primitives::{Timestamp, ACTIVE_DURATION_SECS};
@@ -520,10 +520,9 @@ impl TestState {
 	) -> SignedDisputeStatement {
 		let public = self.validator_public.get(index).unwrap().clone();
 
-		let keystore = self.master_keystore.clone() as SyncCryptoStorePtr;
+		let keystore = self.master_keystore.clone() as KeystorePtr;
 
 		SignedDisputeStatement::sign_explicit(&keystore, valid, candidate_hash, session, public)
-			.await
 			.unwrap()
 			.unwrap()
 	}
@@ -534,7 +533,7 @@ impl TestState {
 		candidate_hash: CandidateHash,
 		session: SessionIndex,
 	) -> SignedDisputeStatement {
-		let keystore = self.master_keystore.clone() as SyncCryptoStorePtr;
+		let keystore = self.master_keystore.clone() as KeystorePtr;
 		let validator_id = self.validators[index.0 as usize].public().into();
 		let context =
 			SigningContext { session_index: session, parent_hash: Hash::repeat_byte(0xac) };
@@ -546,7 +545,6 @@ impl TestState {
 			index,
 			&validator_id,
 		)
-		.await
 		.unwrap()
 		.unwrap()
 		.into_unchecked();
@@ -560,19 +558,15 @@ impl TestState {
 		candidate_hash: CandidateHash,
 		session: SessionIndex,
 	) -> SignedDisputeStatement {
-		let keystore = self.master_keystore.clone() as SyncCryptoStorePtr;
+		let keystore = self.master_keystore.clone() as KeystorePtr;
 		let validator_id = self.validators[index.0 as usize].public();
 
 		let payload = ApprovalVote(candidate_hash).signing_payload(session);
-		let signature = SyncCryptoStore::sign_with(
-			&*keystore,
-			ValidatorId::ID,
-			&validator_id.into(),
-			&payload[..],
-		)
-		.ok()
-		.flatten()
-		.unwrap();
+		let signature =
+			Keystore::sign_with(&*keystore, ValidatorId::ID, &validator_id.into(), &payload[..])
+				.ok()
+				.flatten()
+				.unwrap();
 
 		SignedDisputeStatement::new_unchecked_from_trusted_source(
 			DisputeStatement::Valid(ValidDisputeStatementKind::ApprovalChecking),

polkadot/node/core/provisioner/src/tests.rs

@@ -56,19 +56,17 @@ pub fn scheduled_core(id: u32) -> ScheduledCore {
 
 mod select_availability_bitfields {
 	use super::{super::*, default_bitvec, occupied_core};
-	use futures::executor::block_on;
 	use polkadot_primitives::{ScheduledCore, SigningContext, ValidatorId, ValidatorIndex};
 	use sp_application_crypto::AppKey;
-	use sp_keystore::{testing::KeyStore, CryptoStore, SyncCryptoStorePtr};
+	use sp_keystore::{testing::MemoryKeystore, Keystore, KeystorePtr};
 	use std::sync::Arc;
 
-	async fn signed_bitfield(
-		keystore: &SyncCryptoStorePtr,
+	fn signed_bitfield(
+		keystore: &KeystorePtr,
 		field: CoreAvailability,
 		validator_idx: ValidatorIndex,
 	) -> SignedAvailabilityBitfield {
-		let public = CryptoStore::sr25519_generate_new(&**keystore, ValidatorId::ID, None)
-			.await
+		let public = Keystore::sr25519_generate_new(&**keystore, ValidatorId::ID, None)
 			.expect("generated sr25519 key");
 		SignedAvailabilityBitfield::sign(
 			&keystore,
@@ -77,7 +75,6 @@ mod select_availability_bitfields {
 			validator_idx,
 			&public.into(),
 		)
-		.await
 		.ok()
 		.flatten()
 		.expect("Should be signed")
@@ -85,7 +82,7 @@ mod select_availability_bitfields {
 
 	#[test]
 	fn not_more_than_one_per_validator() {
-		let keystore: SyncCryptoStorePtr = Arc::new(KeyStore::new());
+		let keystore: KeystorePtr = Arc::new(MemoryKeystore::new());
 		let mut bitvec = default_bitvec(2);
 		bitvec.set(0, true);
 		bitvec.set(1, true);
@@ -95,9 +92,9 @@ mod select_availability_bitfields {
 		// we pass in three bitfields with two validators
 		// this helps us check the postcondition that we get two bitfields back, for which the validators differ
 		let bitfields = vec![
-			block_on(signed_bitfield(&keystore, bitvec.clone(), ValidatorIndex(0))),
-			block_on(signed_bitfield(&keystore, bitvec.clone(), ValidatorIndex(1))),
-			block_on(signed_bitfield(&keystore, bitvec, ValidatorIndex(1))),
+			signed_bitfield(&keystore, bitvec.clone(), ValidatorIndex(0)),
+			signed_bitfield(&keystore, bitvec.clone(), ValidatorIndex(1)),
+			signed_bitfield(&keystore, bitvec, ValidatorIndex(1)),
 		];
 
 		let mut selected_bitfields =
@@ -112,7 +109,7 @@ mod select_availability_bitfields {
 
 	#[test]
 	fn each_corresponds_to_an_occupied_core() {
-		let keystore: SyncCryptoStorePtr = Arc::new(KeyStore::new());
+		let keystore: KeystorePtr = Arc::new(MemoryKeystore::new());
 		let bitvec = default_bitvec(3);
 
 		// invalid: bit on free core
@@ -134,9 +131,9 @@ mod select_availability_bitfields {
 		];
 
 		let bitfields = vec![
-			block_on(signed_bitfield(&keystore, bitvec0, ValidatorIndex(0))),
-			block_on(signed_bitfield(&keystore, bitvec1, ValidatorIndex(1))),
-			block_on(signed_bitfield(&keystore, bitvec2.clone(), ValidatorIndex(2))),
+			signed_bitfield(&keystore, bitvec0, ValidatorIndex(0)),
+			signed_bitfield(&keystore, bitvec1, ValidatorIndex(1)),
+			signed_bitfield(&keystore, bitvec2.clone(), ValidatorIndex(2)),
 		];
 
 		let selected_bitfields =
@@ -149,7 +146,7 @@ mod select_availability_bitfields {
 
 	#[test]
 	fn more_set_bits_win_conflicts() {
-		let keystore: SyncCryptoStorePtr = Arc::new(KeyStore::new());
+		let keystore: KeystorePtr = Arc::new(MemoryKeystore::new());
 		let mut bitvec = default_bitvec(2);
 		bitvec.set(0, true);
 
@@ -159,8 +156,8 @@ mod select_availability_bitfields {
 		let cores = vec![occupied_core(0), occupied_core(1)];
 
 		let bitfields = vec![
-			block_on(signed_bitfield(&keystore, bitvec, ValidatorIndex(1))),
-			block_on(signed_bitfield(&keystore, bitvec1.clone(), ValidatorIndex(1))),
+			signed_bitfield(&keystore, bitvec, ValidatorIndex(1)),
+			signed_bitfield(&keystore, bitvec1.clone(), ValidatorIndex(1)),
 		];
 
 		let selected_bitfields =
@@ -171,7 +168,7 @@ mod select_availability_bitfields {
 
 	#[test]
 	fn more_complex_bitfields() {
-		let keystore: SyncCryptoStorePtr = Arc::new(KeyStore::new());
+		let keystore: KeystorePtr = Arc::new(MemoryKeystore::new());
 
 		let cores = vec![occupied_core(0), occupied_core(1), occupied_core(2), occupied_core(3)];
 
@@ -194,11 +191,11 @@ mod select_availability_bitfields {
 		// these are out of order but will be selected in order. The better
 		// bitfield for 3 will be selected.
 		let bitfields = vec![
-			block_on(signed_bitfield(&keystore, bitvec2.clone(), ValidatorIndex(3))),
-			block_on(signed_bitfield(&keystore, bitvec3.clone(), ValidatorIndex(3))),
-			block_on(signed_bitfield(&keystore, bitvec0.clone(), ValidatorIndex(0))),
-			block_on(signed_bitfield(&keystore, bitvec2.clone(), ValidatorIndex(2))),
-			block_on(signed_bitfield(&keystore, bitvec1.clone(), ValidatorIndex(1))),
+			signed_bitfield(&keystore, bitvec2.clone(), ValidatorIndex(3)),
+			signed_bitfield(&keystore, bitvec3.clone(), ValidatorIndex(3)),
+			signed_bitfield(&keystore, bitvec0.clone(), ValidatorIndex(0)),
+			signed_bitfield(&keystore, bitvec2.clone(), ValidatorIndex(2)),
+			signed_bitfield(&keystore, bitvec1.clone(), ValidatorIndex(1)),
 		];
 
 		let selected_bitfields =

polkadot/node/core/pvf-checker/src/lib.rs

@@ -30,7 +30,7 @@ use polkadot_primitives::{
 	BlockNumber, Hash, PvfCheckStatement, SessionIndex, ValidationCodeHash, ValidatorId,
 	ValidatorIndex,
 };
-use sp_keystore::SyncCryptoStorePtr;
+use sp_keystore::KeystorePtr;
 use std::collections::HashSet;
 
 const LOG_TARGET: &str = "parachain::pvf-checker";
@@ -50,12 +50,12 @@ use self::{
 /// PVF pre-checking subsystem.
 pub struct PvfCheckerSubsystem {
 	enabled: bool,
-	keystore: SyncCryptoStorePtr,
+	keystore: KeystorePtr,
 	metrics: Metrics,
 }
 
 impl PvfCheckerSubsystem {
-	pub fn new(enabled: bool, keystore: SyncCryptoStorePtr, metrics: Metrics) -> Self {
+	pub fn new(enabled: bool, keystore: KeystorePtr, metrics: Metrics) -> Self {
 		PvfCheckerSubsystem { enabled, keystore, metrics }
 	}
 }
@@ -123,7 +123,7 @@ struct State {
 #[overseer::contextbounds(PvfChecker, prefix = self::overseer)]
 async fn run<Context>(
 	mut ctx: Context,
-	keystore: SyncCryptoStorePtr,
+	keystore: KeystorePtr,
 	metrics: Metrics,
 ) -> SubsystemResult<()> {
 	let mut state = State {
@@ -174,7 +174,7 @@ async fn run<Context>(
 async fn handle_pvf_check(
 	state: &mut State,
 	sender: &mut impl overseer::PvfCheckerSenderTrait,
-	keystore: &SyncCryptoStorePtr,
+	keystore: &KeystorePtr,
 	metrics: &Metrics,
 	outcome: PreCheckOutcome,
 	validation_code_hash: ValidationCodeHash,
@@ -244,7 +244,7 @@ struct Conclude;
 async fn handle_from_overseer(
 	state: &mut State,
 	sender: &mut impl overseer::PvfCheckerSenderTrait,
-	keystore: &SyncCryptoStorePtr,
+	keystore: &KeystorePtr,
 	metrics: &Metrics,
 	from_overseer: FromOrchestra<PvfCheckerMessage>,
 ) -> Option<Conclude> {
@@ -270,7 +270,7 @@ async fn handle_from_overseer(
 async fn handle_leaves_update(
 	state: &mut State,
 	sender: &mut impl overseer::PvfCheckerSenderTrait,
-	keystore: &SyncCryptoStorePtr,
+	keystore: &KeystorePtr,
 	metrics: &Metrics,
 	update: ActiveLeavesUpdate,
 ) {
@@ -352,7 +352,7 @@ struct ActivationEffect {
 async fn examine_activation(
 	state: &mut State,
 	sender: &mut impl overseer::PvfCheckerSenderTrait,
-	keystore: &SyncCryptoStorePtr,
+	keystore: &KeystorePtr,
 	leaf_hash: Hash,
 	leaf_number: BlockNumber,
 ) -> Option<ActivationEffect> {
@@ -411,7 +411,7 @@ async fn examine_activation(
 /// returns the [`SigningCredentials`].
 async fn check_signing_credentials(
 	sender: &mut impl SubsystemSender<RuntimeApiMessage>,
-	keystore: &SyncCryptoStorePtr,
+	keystore: &KeystorePtr,
 	leaf: Hash,
 ) -> Option<SigningCredentials> {
 	let validators = match runtime_api::validators(sender, leaf).await {
@@ -427,12 +427,9 @@ async fn check_signing_credentials(
 		},
 	};
 
-	polkadot_node_subsystem_util::signing_key_and_index(&validators, keystore)
-		.await
-		.map(|(validator_key, validator_index)| SigningCredentials {
-			validator_key,
-			validator_index,
-		})
+	polkadot_node_subsystem_util::signing_key_and_index(&validators, keystore).map(
+		|(validator_key, validator_index)| SigningCredentials { validator_key, validator_index },
+	)
 }
 
 /// Signs and submits a vote for or against a given validation code.
@@ -440,7 +437,7 @@ async fn check_signing_credentials(
 /// If the validator already voted for the given code, this function does nothing.
 async fn sign_and_submit_pvf_check_statement(
 	sender: &mut impl overseer::PvfCheckerSenderTrait,
-	keystore: &SyncCryptoStorePtr,
+	keystore: &KeystorePtr,
 	voted: &mut HashSet<ValidationCodeHash>,
 	credentials: &SigningCredentials,
 	metrics: &Metrics,
@@ -482,9 +479,7 @@ async fn sign_and_submit_pvf_check_statement(
 		keystore,
 		&credentials.validator_key,
 		&stmt.signing_payload(),
-	)
-	.await
-	{
+	) {
 		Ok(Some(signature)) => signature,
 		Ok(None) => {
 			gum::warn!(

polkadot/node/core/pvf-checker/src/tests.rs

@@ -32,7 +32,7 @@ use polkadot_primitives::{
 use sp_application_crypto::AppKey;
 use sp_core::testing::TaskExecutor;
 use sp_keyring::Sr25519Keyring;
-use sp_keystore::SyncCryptoStore;
+use sp_keystore::Keystore;
 use sp_runtime::traits::AppVerify;
 use std::{collections::HashMap, sync::Arc, time::Duration};
 
@@ -363,12 +363,8 @@ fn test_harness(test: impl FnOnce(TestState, VirtualOverseer) -> BoxFuture<'stat
 	let keystore = Arc::new(sc_keystore::LocalKeystore::in_memory());
 
 	// Add OUR_VALIDATOR (which is Alice) to the keystore.
-	SyncCryptoStore::sr25519_generate_new(
-		&*keystore,
-		ValidatorId::ID,
-		Some(&OUR_VALIDATOR.to_seed()),
-	)
-	.expect("Generating keys for our node failed");
+	Keystore::sr25519_generate_new(&*keystore, ValidatorId::ID, Some(&OUR_VALIDATOR.to_seed()))
+		.expect("Generating keys for our node failed");
 
 	let subsystem_task = crate::run(ctx, keystore, crate::Metrics::default()).map(|x| x.unwrap());