Adding is_descendent_of defenitions and fork tree testing with blockqueues

sidechain/consensus/common/src/header_db.rs

@@ -0,0 +1,88 @@
+/*
+	Copyright 2021 Integritee AG and Supercomputing Systems AG
+
+	Licensed under the Apache License, Version 2.0 (the "License");
+	you may not use this file except in compliance with the License.
+	You may obtain a copy of the License at
+
+		http://www.apache.org/licenses/LICENSE-2.0
+
+	Unless required by applicable law or agreed to in writing, software
+	distributed under the License is distributed on an "AS IS" BASIS,
+	WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+	See the License for the specific language governing permissions and
+	limitations under the License.
+
+*/
+use itp_types::H256;
+use its_primitives::{traits::Header as HeaderT, types::header::SidechainHeader};
+use std::{collections::HashMap, hash::Hash as HashT};
+
+// Normally implemented on the Client in substrate
+pub trait HeaderDbTrait {
+	type Header: HeaderT;
+	/// Retrieves Header for the corresponding block hash.
+	fn header(&self, hash: &H256) -> Option<Self::Header>;
+}
+
+/// A mocked Header Database which allows you to take a Block Hash and Query a Block Header.
+pub struct HeaderDb<Hash, Header>(pub HashMap<Hash, Header>);
+impl<Hash, Header> HeaderDb<Hash, Header>
+where
+	Hash: PartialEq + Eq + HashT + Clone,
+	Header: Clone,
+{
+	pub fn new() -> Self {
+		Self(HashMap::new())
+	}
+
+	pub fn insert(&mut self, hash: Hash, header: Header) {
+		let _ = self.0.insert(hash, header);
+	}
+}
+
+impl<Hash, Header> From<&[(Hash, Header)]> for HeaderDb<Hash, Header>
+where
+	Hash: HashT + Eq + Copy + Clone,
+	Header: Copy + Clone,
+{
+	fn from(items: &[(Hash, Header)]) -> Self {
+		let mut header_db = HeaderDb::<Hash, Header>::new();
+		for item in items {
+			let (hash, header) = item;
+			header_db.insert(*hash, *header);
+		}
+		header_db
+	}
+}
+
+impl<Hash, Header> HeaderDbTrait for HeaderDb<Hash, Header>
+where
+	Hash: PartialEq + HashT + Into<H256> + From<H256> + std::cmp::Eq + Clone,
+	Header: HeaderT + Clone + Into<SidechainHeader>,
+{
+	type Header = SidechainHeader;
+
+	fn header(&self, hash: &H256) -> Option<Self::Header> {
+		let header = self.0.get(&Hash::from(*hash))?;
+		Some(header.clone().into())
+	}
+}
+#[derive(Debug)]
+pub enum TestError {
+	Error,
+}
+
+impl From<()> for TestError {
+	fn from(_a: ()) -> Self {
+		TestError::Error
+	}
+}
+
+impl std::fmt::Display for TestError {
+	fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+		write!(f, "TestError")
+	}
+}
+
+impl std::error::Error for TestError {}

sidechain/consensus/common/src/is_descendent_of_builder.rs

@@ -1,35 +1,129 @@
-#[cfg(test)]
-use std::marker::PhantomData;
-
-#[cfg(test)]
-pub struct IsDescendentOfBuilder<Hash>(PhantomData<Hash>);
-#[cfg(test)]
-impl<'a, Hash: PartialEq> IsDescendentOfBuilder<Hash> {
-	#[cfg(test)]
+/*
+	Copyright 2021 Integritee AG and Supercomputing Systems AG
+
+	Licensed under the Apache License, Version 2.0 (the "License");
+	you may not use this file except in compliance with the License.
+	You may obtain a copy of the License at
+
+		http://www.apache.org/licenses/LICENSE-2.0
+
+	Unless required by applicable law or agreed to in writing, software
+	distributed under the License is distributed on an "AS IS" BASIS,
+	WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+	See the License for the specific language governing permissions and
+	limitations under the License.
+
+*/
+use crate::header_db::HeaderDbTrait;
+use itp_types::H256;
+use its_primitives::traits::Header as HeaderT;
+use std::{hash::Hash as HashT, marker::PhantomData};
+
+#[allow(dead_code)]
+pub struct IsDescendentOfBuilder<Hash, HeaderDb, Error>(PhantomData<(Hash, HeaderDb, Error)>);
+impl<'a, Hash, HeaderDb, Error> IsDescendentOfBuilder<Hash, HeaderDb, Error>
+where
+	Error: From<()>,
+	Hash: PartialEq + HashT + Default + Into<H256> + From<H256> + Clone,
+	HeaderDb: HeaderDbTrait,
+{
 	/// Build the `is_descendent_of` closure for the fork-tree structure
 	/// to utilize when adding and removing nodes from the tree.
+	#[allow(dead_code)]
 	pub fn build_is_descendent_of(
-		_curr_block: Option<(&Hash, &Hash)>,
-	) -> impl Fn(&Hash, &Hash) -> Result<bool, ()> + 'a {
-		move |_base, _head| Ok(true)
+		current: Option<(&'a Hash, &'a Hash)>,
+		header_db: &'a HeaderDb,
+	) -> impl Fn(&Hash, &Hash) -> Result<bool, Error> + 'a {
+		move |base, head| {
+			if base == head {
+				return Ok(false)
+			}
+
+			let mut head = head;
+			if let Some((current_hash, current_parent_hash)) = current {
+				if current_hash == base {
+					return Ok(false)
+				}
+
+				if current_hash == head {
+					if current_parent_hash == base {
+						return Ok(true)
+					} else {
+						head = current_parent_hash;
+					}
+				}
+			}
+
+			let ancestor =
+				<LowestCommonAncestorFinder<Hash, HeaderDb>>::find_lowest_common_ancestor(
+					head, base, header_db,
+				)?;
+			Ok(ancestor == *base)
+		}
 	}
 }
 
