Kill the light client, CHTs and change tries. (#10080)

* Remove light client, change tries and CHTs

* Update tests

* fmt

* Restore changes_root

* Fixed benches

* Cargo fmt

* fmt

* fmt

substrate/client/consensus/aura/src/import_queue.rs

@@ -33,7 +33,7 @@ use sp_api::{ApiExt, ProvideRuntimeApi};
 use sp_block_builder::BlockBuilder as BlockBuilderApi;
 use sp_blockchain::{
 	well_known_cache_keys::{self, Id as CacheKeyId},
-	HeaderBackend, ProvideCache,
+	HeaderBackend,
 };
 use sp_consensus::{CanAuthorWith, Error as ConsensusError};
 use sp_consensus_aura::{
@@ -45,7 +45,8 @@ use sp_core::{crypto::Pair, ExecutionContext};
 use sp_inherents::{CreateInherentDataProviders, InherentDataProvider as _};
 use sp_runtime::{
 	generic::{BlockId, OpaqueDigestItemId},
-	traits::{Block as BlockT, DigestItemFor, Header},
+	traits::{Block as BlockT, Header},
+	DigestItem,
 };
 use std::{fmt::Debug, hash::Hash, marker::PhantomData, sync::Arc};
 
@@ -61,9 +62,8 @@ fn check_header<C, B: BlockT, P: Pair>(
 	hash: B::Hash,
 	authorities: &[AuthorityId<P>],
 	check_for_equivocation: CheckForEquivocation,
-) -> Result<CheckedHeader<B::Header, (Slot, DigestItemFor<B>)>, Error<B>>
+) -> Result<CheckedHeader<B::Header, (Slot, DigestItem)>, Error<B>>
 where
-	DigestItemFor<B>: CompatibleDigestItem<P::Signature>,
 	P::Signature: Codec,
 	C: sc_client_api::backend::AuxStore,
 	P::Public: Encode + Decode + PartialEq + Clone,
@@ -189,14 +189,8 @@ where
 #[async_trait::async_trait]
 impl<B: BlockT, C, P, CAW, CIDP> Verifier<B> for AuraVerifier<C, P, CAW, CIDP>
 where
-	C: ProvideRuntimeApi<B>
-		+ Send
-		+ Sync
-		+ sc_client_api::backend::AuxStore
-		+ ProvideCache<B>
-		+ BlockOf,
+	C: ProvideRuntimeApi<B> + Send + Sync + sc_client_api::backend::AuxStore + BlockOf,
 	C::Api: BlockBuilderApi<B> + AuraApi<B, AuthorityId<P>> + ApiExt<B>,
-	DigestItemFor<B>: CompatibleDigestItem<P::Signature>,
 	P: Pair + Send + Sync + 'static,
 	P::Public: Send + Sync + Hash + Eq + Clone + Decode + Encode + Debug + 'static,
 	P::Signature: Encode + Decode,
@@ -385,7 +379,6 @@ where
 	C: 'static
 		+ ProvideRuntimeApi<Block>
 		+ BlockOf
-		+ ProvideCache<Block>
 		+ Send
 		+ Sync
 		+ AuxStore
@@ -395,7 +388,6 @@ where
 		+ Send
 		+ Sync
 		+ 'static,
-	DigestItemFor<Block>: CompatibleDigestItem<P::Signature>,
 	P: Pair + Send + Sync + 'static,
 	P::Public: Clone + Eq + Send + Sync + Hash + Debug + Encode + Decode,
 	P::Signature: Encode + Decode,

substrate/client/consensus/aura/src/lib.rs

@@ -52,7 +52,7 @@ use sc_consensus_slots::{
 use sc_telemetry::TelemetryHandle;
 use sp_api::ProvideRuntimeApi;
 use sp_application_crypto::{AppKey, AppPublic};
-use sp_blockchain::{HeaderBackend, ProvideCache, Result as CResult};
+use sp_blockchain::{HeaderBackend, Result as CResult};
 use sp_consensus::{
 	BlockOrigin, CanAuthorWith, Environment, Error as ConsensusError, Proposer, SelectChain,
 };
@@ -62,7 +62,8 @@ use sp_inherents::CreateInherentDataProviders;
 use sp_keystore::{SyncCryptoStore, SyncCryptoStorePtr};
 use sp_runtime::{
 	generic::BlockId,
-	traits::{Block as BlockT, DigestItemFor, Header, Member, NumberFor, Zero},
+	traits::{Block as BlockT, Header, Member, NumberFor, Zero},
+	DigestItem,
 };
 
 mod import_queue;
@@ -178,7 +179,7 @@ where
 	P::Public: AppPublic + Hash + Member + Encode + Decode,
 	P::Signature: TryFrom<Vec<u8>> + Hash + Member + Encode + Decode,
 	B: BlockT,
-	C: ProvideRuntimeApi<B> + BlockOf + ProvideCache<B> + AuxStore + HeaderBackend<B> + Send + Sync,
+	C: ProvideRuntimeApi<B> + BlockOf + AuxStore + HeaderBackend<B> + Send + Sync,
 	C::Api: AuraApi<B, AuthorityId<P>>,
 	SC: SelectChain<B>,
 	I: BlockImport<B, Transaction = sp_api::TransactionFor<C, B>> + Send + Sync + 'static,
@@ -267,7 +268,7 @@ pub fn build_aura_worker<P, B, C, PF, I, SO, L, BS, Error>(
 ) -> impl sc_consensus_slots::SlotWorker<B, <PF::Proposer as Proposer<B>>::Proof>
 where
 	B: BlockT,
-	C: ProvideRuntimeApi<B> + BlockOf + ProvideCache<B> + AuxStore + HeaderBackend<B> + Send + Sync,
+	C: ProvideRuntimeApi<B> + BlockOf + AuxStore + HeaderBackend<B> + Send + Sync,
 	C::Api: AuraApi<B, AuthorityId<P>>,
 	PF: Environment<B, Error = Error> + Send + Sync + 'static,
 	PF::Proposer: Proposer<B, Error = Error, Transaction = sp_api::TransactionFor<C, B>>,
@@ -316,7 +317,7 @@ impl<B, C, E, I, P, Error, SO, L, BS> sc_consensus_slots::SimpleSlotWorker<B>
 	for AuraWorker<C, E, I, P, SO, L, BS>
 where
 	B: BlockT,
-	C: ProvideRuntimeApi<B> + BlockOf + ProvideCache<B> + HeaderBackend<B> + Sync,
+	C: ProvideRuntimeApi<B> + BlockOf + HeaderBackend<B> + Sync,
 	C::Api: AuraApi<B, AuthorityId<P>>,
 	E: Environment<B, Error = Error> + Send + Sync,
 	E::Proposer: Proposer<B, Error = Error, Transaction = sp_api::TransactionFor<C, B>>,
@@ -377,12 +378,8 @@ where
 		})
 	}
 
