Inner hashing of value in state trie (chainspec versioning).

Cargo.toml

@@ -265,3 +265,10 @@ zeroize = { opt-level = 3 }
 [profile.release]
 # Substrate runtime requires unwinding.
 panic = "unwind"
+
+[patch.crates-io]
+hash-db = { git = "https://github.com/cheme/trie.git", branch = "hashed-value-simple4-new" }
+memory-db = { git = "https://github.com/cheme/trie.git", branch = "hashed-value-simple4-new" }
+trie-db = { git = "https://github.com/cheme/trie.git", branch = "hashed-value-simple4-new" }
+trie-root = { git = "https://github.com/cheme/trie.git", branch = "hashed-value-simple4-new" }
+trie-bench = { git = "https://github.com/cheme/trie.git", branch = "hashed-value-simple4-new" }

bin/node-template/node/src/chain_spec.rs

@@ -72,6 +72,8 @@ pub fn development_config() -> Result<ChainSpec, String> {
 		None,
 		// Extensions
 		None,
+		// StateVersion
+		Default::default(),
 	))
 }
 
@@ -119,6 +121,8 @@ pub fn local_testnet_config() -> Result<ChainSpec, String> {
 		None,
 		// Extensions
 		None,
+		// StateVersion
+		Default::default(),
 	))
 }
 

bin/node/bench/src/generator.rs

@@ -23,6 +23,7 @@ use node_primitives::Hash;
 use sp_trie::{trie_types::TrieDBMut, TrieMut};
 
 use crate::simple_trie::SimpleTrie;
+use sp_core::state_version::StateVersion;
 
 /// Generate trie from given `key_values`.
 ///
