bloom refactor (#7475)

* ethereum-types refactor in progress

* ethereum-types refactor in progress

* ethereum-types refactor in progress

* ethereum-types refactor in progress

* ethereum-types refactor finished

* cleanup bloom mess

* simplify usage of Bloom in few places

* removed obsolete util/src/lib.rs

* removed commented out code

* ethereum-types 0.1.4

* updated ethereum-types and tiny-keccak

util/bloomchain/src/position/manager.rs

@@ -0,0 +1,142 @@
+//! Simplifies working with bloom indexes.
+
+use super::Position;
+
+/// Simplifies working with bloom indexes.
+pub struct Manager {
+	index_size: usize,
+	level_sizes: Vec<usize>,
+}
+
+impl Manager {
+	/// Creates new indexer.
+	pub fn new(index_size: usize, levels: usize) -> Self {
+		if levels == 0 {
+			panic!("Manager requires at least 1 level.");
+		}
+
+		let mut level_sizes = vec![1];
+		level_sizes.extend_from_slice(&(1..).into_iter()
+			.scan(1, |acc, _| {
+				*acc = *acc * index_size;
+				Some(*acc)
+			})
+			.take(levels - 1)
+			.collect::<Vec<usize>>());
+
+		Manager {
+			index_size: index_size,
+			level_sizes: level_sizes,
+		}
+	}
+
+	/// Unsafely get level size.
+	pub fn level_size(&self, level: usize) -> usize {
+		self.level_sizes[level as usize]
+	}
+
+	/// Converts block number and level to `Position`.
+	pub fn position(&self, block_number: usize, level: usize) -> Position {
+		Position {
+			level: level,
+			index: block_number / self.level_size(level),
+		}
+	}
+
+	/// Return bloom which are dependencies for given index.
+	///
+	/// Bloom indexes are ordered from lowest to highest.
+	pub fn lower_level_positions(&self, index: &Position) -> Vec<Position> {
+		// this is the lowest level
+		if index.level == 0 {
+			return vec![];
+		}
+
+		let new_level = index.level - 1;
+		let offset = self.index_size * index.index;
+
+		(0..self.index_size)
+			.map(|i| Position {
+				level: new_level, 
+				index: offset + i
+			})
+			.collect()
+	}
+
+	/// Return number of levels.
+	pub fn levels(&self) -> usize {
+		self.level_sizes.len()
+	}
+
+	/// Returns max indexer level.
+	pub fn max_level(&self) -> usize {
+		self.level_sizes.len() - 1
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use position::Position;
+	use super::*;
+	#[test]
+	fn test_level_size() {
+		let indexer = Manager::new(16, 3);
+		assert_eq!(indexer.level_size(0), 1);
+		assert_eq!(indexer.level_size(1), 16);
+		assert_eq!(indexer.level_size(2), 256);
+	}
+
+	#[test]
+	fn test_position() {
+		let indexer = Manager::new(16, 3);
+
+		let bi0 = indexer.position(0, 0);
+		assert_eq!(bi0.level, 0);
+		assert_eq!(bi0.index, 0);
+
+		let bi1 = indexer.position(1, 0);
+		assert_eq!(bi1.level, 0);
+		assert_eq!(bi1.index, 1);
+
+		let bi2 = indexer.position(2, 0);
+		assert_eq!(bi2.level, 0);
+		assert_eq!(bi2.index, 2);
+
+		let bi3 = indexer.position(3, 1);
+		assert_eq!(bi3.level, 1);
+		assert_eq!(bi3.index, 0);
+
+		let bi4 = indexer.position(15, 1);
+		assert_eq!(bi4.level, 1);
+		assert_eq!(bi4.index, 0);
+
+		let bi5 = indexer.position(16, 1);
+		assert_eq!(bi5.level, 1);
+		assert_eq!(bi5.index, 1);
+
+		let bi6 = indexer.position(255, 2);
+		assert_eq!(bi6.level, 2);
+		assert_eq!(bi6.index, 0);
+
+		let bi7 = indexer.position(256, 2);
+		assert_eq!(bi7.level, 2);
+		assert_eq!(bi7.index, 1);
+	}
+
+	#[test]
+	fn test_lower_level_positions() {
+		let indexer = Manager::new(16, 3);
+
+		let bi = indexer.position(256, 2);
+		assert_eq!(bi.level, 2);
+		assert_eq!(bi.index, 1);
+
+		let mut ebis = vec![];
+		for i in 16..32 {
+			ebis.push(Position { level: 1, index: i});
+		}
+
+		let bis = indexer.lower_level_positions(&bi);
+		assert_eq!(ebis, bis);
+	}
+}

util/bloomchain/src/position/mod.rs

@@ -0,0 +1,5 @@
+pub mod position;
+pub mod manager;
+
+pub use self::position::Position;
+pub use self::manager::Manager;

util/bloomchain/src/position/position.rs

@@ -0,0 +1,8 @@
+/// Uniquely identifies bloom position.
+#[derive(Debug, PartialEq, Eq, Hash)]
+pub struct Position {
+	/// Bloom level.
+	pub level: usize,
+	/// Index of the bloom.
+	pub index: usize,
+}