-	fn pre_digest_data(
-		&self,
-		slot: Slot,
-		_claim: &Self::Claim,
-	) -> Vec<sp_runtime::DigestItem<B::Hash>> {
-		vec![<DigestItemFor<B> as CompatibleDigestItem<P::Signature>>::aura_pre_digest(slot)]
+	fn pre_digest_data(&self, slot: Slot, _claim: &Self::Claim) -> Vec<sp_runtime::DigestItem> {
+		vec![<DigestItem as CompatibleDigestItem<P::Signature>>::aura_pre_digest(slot)]
 	}
 
 	fn block_import_params(
@@ -426,7 +423,7 @@ where
 				.map_err(|_| sp_consensus::Error::InvalidSignature(signature, public))?;
 
 			let signature_digest_item =
-				<DigestItemFor<B> as CompatibleDigestItem<P::Signature>>::aura_seal(signature);
+				<DigestItem as CompatibleDigestItem<P::Signature>>::aura_seal(signature);
 
 			let mut import_block = BlockImportParams::new(BlockOrigin::Own, header);
 			import_block.post_digests.push(signature_digest_item);
@@ -545,7 +542,7 @@ fn authorities<A, B, C>(client: &C, at: &BlockId<B>) -> Result<Vec<A>, Consensus
 where
 	A: Codec + Debug,
 	B: BlockT,
-	C: ProvideRuntimeApi<B> + BlockOf + ProvideCache<B>,
+	C: ProvideRuntimeApi<B> + BlockOf,
 	C::Api: AuraApi<B, A>,
 {
 	client
@@ -574,7 +571,10 @@ mod tests {
 	use sp_consensus_aura::sr25519::AuthorityPair;
 	use sp_inherents::InherentData;
 	use sp_keyring::sr25519::Keyring;
-	use sp_runtime::traits::{Block as BlockT, DigestFor, Header as _};
+	use sp_runtime::{
+		traits::{Block as BlockT, Header as _},
+		Digest,
+	};
 	use sp_timestamp::InherentDataProvider as TimestampInherentDataProvider;
 	use std::{
 		task::Poll,
@@ -611,7 +611,7 @@ mod tests {
 		fn propose(
 			self,
 			_: InherentData,
-			digests: DigestFor<TestBlock>,
+			digests: Digest,
 			_: Duration,
 			_: Option<usize>,
 		) -> Self::Proposal {
@@ -661,29 +661,25 @@ mod tests {
 			_cfg: &ProtocolConfig,
 			_peer_data: &(),
 		) -> Self::Verifier {
-			match client {
-				PeersClient::Full(client, _) => {
-					let slot_duration = slot_duration(&*client).expect("slot duration available");
+			let client = client.as_client();
+			let slot_duration = slot_duration(&*client).expect("slot duration available");
 
-					assert_eq!(slot_duration.slot_duration().as_millis() as u64, SLOT_DURATION);
-					import_queue::AuraVerifier::new(
-						client,
-						Box::new(|_, _| async {
-							let timestamp = TimestampInherentDataProvider::from_system_time();
-							let slot = InherentDataProvider::from_timestamp_and_duration(
-								*timestamp,
-								Duration::from_secs(6),
-							);
+			assert_eq!(slot_duration.slot_duration().as_millis() as u64, SLOT_DURATION);
+			import_queue::AuraVerifier::new(
+				client,
+				Box::new(|_, _| async {
+					let timestamp = TimestampInherentDataProvider::from_system_time();
+					let slot = InherentDataProvider::from_timestamp_and_duration(
+						*timestamp,
+						Duration::from_secs(6),
+					);
 
-							Ok((timestamp, slot))
-						}),
-						AlwaysCanAuthor,
-						CheckForEquivocation::Yes,
-						None,
-					)
-				},
-				PeersClient::Light(_, _) => unreachable!("No (yet) tests for light client + Aura"),
-			}
+					Ok((timestamp, slot))
+				}),
+				AlwaysCanAuthor,
+				CheckForEquivocation::Yes,
+				None,
+			)
 		}
 
 		fn make_block_import(
@@ -724,7 +720,7 @@ mod tests {
 		for (peer_id, key) in peers {
 			let mut net = net.lock();
 			let peer = net.peer(*peer_id);
-			let client = peer.client().as_full().expect("full clients are created").clone();
+			let client = peer.client().as_client();
 			let select_chain = peer.select_chain().expect("full client has a select chain");
 			let keystore_path = tempfile::tempdir().expect("Creates keystore path");
 			let keystore = Arc::new(
@@ -823,7 +819,7 @@ mod tests {
 
 		let mut net = net.lock();
 		let peer = net.peer(3);
-		let client = peer.client().as_full().expect("full clients are created").clone();
+		let client = peer.client().as_client();
 		let environ = DummyFactory(client.clone());
 
 		let worker = AuraWorker {
@@ -875,7 +871,7 @@ mod tests {
 
 		let mut net = net.lock();
 		let peer = net.peer(3);
-		let client = peer.client().as_full().expect("full clients are created").clone();
+		let client = peer.client().as_client();
 		let environ = DummyFactory(client.clone());
 
 		let mut worker = AuraWorker {

substrate/client/consensus/babe/src/lib.rs

@@ -103,9 +103,7 @@ use sc_telemetry::{telemetry, TelemetryHandle, CONSENSUS_DEBUG, CONSENSUS_TRACE}
 use sp_api::{ApiExt, NumberFor, ProvideRuntimeApi};
 use sp_application_crypto::AppKey;
 use sp_block_builder::BlockBuilder as BlockBuilderApi;
-use sp_blockchain::{
-	Error as ClientError, HeaderBackend, HeaderMetadata, ProvideCache, Result as ClientResult,
-};
+use sp_blockchain::{Error as ClientError, HeaderBackend, HeaderMetadata, Result as ClientResult};
 use sp_consensus::{
 	BlockOrigin, CacheKeyId, CanAuthorWith, Environment, Error as ConsensusError, Proposer,
 	SelectChain, SlotData,
@@ -117,7 +115,8 @@ use sp_inherents::{CreateInherentDataProviders, InherentData, InherentDataProvid
 use sp_keystore::{SyncCryptoStore, SyncCryptoStorePtr};
 use sp_runtime::{
 	generic::{BlockId, OpaqueDigestItemId},
-	traits::{Block as BlockT, DigestItemFor, Header, Zero},
+	traits::{Block as BlockT, Header, Zero},
+	DigestItem,
 };
 
 pub use sc_consensus_slots::SlotProportion;
@@ -465,7 +464,6 @@ pub fn start_babe<B, C, SC, E, I, SO, CIDP, BS, CAW, L, Error>(
 where
 	B: BlockT,
 	C: ProvideRuntimeApi<B>
-		+ ProvideCache<B>
 		+ ProvideUncles<B>
 		+ BlockchainEvents<B>
 		+ HeaderBackend<B>
@@ -539,7 +537,6 @@ async fn answer_requests<B: BlockT, C>(
 	epoch_changes: SharedEpochChanges<B, Epoch>,
 ) where
 	C: ProvideRuntimeApi<B>
-		+ ProvideCache<B>
 		+ ProvideUncles<B>
 		+ BlockchainEvents<B>
 		+ HeaderBackend<B>
@@ -677,10 +674,7 @@ impl<B, C, E, I, Error, SO, L, BS> sc_consensus_slots::SimpleSlotWorker<B>
 	for BabeSlotWorker<B, C, E, I, SO, L, BS>
 where
 	B: BlockT,
-	C: ProvideRuntimeApi<B>
-		+ ProvideCache<B>
-		+ HeaderBackend<B>
-		+ HeaderMetadata<B, Error = ClientError>,
+	C: ProvideRuntimeApi<B> + HeaderBackend<B> + HeaderMetadata<B, Error = ClientError>,
 	C::Api: BabeApi<B>,
 	E: Environment<B, Error = Error> + Sync,
 	E::Proposer: Proposer<B, Error = Error, Transaction = sp_api::TransactionFor<C, B>>,
@@ -774,12 +768,8 @@ where
 		});
 	}
 
-	fn pre_digest_data(
-		&self,
-		_slot: Slot,
-		claim: &Self::Claim,
-	) -> Vec<sp_runtime::DigestItem<B::Hash>> {
-		vec![<DigestItemFor<B> as CompatibleDigestItem>::babe_pre_digest(claim.0.clone())]
+	fn pre_digest_data(&self, _slot: Slot, claim: &Self::Claim) -> Vec<sp_runtime::DigestItem> {
+		vec![<DigestItem as CompatibleDigestItem>::babe_pre_digest(claim.0.clone())]
 	}
 
 	fn block_import_params(
@@ -820,8 +810,7 @@ where
 					.clone()
 					.try_into()
 					.map_err(|_| sp_consensus::Error::InvalidSignature(signature, public))?;
-				let digest_item =
-					<DigestItemFor<B> as CompatibleDigestItem>::babe_seal(signature.into());
+				let digest_item = <DigestItem as CompatibleDigestItem>::babe_seal(signature.into());
 
 				let mut import_block = BlockImportParams::new(BlockOrigin::Own, header);
 				import_block.post_digests.push(digest_item);
@@ -921,10 +910,7 @@ pub fn find_pre_digest<B: BlockT>(header: &B::Header) -> Result<PreDigest, Error
 /// Extract the BABE epoch change digest from the given header, if it exists.
 fn find_next_epoch_digest<B: BlockT>(
 	header: &B::Header,
-) -> Result<Option<NextEpochDescriptor>, Error<B>>
-where
-	DigestItemFor<B>: CompatibleDigestItem,
-{
+) -> Result<Option<NextEpochDescriptor>, Error<B>> {
 	let mut epoch_digest: Option<_> = None;
 	for log in header.digest().logs() {
 		trace!(target: "babe", "Checking log {:?}, looking for epoch change digest.", log);
@@ -943,10 +929,7 @@ where
 /// Extract the BABE config change digest from the given header, if it exists.
 fn find_next_config_digest<B: BlockT>(
 	header: &B::Header,
-) -> Result<Option<NextConfigDescriptor>, Error<B>>
-where
-	DigestItemFor<B>: CompatibleDigestItem,
-{
+) -> Result<Option<NextConfigDescriptor>, Error<B>> {
 	let mut config_digest: Option<_> = None;
 	for log in header.digest().logs() {
 		trace!(target: "babe", "Checking log {:?}, looking for epoch change digest.", log);
@@ -1132,8 +1115,7 @@ where
 		+ ProvideRuntimeApi<Block>
 		+ Send
 		+ Sync
-		+ AuxStore
-		+ ProvideCache<Block>,
+		+ AuxStore,
 	Client::Api: BlockBuilderApi<Block> + BabeApi<Block>,
 	SelectChain: sp_consensus::SelectChain<Block>,
 	CAW: CanAuthorWith<Block> + Send + Sync,
@@ -1332,7 +1314,6 @@ where
 		+ HeaderMetadata<Block, Error = sp_blockchain::Error>
 		+ AuxStore
 		+ ProvideRuntimeApi<Block>
-		+ ProvideCache<Block>
 		+ Send
 		+ Sync,
 	Client::Api: BabeApi<Block> + ApiExt<Block>,
@@ -1399,7 +1380,6 @@ where
 		+ HeaderMetadata<Block, Error = sp_blockchain::Error>
 		+ AuxStore
 		+ ProvideRuntimeApi<Block>
-		+ ProvideCache<Block>
 		+ Send
 		+ Sync,
 	Client::Api: BabeApi<Block> + ApiExt<Block>,
@@ -1756,7 +1736,6 @@ where
 		+ Sync
 		+ 'static,
 	Client: ProvideRuntimeApi<Block>
-		+ ProvideCache<Block>
 		+ HeaderBackend<Block>
 		+ HeaderMetadata<Block, Error = sp_blockchain::Error>
 		+ AuxStore

substrate/client/consensus/babe/src/tests.rs

@@ -43,13 +43,13 @@ use sp_consensus_babe::{
 use sp_core::crypto::Pair;
 use sp_keystore::{vrf::make_transcript as transcript_from_data, SyncCryptoStore};
 use sp_runtime::{
-	generic::DigestItem,
-	traits::{Block as BlockT, DigestFor},
+	generic::{Digest, DigestItem},
+	traits::Block as BlockT,
 };
 use sp_timestamp::InherentDataProvider as TimestampInherentDataProvider;
 use std::{cell::RefCell, task::Poll, time::Duration};
 
-type Item = DigestItem<Hash>;
+type Item = DigestItem;
 
 type Error = sp_blockchain::Error;
 
@@ -108,7 +108,7 @@ impl Environment<TestBlock> for DummyFactory {
 impl DummyProposer {
 	fn propose_with(
 		&mut self,
-		pre_digests: DigestFor<TestBlock>,
+		pre_digests: Digest,
 	) -> future::Ready<
 		Result<
 			Proposal<
@@ -181,7 +181,7 @@ impl Proposer<TestBlock> for DummyProposer {
 	fn propose(
 		mut self,
 		_: InherentData,
-		pre_digests: DigestFor<TestBlock>,
+		pre_digests: Digest,
 		_: Duration,
 		_: Option<usize>,
 	) -> Self::Proposal {
@@ -295,7 +295,7 @@ impl TestNetFactory for BabeTestNet {
 		Option<BoxJustificationImport<Block>>,
 		Option<PeerData>,
 	) {
-		let client = client.as_full().expect("only full clients are tested");
+		let client = client.as_client();
 
 		let config = Config::get_or_compute(&*client).expect("config available");
 		let (block_import, link) = crate::block_import(config, client.clone(), client.clone())
@@ -320,7 +320,7 @@ impl TestNetFactory for BabeTestNet {
 	) -> Self::Verifier {
 		use substrate_test_runtime_client::DefaultTestClientBuilderExt;
 
-		let client = client.as_full().expect("only full clients are used in test");
+		let client = client.as_client();
 		trace!(target: "babe", "Creating a verifier");
 
 		// ensure block import and verifier are linked correctly.
@@ -395,7 +395,7 @@ fn run_one_test(mutator: impl Fn(&mut TestHeader, Stage) + Send + Sync + 'static
 	for (peer_id, seed) in peers {
 		let mut net = net.lock();
 		let peer = net.peer(*peer_id);
-		let client = peer.client().as_full().expect("Only full clients are used in tests").clone();
+		let client = peer.client().as_client();
 		let select_chain = peer.select_chain().expect("Full client has select_chain");
 
 		let keystore_path = tempfile::tempdir().expect("Creates keystore path");
@@ -679,7 +679,7 @@ fn importing_block_one_sets_genesis_epoch() {
 
 	let peer = net.peer(0);
 	let data = peer.data.as_ref().expect("babe link set up during initialization");
-	let client = peer.client().as_full().expect("Only full clients are used in tests").clone();
+	let client = peer.client().as_client();
 
 	let mut proposer_factory = DummyFactory {
 		client: client.clone(),
@@ -721,7 +721,7 @@ fn importing_epoch_change_block_prunes_tree() {
 	let peer = net.peer(0);
 	let data = peer.data.as_ref().expect("babe link set up during initialization");
 
-	let client = peer.client().as_full().expect("Only full clients are used in tests").clone();
+	let client = peer.client().as_client();
 	let mut block_import = data.block_import.lock().take().expect("import set up during init");
 	let epoch_changes = data.link.epoch_changes.clone();
 
@@ -836,7 +836,7 @@ fn verify_slots_are_strictly_increasing() {
 	let peer = net.peer(0);
 	let data = peer.data.as_ref().expect("babe link set up during initialization");
 
-	let client = peer.client().as_full().expect("Only full clients are used in tests").clone();
+	let client = peer.client().as_client();
 	let mut block_import = data.block_import.lock().take().expect("import set up during init");
 
 	let mut proposer_factory = DummyFactory {

substrate/client/consensus/babe/src/verification.rs

@@ -32,7 +32,7 @@ use sp_consensus_babe::{
 };
 use sp_consensus_slots::Slot;
 use sp_core::{Pair, Public};
-use sp_runtime::traits::{DigestItemFor, Header};
+use sp_runtime::{traits::Header, DigestItem};
 
 /// BABE verification parameters
 pub(super) struct VerificationParams<'a, B: 'a + BlockT> {
@@ -61,10 +61,7 @@ pub(super) struct VerificationParams<'a, B: 'a + BlockT> {
 /// with each having different validation logic.
 pub(super) fn check_header<B: BlockT + Sized>(
 	params: VerificationParams<B>,
-) -> Result<CheckedHeader<B::Header, VerifiedHeaderInfo<B>>, Error<B>>
-where
-	DigestItemFor<B>: CompatibleDigestItem,
-{
+) -> Result<CheckedHeader<B::Header, VerifiedHeaderInfo>, Error<B>> {
 	let VerificationParams { mut header, pre_digest, slot_now, epoch } = params;
 
 	let authorities = &epoch.authorities;
@@ -137,9 +134,9 @@ where
 	Ok(CheckedHeader::Checked(header, info))
 }
 
-pub(super) struct VerifiedHeaderInfo<B: BlockT> {
-	pub(super) pre_digest: DigestItemFor<B>,
-	pub(super) seal: DigestItemFor<B>,
+pub(super) struct VerifiedHeaderInfo {
+	pub(super) pre_digest: DigestItem,
+	pub(super) seal: DigestItem,
 	pub(super) author: AuthorityId,
 }
 

substrate/client/consensus/common/src/block_import.rs

@@ -20,8 +20,8 @@
 
 use serde::{Deserialize, Serialize};
 use sp_runtime::{
-	traits::{Block as BlockT, DigestItemFor, HashFor, Header as HeaderT, NumberFor},
-	Justification, Justifications,
+	traits::{Block as BlockT, HashFor, Header as HeaderT, NumberFor},
+	DigestItem, Justification, Justifications,
 };
 use std::{any::Any, borrow::Cow, collections::HashMap, sync::Arc};
 
@@ -122,7 +122,7 @@ pub struct BlockCheckParams<Block: BlockT> {
 /// Precomputed storage.
 pub enum StorageChanges<Block: BlockT, Transaction> {
 	/// Changes coming from block execution.
-	Changes(sp_state_machine::StorageChanges<Transaction, HashFor<Block>, NumberFor<Block>>),
+	Changes(sp_state_machine::StorageChanges<Transaction, HashFor<Block>>),
 	/// Whole new state.
 	Import(ImportedState<Block>),
 }
@@ -175,7 +175,7 @@ pub struct BlockImportParams<Block: BlockT, Transaction> {
 	pub justifications: Option<Justifications>,
 	/// Digest items that have been added after the runtime for external
 	/// work, like a consensus signature.
-	pub post_digests: Vec<DigestItemFor<Block>>,
+	pub post_digests: Vec<DigestItem>,
 	/// The body of the block.
 	pub body: Option<Vec<Block::Extrinsic>>,
 	/// Indexed transaction body of the block.

substrate/client/consensus/manual-seal/src/consensus.rs

@@ -21,7 +21,7 @@ use super::Error;
 
 use sc_consensus::BlockImportParams;
 use sp_inherents::InherentData;
-use sp_runtime::traits::{Block as BlockT, DigestFor};
+use sp_runtime::{traits::Block as BlockT, Digest};
 
 pub mod babe;
 
@@ -32,11 +32,7 @@ pub trait ConsensusDataProvider<B: BlockT>: Send + Sync {
 	type Transaction;
 
 	/// Attempt to create a consensus digest.
-	fn create_digest(
-		&self,
-		parent: &B::Header,
-		inherents: &InherentData,
-	) -> Result<DigestFor<B>, Error>;
+	fn create_digest(&self, parent: &B::Header, inherents: &InherentData) -> Result<Digest, Error>;
 
 	/// set up the neccessary import params.
 	fn append_block_import(

substrate/client/consensus/manual-seal/src/consensus/babe.rs

@@ -49,7 +49,8 @@ use sp_consensus_slots::Slot;
 use sp_inherents::{InherentData, InherentDataProvider, InherentIdentifier};
 use sp_runtime::{
 	generic::{BlockId, Digest},
-	traits::{Block as BlockT, DigestFor, DigestItemFor, Header, Zero},
+	traits::{Block as BlockT, Header, Zero},
+	DigestItem,
 };
 use sp_timestamp::{InherentType, TimestampInherentData, INHERENT_IDENTIFIER};
 
@@ -193,11 +194,7 @@ where
 {
 	type Transaction = TransactionFor<C, B>;
 
-	fn create_digest(
-		&self,
-		parent: &B::Header,
-		inherents: &InherentData,
-	) -> Result<DigestFor<B>, Error> {
+	fn create_digest(&self, parent: &B::Header, inherents: &InherentData) -> Result<Digest, Error> {
 		let slot = inherents
 			.babe_inherent_data()?
 			.ok_or_else(|| Error::StringError("No babe inherent data".into()))?;
@@ -207,7 +204,7 @@ where
 		let logs = if let Some((predigest, _)) =
 			authorship::claim_slot(slot, &epoch, &self.keystore)
 		{
-			vec![<DigestItemFor<B> as CompatibleDigestItem>::babe_pre_digest(predigest)]
+			vec![<DigestItem as CompatibleDigestItem>::babe_pre_digest(predigest)]
 		} else {
 			// well we couldn't claim a slot because this is an existing chain and we're not in the
 			// authorities. we need to tell BabeBlockImport that the epoch has changed, and we put
@@ -244,13 +241,13 @@ where
 					});
 
 					vec![
-						DigestItemFor::<B>::PreRuntime(BABE_ENGINE_ID, predigest.encode()),
-						DigestItemFor::<B>::Consensus(BABE_ENGINE_ID, next_epoch.encode()),
+						DigestItem::PreRuntime(BABE_ENGINE_ID, predigest.encode()),
+						DigestItem::Consensus(BABE_ENGINE_ID, next_epoch.encode()),
 					]
 				},
 				ViableEpochDescriptor::UnimportedGenesis(_) => {
 					// since this is the genesis, secondary predigest works for now.
-					vec![DigestItemFor::<B>::PreRuntime(BABE_ENGINE_ID, predigest.encode())]
+					vec![DigestItem::PreRuntime(BABE_ENGINE_ID, predigest.encode())]
 				},
 			}
 		};

substrate/client/consensus/pow/src/lib.rs

@@ -55,7 +55,7 @@ use sc_consensus::{
 };
 use sp_api::ProvideRuntimeApi;
 use sp_block_builder::BlockBuilder as BlockBuilderApi;
-use sp_blockchain::{well_known_cache_keys::Id as CacheKeyId, HeaderBackend, ProvideCache};
+use sp_blockchain::{well_known_cache_keys::Id as CacheKeyId, HeaderBackend};
 use sp_consensus::{
 	CanAuthorWith, Environment, Error as ConsensusError, Proposer, SelectChain, SyncOracle,
 };
@@ -240,7 +240,7 @@ where
 	B: BlockT,
 	I: BlockImport<B, Transaction = sp_api::TransactionFor<C, B>> + Send + Sync,
 	I::Error: Into<ConsensusError>,
-	C: ProvideRuntimeApi<B> + Send + Sync + HeaderBackend<B> + AuxStore + ProvideCache<B> + BlockOf,
+	C: ProvideRuntimeApi<B> + Send + Sync + HeaderBackend<B> + AuxStore + BlockOf,
 	C::Api: BlockBuilderApi<B>,
 	Algorithm: PowAlgorithm<B>,
 	CAW: CanAuthorWith<B>,
@@ -319,7 +319,7 @@ where
 	I: BlockImport<B, Transaction = sp_api::TransactionFor<C, B>> + Send + Sync,
 	I::Error: Into<ConsensusError>,
 	S: SelectChain<B>,
-	C: ProvideRuntimeApi<B> + Send + Sync + HeaderBackend<B> + AuxStore + ProvideCache<B> + BlockOf,
+	C: ProvideRuntimeApi<B> + Send + Sync + HeaderBackend<B> + AuxStore + BlockOf,
 	C::Api: BlockBuilderApi<B>,
 	Algorithm: PowAlgorithm<B> + Send + Sync,
 	Algorithm::Difficulty: 'static + Send,
@@ -425,10 +425,7 @@ impl<B: BlockT, Algorithm> PowVerifier<B, Algorithm> {
 		Self { algorithm, _marker: PhantomData }
 	}
 
-	fn check_header(
-		&self,
-		mut header: B::Header,
-	) -> Result<(B::Header, DigestItem<B::Hash>), Error<B>>
+	fn check_header(&self, mut header: B::Header) -> Result<(B::Header, DigestItem), Error<B>>
 	where
 		Algorithm: PowAlgorithm<B>,
 	{
@@ -630,7 +627,7 @@ where
 				},
 			};
 
-			let mut inherent_digest = Digest::<Block::Hash>::default();
+			let mut inherent_digest = Digest::default();
 			if let Some(pre_runtime) = &pre_runtime {
 				inherent_digest.push(DigestItem::PreRuntime(POW_ENGINE_ID, pre_runtime.to_vec()));
 			}
@@ -702,10 +699,7 @@ fn find_pre_digest<B: BlockT>(header: &B::Header) -> Result<Option<Vec<u8>>, Err
 }
 
 /// Fetch PoW seal.
-fn fetch_seal<B: BlockT>(
-	digest: Option<&DigestItem<B::Hash>>,
-	hash: B::Hash,
-) -> Result<Vec<u8>, Error<B>> {
+fn fetch_seal<B: BlockT>(digest: Option<&DigestItem>, hash: B::Hash) -> Result<Vec<u8>, Error<B>> {
 	match digest {
 		Some(DigestItem::Seal(id, seal)) =>
 			if id == &POW_ENGINE_ID {

substrate/client/consensus/slots/src/lib.rs

@@ -45,7 +45,7 @@ use sp_consensus_slots::Slot;
 use sp_inherents::CreateInherentDataProviders;
 use sp_runtime::{
 	generic::BlockId,
-	traits::{Block as BlockT, HashFor, Header as HeaderT, NumberFor},
+	traits::{Block as BlockT, HashFor, Header as HeaderT},
 };
 use sp_timestamp::Timestamp;
 use std::{fmt::Debug, ops::Deref, time::Duration};
@@ -54,7 +54,7 @@ use std::{fmt::Debug, ops::Deref, time::Duration};
 ///
 /// See [`sp_state_machine::StorageChanges`] for more information.
 pub type StorageChanges<Transaction, Block> =
-	sp_state_machine::StorageChanges<Transaction, HashFor<Block>, NumberFor<Block>>;
+	sp_state_machine::StorageChanges<Transaction, HashFor<Block>>;
 
 /// The result of [`SlotWorker::on_slot`].
 #[derive(Debug, Clone)]
@@ -141,11 +141,7 @@ pub trait SimpleSlotWorker<B: BlockT> {
 	fn notify_slot(&self, _header: &B::Header, _slot: Slot, _epoch_data: &Self::EpochData) {}
 
 	/// Return the pre digest data to include in a block authored with the given claim.
-	fn pre_digest_data(
-		&self,
-		slot: Slot,
-		claim: &Self::Claim,
-	) -> Vec<sp_runtime::DigestItem<B::Hash>>;
+	fn pre_digest_data(&self, slot: Slot, claim: &Self::Claim) -> Vec<sp_runtime::DigestItem>;
 
 	/// Returns a function which produces a `BlockImportParams`.
 	fn block_import_params(