Allow updating configuration of changes tries

client/api/src/backend.rs

@@ -23,7 +23,7 @@ use sp_core::offchain::OffchainStorage;
 use sp_runtime::{generic::BlockId, Justification, Storage};
 use sp_runtime::traits::{Block as BlockT, NumberFor};
 use sp_state_machine::backend::Backend as StateBackend;
-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
@@ -237,8 +237,6 @@ pub trait Backend<Block, H>: AuxStore + Send + Sync where
 	type Blockchain: BlockchainBackend<Block>;
 	/// Associated state backend type.
 	type State: StateBackend<H>;
-	/// Changes trie storage.
-	type ChangesTrieStorage: PrunableStateChangesTrieStorage<Block, H>;
 	/// Offchain workers local storage.
 	type OffchainStorage: OffchainStorage;
 
@@ -265,7 +263,7 @@ pub trait Backend<Block, H>: AuxStore + Send + Sync where
 	fn used_state_cache_size(&self) -> Option<usize>;
 
 	/// Returns reference to changes trie storage.
-	fn changes_trie_storage(&self) -> Option<&Self::ChangesTrieStorage>;
+	fn changes_trie_storage(&self) -> Option<&dyn PrunableStateChangesTrieStorage<Block, H>>;
 
 	/// Returns a handle to offchain storage.
 	fn offchain_storage(&self) -> Option<Self::OffchainStorage>;
@@ -313,16 +311,29 @@ pub trait Backend<Block, H>: AuxStore + Send + Sync where
 	fn get_import_lock(&self) -> &RwLock<()>;
 }
 
+/// Changes trie configuration range.
+#[derive(Debug)]
+pub struct ChangesTrieConfigurationRange<Block: BlockT> {
+	/// Zero block of this configuration. First trie that uses this configuration is build at the next block.
+	pub zero: (NumberFor<Block>, Block::Hash),
+	/// End block where last trie that uses this configuration has been build. None if configuration is active.
+	pub end: Option<(NumberFor<Block>, Block::Hash)>,
+	/// Configuration itself. None if changes tries are disabled within this range.
+	pub config: Option<ChangesTrieConfiguration>,
+}
+
 /// Changes trie storage that supports pruning.
 pub trait PrunableStateChangesTrieStorage<Block: BlockT, H: Hasher>:
 	StateChangesTrieStorage<H, 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<H, NumberFor<Block>>;
+	/// Get coniguration at given block.
+	fn configuration_at(&self, at: &BlockId<Block>) -> sp_blockchain::Result<ChangesTrieConfigurationRange<Block>>;
+	/// 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.
@@ -347,3 +358,23 @@ where
 	/// 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, H: Hasher>(
+	block: &BlockId<Block>,
+	maybe_storage: Option<&'a dyn PrunableStateChangesTrieStorage<Block, H>>,
+) -> sp_blockchain::Result<Option<ChangesTrieState<'a, H, NumberFor<Block>>>>
+	where
+		H: Hasher<Out=Block::Hash>,
+{
+	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/call_executor.rs

@@ -101,6 +101,7 @@ where
 		NC: FnOnce() -> result::Result<R, String> + UnwindSafe,
 	>(&self,
 		state: &S,
+		state_block: &BlockId<B>,
 		overlay: &mut OverlayedChanges,
 		method: &str,
 		call_data: &[u8],

client/api/src/light.rs

@@ -95,8 +95,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<(Header::Number, Option<Header::Number>, ChangesTrieConfiguration)>,
 	/// 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/consensus/aura/src/lib.rs

@@ -653,19 +653,20 @@ 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)
+		.get_at(&well_known_cache_keys::AUTHORITIES, &genesis_id).map_err(map_err)?
 		.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)?;
@@ -684,6 +685,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())