WIP

core/client/src/cht.rs

@@ -44,7 +44,7 @@ pub const SIZE: u64 = 2048;
 /// Returns Some(cht_number) if CHT is need to be built when the block with given number is canonized.
 pub fn is_build_required<N>(cht_size: u64, block_num: N) -> Option<N>
 	where
-		N: Clone + SimpleArithmetic,
+		N: Clone + SimpleArithmetic + From<u64>,
 {
 	let block_cht_num = block_to_cht_number(cht_size, block_num.clone())?;
 	let two = N::one() + N::one();
@@ -184,7 +184,7 @@ pub fn for_each_cht_group<Header, I, F, P>(
 	let mut current_cht_num = None;
 	let mut current_cht_blocks = Vec::new();
 	for block in blocks {
-		let new_cht_num = match block_to_cht_number(cht_size, block.as_()) {
+		let new_cht_num = match block_to_cht_number(cht_size, block) {
 			Some(new_cht_num) => new_cht_num,
 			None => return Err(ClientError::Backend(format!(
 				"Cannot compute CHT root for the block #{}", block)).into()
@@ -199,7 +199,7 @@ pub fn for_each_cht_group<Header, I, F, P>(
 
 			functor_param = functor(
 				functor_param,
-				As::sa(current_cht_num),
+				current_cht_num,
 				::std::mem::replace(&mut current_cht_blocks, Vec::new()),
 			)?;
 		}
@@ -211,7 +211,7 @@ pub fn for_each_cht_group<Header, I, F, P>(
 	if let Some(current_cht_num) = current_cht_num {
 		functor(
 			functor_param,
-			As::sa(current_cht_num),
+			current_cht_num,
 			::std::mem::replace(&mut current_cht_blocks, Vec::new()),
 		)?;
 	}
@@ -234,7 +234,8 @@ fn build_pairs<Header, I>(
 	let mut hash_number = start_num;
 	for hash in hashes.into_iter().take(cht_size as usize) {
 		let hash = hash?.ok_or_else(|| ClientError::from(
-			ClientError::MissingHashRequiredForCHT(cht_num.as_(), hash_number.as_())
+				// TODO TODO: make error generic
+			ClientError::MissingHashRequiredForCHT(0, 0)//cht_num, hash_number)
 		))?;
 		pairs.push((
 			encode_cht_key(hash_number).to_vec(),
@@ -246,7 +247,8 @@ fn build_pairs<Header, I>(
 	if pairs.len() as u64 == cht_size {
 		Ok(pairs)
 	} else {
-		Err(ClientError::MissingHashRequiredForCHT(cht_num.as_(), hash_number.as_()))
+				// TODO TODO: make error generic
+		Err(ClientError::MissingHashRequiredForCHT(0, 0))//cht_num.as_(), hash_number.as_()))
 	}
 }
 
@@ -256,38 +258,41 @@ fn build_pairs<Header, I>(
 /// More generally: CHT N includes block (1 + N*SIZE)...((N+1)*SIZE).
 /// This is because the genesis hash is assumed to be known
 /// and including it would be redundant.
-pub fn start_number<N: SimpleArithmetic>(cht_size: u64, cht_num: N) -> N {
-	(cht_num * As::sa(cht_size)) + N::one()
+pub fn start_number<N: SimpleArithmetic + From<u64>>(cht_size: u64, cht_num: N) -> N {
+	cht_num * cht_size.into() + N::one()
 }
 
 /// Get the ending block of a given CHT.
-pub fn end_number<N: SimpleArithmetic>(cht_size: u64, cht_num: N) -> N {
-	(cht_num + N::one()) * As::sa(cht_size)
+// TODO TODO: we can convert cht_size to balance or overwise bound Mul<u64> that could make sense
+// actually but at the end probably both would be implmeented same way
+pub fn end_number<N: SimpleArithmetic + From<u64>>(cht_size: u64, cht_num: N) -> N {
+	(cht_num + N::one()) * cht_size.into()
 }
 
 /// Convert a block number to a CHT number.
 /// Returns `None` for `block_num` == 0, `Some` otherwise.
-pub fn block_to_cht_number<N: SimpleArithmetic>(cht_size: u64, block_num: N) -> Option<N> {
+pub fn block_to_cht_number<N: SimpleArithmetic + From<u64>>(cht_size: u64, block_num: N) -> Option<N> {
 	if block_num == N::zero() {
 		None
 	} else {
-		Some((block_num - N::one()) / As::sa(cht_size))
+		Some((block_num - N::one()) / cht_size.into())
 	}
 }
 
 /// Convert header number into CHT key.
-pub fn encode_cht_key<N: As<u64>>(number: N) -> Vec<u8> {
-	let number: u64 = number.as_();
-	vec![
-		(number >> 56) as u8,
-		((number >> 48) & 0xff) as u8,
-		((number >> 40) & 0xff) as u8,
-		((number >> 32) & 0xff) as u8,
-		((number >> 24) & 0xff) as u8,
-		((number >> 16) & 0xff) as u8,
-		((number >> 8) & 0xff) as u8,
-		(number & 0xff) as u8
-	]
+pub fn encode_cht_key<N>(number: N) -> Vec<u8> {
+	unimplemented!();
+	// let number: u64 = number.as_();
+	// vec![
+	// 	(number >> 56) as u8,
+	// 	((number >> 48) & 0xff) as u8,
+	// 	((number >> 40) & 0xff) as u8,
+	// 	((number >> 32) & 0xff) as u8,
+	// 	((number >> 24) & 0xff) as u8,
+	// 	((number >> 16) & 0xff) as u8,
+	// 	((number >> 8) & 0xff) as u8,
+	// 	(number & 0xff) as u8
+	// ]
 }
 
 /// Convert header hash into CHT value.

core/client/src/in_mem.rs

@@ -625,7 +625,7 @@ where
 			if let Some(changes_trie_root) = changes_trie_root {
 				if let Some(changes_trie_update) = operation.changes_trie_update {
 					let changes_trie_root: H::Out = changes_trie_root.into();
-					self.changes_trie_storage.0.insert(header.number().as_(), changes_trie_root, changes_trie_update);
+					self.changes_trie_storage.0.insert(header.number(), changes_trie_root, changes_trie_update);
 				}
 			}
 

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

@@ -68,10 +68,10 @@ pub struct AnchorBlockId<Hash: ::std::fmt::Debug> {
 }
 
 /// Changes trie storage. Provides access to trie roots and trie nodes.
-pub trait RootsStorage<H: Hasher>: Send + Sync {
+pub trait RootsStorage<H: Hasher, BlockNumber>: Send + Sync {
 	/// Get changes trie root for the block with given number which is an ancestor (or the block
 	/// itself) of the anchor_block (i.e. anchor_block.number >= block).
-	fn root(&self, anchor: &AnchorBlockId<H::Out>, block: u64) -> Result<Option<H::Out>, String>;
+	fn root(&self, anchor: &AnchorBlockId<H::Out>, block: BlockNumber) -> Result<Option<H::Out>, String>;
 }
 
 /// Changes trie storage. Provides access to trie roots and trie nodes.

core/state-machine/src/changes_trie/storage.rs

@@ -33,8 +33,8 @@ use crate::backend::insert_into_memory_db;
 use crate::changes_trie::input::InputPair;
 
 /// In-memory implementation of changes trie storage.
-pub struct InMemoryStorage<H: Hasher> where H::Out: HeapSizeOf {
-	data: RwLock<InMemoryStorageData<H>>,
+pub struct InMemoryStorage<H: Hasher, BlockNumber> where H::Out: HeapSizeOf {
+	data: RwLock<InMemoryStorageData<H, BlockNumber>>,
 }
 
 /// Adapter for using changes trie storage as a TrieBackendEssence' storage.
@@ -43,12 +43,12 @@ pub struct TrieBackendAdapter<'a, H: Hasher, S: 'a + Storage<H>> {
 	_hasher: ::std::marker::PhantomData<H>,
 }
 
-struct InMemoryStorageData<H: Hasher> where H::Out: HeapSizeOf {
-	roots: HashMap<u64, H::Out>,
+struct InMemoryStorageData<H: Hasher, BlockNumber> where H::Out: HeapSizeOf {
+	roots: HashMap<BlockNumber, H::Out>,
 	mdb: MemoryDB<H>,
 }
 
-impl<H: Hasher> InMemoryStorage<H> where H::Out: HeapSizeOf {
+impl<H: Hasher, BlockNumber> InMemoryStorage<H, BlockNumber> where H::Out: HeapSizeOf {
 	/// Create the storage from given in-memory database.
 	pub fn with_db(mdb: MemoryDB<H>) -> Self {
 		Self {
@@ -102,20 +102,20 @@ impl<H: Hasher> InMemoryStorage<H> where H::Out: HeapSizeOf {
 	}
 
 	/// Insert changes trie for given block.
-	pub fn insert(&self, block: u64, changes_trie_root: H::Out, trie: MemoryDB<H>) {
+	pub fn insert(&self, block: BlockNumber, changes_trie_root: H::Out, trie: MemoryDB<H>) {
 		let mut data = self.data.write();
 		data.roots.insert(block, changes_trie_root);
 		data.mdb.consolidate(trie);
 	}
 }
 
-impl<H: Hasher> RootsStorage<H> for InMemoryStorage<H> where H::Out: HeapSizeOf {
-	fn root(&self, _anchor_block: &AnchorBlockId<H::Out>, block: u64) -> Result<Option<H::Out>, String> {
+impl<H: Hasher, BlockNumber: Send + Sync> RootsStorage<H> for InMemoryStorage<H, BlockNumber> where H::Out: HeapSizeOf {
+	fn root(&self, _anchor_block: &AnchorBlockId<H::Out>, block: BlockNumber) -> Result<Option<H::Out>, String> {
 		Ok(self.data.read().roots.get(&block).cloned())
 	}
 }
 
-impl<H: Hasher> Storage<H> for InMemoryStorage<H> where H::Out: HeapSizeOf {
+impl<H: Hasher, BlockNumber: Send + Sync> Storage<H> for InMemoryStorage<H, BlockNumber> where H::Out: HeapSizeOf {
 	fn get(&self, key: &H::Out, prefix: &[u8]) -> Result<Option<DBValue>, String> {
 		MemoryDB::<H>::get(&self.data.read().mdb, key, prefix)
 	}

core/state-machine/src/testing.rs

@@ -28,14 +28,14 @@ use parity_codec::Encode;
 use super::{Externalities, OverlayedChanges};
 
 /// Simple HashMap-based Externalities impl.
-pub struct TestExternalities<H: Hasher> where H::Out: HeapSizeOf {
+pub struct TestExternalities<H: Hasher, BlockNumber> where H::Out: HeapSizeOf {
 	inner: HashMap<Vec<u8>, Vec<u8>>,
-	changes_trie_storage: ChangesTrieInMemoryStorage<H>,
+	changes_trie_storage: ChangesTrieInMemoryStorage<H, BlockNumber>,
 	changes: OverlayedChanges,
 	code: Option<Vec<u8>>,
 }
 
-impl<H: Hasher> TestExternalities<H> where H::Out: HeapSizeOf {
+impl<H: Hasher, BlockNumber> TestExternalities<H, BlockNumber> where H::Out: HeapSizeOf {
 	/// Create a new instance of `TestExternalities`
 	pub fn new(inner: HashMap<Vec<u8>, Vec<u8>>) -> Self {
 		Self::new_with_code(&[], inner)
@@ -66,37 +66,37 @@ impl<H: Hasher> TestExternalities<H> where H::Out: HeapSizeOf {
 	}
 }
 
-impl<H: Hasher> ::std::fmt::Debug for TestExternalities<H> where H::Out: HeapSizeOf {
+impl<H: Hasher, BlockNumber> ::std::fmt::Debug for TestExternalities<H, BlockNumber> where H::Out: HeapSizeOf {
 	fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
 		write!(f, "{:?}", self.inner)
 	}
 }
 
-impl<H: Hasher> PartialEq for TestExternalities<H> where H::Out: HeapSizeOf {
-	fn eq(&self, other: &TestExternalities<H>) -> bool {
+impl<H: Hasher, BlockNumber> PartialEq for TestExternalities<H, BlockNumber> where H::Out: HeapSizeOf {
+	fn eq(&self, other: &TestExternalities<H, BlockNumber>) -> bool {
 		self.inner.eq(&other.inner)
 	}
 }
 
-impl<H: Hasher> FromIterator<(Vec<u8>, Vec<u8>)> for TestExternalities<H> where H::Out: HeapSizeOf {
+impl<H: Hasher, BlockNumber> FromIterator<(Vec<u8>, Vec<u8>)> for TestExternalities<H, BlockNumber> where H::Out: HeapSizeOf {
 	fn from_iter<I: IntoIterator<Item=(Vec<u8>, Vec<u8>)>>(iter: I) -> Self {
 		let mut t = Self::new(Default::default());
 		t.inner.extend(iter);
 		t
 	}
 }
 
-impl<H: Hasher> Default for TestExternalities<H> where H::Out: HeapSizeOf {
+impl<H: Hasher, BlockNumber> Default for TestExternalities<H, BlockNumber> where H::Out: HeapSizeOf {
 	fn default() -> Self { Self::new(Default::default()) }
 }
 
-impl<H: Hasher> From<TestExternalities<H>> for HashMap<Vec<u8>, Vec<u8>> where H::Out: HeapSizeOf {
-	fn from(tex: TestExternalities<H>) -> Self {
+impl<H: Hasher, BlockNumber> From<TestExternalities<H, BlockNumber>> for HashMap<Vec<u8>, Vec<u8>> where H::Out: HeapSizeOf {
+	fn from(tex: TestExternalities<H, BlockNumber>) -> Self {
 		tex.inner.into()
 	}
 }
 
-impl<H: Hasher> From< HashMap<Vec<u8>, Vec<u8>> > for TestExternalities<H> where H::Out: HeapSizeOf {
+impl<H: Hasher, BlockNumber> From< HashMap<Vec<u8>, Vec<u8>> > for TestExternalities<H, BlockNumber> where H::Out: HeapSizeOf {
 	fn from(hashmap: HashMap<Vec<u8>, Vec<u8>>) -> Self {
 		TestExternalities {
 			inner: hashmap,
@@ -110,7 +110,7 @@ impl<H: Hasher> From< HashMap<Vec<u8>, Vec<u8>> > for TestExternalities<H> where
 // TODO child test primitives are currently limited to `changes` (for non child the way
 // things are defined seems utterly odd to (put changes in changes but never make them
 // available for read through inner)
-impl<H: Hasher> Externalities<H> for TestExternalities<H> where H::Out: Ord + HeapSizeOf {
+impl<H: Hasher, BlockNumber> Externalities<H> for TestExternalities<H, BlockNumber> where H::Out: Ord + HeapSizeOf {
 	fn storage(&self, key: &[u8]) -> Option<Vec<u8>> {
 		match key {
 			CODE => self.code.clone(),