Merge branch 'master' into child-trie-soft-min

core/client/db/src/lib.rs

@@ -54,7 +54,7 @@ use sr_primitives::{
 	generic::{BlockId, DigestItem}, Justification, StorageOverlay, ChildrenStorageOverlay,
 	BuildStorage
 };
-use runtime_primitives::traits::{
+use sr_primitives::traits::{
 	Block as BlockT, Header as HeaderT, NumberFor, Zero, One, SaturatedConversion,
 };
 use state_machine::backend::Backend as StateBackend;

core/client/src/client.rs

@@ -25,7 +25,7 @@ use futures::channel::mpsc;
 use parking_lot::{Mutex, RwLock};
 use primitives::NativeOrEncoded;
 use primitives::child_trie::{ChildTrie, ChildTrieReadRef};
-use runtime_primitives::{
+use sr_primitives::{
 	Justification,
 	generic::{BlockId, SignedBlock},
 };

core/client/src/light/backend.rs

@@ -21,12 +21,12 @@ use std::collections::HashMap;
 use std::sync::{Arc, Weak};
 use parking_lot::{RwLock, Mutex};
 
-use runtime_primitives::{generic::BlockId, Justification, StorageOverlay, ChildrenStorageOverlay};
+use sr_primitives::{generic::BlockId, Justification, StorageOverlay, ChildrenStorageOverlay};
 use primitives::child_trie::ChildTrie;
 use primitives::child_trie::ChildTrieReadRef;
 use state_machine::{Backend as StateBackend, TrieBackend};
 use state_machine::backend::{InMemory as InMemoryState, MapTransaction};
-use runtime_primitives::traits::{Block as BlockT, NumberFor, Zero, Header};
+use sr_primitives::traits::{Block as BlockT, NumberFor, Zero, Header};
 use crate::in_mem::{self, check_genesis_storage};
 use crate::backend::{
 	AuxStore, Backend as ClientBackend, BlockImportOperation, RemoteBackend, NewBlockState,

core/client/src/light/fetcher.rs

@@ -25,7 +25,7 @@ use hash_db::{HashDB, Hasher};
 use parity_codec::{Decode, Encode};
 use primitives::{ChangesTrieConfiguration, convert_hash};
 use primitives::child_trie::ChildTrieRead;
-use runtime_primitives::traits::{
+use sr_primitives::traits::{
 	Block as BlockT, Header as HeaderT, Hash, HashFor, NumberFor,
 	SimpleArithmetic, CheckedConversion,
 };

core/network/src/protocol/message.rs

@@ -17,7 +17,7 @@
 //! Network packet message types. These get serialized and put into the lower level protocol payload.
 
 use bitflags::bitflags;
-use runtime_primitives::{ConsensusEngineId, traits::{Block as BlockT, Header as HeaderT}};
+use sr_primitives::{ConsensusEngineId, traits::{Block as BlockT, Header as HeaderT}};
 use primitives::child_trie::ChildTrieRead;
 use parity_codec::{Encode, Decode, Input, Output};
 pub use self::generic::{

core/network/src/protocol/on_demand.rs

@@ -29,7 +29,7 @@ use client::light::fetcher::{FetchChecker, RemoteHeaderRequest,
 use crate::message::{self, BlockAttributes, Direction, FromBlock, RequestId};
 use libp2p::PeerId;
 use crate::config::Roles;
-use runtime_primitives::traits::{Block as BlockT, Header as HeaderT, NumberFor};
+use sr_primitives::traits::{Block as BlockT, Header as HeaderT, NumberFor};
 use primitives::child_trie::ChildTrieRead;
 
 /// Remote request timeout.
@@ -639,7 +639,7 @@ pub mod tests {
 	use std::time::Instant;
 	use futures::{Future, sync::oneshot};
 	use primitives::child_trie::ChildTrieRead;
-	use runtime_primitives::traits::{Block as BlockT, NumberFor, Header as HeaderT};
+	use sr_primitives::traits::{Block as BlockT, NumberFor, Header as HeaderT};
 	use client::{error::{Error as ClientError, Result as ClientResult}};
 	use client::light::fetcher::{FetchChecker, RemoteHeaderRequest,
 		ChangesProof,	RemoteCallRequest, RemoteReadRequest,

core/service/src/chain_spec.rs

@@ -22,7 +22,7 @@ use std::fs::File;
 use std::path::PathBuf;
 use serde::{Serialize, Deserialize};
 use primitives::storage::{StorageKey, StorageData};
-use runtime_primitives::{BuildStorage, StorageOverlay, ChildrenStorageOverlay, MapTransaction};
+use sr_primitives::{BuildStorage, StorageOverlay, ChildrenStorageOverlay, MapTransaction};
 use serde_json as json;
 use crate::components::RuntimeGenesis;
 use network::Multiaddr;

core/sr-io/src/lib.rs

@@ -124,10 +124,11 @@ export_api! {
 		/// `ChildTrie` input need to be fetch or instantiate from a valid `Keyspace` generator.
 		fn set_child_trie(ct: ChildTrie) -> bool;
 
-		/// Get `key` from child storage, placing the value into `value_out` (as much of it as possible) and return
-		/// the number of bytes that the entry in storage had beyond the offset or None if the storage entry
-		/// doesn't exist at all. Note that if the buffer is smaller than the storage entry length, the returned
-		/// number of bytes is not equal to the number of bytes written to the `value_out`.
+		/// Get `key` from child storage, placing the value into `value_out` and return the number
+		/// of bytes that the entry in storage has beyond the offset or `None` if the storage entry
+		/// doesn't exist at all.
+		/// If `value_out` length is smaller than the returned length, only `value_out` length bytes
+		/// are copied into `value_out`.
 		fn read_child_storage(
 			child_trie: ChildTrieReadRef,
 			key: &[u8],

core/sr-io/without_std.rs

@@ -19,7 +19,7 @@ pub use rstd;
 pub use rstd::{mem, slice};
 
 use core::{intrinsics, panic::PanicInfo};
-use rstd::{vec::Vec, cell::Cell, convert::TryInto, ptr};
+use rstd::{vec::Vec, cell::Cell, convert::TryInto, convert::TryFrom, ptr};
 use primitives::{offchain, Blake2Hasher,
 	child_trie::{ChildTrie, ChildTrieReadRef}};
 
@@ -695,28 +695,37 @@ impl StorageApi for () {
 
 	/// Get child trie at storage key location.
 	fn child_trie(storage_key: &[u8]) -> Option<ChildTrie> {
-		let mut k = ptr::null_mut();
-		let mut kl = 0u32;
-		let mut r = ptr::null_mut();
-		let mut rl = 0u32;
-		let mut p = ptr::null_mut();
-		let mut pl = 0u32;
-		let mut e = ptr::null_mut();
-		let mut el = 0u32;
+		let mut key = ptr::null_mut();
+		let mut key_length = 0u32;
+		let mut root = ptr::null_mut();
+		let mut root_length = 0u32;
+		let mut parent = ptr::null_mut();
+		let mut parent_length = 0u32;
+		let mut extension = ptr::null_mut();
+		let mut extension_length = 0u32;
 		unsafe {
 			if ext_child_trie.get()(
 				storage_key.as_ptr(),
 				storage_key.len() as u32,
-				&mut k as *mut _,
-				&mut kl,
-				&mut r as *mut _,
-				&mut rl,
-				&mut p as *mut _,
-				&mut pl,
-				&mut e as *mut _,
-				&mut el,
+				&mut key as *mut _,
+				&mut key_length,
+				&mut root as *mut _,
+				&mut root_length,
+				&mut parent as *mut _,
+				&mut parent_length,
+				&mut extension as *mut _,
+				&mut extension_length,
 			) == 1 {
-				Some(ChildTrie::unsafe_from_ptr_child_trie(k, kl, r, rl, p, pl, e, el))
+				Some(ChildTrie::unsafe_from_ptr_child_trie(
+					key,
+					key_length,
+					root,
+					root_length,
+					parent,
+					parent_length,
+					extension,
+					extension_length,
+				))
 			} else {
 				None
 			}

core/state-machine/src/basic.rs

@@ -22,9 +22,8 @@ use crate::backend::{Backend, InMemory, MapTransaction};
 use hash_db::Hasher;
 use trie::{trie_root, default_child_trie_root};
 use primitives::offchain;
-use primitives::storage::well_known_keys::{HEAP_PAGES, is_child_storage_key};
+use primitives::storage::well_known_keys::is_child_storage_key;
 use primitives::child_trie::{ChildTrie, ChildTrieReadRef, KeySpace};
-use parity_codec::Encode;
 use super::Externalities;
 use log::warn;
 
@@ -43,8 +42,7 @@ impl BasicExternalities {
 	}
 
 	/// Create a new instance of `BasicExternalities` with children
-	pub fn new_with_children(mut map: MapTransaction) -> Self {
-		map.top.insert(HEAP_PAGES.to_vec(), 8u64.encode());
+	pub fn new_with_children(map: MapTransaction) -> Self {
 		let pending_child = map.children.values()
 			.map(|(_, child_trie)| (
 					child_trie.parent_slice().to_vec(),
@@ -280,8 +278,8 @@ mod tests {
 	#[test]
 	fn basic_externalities_is_empty() {
 		// Make sure no values are set by default in `BasicExternalities`.
-		let (storage, child_storage) = BasicExternalities::new(Default::default()).into_storages();
-		assert!(storage.is_empty());
-		assert!(child_storage.is_empty());
+		let storages = BasicExternalities::new(Default::default()).into_storages();
+		assert!(storages.top.is_empty());
+		assert!(storages.children.is_empty());
 	}
 }

core/test-client/src/lib.rs

@@ -31,15 +31,15 @@ pub use keyring::{
 	sr25519::Keyring as Sr25519Keyring,
 };
 pub use primitives::Blake2Hasher;
-pub use runtime_primitives::MapTransaction;
+pub use sr_primitives::MapTransaction;
 pub use state_machine::ExecutionStrategy;
 
 use std::sync::Arc;
 use std::collections::HashMap;
 use primitives::child_trie::ChildTrie;
 use futures::future::Ready;
 use hash_db::Hasher;
-use runtime_primitives::traits::{
+use sr_primitives::traits::{
 	Block as BlockT, NumberFor
 };
 use client::LocalCallExecutor;

core/test-runtime/client/src/lib.rs

@@ -100,7 +100,7 @@ pub struct GenesisParameters {
 
 impl generic_test_client::GenesisInit for GenesisParameters {
 	fn genesis_storage(&self) -> MapTransaction {
-		let mut storage = genesis_config(self.support_changes_trie).genesis_map();
+		let mut storage = genesis_config(self.support_changes_trie, self.heap_pages_override).genesis_map();
 
 		let state_root = <<<runtime::Block as BlockT>::Header as HeaderT>::Hashing as HashT>::trie_root(
 			storage.clone().into_iter()

core/trie/src/lib.rs

@@ -23,7 +23,7 @@ mod node_header;
 mod node_codec;
 mod trie_stream;
 
-use substrate_primitives::child_trie::{ChildTrieReadRef, KeySpace, keyspace_as_prefix_alloc};
+use primitives::child_trie::{ChildTrieReadRef, KeySpace, keyspace_as_prefix_alloc};
 use rstd::boxed::Box;
 use rstd::vec::Vec;
 use rstd::marker::PhantomData;
@@ -38,7 +38,7 @@ pub use node_codec::NodeCodec;
 pub use trie_db::{Trie, TrieMut, DBValue, Recorder, Query};
 /// Various re-exports from the `memory-db` crate.
 pub use memory_db::KeyFunction;
-pub use substrate_primitives::child_trie::prefixed_key;
+pub use primitives::child_trie::prefixed_key;
 /// Various re-exports from the `hash-db` crate.
 pub use hash_db::HashDB as HashDBT;
 
@@ -146,7 +146,7 @@ pub fn ordered_trie_root<H: Hasher, I, A>(input: I) -> H::Out where
 	)
 }
 
-/// This function returns the default child trie root.
+/// Determine the default child trie root.
 /// see issue FIXME #2741, this is not efficient.
 pub fn default_child_trie_root<H: Hasher>() -> Vec<u8> {
 	trie_root::<H, _, Vec<u8>, Vec<u8>>(core::iter::empty()).as_ref().iter().cloned().collect()

node/runtime/src/lib.rs

@@ -79,8 +79,8 @@ pub const VERSION: RuntimeVersion = RuntimeVersion {
 	// and set impl_version to equal spec_version. If only runtime
 	// implementation changes and behavior does not, then leave spec_version as
 	// is and increment impl_version.
-	spec_version: 114,
-	impl_version: 114,
+	spec_version: 124,
+	impl_version: 124,
 	apis: RUNTIME_API_VERSIONS,
 };
 

srml/contracts/src/lib.rs

@@ -96,8 +96,8 @@ use crate::wasm::{WasmLoader, WasmVm};
 
 #[cfg(feature = "std")]
 use serde::{Serialize, Deserialize};
-use substrate_primitives::crypto::UncheckedFrom;
-use substrate_primitives::child_trie::ChildTrie;
+use primitives::crypto::UncheckedFrom;
+use primitives::child_trie::ChildTrie;
 use rstd::{prelude::*, marker::PhantomData};
 use parity_codec::{Codec, Encode, Decode};
 use runtime_io::blake2_256;

srml/contracts/src/rent.rs

@@ -16,7 +16,7 @@
 
 use crate::{BalanceOf, ContractInfo, ContractInfoOf, TombstoneContractInfo,
 	Trait, contract_child_trie, AliveContractInfo};
-use runtime_primitives::traits::{Bounded, CheckedDiv, CheckedMul, Saturating, Zero,
+use sr_primitives::traits::{Bounded, CheckedDiv, CheckedMul, Saturating, Zero,
 	SaturatedConversion, Hash as HashT};
 use srml_support::traits::{Currency, ExistenceRequirement, Get, WithdrawReason};
 use srml_support::StorageMap;

srml/contracts/src/tests.rs

@@ -38,9 +38,9 @@ use srml_support::{
 };
 use std::cell::RefCell;
 use std::sync::atomic::{AtomicUsize, Ordering};
-use substrate_primitives::child_trie::ChildTrie;
-use substrate_primitives::storage::well_known_keys;
-use substrate_primitives::Blake2Hasher;
+use primitives::child_trie::ChildTrie;
+use primitives::storage::well_known_keys;
+use primitives::Blake2Hasher;
 use system::{self, EventRecord, Phase};
 use {balances, wabt};
 

srml/executive/src/lib.rs

@@ -466,7 +466,8 @@ mod tests {
 			balances: vec![(1, 211)],
 			vesting: vec![],
 		}.assimilate_storage(&mut t.top, &mut t.children).unwrap();
-		let xt = primitives::testing::TestXt(Some(1), 0, Call::transfer(2, 69));
+		let xt = sr_primitives::testing::TestXt(sign_extra(1, 0, 0), Call::transfer(2, 69));
+		let weight = xt.get_dispatch_info().weight as u64;
 		let mut t = runtime_io::TestExternalities::<Blake2Hasher>::new_with_children(t);
 		with_externalities(&mut t, || {
 			Executive::initialize_block(&Header::new(
@@ -483,7 +484,7 @@ mod tests {
 		});
 	}
 
-	fn new_test_ext() -> runtime_io::TestExternalities<Blake2Hasher> {
+	fn new_test_ext(balance_factor: u64) -> runtime_io::TestExternalities<Blake2Hasher> {
 		let mut t = system::GenesisConfig::default().build_storage::<Runtime>().unwrap();
 		t.extend(balances::GenesisConfig::<Runtime> {
 			balances: vec![(1, 111 * balance_factor)],

srml/support/procedural/src/storage/transformation.rs

@@ -530,13 +530,13 @@ fn decl_store_extra_genesis(
 			#[cfg(feature = "std")]
 			impl#fparam_impl GenesisConfig#sparam #genesis_where_clause {
 				pub fn build_storage #fn_generic (self) -> std::result::Result<
-					#scrate::runtime_primitives::MapTransaction,
+					#scrate::sr_primitives::MapTransaction,
 					String
 				> #fn_where_clause {
 					let mut storage = Default::default();
 					let mut child_storage = Default::default();
 					self.assimilate_storage::<#fn_traitinstance>(&mut storage, &mut child_storage)?;
-					Ok(#scrate::runtime_primitives::MapTransaction { top: storage, children: child_storage })
+					Ok(#scrate::sr_primitives::MapTransaction { top: storage, children: child_storage })
 				}
 
 				/// Assimilate the storage for this module into pre-existing overlays.