-#[cfg(test)]
-pub struct LowestCommonAncestorFinder<Hash>(PhantomData<Hash>);
-#[cfg(test)]
-impl<Hash: PartialEq + Default> LowestCommonAncestorFinder<Hash> {
-	#[cfg(test)]
+#[allow(dead_code)]
+pub struct LowestCommonAncestorFinder<Hash, HeaderDb>(PhantomData<(Hash, HeaderDb)>);
+impl<Hash, HeaderDb> LowestCommonAncestorFinder<Hash, HeaderDb>
+where
+	Hash: PartialEq + Default + Into<H256> + From<H256> + Clone,
+	HeaderDb: HeaderDbTrait,
+{
 	/// Used by the `build_is_descendent_of` to find the LCA of two nodes in the fork-tree.
-	pub fn find_lowest_common_ancestor(_a: Hash, _b: Hash) -> Hash {
-		Default::default()
-	}
-}
+	#[allow(dead_code)]
+	fn find_lowest_common_ancestor(a: &Hash, b: &Hash, header_db: &HeaderDb) -> Result<Hash, ()> {
+		let header_1 = header_db.header(&a.clone().into()).ok_or(())?;
+		let header_2 = header_db.header(&b.clone().into()).ok_or(())?;
+		let mut blocknum_1 = header_1.block_number();
+		let mut blocknum_2 = header_2.block_number();
+		let mut parent_1 = Hash::from(header_1.parent_hash());
+		let mut parent_2 = Hash::from(header_2.parent_hash());
+
+		if *a == parent_2 {
+			// Then a is the common ancestor of b and it means it is itself the ancestor
+			return Ok(parent_2)
+		}
+
+		if *b == parent_1 {
+			// Then b is the common ancestor of a and it means it is itself the ancestor
+			return Ok(parent_1)
+		}
+
+		while blocknum_1 > blocknum_2 {
+			// This means block 1 is further down in the tree than block 2
+			let new_parent = header_db.header(&parent_1.clone().into()).ok_or(())?;
+
+			if new_parent.block_number() >= blocknum_2 {
+				blocknum_1 = new_parent.block_number();
+				parent_1 = Hash::from(new_parent.parent_hash());
+			} else {
+				break
+			}
+		}
 
-#[cfg(test)]
-#[test]
-fn test_build_is_descendent_of_works() {
-	let is_descendent_of = <IsDescendentOfBuilder<u64>>::build_is_descendent_of(None);
-	let my_result = is_descendent_of(&42u64, &42u64);
-	assert_eq!(my_result, Ok(true));
+		while blocknum_2 > blocknum_1 {
+			// This means block 2 is further down in the tree than block 1
+			let new_parent = header_db.header(&parent_2.clone().into()).ok_or(())?;
+
+			if new_parent.block_number() >= blocknum_1 {
+				blocknum_2 = new_parent.block_number();
+				parent_2 = Hash::from(new_parent.parent_hash());
+			} else {
+				break
+			}
+		}
+
+		// At this point will be at equal height
+		while parent_1 != parent_2 {
+			// go up on both nodes
+			let new_header_1 = header_db.header(&parent_1.into()).ok_or(())?;
+			let new_header_2 = header_db.header(&parent_2.into()).ok_or(())?;
+			parent_1 = Hash::from(new_header_1.parent_hash());
+			parent_2 = Hash::from(new_header_2.parent_hash());
+		}
+
+		// Return any Parent node Hash as in worst case scenario it is the root which is shared amongst all
+		Ok(parent_1)
+	}
 }

sidechain/consensus/common/src/lib.rs

@@ -36,6 +36,7 @@ mod block_import;
 mod block_import_confirmation_handler;
 mod block_import_queue_worker;
 mod error;
+mod header_db;
 mod is_descendent_of_builder;
 mod peer_block_sync;