SubTrie struct renaming (and single encode point)

core/client/db/src/storage_cache.rs

@@ -25,7 +25,7 @@ use runtime_primitives::traits::{Block, Header};
 use state_machine::{backend::Backend as StateBackend, TrieBackend};
 use log::trace;
 use primitives::subtrie::SubTrie;
-use primitives::subtrie::SubTrieNodeRef;
+use primitives::subtrie::SubTrieReadRef;
 
 const STATE_CACHE_BLOCKS: usize = 12;
 
@@ -359,23 +359,23 @@ impl<H: Hasher, S: StateBackend<H>, B:Block> StateBackend<H> for CachingState<H,
 		Ok(hash)
 	}
 
-	fn child_storage(&self, subtrie: SubTrieNodeRef, key: &[u8]) -> Result<Option<Vec<u8>>, Self::Error> {
+	fn child_storage(&self, subtrie: SubTrieReadRef, key: &[u8]) -> Result<Option<Vec<u8>>, Self::Error> {
 		self.state.child_storage(subtrie, key)
 	}
 
 	fn exists_storage(&self, key: &[u8]) -> Result<bool, Self::Error> {
 		Ok(self.storage(key)?.is_some())
 	}
 
-	fn exists_child_storage(&self, subtrie: SubTrieNodeRef, key: &[u8]) -> Result<bool, Self::Error> {
+	fn exists_child_storage(&self, subtrie: SubTrieReadRef, key: &[u8]) -> Result<bool, Self::Error> {
 		self.state.exists_child_storage(subtrie, key)
 	}
 
 	fn for_keys_with_prefix<F: FnMut(&[u8])>(&self, prefix: &[u8], f: F) {
 		self.state.for_keys_with_prefix(prefix, f)
 	}
 
-	fn for_keys_in_child_storage<F: FnMut(&[u8])>(&self, subtrie: SubTrieNodeRef, f: F) {
+	fn for_keys_in_child_storage<F: FnMut(&[u8])>(&self, subtrie: SubTrieReadRef, f: F) {
 		self.state.for_keys_in_child_storage(subtrie, f)
 	}
 

core/client/src/client.rs

@@ -24,7 +24,7 @@ use crate::error::Error;
 use futures::sync::mpsc;
 use parking_lot::{Mutex, RwLock};
 use primitives::NativeOrEncoded;
-use primitives::subtrie::SubTrieNodeRef;
+use primitives::subtrie::SubTrieReadRef;
 use runtime_primitives::{
 	Justification,
 	generic::{BlockId, SignedBlock},
@@ -380,7 +380,7 @@ impl<B, E, Block, RA> Client<B, E, Block, RA> where
 	pub fn read_child_proof(
 		&self,
 		id: &BlockId<Block>,
-		subtrie: SubTrieNodeRef,
+		subtrie: SubTrieReadRef,
 		key: &[u8]
 	) -> error::Result<Vec<Vec<u8>>> {
 		self.state_at(id)

core/client/src/light/backend.rs

@@ -24,7 +24,7 @@ use parking_lot::RwLock;
 
 use runtime_primitives::{generic::BlockId, Justification, StorageOverlay, ChildrenStorageOverlay};
 use primitives::subtrie::SubTrie;
-use primitives::subtrie::SubTrieNodeRef;
+use primitives::subtrie::SubTrieReadRef;
 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};
@@ -345,15 +345,15 @@ where
 			.into_future().wait()
 	}
 
-	fn child_storage(&self, _subtrie: SubTrieNodeRef, _key: &[u8]) -> ClientResult<Option<Vec<u8>>> {
+	fn child_storage(&self, _subtrie: SubTrieReadRef, _key: &[u8]) -> ClientResult<Option<Vec<u8>>> {
 		Err(ClientError::NotAvailableOnLightClient.into())
 	}
 
 	fn for_keys_with_prefix<A: FnMut(&[u8])>(&self, _prefix: &[u8], _action: A) {
 		// whole state is not available on light node
 	}
 
-	fn for_keys_in_child_storage<A: FnMut(&[u8])>(&self, _subtrie: SubTrieNodeRef, _action: A) {
+	fn for_keys_in_child_storage<A: FnMut(&[u8])>(&self, _subtrie: SubTrieReadRef, _action: A) {
 		// whole state is not available on light node
 	}
 
@@ -407,7 +407,7 @@ where
 		}
 	}
 
-	fn child_storage(&self, subtrie: SubTrieNodeRef, key: &[u8]) -> ClientResult<Option<Vec<u8>>> {
+	fn child_storage(&self, subtrie: SubTrieReadRef, key: &[u8]) -> ClientResult<Option<Vec<u8>>> {
 		match *self {
 			OnDemandOrGenesisState::OnDemand(ref state) =>
 				StateBackend::<H>::child_storage(state, subtrie, key),
@@ -424,7 +424,7 @@ where
 		}
 	}
 
-	fn for_keys_in_child_storage<A: FnMut(&[u8])>(&self, subtrie: SubTrieNodeRef, action: A) {
+	fn for_keys_in_child_storage<A: FnMut(&[u8])>(&self, subtrie: SubTrieReadRef, action: A) {
 		match *self {
 			OnDemandOrGenesisState::OnDemand(ref state) =>
 				StateBackend::<H>::for_keys_in_child_storage(state, subtrie, action),

core/client/src/light/fetcher.rs

@@ -23,7 +23,7 @@ use futures::IntoFuture;
 
 use hash_db::{HashDB, Hasher};
 use primitives::{ChangesTrieConfiguration, convert_hash};
-use primitives::subtrie::SubTrieNodeCodec;
+use primitives::subtrie::SubTrieRead;
 use runtime_primitives::traits::{As, Block as BlockT, Header as HeaderT, NumberFor};
 use state_machine::{CodeExecutor, ChangesTrieRootsStorage, ChangesTrieAnchorBlockId,
 	TrieBackend, read_proof_check, key_changes_proof_check,
@@ -81,7 +81,7 @@ pub struct RemoteReadChildRequest<Header: HeaderT> {
 	/// Header of block at which read is performed.
 	pub header: Header,
 	/// Child trie
-	pub child_trie: SubTrieNodeCodec,
+	pub child_trie: SubTrieRead,
 	/// Child storage key to read.
 	pub key: Vec<u8>,
 	/// Number of times to retry request. None means that default RETRY_COUNT is used.

core/executor/src/wasm_executor.rs

@@ -31,7 +31,7 @@ use crate::wasm_utils::UserError;
 use primitives::{blake2_128, blake2_256, twox_64, twox_128, twox_256, ed25519, sr25519, Pair};
 use primitives::hexdisplay::HexDisplay;
 use primitives::sandbox as sandbox_primitives;
-use primitives::{H256, Blake2Hasher, subtrie::{SubTrie, SubTrieNodeRef}};
+use primitives::{H256, Blake2Hasher, subtrie::{SubTrie, SubTrieReadRef}};
 use trie::ordered_trie_root;
 use crate::sandbox;
 use crate::allocator;
@@ -241,7 +241,7 @@ impl_function_executor!(this: FunctionExecutor<'e, E>,
 		let root = this.memory.get(root_data, root_len as usize).map_err(|_| UserError("Invalid attempt to determine storage_key in ext_set_child_storage"))?;
 		let key = this.memory.get(key_data, key_len as usize).map_err(|_| UserError("Invalid attempt to determine key in ext_exists_child_storage"))?;
 		let root = if root.len() > 0 { Some(&root[..]) } else { None };
-		let subtrie = SubTrieNodeRef::new(&keyspace, root);
+		let subtrie = SubTrieReadRef::new(&keyspace, root);
 		Ok(if this.ext.exists_child_storage(subtrie, &key) { 1 } else { 0 })
 	},
 	ext_clear_prefix(prefix_data: *const u8, prefix_len: u32) => {
@@ -309,7 +309,7 @@ impl_function_executor!(this: FunctionExecutor<'e, E>,
 			key_len as usize
 		).map_err(|_| UserError("Invalid attempt to determine key in ext_get_allocated_child_storage"))?;
 		let root = if root.len() > 0 { Some(&root[..]) } else { None };
-		let subtrie = SubTrieNodeRef::new(&keyspace, root);
+		let subtrie = SubTrieReadRef::new(&keyspace, root);
 		let maybe_value = this.ext.child_storage(subtrie, &key);
 
 		debug_trace!(target: "wasm-trace", "*** Getting child storage: {} -> {} == {}   [k={}]",
@@ -384,7 +384,7 @@ impl_function_executor!(this: FunctionExecutor<'e, E>,
 			key_len as usize
 		).map_err(|_| UserError("Invalid attempt to determine key in ext_get_allocated_child_storage"))?;
 		let root = if root.len() > 0 { Some(&root[..]) } else { None };
-		let subtrie = SubTrieNodeRef::new(&keyspace, root);
+		let subtrie = SubTrieReadRef::new(&keyspace, root);
 
 		let maybe_value = this.ext.child_storage(subtrie, &key);
 		debug_trace!(target: "wasm-trace", "*** Getting storage: {} -> {} == {}   [k={}]",

core/network/src/message.rs

@@ -18,7 +18,7 @@
 
 use bitflags::bitflags;
 use runtime_primitives::{ConsensusEngineId, traits::{Block as BlockT, Header as HeaderT}};
-use primitives::subtrie::SubTrieNodeCodec;
+use primitives::subtrie::SubTrieRead;
 use parity_codec::{Encode, Decode, Input, Output};
 pub use self::generic::{
 	BlockAnnounce, RemoteCallRequest, RemoteReadRequest,
@@ -131,7 +131,7 @@ pub mod generic {
 	use runtime_primitives::Justification;
 	use crate::config::Roles;
 	use super::{
-		RemoteReadResponse, Transactions, Direction, SubTrieNodeCodec,
+		RemoteReadResponse, Transactions, Direction, SubTrieRead,
 		RequestId, BlockAttributes, RemoteCallResponse, ConsensusEngineId,
 	};
 	/// Consensus is mostly opaque to us
@@ -307,7 +307,7 @@ pub mod generic {
 		/// Block at which to perform call.
 		pub block: H,
 		/// Child trie info.
-		pub child_trie: SubTrieNodeCodec,
+		pub child_trie: SubTrieRead,
 		/// Storage key.
 		pub key: Vec<u8>,
 	}

core/network/src/on_demand.rs

@@ -633,7 +633,7 @@ pub mod tests {
 	use std::sync::{Arc, Mutex};
 	use std::time::Instant;
 	use futures::Future;
-	use primitives::subtrie::SubTrieNodeCodec;
+	use primitives::subtrie::SubTrieRead;
 	use runtime_primitives::traits::{Block as BlockT, NumberFor};
 	use client::{error::{Error as ClientError, Result as ClientResult}};
 	use client::light::fetcher::{Fetcher, FetchChecker, RemoteHeaderRequest,
@@ -977,7 +977,7 @@ pub mod tests {
 		let response = on_demand.remote_read_child(RemoteReadChildRequest {
 			header: dummy_header(),
 			block: Default::default(),
-			child_trie: SubTrieNodeCodec {
+			child_trie: SubTrieRead {
 				keyspace: b"keyspace".to_vec(),
 				// dummy : this should be queried
 				root: b"root".to_vec(),

core/primitives/src/subtrie.rs

@@ -50,51 +50,60 @@ pub fn keyspace_as_prefix_alloc(ks: &KeySpace, prefix: &[u8]) -> Vec<u8> {
 	res
 }
 
-/// `SubTrieNodeRef` used for non changing state query
+/// `SubTrieReadRef` used for non changing state query
 /// so it is safe to build
 #[derive(Clone)]
-pub struct SubTrieNodeRef<'a> {
+pub struct SubTrieReadRef<'a> {
 	/// subtrie unique keyspace
 	pub keyspace: &'a KeySpace,
 	/// subtrie root hash
 	pub root: Option<&'a [u8]>,
 }
 
-impl<'a> SubTrieNodeRef<'a> {
-	/// create a SubTrieNodeRef
+impl<'a> SubTrieReadRef<'a> {
+	/// create a SubTrieReadRef
 	pub fn new(keyspace: &'a KeySpace, root: Option<&'a[u8]>) -> Self {
-		SubTrieNodeRef {keyspace, root}
+		SubTrieReadRef {keyspace, root}
 	}
 	// should not be public as it produce incomplete content
-	fn enc(&self) -> Option<SubTrieNodeCodecRef> {
-		self.root.map(|r|SubTrieNodeCodecRef {keyspace: self.keyspace, root: r})
+	fn enc(&self) -> Option<SubTrieReadEncode> {
+		self.root.map(|r|SubTrieReadEncode {keyspace: self.keyspace, root: r})
 	}
 }
 
 /// `SubTrieNode` encoder internal implementation
 /// shall never be exposed
 #[derive(Encode, Clone)]
-struct SubTrieNodeCodecRef<'a> {
+struct SubTrieReadEncode<'a> {
 	/// subtrie unique keyspace
 	pub keyspace: &'a KeySpace,
 	/// subtrie root hash
 	pub root: &'a [u8],
 }
 
-#[derive(PartialEq, Eq, Clone, Encode, Decode)]
+#[derive(PartialEq, Eq, Clone, Decode)]
 #[cfg_attr(feature = "std", derive(Debug, Hash, PartialOrd, Ord))]
 /// Subtrie node info for query (with a valid root)
-pub struct SubTrieNodeCodec {
+pub struct SubTrieRead {
 	/// subtrie unique keyspace
 	pub keyspace: KeySpace,
 	/// subtrie root hash
 	pub root: Vec<u8>,
 }
-impl SubTrieNodeCodec {
+impl SubTrieRead {
 	/// get node ref for read only query
-	pub fn node_ref(&self) -> SubTrieNodeRef {
+	pub fn node_ref(&self) -> SubTrieReadRef {
 		debug_assert!(self.root.len() > 0);
-		SubTrieNodeRef::new(&self.keyspace, Some(&self.root[..]))
+		SubTrieReadRef::new(&self.keyspace, Some(&self.root[..]))
+	}
+}
+
+impl parity_codec::Encode for SubTrieRead {
+	fn encode(&self) -> Vec<u8> {
+		SubTrieReadEncode {
+			keyspace: &self.keyspace,
+			root: &self.root[..]
+		}.encode()
 	}
 }
 
@@ -131,8 +140,8 @@ impl SubTrie {
 		}
 	}
 	/// node ref of subtrie
-	pub fn node_ref(&self) -> SubTrieNodeRef {
-		SubTrieNodeRef::new(&self.keyspace, self.root.as_ref().map(|r|&r[..]))
+	pub fn node_ref(&self) -> SubTrieReadRef {
+		SubTrieReadRef::new(&self.keyspace, self.root.as_ref().map(|r|&r[..]))
 	}
 	/// instantiate subtrie from a read node value
 	pub fn decode_node(encoded_node: &[u8], parent: &[u8]) -> Option<Self> {
@@ -142,7 +151,7 @@ impl SubTrie {
 	/// instantiate subtrie from a read node value, parent node is prefixed
 	pub fn decode_node_prefixed_parent(encoded_node: &[u8], parent: Vec<u8>) -> Option<Self> {
 		let input = &mut &encoded_node[..];
-		SubTrieNodeCodec::decode(input).map(|SubTrieNodeCodec { keyspace, root }|
+		SubTrieRead::decode(input).map(|SubTrieRead { keyspace, root }|
 			SubTrie {
 				keyspace,
 				root: Some(root),
@@ -180,7 +189,7 @@ impl SubTrie {
 	}
 	/// encdode with an updated root
 	pub fn encoded_with_root(&self, new_root: &[u8]) -> Vec<u8> {
-		let mut enc = parity_codec::Encode::encode(&SubTrieNodeCodecRef{
+		let mut enc = parity_codec::Encode::encode(&SubTrieReadEncode{
 			keyspace: &self.keyspace,
 			root: new_root,
 		});

core/sr-io/src/lib.rs

@@ -33,7 +33,7 @@ use rstd::vec::Vec;
 pub use codec;
 
 pub use primitives::Blake2Hasher;
-pub use primitives::subtrie::{SubTrie, SubTrieNodeRef};
+pub use primitives::subtrie::{SubTrie, SubTrieReadRef};
 
 /// Error verifying ECDSA signature
 pub enum EcdsaVerifyError {
@@ -94,7 +94,7 @@ export_api! {
 		fn storage(key: &[u8]) -> Option<Vec<u8>>;
 
 		/// Get `key` from child storage and return a `Vec`, empty if there's a problem.
-		fn child_storage(subtrie: SubTrieNodeRef, key: &[u8]) -> Option<Vec<u8>>;
+		fn child_storage(subtrie: SubTrieReadRef, key: &[u8]) -> Option<Vec<u8>>;
 
 		/// Get `key` from 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
@@ -109,7 +109,7 @@ export_api! {
 		/// 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`.
-		fn read_child_storage(subtrie: SubTrieNodeRef, key: &[u8], value_out: &mut [u8], value_offset: usize) -> Option<usize>;
+		fn read_child_storage(subtrie: SubTrieReadRef, key: &[u8], value_out: &mut [u8], value_offset: usize) -> Option<usize>;
 
 		/// Set the storage of some particular key to Some value.
 		fn set_storage(key: &[u8], value: &[u8]);
@@ -130,7 +130,7 @@ export_api! {
 		fn exists_storage(key: &[u8]) -> bool;
 
 		/// Check whether a given `key` exists in storage.
-		fn exists_child_storage(subtrie: SubTrieNodeRef, key: &[u8]) -> bool;
+		fn exists_child_storage(subtrie: SubTrieReadRef, key: &[u8]) -> bool;
 
 		/// Clear the storage entries with a key that starts with the given prefix.
 		fn clear_prefix(prefix: &[u8]);

core/sr-io/with_std.rs

@@ -17,7 +17,7 @@
 // re-export hashing functions.
 pub use primitives::{
 	blake2_128, blake2_256, twox_128, twox_256, twox_64, ed25519, Blake2Hasher,
-	sr25519, Pair, subtrie::{SubTrie, SubTrieNodeRef, KeySpace},
+	sr25519, Pair, subtrie::{SubTrie, SubTrieReadRef, KeySpace},
 };
 // Switch to this after PoC-3
 // pub use primitives::BlakeHasher;
@@ -72,7 +72,7 @@ impl StorageApi for () {
 			.expect("storage cannot be called outside of an Externalities-provided environment.")
 	}
 
-	fn child_storage(subtrie: SubTrieNodeRef, key: &[u8]) -> Option<Vec<u8>> {
+	fn child_storage(subtrie: SubTrieReadRef, key: &[u8]) -> Option<Vec<u8>> {
 		ext::with(|ext| {
 			ext.child_storage(subtrie, key).map(|s| s.to_vec())
 		})
@@ -86,7 +86,7 @@ impl StorageApi for () {
 	}
 
 	fn read_child_storage(
-		subtrie: SubTrieNodeRef,
+		subtrie: SubTrieReadRef,
 		key: &[u8],
 		value_out: &mut [u8],
 		value_offset: usize,
@@ -133,7 +133,7 @@ impl StorageApi for () {
 		).unwrap_or(false)
 	}
 
-	fn exists_child_storage(subtrie: SubTrieNodeRef, key: &[u8]) -> bool {
+	fn exists_child_storage(subtrie: SubTrieReadRef, key: &[u8]) -> bool {
 		ext::with(|ext| {
 			ext.exists_child_storage(subtrie, key)
 		}).unwrap_or(false)