Allow updating configuration of changes tries

client/api/src/backend.rs

@@ -18,11 +18,11 @@
 
 use std::sync::Arc;
 use std::collections::HashMap;
-use sp_core::ChangesTrieConfiguration;
+use sp_core::ChangesTrieConfigurationRange;
 use sp_core::offchain::OffchainStorage;
 use sp_runtime::{generic::BlockId, Justification, Storage};
 use sp_runtime::traits::{Block as BlockT, NumberFor, HasherFor};
-use sp_state_machine::{ChangesTrieStorage as StateChangesTrieStorage, ChangesTrieTransaction};
+use sp_state_machine::{ChangesTrieState, ChangesTrieStorage as StateChangesTrieStorage, ChangesTrieTransaction};
 use crate::{
 	blockchain::{
 		Backend as BlockchainBackend, well_known_cache_keys
@@ -248,8 +248,6 @@ pub trait Backend<Block: BlockT>: AuxStore + Send + Sync {
 	type Blockchain: BlockchainBackend<Block>;
 	/// Associated state backend type.
 	type State: StateBackend<HasherFor<Block>> + Send;
-	/// Changes trie storage.
-	type ChangesTrieStorage: PrunableStateChangesTrieStorage<Block>;
 	/// Offchain workers local storage.
 	type OffchainStorage: OffchainStorage;
 
@@ -284,7 +282,7 @@ pub trait Backend<Block: BlockT>: AuxStore + Send + Sync {
 	fn usage_info(&self) -> Option<UsageInfo>;
 
 	/// Returns reference to changes trie storage.
-	fn changes_trie_storage(&self) -> Option<&Self::ChangesTrieStorage>;
+	fn changes_trie_storage(&self) -> Option<&dyn PrunableStateChangesTrieStorage<Block>>;
 
 	/// Returns a handle to offchain storage.
 	fn offchain_storage(&self) -> Option<Self::OffchainStorage>;
@@ -342,12 +340,16 @@ pub trait Backend<Block: BlockT>: AuxStore + Send + Sync {
 pub trait PrunableStateChangesTrieStorage<Block: BlockT>:
 	StateChangesTrieStorage<HasherFor<Block>, NumberFor<Block>>
 {
-	/// Get number block of oldest, non-pruned changes trie.
-	fn oldest_changes_trie_block(
-		&self,
-		config: &ChangesTrieConfiguration,
-		best_finalized: NumberFor<Block>,
-	) -> NumberFor<Block>;
+	/// Get reference to StateChangesTrieStorage.
+	fn storage(&self) -> &dyn StateChangesTrieStorage<HasherFor<Block>, NumberFor<Block>>;
+	/// Get configuration at given block.
+	fn configuration_at(&self, at: &BlockId<Block>) -> sp_blockchain::Result<
+		ChangesTrieConfigurationRange<NumberFor<Block>, Block::Hash>
+	>;
+	/// Get end block (inclusive) of oldest pruned max-level (or skewed) digest trie blocks range.
+	/// It is guaranteed that we have no any changes tries before (and including) this block.
+	/// It is guaranteed that all existing changes tries after this block are not yet pruned (if created).
+	fn oldest_pruned_digest_range_end(&self) -> NumberFor<Block>;
 }
 
 /// Mark for all Backend implementations, that are making use of state data, stored locally.
@@ -364,3 +366,20 @@ pub trait RemoteBackend<Block: BlockT>: Backend<Block> {
 	/// locally, or prepares request to fetch that data from remote node.
 	fn remote_blockchain(&self) -> Arc<dyn RemoteBlockchain<Block>>;
 }
+
+/// Return changes tries state at given block.
+pub fn changes_tries_state_at_block<'a, Block: BlockT>(
+	block: &BlockId<Block>,
+	maybe_storage: Option<&'a dyn PrunableStateChangesTrieStorage<Block>>,
+) -> sp_blockchain::Result<Option<ChangesTrieState<'a, HasherFor<Block>, NumberFor<Block>>>> {
+	let storage = match maybe_storage {
+		Some(storage) => storage,
+		None => return Ok(None),
+	};
+
+	let config_range = storage.configuration_at(block)?;
+	match config_range.config {
+		Some(config) => Ok(Some(ChangesTrieState::new(config, config_range.zero.0, storage.storage()))),
+		None => Ok(None),
+	}
+}

client/api/src/light.rs

@@ -26,7 +26,7 @@ use sp_runtime::{
     },
     generic::BlockId
 };
-use sp_core::ChangesTrieConfiguration;
+use sp_core::ChangesTrieConfigurationRange;
 use sp_state_machine::StorageProof;
 use sp_blockchain::{
 	HeaderMetadata, well_known_cache_keys, HeaderBackend, Cache as BlockchainCache,
@@ -96,8 +96,8 @@ pub struct RemoteReadChildRequest<Header: HeaderT> {
 /// Remote key changes read request.
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct RemoteChangesRequest<Header: HeaderT> {
-	/// Changes trie configuration.
-	pub changes_trie_config: ChangesTrieConfiguration,
+	/// All changes trie configurations that are valid within [first_block; last_block].
+	pub changes_trie_configs: Vec<ChangesTrieConfigurationRange<Header::Number, Header::Hash>>,
 	/// Query changes from range of blocks, starting (and including) with this hash...
 	pub first_block: (Header::Number, Header::Hash),
 	/// ...ending (and including) with this hash. Should come after first_block and

client/authority-discovery/src/tests.rs

@@ -212,12 +212,10 @@ impl ApiExt<Block> for RuntimeApi {
 		unimplemented!("Not required for testing!")
 	}
 
-	fn into_storage_changes<
-		T: sp_api::ChangesTrieStorage<sp_api::HasherFor<Block>, sp_api::NumberFor<Block>>
-	>(
+	fn into_storage_changes(
 		&self,
 		_: &Self::StateBackend,
-		_: Option<&T>,
+		_: Option<&sp_api::ChangesTrieState<sp_api::HasherFor<Block>, sp_api::NumberFor<Block>>>,
 		_: <Block as sp_api::BlockT>::Hash,
 	) -> std::result::Result<sp_api::StorageChanges<Self::StateBackend, Block>, String>
 		where Self: Sized

client/basic-authorship/src/basic_authorship.rs

@@ -374,9 +374,12 @@ mod tests {
 		api.execute_block(&block_id, proposal.block).unwrap();
 
 		let state = backend.state_at(block_id).unwrap();
-		let changes_trie_storage = backend.changes_trie_storage();
+		let changes_trie_state = backend::changes_tries_state_at_block(
+			&block_id,
+			backend.changes_trie_storage(),
+		).unwrap();
 
-		let storage_changes = api.into_storage_changes(&state, changes_trie_storage, genesis_hash)
+		let storage_changes = api.into_storage_changes(&state, changes_trie_state.as_ref(), genesis_hash)
 			.unwrap();
 
 		assert_eq!(

client/block-builder/src/lib.rs

@@ -191,14 +191,17 @@ where
 		let proof = self.api.extract_proof();
 
 		let state = self.backend.state_at(self.block_id)?;
-		let changes_trie_storage = self.backend.changes_trie_storage();
+		let changes_trie_state = backend::changes_tries_state_at_block(
+			&self.block_id,
+			self.backend.changes_trie_storage(),
+		)?;
 		let parent_hash = self.parent_hash;
 
 		// The unsafe is required because the consume requires that we drop/consume the inner api
 		// (what we do here).
 		let storage_changes = self.api.into_storage_changes(
 			&state,
-			changes_trie_storage,
+			changes_trie_state.as_ref(),
 			parent_hash,
 		);
 

client/consensus/aura/src/lib.rs

@@ -675,19 +675,21 @@ fn initialize_authorities_cache<A, B, C>(client: &C) -> Result<(), ConsensusErro
 	};
 
 	// check if we already have initialized the cache
+	let map_err = |error| sp_consensus::Error::from(sp_consensus::Error::ClientImport(
+		format!(
+			"Error initializing authorities cache: {}",
+			error,
+		)));
+
 	let genesis_id = BlockId::Number(Zero::zero());
 	let genesis_authorities: Option<Vec<A>> = cache
 		.get_at(&well_known_cache_keys::AUTHORITIES, &genesis_id)
+		.unwrap_or(None)
 		.and_then(|(_, _, v)| Decode::decode(&mut &v[..]).ok());
 	if genesis_authorities.is_some() {
 		return Ok(());
 	}
 
-	let map_err = |error| sp_consensus::Error::from(sp_consensus::Error::ClientImport(
-		format!(
-			"Error initializing authorities cache: {}",
-			error,
-		)));
 	let genesis_authorities = authorities(client, &genesis_id)?;
 	cache.initialize(&well_known_cache_keys::AUTHORITIES, genesis_authorities.encode())
 		.map_err(map_err)?;
@@ -706,6 +708,7 @@ fn authorities<A, B, C>(client: &C, at: &BlockId<B>) -> Result<Vec<A>, Consensus
 		.cache()
 		.and_then(|cache| cache
 			.get_at(&well_known_cache_keys::AUTHORITIES, at)
+			.unwrap_or(None)
 			.and_then(|(_, _, v)| Decode::decode(&mut &v[..]).ok())
 		)
 		.or_else(|| AuraApi::authorities(&*client.runtime_api(), at).ok())

client/db/Cargo.toml

@@ -31,6 +31,8 @@ sp-keyring = { version = "2.0.0", path = "../../primitives/keyring" }
 substrate-test-runtime-client = { version = "2.0.0", path = "../../test-utils/runtime/client" }
 env_logger = "0.7.0"
 quickcheck = "0.9"
+kvdb-rocksdb = "0.4"
+tempdir = "0.3"
 
 [features]
 default = []