@@ -31,6 +32,7 @@ use crate::simple_trie::SimpleTrie;
 pub fn generate_trie(
 	db: Arc<dyn KeyValueDB>,
 	key_values: impl IntoIterator<Item = (Vec<u8>, Vec<u8>)>,
+	state_version: StateVersion,
 ) -> Hash {
 	let mut root = Hash::default();
 
@@ -43,8 +45,15 @@ pub fn generate_trie(
 		);
 		let mut trie = SimpleTrie { db, overlay: &mut overlay };
 		{
-			let mut trie_db = TrieDBMut::new(&mut trie, &mut root);
-
+			let mut trie_db = match state_version {
+				StateVersion::V0 => TrieDBMut::new(&mut trie, &mut root),
+				StateVersion::V1 { threshold } => {
+					let layout = sp_trie::Layout::with_max_inline_value(threshold);
+					TrieDBMut::<crate::simple_trie::Hasher>::new_with_layout(
+						&mut trie, &mut root, layout,
+					)
+				},
+			};
 			for (key, value) in key_values {
 				trie_db.insert(&key, &value).expect("trie insertion failed");
 			}

bin/node/bench/src/trie.rs

@@ -142,7 +142,7 @@ impl core::BenchmarkDescription for TrieReadBenchmarkDescription {
 		assert_eq!(warmup_keys.len(), SAMPLE_SIZE);
 		assert_eq!(query_keys.len(), SAMPLE_SIZE);
 
-		let root = generate_trie(database.open(self.database_type), key_values);
+		let root = generate_trie(database.open(self.database_type), key_values, Default::default());
 
 		Box::new(TrieReadBenchmark {
 			database,
@@ -180,7 +180,8 @@ impl core::Benchmark for TrieReadBenchmark {
 		let storage: Arc<dyn sp_state_machine::Storage<sp_core::Blake2Hasher>> =
 			Arc::new(Storage(db.open(self.database_type)));
 
-		let trie_backend = sp_state_machine::TrieBackend::new(storage, self.root);
+		let state_version = Default::default();
+		let trie_backend = sp_state_machine::TrieBackend::new(storage, self.root, state_version);
 		for (warmup_key, warmup_value) in self.warmup_keys.iter() {
 			let value = trie_backend
 				.storage(&warmup_key[..])
@@ -248,7 +249,7 @@ impl core::BenchmarkDescription for TrieWriteBenchmarkDescription {
 
 		assert_eq!(warmup_keys.len(), SAMPLE_SIZE);
 
-		let root = generate_trie(database.open(self.database_type), key_values);
+		let root = generate_trie(database.open(self.database_type), key_values, Default::default());
 
 		Box::new(TrieWriteBenchmark {
 			database,

bin/node/cli/src/chain_spec.rs

@@ -197,6 +197,7 @@ pub fn staging_testnet_config() -> ChainSpec {
 		None,
 		None,
 		Default::default(),
+		Default::default(),
 	)
 }
 
@@ -387,6 +388,7 @@ pub fn development_config() -> ChainSpec {
 		None,
 		None,
 		Default::default(),
+		Default::default(),
 	)
 }
 
@@ -411,6 +413,7 @@ pub fn local_testnet_config() -> ChainSpec {
 		None,
 		None,
 		Default::default(),
+		Default::default(),
 	)
 }
 
@@ -442,6 +445,7 @@ pub(crate) mod tests {
 			None,
 			None,
 			Default::default(),
+			Default::default(),
 		)
 	}
 
@@ -457,6 +461,7 @@ pub(crate) mod tests {
 			None,
 			None,
 			Default::default(),
+			Default::default(),
 		)
 	}
 

bin/node/executor/benches/bench.rs

@@ -89,10 +89,10 @@ fn construct_block<E: Externalities>(
 	let extrinsics = extrinsics.into_iter().map(sign).collect::<Vec<_>>();
 
 	// calculate the header fields that we can.
-	let extrinsics_root =
-		Layout::<BlakeTwo256>::ordered_trie_root(extrinsics.iter().map(Encode::encode))
-			.to_fixed_bytes()
-			.into();
+	let extrinsics_root = Layout::<BlakeTwo256>::default()
+		.ordered_trie_root(extrinsics.iter().map(Encode::encode))
+		.to_fixed_bytes()
+		.into();
 
 	let header = Header {
 		parent_hash,

bin/node/executor/tests/common.rs

@@ -151,10 +151,10 @@ pub fn construct_block(
 	let extrinsics = extrinsics.into_iter().map(sign).collect::<Vec<_>>();
 
 	// calculate the header fields that we can.
-	let extrinsics_root =
-		Layout::<BlakeTwo256>::ordered_trie_root(extrinsics.iter().map(Encode::encode))
-			.to_fixed_bytes()
-			.into();
+	let extrinsics_root = Layout::<BlakeTwo256>::default()
+		.ordered_trie_root(extrinsics.iter().map(Encode::encode))
+		.to_fixed_bytes()
+		.into();
 
 	let header = Header {
 		parent_hash,

bin/node/testing/src/bench.rs

@@ -387,7 +387,8 @@ impl BenchDb {
 		};
 		let task_executor = TaskExecutor::new();
 
-		let backend = sc_service::new_db_backend(db_config).expect("Should not fail");
+		let backend =
+			sc_service::new_db_backend(db_config, Default::default()).expect("Should not fail");
 		let client = sc_service::new_client(
 			backend.clone(),
 			NativeElseWasmExecutor::new(WasmExecutionMethod::Compiled, None, 8),

bin/utils/chain-spec-builder/src/main.rs

@@ -156,6 +156,7 @@ fn generate_chain_spec(
 		None,
 		None,
 		Default::default(),
+		Default::default(),
 	);
 
 	chain_spec.as_json(false).map_err(|err| err)

client/api/src/cht.rs

@@ -94,9 +94,8 @@ where
 	I: IntoIterator<Item = ClientResult<Option<Header::Hash>>>,
 {
 	use sp_trie::TrieConfiguration;
-	Ok(sp_trie::trie_types::Layout::<Hasher>::trie_root(build_pairs::<Header, I>(
-		cht_size, cht_num, hashes,
-	)?))
+	Ok(sp_trie::Layout::<Hasher>::default()
+		.trie_root(build_pairs::<Header, I>(cht_size, cht_num, hashes)?))
 }
 
 /// Build CHT-based header proof.
@@ -117,7 +116,9 @@ where
 		.into_iter()
 		.map(|(k, v)| (k, Some(v)))
 		.collect::<Vec<_>>();
-	let storage = InMemoryBackend::<Hasher>::default().update(vec![(None, transaction)]);
+	// No inner hashing for cht.
+	let backend: InMemoryBackend<Hasher> = sp_runtime::StateVersion::V0.into();
+	let storage = backend.update(vec![(None, transaction)]);
 	let trie_storage = storage
 		.as_trie_backend()
 		.expect("InMemoryState::as_trie_backend always returns Some; qed");

client/api/src/in_mem.rs

@@ -26,7 +26,7 @@ use sp_core::{
 use sp_runtime::{
 	generic::BlockId,
 	traits::{Block as BlockT, HashFor, Header as HeaderT, NumberFor, Zero},
-	Justification, Justifications, Storage,
+	Justification, Justifications, StateVersion, StateVersions, Storage,
 };
 use sp_state_machine::{
 	Backend as StateBackend, ChangesTrieTransaction, ChildStorageCollection, InMemoryBackend,
@@ -112,6 +112,7 @@ struct BlockchainStorage<Block: BlockT> {
 	changes_trie_cht_roots: HashMap<NumberFor<Block>, Block::Hash>,
 	leaves: LeafSet<Block::Hash, NumberFor<Block>>,
 	aux: HashMap<Vec<u8>, Vec<u8>>,
+	state_versions: StateVersions<Block>,
 }
 
 /// In-memory blockchain. Supports concurrent reads.
@@ -141,6 +142,20 @@ impl<Block: BlockT> Blockchain<Block> {
 		}
 	}
 
+	/// Get version of state.
+	pub fn state_version(&self, id: BlockId<Block>) -> StateVersion {
+		let number = match id {
+			BlockId::Hash(h) =>
+				if let Ok(Some(header)) = self.header(BlockId::Hash(h)) {
+					header.number().clone()
+				} else {
+					0u32.into()
+				},
+			BlockId::Number(n) => n,
+		};
+		self.storage.read().state_versions.state_version_at(number)
+	}
+
 	/// Create new in-memory blockchain storage.
 	pub fn new() -> Blockchain<Block> {
 		let storage = Arc::new(RwLock::new(BlockchainStorage {
@@ -155,6 +170,7 @@ impl<Block: BlockT> Blockchain<Block> {
 			changes_trie_cht_roots: HashMap::new(),
 			leaves: LeafSet::new(),
 			aux: HashMap::new(),
+			state_versions: StateVersions::default(),
 		}));
 		Blockchain { storage }
 	}
@@ -855,7 +871,8 @@ where
 
 	fn state_at(&self, block: BlockId<Block>) -> sp_blockchain::Result<Self::State> {
 		match block {
-			BlockId::Hash(h) if h == Default::default() => return Ok(Self::State::default()),
+			BlockId::Hash(h) if h == Default::default() =>
+				return Ok(self.blockchain.state_version(BlockId::Hash(h)).into()),
 			_ => {},
 		}