encodable ChangesTrieConfiguration

demo/executor/src/lib.rs

@@ -48,7 +48,7 @@ mod tests {
 	use keyring::Keyring;
 	use runtime_support::{Hashable, StorageValue, StorageMap};
 	use state_machine::{CodeExecutor, Externalities, TestExternalities};
-	use primitives::{twox_128, KeccakHasher, RlpCodec};
+	use primitives::{twox_128, KeccakHasher, RlpCodec, ChangesTrieConfiguration};
 	use demo_primitives::{Hash, BlockNumber, AccountId};
 	use runtime_primitives::traits::Header as HeaderT;
 	use runtime_primitives::{ApplyOutcome, ApplyError, ApplyResult, MaybeUnsigned};
@@ -196,9 +196,11 @@ mod tests {
 		TestExternalities::new(GenesisConfig {
 			consensus: Some(Default::default()),
 			system: Some(SystemConfig {
-				changes_trie_enabled: support_changes_trie,
-				changes_trie_digest_interval: Some(2),
-				changes_trie_digest_levels: Some(2),
+				changes_trie_config: if support_changes_trie { Some(ChangesTrieConfiguration {
+					digest_interval: 2,
+					digest_levels: 2,
+				}) } else { None },
+				..Default::default()
 			}),
 			session: Some(SessionConfig {
 				session_length: 2,
@@ -262,9 +264,9 @@ mod tests {
 			1,
 			[69u8; 32].into(),
 			if support_changes_trie {
-				hex!("4011519eba01902e40392378ebc85375bf780acb68f44ebbf311ee68d4e76732").into()
+				hex!("7fff2f2adbc30e5382b7ad7c515983d1de901724a41af14abf794d68c6093193").into()
 			} else {
-				hex!("3b57e52e95c1a839ce4a1a54761fb7f28c90f74d2cafdbf52265646384d74528").into()
+				hex!("56c9a542e48ccf4e0821de301ea4384e87425604278b12a9db31c6d4e89ca51e").into()
 			},
 			if support_changes_trie {
 				Some(hex!("ba0c0313a9812380261438c1cbf38a9c75d5a7628d29193393a17ae7b7181dcd").into())
@@ -283,7 +285,7 @@ mod tests {
 		construct_block(
 			2,
 			block1(false).1,
-			hex!("e4451178254b2c0fd193c1613aa57a43f32aa9bdd6e179ae32150ee2bf5af0ee").into(),
+			hex!("e0172ce6c10694ea74c17694cf9ab83f9553b4797aa74cc51dece45bd91533b4").into(),
 			None,
 			vec![
 				BareExtrinsic {
@@ -304,7 +306,7 @@ mod tests {
 		construct_block(
 			1,
 			[69u8; 32].into(),
-			hex!("a5579b8696887b5a86b9adca9528af1f7e5a183f97a5e5052a904571b5323002").into(),
+			hex!("be186810570e437f0d803493fced9879207b064a0701fd8d68662b9563b4d33e").into(),
 			None,
 			vec![BareExtrinsic {
 				signed: alice(),

substrate/executor/src/wasm_executor.rs

@@ -199,7 +199,7 @@ impl_function_executor!(this: FunctionExecutor<'e, E>,
 		debug_trace!(target: "runtime-io", "free {}", addr);
 		Ok(())
 	},
-	ext_set_changes_trie_config(block: u64, digest_interval: u64, digest_levels: u8) => {
+	ext_set_changes_trie_config(block: u64, digest_interval: u64, digest_levels: u32) => {
 		debug_trace!(target: "runtime-io", "ext_set_changes_trie_config {} {} {}",
 			block, digest_interval, digest_levels);
 		this.ext.set_changes_trie_config(block, digest_interval, digest_levels);

substrate/executor/src/wasm_utils.rs

@@ -31,8 +31,6 @@ impl HostError for UserError {
 }
 
 pub trait ConvertibleToWasm { const VALUE_TYPE: ValueType; type NativeType; fn to_runtime_value(self) -> RuntimeValue; }
-impl ConvertibleToWasm for i8 { type NativeType = i8; const VALUE_TYPE: ValueType = ValueType::I32; fn to_runtime_value(self) -> RuntimeValue { RuntimeValue::I32(self as i32) } }
-impl ConvertibleToWasm for u8 { type NativeType = u8; const VALUE_TYPE: ValueType = ValueType::I32; fn to_runtime_value(self) -> RuntimeValue { RuntimeValue::I32(self as i32) } }
 impl ConvertibleToWasm for i32 { type NativeType = i32; const VALUE_TYPE: ValueType = ValueType::I32; fn to_runtime_value(self) -> RuntimeValue { RuntimeValue::I32(self) } }
 impl ConvertibleToWasm for u32 { type NativeType = u32; const VALUE_TYPE: ValueType = ValueType::I32; fn to_runtime_value(self) -> RuntimeValue { RuntimeValue::I32(self as i32) } }
 impl ConvertibleToWasm for i64 { type NativeType = i64; const VALUE_TYPE: ValueType = ValueType::I64; fn to_runtime_value(self) -> RuntimeValue { RuntimeValue::I64(self) } }

substrate/primitives/src/changes_trie.rs

@@ -0,0 +1,30 @@
+// Copyright 2018 Parity Technologies (UK) Ltd.
+// This file is part of Substrate.
+
+// Substrate is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Substrate is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Substrate.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Substrate changes trie configuration.
+
+/// An identifier for an authority in the consensus algorithm. The same size as ed25519::Public.
+#[cfg_attr(any(feature = "std", test), derive(Serialize, Deserialize))]
+#[derive(Debug, Clone, PartialEq, Eq, Default, Encode, Decode)]
+pub struct ChangesTrieConfiguration {
+	/// Interval (in blocks) at which level1-digests are created. Digests are not
+	/// created when this is less or equal to 1.
+	pub digest_interval: u64,
+	/// Maximal number of digest levels in hierarchy. 0 means that digests are not
+	/// created at all (even level1 digests). 1 means only level1-digests are created.
+	/// 2 means that every digest_interval^2 there will be a level2-digest, and so on.
+	pub digest_levels: u32,
+}

substrate/primitives/src/lib.rs

@@ -100,13 +100,15 @@ pub mod uint;
 mod authority_id;
 #[cfg(feature = "std")]
 mod rlp_codec;
+mod changes_trie;
 
 #[cfg(test)]
 mod tests;
 
 pub use self::hash::{H160, H256, H512};
 pub use self::uint::U256;
 pub use authority_id::AuthorityId;
+pub use changes_trie::ChangesTrieConfiguration;
 
 // Switch back to Blake after PoC-3 is out
 // pub use self::hasher::blake::BlakeHasher;

substrate/runtime-io/with_std.rs

@@ -42,7 +42,7 @@ environmental!(ext: trait Externalities<KeccakHasher>);
 
 /// Sets changes trie configuration parameters, announcing that this runtime is
 /// configured to gather and store changes tries.
-pub fn set_changes_trie_config(block: u64, digest_interval: u64, digest_levels: u8) {
+pub fn set_changes_trie_config(block: u64, digest_interval: u64, digest_levels: u32) {
 	ext::with(|ext|
 		ext.set_changes_trie_config(block, digest_interval, digest_levels)
 	);

substrate/runtime-io/without_std.rs

@@ -54,7 +54,7 @@ extern "C" {
 	fn ext_print_utf8(utf8_data: *const u8, utf8_len: u32);
 	fn ext_print_hex(data: *const u8, len: u32);
 	fn ext_print_num(value: u64);
-	fn ext_set_changes_trie_config(block: u64, digest_interval: u64, digest_levels: u8);
+	fn ext_set_changes_trie_config(block: u64, digest_interval: u64, digest_levels: u32);
 	fn ext_bind_to_extrinsic(extrinsic_index: u32);
 	fn ext_set_storage(key_data: *const u8, key_len: u32, value_data: *const u8, value_len: u32);
 	fn ext_clear_storage(key_data: *const u8, key_len: u32);
@@ -73,7 +73,7 @@ extern "C" {
 }
 /// Sets changes trie configuration parameters, announcing that this runtime is
 /// configured to gather and store changes tries.
-pub fn set_changes_trie_config(block: u64, digest_interval: u64, digest_levels: u8) {
+pub fn set_changes_trie_config(block: u64, digest_interval: u64, digest_levels: u32) {
 	unsafe {
 		ext_set_changes_trie_config(
 			block,

substrate/runtime/executive/src/lib.rs

@@ -337,7 +337,7 @@ mod tests {
 				header: Header {
 					parent_hash: [69u8; 32].into(),
 					number: 1,
-					state_root: hex!("06aa388b73073d5cb9395d544f22ee8b6b0e4730df06aaf295031bf88070b4d4").into(),
+					state_root: hex!("246ea6d86eefe3fc32f746fdcb1749a5f245570c70a04b43d08b5defac44505a").into(),
 					changes_root: None,
 					extrinsics_root: hex!("56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421").into(),
 					digest: Digest { logs: vec![], },
@@ -373,7 +373,7 @@ mod tests {
 				header: Header {
 					parent_hash: [69u8; 32].into(),
 					number: 1,
-					state_root: hex!("06aa388b73073d5cb9395d544f22ee8b6b0e4730df06aaf295031bf88070b4d4").into(),
+					state_root: hex!("246ea6d86eefe3fc32f746fdcb1749a5f245570c70a04b43d08b5defac44505a").into(),
 					changes_root: None,
 					extrinsics_root: [0u8; 32].into(),
 					digest: Digest { logs: vec![], },

substrate/runtime/system/src/lib.rs

@@ -19,7 +19,6 @@
 
 #![cfg_attr(not(feature = "std"), no_std)]
 
-#[cfg(any(feature = "std", test))]
 extern crate substrate_primitives;
 
 #[cfg_attr(any(feature = "std", test), macro_use)]
@@ -44,6 +43,7 @@ extern crate substrate_runtime_primitives as primitives;
 extern crate safe_mix;
 
 use rstd::prelude::*;
+use substrate_primitives::ChangesTrieConfiguration;
 use primitives::traits::{self, CheckEqual, SimpleArithmetic, SimpleBitOps, Zero, One, Bounded,
 	Hash, Member, MaybeDisplay, As};
 use runtime_support::{StorageValue, StorageMap, Parameter};
@@ -115,9 +115,7 @@ decl_storage! {
 	pub ExtrinsicIndex get(extrinsic_index): b"sys:xti" => u32;
 	ExtrinsicData get(extrinsic_data): b"sys:xtd" => required map [ u32 => Vec<u8> ];
 	RandomSeed get(random_seed): b"sys:rnd" => required T::Hash;
-	ChangesTrieCreationEnabled get(changes_trie_creation_enabled): b"sys:changes_trie_creation_enabled" => default bool;
-	ChangesTrieDigestInterval get(changes_trie_digest_interval): b"sys:changes_trie_digest_interval" => default T::BlockNumber;
-	ChangesTrieDigestLevels get(changes_trie_digest_level): b"sys:changes_trie_digest_levels" => default u32;
+	ChangesTrieConfig: b"sys:changes_trie_cfg" => ChangesTrieConfiguration;
 	// The current block number being processed. Set by `execute_block`.
 	Number get(block_number): b"sys:num" => required T::BlockNumber;
 	ParentHash get(parent_hash): b"sys:pha" => required T::Hash;
@@ -139,15 +137,11 @@ impl<T: Trait> Module<T> {
 		<ExtrinsicIndex<T>>::put(0u32);
 		<Events<T>>::kill();
 
-		if <ChangesTrieCreationEnabled<T>>::get() {
-			let digest_interval = <ChangesTrieDigestInterval<T>>::get();
-			let digest_levels = <ChangesTrieDigestLevels<T>>::get();
-			assert!(digest_levels <= 255u32, "changes_trie_digest_levels is too large to fit into u8");
-
+		if let Some(changes_trie_config) = <ChangesTrieConfig<T>>::get() {
 			runtime_io::set_changes_trie_config(
 				number.as_(),
-				digest_interval.as_(),
-				digest_levels as u8);
+				changes_trie_config.digest_interval,
+				changes_trie_config.digest_levels);
 			runtime_io::bind_to_extrinsic(0u32);
 		}
 	}
@@ -267,24 +261,18 @@ impl<T: Trait> Module<T> {
 #[serde(rename_all = "camelCase")]
 #[serde(deny_unknown_fields)]
 pub struct GenesisConfig<T: Trait> {
-	/// True if changes trie creation is enabled.
-	pub changes_trie_enabled: bool,
-	/// Interval (in blocks) at which level1-digests are created. Digests are not
-	/// created when this is None or less or equal to 1.
-	pub changes_trie_digest_interval: Option<T::BlockNumber>,
-	/// Maximal number of digest levels in hierarchy. None/0 means that digests are not
-	/// created at all (even level1 digests). 1 means only level1-digests are created.
-	/// 2 means that every digest_interval^2 there will be a level2-digest, and so on.
-	pub changes_trie_digest_levels: Option<u8>,
+	/// Changes trie configuration.
+	pub changes_trie_config: Option<ChangesTrieConfiguration>,
+	/// Marker for 'storing' T.
+	pub _phantom: ::std::marker::PhantomData<T>,
 }
 
 #[cfg(any(feature = "std", test))]
 impl<T: Trait> Default for GenesisConfig<T> {
 	fn default() -> Self {
 		GenesisConfig {
-			changes_trie_enabled: false,
-			changes_trie_digest_interval: None,
-			changes_trie_digest_levels: None,
+			changes_trie_config: Default::default(),
+			_phantom: Default::default(),
 		}
 	}
 }
@@ -296,26 +284,17 @@ impl<T: Trait> primitives::BuildStorage for GenesisConfig<T>
 		use codec::Encode;
 
 		let mut storage: primitives::StorageMap = map![
-			Self::hash(<ChangesTrieCreationEnabled<T>>::key()).to_vec() => self.changes_trie_enabled.encode(),
 			Self::hash(&<BlockHash<T>>::key_for(T::BlockNumber::zero())).to_vec() => [69u8; 32].encode(),
 			Self::hash(<Number<T>>::key()).to_vec() => 1u64.encode(),
 			Self::hash(<ParentHash<T>>::key()).to_vec() => [69u8; 32].encode(),
 			Self::hash(<RandomSeed<T>>::key()).to_vec() => [0u8; 32].encode(),
 			Self::hash(<ExtrinsicIndex<T>>::key()).to_vec() => [0u8; 4].encode()
 		];
 
-		if self.changes_trie_enabled {
-			if let Some(changes_trie_digest_interval) = self.changes_trie_digest_interval {
-				storage.insert(
-					Self::hash(<ChangesTrieDigestInterval<T>>::key()).to_vec(),
-					changes_trie_digest_interval.encode());
-			}
-
-			if let Some(changes_trie_digest_levels) = self.changes_trie_digest_levels {
-				storage.insert(
-					Self::hash(<ChangesTrieDigestLevels<T>>::key()).to_vec(),
-					(changes_trie_digest_levels as u32).encode());
-			}
+		if let Some(changes_trie_config) = self.changes_trie_config {
+			storage.insert(
+				Self::hash(<ChangesTrieConfig<T>>::key()).to_vec(),
+				changes_trie_config.encode());
 		}
 
 		Ok(storage)

substrate/state-machine/src/changes_trie/build_iterator.rs

@@ -35,7 +35,7 @@ pub fn digest_build_iterator(config: &Configuration, block: u64) -> DigestBuildI
 
 	// we have checked that the block is at least level1-digest
 	// => try to find highest digest level for inclusion
-	let mut current_level = 1u8;
+	let mut current_level = 1u32;
 	let mut digest_step = 1u64;
 	while current_level < config.digest_levels {
 		let new_digest_interval = match digest_interval.checked_mul(config.digest_interval) {
@@ -117,16 +117,16 @@ impl Iterator for DigestBuildIterator {
 mod tests {
 	use super::*;
 
-	fn digest_build_iterator(digest_interval: u64, digest_levels: u8, block: u64) -> DigestBuildIterator {
+	fn digest_build_iterator(digest_interval: u64, digest_levels: u32, block: u64) -> DigestBuildIterator {
 		super::digest_build_iterator(&Configuration { digest_interval, digest_levels }, block)
 	}
 
-	fn digest_build_iterator_basic(digest_interval: u64, digest_levels: u8, block: u64) -> (u64, u64, u64) {
+	fn digest_build_iterator_basic(digest_interval: u64, digest_levels: u32, block: u64) -> (u64, u64, u64) {
 		let iter = digest_build_iterator(digest_interval, digest_levels, block);
 		(iter.block, iter.digest_interval, iter.max_step)
 	}
 
-	fn digest_build_iterator_blocks(digest_interval: u64, digest_levels: u8, block: u64) -> Vec<u64> {
+	fn digest_build_iterator_blocks(digest_interval: u64, digest_levels: u32, block: u64) -> Vec<u64> {
 		digest_build_iterator(digest_interval, digest_levels, block).collect()
 	}
 

substrate/state-machine/src/changes_trie/changes_iterator.rs

@@ -129,11 +129,11 @@ pub struct SurfaceIterator<'a> {
 	current: Option<u64>,
 	current_begin: u64,
 	digest_step: u64,
-	digest_level: u8,
+	digest_level: u32,
 }
 
 impl<'a> Iterator for SurfaceIterator<'a> {
-	type Item = Result<(u64, u8), String>;
+	type Item = Result<(u64, u32), String>;
 
 	fn next(&mut self) -> Option<Self::Item> {
 		let current = self.current?;
@@ -176,7 +176,7 @@ pub struct DrilldownIteratorEssence<'a, RS: 'a + Storage<H>, S: 'a + Storage<H>,
 	surface: SurfaceIterator<'a>,
 
 	extrinsics: VecDeque<(u64, u32)>,
-	blocks: VecDeque<(u64, u8)>,
+	blocks: VecDeque<(u64, u32)>,
 
 	_hasher: ::std::marker::PhantomData<H>,
 }
@@ -303,12 +303,12 @@ fn lower_bound_max_digest(
 	max: u64,
 	begin: u64,
 	end: u64,
-) -> Result<(u64, u64, u64, u8), String> {
+) -> Result<(u64, u64, u64, u32), String> {
 	if end > max || begin > end {
 		return Err("invalid changes range".into());
 	}
 
-	let mut digest_level = 0u8;
+	let mut digest_level = 0u32;
 	let mut digest_step = 1u64;
 	let mut digest_interval = 0u64;
 	let mut current = end;

substrate/state-machine/src/changes_trie/mod.rs

@@ -46,6 +46,7 @@ use heapsize::HeapSizeOf;
 use patricia_trie::NodeCodec;
 use rlp::Encodable;
 use backend::Backend;
+use primitives;
 use changes_trie::build::prepare_input;
 use overlayed_changes::OverlayedChanges;
 use trie_backend_essence::TrieBackendStorage;
@@ -62,16 +63,7 @@ pub trait Storage<H: Hasher>: Send + Sync {
 }
 
 /// Changes trie configuration.
-#[derive(Debug, Clone, PartialEq)]
-pub struct Configuration {
-	/// Interval (in blocks) at which level1-digests are created. Digests are not
-	/// created when this is less or equal to 1.
-	pub digest_interval: u64,
-	/// Maximal number of digest levels in hierarchy. 0 means that digests are not
-	/// created at all (even level1 digests). 1 means only level1-digests are created.
-	/// 2 means that every digest_interval^2 there will be a level2-digest, and so on.
-	pub digest_levels: u8,
-}
+pub type Configuration = primitives::ChangesTrieConfiguration;
 
 /// Compute the changes trie root and transaction for given block.
 /// Returns None if there's no data to perform computation.

substrate/state-machine/src/ext.rs

@@ -154,7 +154,7 @@ where
 	T: 'a + ChangesTrieStorage<H>,
 	H::Out: Ord + Encodable + HeapSizeOf,
 {
-	fn set_changes_trie_config(&mut self, block: u64, digest_interval: u64, digest_levels: u8) {
+	fn set_changes_trie_config(&mut self, block: u64, digest_interval: u64, digest_levels: u32) {
 		self.overlay.set_changes_trie_config(block, ChangesTrieConfig {
 			digest_interval,
 			digest_levels,

substrate/state-machine/src/lib.rs

@@ -34,7 +34,6 @@ extern crate byteorder;
 extern crate parking_lot;
 extern crate rlp;
 extern crate heapsize;
-#[cfg(test)]
 extern crate substrate_primitives as primitives;
 
 use std::fmt;
@@ -94,7 +93,7 @@ pub trait Externalities<H: Hasher> {
 	/// Sets changes trie configuration parameters. Runtime announces that this it is
 	/// configured to gather and store changes tries by calling this method and bind_to_extrinsic
 	/// afterwards.
-	fn set_changes_trie_config(&mut self, block: u64, digest_interval: u64, digest_levels: u8);
+	fn set_changes_trie_config(&mut self, block: u64, digest_interval: u64, digest_levels: u32);
 
 	/// Start binding storage changes to the extrinsic number they're changes in.
 	/// This is used later by storage_changes_root to compose changes trie.

substrate/state-machine/src/testing.rs

@@ -96,7 +96,7 @@ impl<H: Hasher, C: NodeCodec<H>> From< HashMap<Vec<u8>, Vec<u8>> > for TestExter
 }
 
 impl<H: Hasher, C: NodeCodec<H>> Externalities<H> for TestExternalities<H, C> where H::Out: Ord + Encodable + HeapSizeOf {
-	fn set_changes_trie_config(&mut self, block: u64, digest_interval: u64, digest_levels: u8) {
+	fn set_changes_trie_config(&mut self, block: u64, digest_interval: u64, digest_levels: u32) {
 		self.changes.set_changes_trie_config(block, ChangesTrieConfig {
 			digest_interval,
 			digest_levels,