Use ranged changes trie configuration in CT functions (#3404)

* CT config methods are accepting zero

* intrduce && use configuration range in CT

* Update core/client/db/src/lib.rs

Co-Authored-By: cheme <emericchevalier.pro@gmail.com>

* full PR URI

* updated next_max_level_digest_range comment

* added skewed digest description

* added comment for loop

* call next_max_level_digest_range from prev_max_level_digest_block

* more test cases

* Update core/state-machine/src/changes_trie/surface_iterator.rs

Co-Authored-By: cheme <emericchevalier.pro@gmail.com>

* updated comment

substrate/core/primitives/src/changes_trie.rs

@@ -39,19 +39,30 @@ pub struct ChangesTrieConfiguration {
 }
 
 impl ChangesTrieConfiguration {
+	/// Create new configuration given digest interval and levels.
+	pub fn new(digest_interval: u32, digest_levels: u32) -> Self {
+		Self { digest_interval, digest_levels }
+	}
+
 	/// Is digest build enabled?
 	pub fn is_digest_build_enabled(&self) -> bool {
 		self.digest_interval > 1 && self.digest_levels > 0
 	}
 
 	/// Do we need to build digest at given block?
-	pub fn is_digest_build_required_at_block<Number>(&self, block: Number) -> bool
+	pub fn is_digest_build_required_at_block<Number>(
+		&self,
+		zero: Number,
+		block: Number,
+	) -> bool
 		where
-			Number: From<u32> + PartialEq + ::rstd::ops::Rem<Output=Number> + Zero,
+			Number: From<u32> + PartialEq +
+			::rstd::ops::Rem<Output=Number> + ::rstd::ops::Sub<Output=Number> +
+			::rstd::cmp::PartialOrd + Zero,
 	{
-		block != 0.into()
+		block > zero
 			&& self.is_digest_build_enabled()
-			&& (block % self.digest_interval.into()).is_zero()
+			&& ((block - zero) % self.digest_interval.into()).is_zero()
 	}
 
 	/// Returns max digest interval. One if digests are not created at all.
@@ -71,6 +82,74 @@ impl ChangesTrieConfiguration {
 		}
 	}
 
+	/// Returns max level digest block number that has been created at block <= passed block number.
+	///
+	/// Returns None if digests are not created at all.
+	pub fn prev_max_level_digest_block<Number>(
+		&self,
+		zero: Number,
+		block: Number,
+	) -> Option<Number>
+		where
+			Number: Clone + From<u32> + PartialOrd + PartialEq +
+			::rstd::ops::Add<Output=Number> + ::rstd::ops::Sub<Output=Number> +
+			::rstd::ops::Div<Output=Number> + ::rstd::ops::Mul<Output=Number> + Zero,
+	{
+		if block <= zero {
+			return None;
+		}
+
+		let (next_begin, next_end) = self.next_max_level_digest_range(zero.clone(), block.clone())?;
+
+		// if 'next' digest includes our block, then it is a also a previous digest
+		if next_end == block {
+			return Some(block);
+		}
+
+		// if previous digest ends at zero block, then there are no previous digest
+		let prev_end = next_begin - 1.into();
+		if prev_end == zero {
+			None
+		} else {
+			Some(prev_end)
+		}
+	}
+
+	/// Returns max level digest blocks range (inclusive) which includes passed block.
+	///
+	/// Returns None if digests are not created at all.
+	/// It will return the first max-level digest if block is <= zero.
+	pub fn next_max_level_digest_range<Number>(
+		&self,
+		zero: Number,
+		mut block: Number,
+	) -> Option<(Number, Number)>
+		where
+			Number: Clone + From<u32> + PartialOrd + PartialEq +
+			::rstd::ops::Add<Output=Number> + ::rstd::ops::Sub<Output=Number> +
+			::rstd::ops::Div<Output=Number> + ::rstd::ops::Mul<Output=Number>,
+	{
+		if !self.is_digest_build_enabled() {
+			return None;
+		}
+
+		if block <= zero {
+			block = zero.clone() + 1.into();
+		}
+
+		let max_digest_interval: Number = self.max_digest_interval().into();
+		let max_digests_since_zero = (block.clone() - zero.clone()) / max_digest_interval.clone();
+		if max_digests_since_zero == 0.into() {
+			return Some((zero.clone() + 1.into(), zero + max_digest_interval));
+		}
+		let last_max_digest_block = zero + max_digests_since_zero * max_digest_interval.clone();
+		Some(if block == last_max_digest_block {
+			(block.clone() - max_digest_interval + 1.into(), block)
+		} else {
+			(last_max_digest_block.clone() + 1.into(), last_max_digest_block + max_digest_interval)
+		})
+	}
+
 	/// Returns Some if digest must be built at given block number.
 	/// The tuple is:
 	/// (
@@ -78,20 +157,23 @@ impl ChangesTrieConfiguration {
 	///  digest interval (in blocks)
 	///  step between blocks we're interested in when digest is built
 	/// )
-	pub fn digest_level_at_block<Number>(&self, block: Number) -> Option<(u32, u32, u32)>
+	pub fn digest_level_at_block<Number>(&self, zero: Number, block: Number) -> Option<(u32, u32, u32)>
 		where
-			Number: Clone + From<u32> + PartialEq + ::rstd::ops::Rem<Output=Number> + Zero,
+			Number: Clone + From<u32> + PartialEq +
+			::rstd::ops::Rem<Output=Number> + ::rstd::ops::Sub<Output=Number> +
+			::rstd::cmp::PartialOrd + Zero,
 	{
-		if !self.is_digest_build_required_at_block(block.clone()) {
+		if !self.is_digest_build_required_at_block(zero.clone(), block.clone()) {
 			return None;
 		}
 
+		let relative_block = block - zero;
 		let mut digest_interval = self.digest_interval;
 		let mut current_level = 1u32;
 		let mut digest_step = 1u32;
 		while current_level < self.digest_levels {
 			let new_digest_interval = match digest_interval.checked_mul(self.digest_interval) {
-				Some(new_digest_interval) if (block.clone() % new_digest_interval.into()).is_zero()
+				Some(new_digest_interval) if (relative_block.clone() % new_digest_interval.into()).is_zero()
 					=> new_digest_interval,
 				_ => break,
 			};
@@ -131,31 +213,43 @@ mod tests {
 
 	#[test]
 	fn is_digest_build_required_at_block_works() {
-		assert!(!config(8, 4).is_digest_build_required_at_block(0u64));
-		assert!(!config(8, 4).is_digest_build_required_at_block(1u64));
-		assert!(!config(8, 4).is_digest_build_required_at_block(2u64));
-		assert!(!config(8, 4).is_digest_build_required_at_block(4u64));
-		assert!(config(8, 4).is_digest_build_required_at_block(8u64));
-		assert!(!config(8, 4).is_digest_build_required_at_block(9u64));
-		assert!(config(8, 4).is_digest_build_required_at_block(64u64));
-		assert!(config(8, 4).is_digest_build_required_at_block(64u64));
-		assert!(config(8, 4).is_digest_build_required_at_block(512u64));
-		assert!(config(8, 4).is_digest_build_required_at_block(4096u64));
-		assert!(!config(8, 4).is_digest_build_required_at_block(4103u64));
-		assert!(config(8, 4).is_digest_build_required_at_block(4104u64));
-		assert!(!config(8, 4).is_digest_build_required_at_block(4108u64));
+		fn test_with_zero(zero: u64) {
+			assert!(!config(8, 4).is_digest_build_required_at_block(zero, zero + 0u64));
+			assert!(!config(8, 4).is_digest_build_required_at_block(zero, zero + 1u64));
+			assert!(!config(8, 4).is_digest_build_required_at_block(zero, zero + 2u64));
+			assert!(!config(8, 4).is_digest_build_required_at_block(zero, zero + 4u64));
+			assert!(config(8, 4).is_digest_build_required_at_block(zero, zero + 8u64));
+			assert!(!config(8, 4).is_digest_build_required_at_block(zero, zero + 9u64));
+			assert!(config(8, 4).is_digest_build_required_at_block(zero, zero + 64u64));
+			assert!(config(8, 4).is_digest_build_required_at_block(zero, zero + 64u64));
+			assert!(config(8, 4).is_digest_build_required_at_block(zero, zero + 512u64));
+			assert!(config(8, 4).is_digest_build_required_at_block(zero, zero + 4096u64));
+			assert!(!config(8, 4).is_digest_build_required_at_block(zero, zero + 4103u64));
+			assert!(config(8, 4).is_digest_build_required_at_block(zero, zero + 4104u64));
+			assert!(!config(8, 4).is_digest_build_required_at_block(zero, zero + 4108u64));
+		}
+
+		test_with_zero(0);
+		test_with_zero(8);
+		test_with_zero(17);
 	}
 
 	#[test]
 	fn digest_level_at_block_works() {
-		assert_eq!(config(8, 4).digest_level_at_block(0u64), None);
-		assert_eq!(config(8, 4).digest_level_at_block(7u64), None);
-		assert_eq!(config(8, 4).digest_level_at_block(63u64), None);
-		assert_eq!(config(8, 4).digest_level_at_block(8u64), Some((1, 8, 1)));
-		assert_eq!(config(8, 4).digest_level_at_block(64u64), Some((2, 64, 8)));
-		assert_eq!(config(8, 4).digest_level_at_block(512u64), Some((3, 512, 64)));
-		assert_eq!(config(8, 4).digest_level_at_block(4096u64), Some((4, 4096, 512)));
-		assert_eq!(config(8, 4).digest_level_at_block(4112u64), Some((1, 8, 1)));
+		fn test_with_zero(zero: u64) {
+			assert_eq!(config(8, 4).digest_level_at_block(zero, zero + 0u64), None);
+			assert_eq!(config(8, 4).digest_level_at_block(zero, zero + 7u64), None);
+			assert_eq!(config(8, 4).digest_level_at_block(zero, zero + 63u64), None);
+			assert_eq!(config(8, 4).digest_level_at_block(zero, zero + 8u64), Some((1, 8, 1)));
+			assert_eq!(config(8, 4).digest_level_at_block(zero, zero + 64u64), Some((2, 64, 8)));
+			assert_eq!(config(8, 4).digest_level_at_block(zero, zero + 512u64), Some((3, 512, 64)));
+			assert_eq!(config(8, 4).digest_level_at_block(zero, zero + 4096u64), Some((4, 4096, 512)));
+			assert_eq!(config(8, 4).digest_level_at_block(zero, zero + 4112u64), Some((1, 8, 1)));
+		}
+
+		test_with_zero(0);
+		test_with_zero(8);
+		test_with_zero(17);
 	}
 
 	#[test]
@@ -165,4 +259,36 @@ mod tests {
 		assert_eq!(config(8, 4).max_digest_interval(), 4096);
 		assert_eq!(config(::std::u32::MAX, 1024).max_digest_interval(), ::std::u32::MAX);
 	}
+
+	#[test]
+	fn next_max_level_digest_range_works() {
+		assert_eq!(config(0, 0).next_max_level_digest_range(0u64, 16), None);
+		assert_eq!(config(1, 1).next_max_level_digest_range(0u64, 16), None);
+		assert_eq!(config(2, 1).next_max_level_digest_range(0u64, 16), Some((15, 16)));
+		assert_eq!(config(4, 1).next_max_level_digest_range(0u64, 16), Some((13, 16)));
+		assert_eq!(config(32, 1).next_max_level_digest_range(0u64, 16), Some((1, 32)));
+		assert_eq!(config(2, 3).next_max_level_digest_range(0u64, 10), Some((9, 16)));
+		assert_eq!(config(2, 3).next_max_level_digest_range(0u64, 8), Some((1, 8)));
+		assert_eq!(config(2, 1).next_max_level_digest_range(1u64, 1), Some((2, 3)));
+		assert_eq!(config(2, 2).next_max_level_digest_range(7u64, 9), Some((8, 11)));
+
+		assert_eq!(config(2, 2).next_max_level_digest_range(7u64, 5), Some((8, 11)));
+	}
+
+	#[test]
+	fn prev_max_level_digest_block_works() {
+		assert_eq!(config(0, 0).prev_max_level_digest_block(0u64, 16), None);
+		assert_eq!(config(1, 1).prev_max_level_digest_block(0u64, 16), None);
+		assert_eq!(config(2, 1).prev_max_level_digest_block(0u64, 16), Some(16));
+		assert_eq!(config(4, 1).prev_max_level_digest_block(0u64, 16), Some(16));
+		assert_eq!(config(4, 2).prev_max_level_digest_block(0u64, 16), Some(16));
+		assert_eq!(config(4, 2).prev_max_level_digest_block(0u64, 17), Some(16));
+		assert_eq!(config(4, 2).prev_max_level_digest_block(0u64, 33), Some(32));
+		assert_eq!(config(32, 1).prev_max_level_digest_block(0u64, 16), None);
+		assert_eq!(config(2, 3).prev_max_level_digest_block(0u64, 10), Some(8));
+		assert_eq!(config(2, 3).prev_max_level_digest_block(0u64, 8), Some(8));
+		assert_eq!(config(2, 2).prev_max_level_digest_block(7u64, 8), None);
+
+		assert_eq!(config(2, 2).prev_max_level_digest_block(7u64, 5), None);
+	}
 }