added docs and license headers

ethcore/src/blockchain/best_block.rs

@@ -1,23 +1,30 @@
+// Copyright 2015, 2016 Ethcore (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
 use util::hash::H256;
 use util::uint::U256;
 use header::BlockNumber;
 
-/// Information about best block gathered together
+/// Best block info.
 #[derive(Default)]
 pub struct BestBlock {
+	/// Best block hash.
 	pub hash: H256,
+	/// Best block number.
 	pub number: BlockNumber,
+	/// Best block total difficulty.
 	pub total_difficulty: U256
 }
-
-impl BestBlock {
-	pub fn new() -> BestBlock { Default::default() }
-}
-		
-		//BestBlock {
-			//hash: H256::new(),
-			//number: 0,
-			//total_difficulty: U256::from(0)
-		//}
-	//}
-//}

ethcore/src/blockchain/block_info.rs

@@ -1,19 +1,48 @@
+// Copyright 2015, 2016 Ethcore (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
 use util::hash::H256;
 use util::uint::U256;
 use header::BlockNumber;
 
+/// Brief info about inserted block.
 pub struct BlockInfo {
+	/// Block hash.
 	pub hash: H256,
+	/// Block number.
 	pub number: BlockNumber,
+	/// Total block difficulty.
 	pub total_difficulty: U256,
+	/// Block location in blockchain.
 	pub location: BlockLocation
 }
 
+/// Describes location of newly inserted block.
 pub enum BlockLocation {
+	/// It's part of the canon chain.
 	CanonChain,
+	/// It's not a part of the canon chain.
 	Branch,
+	/// It's part of the fork which should become canon chain,
+	/// because it's total difficulty is higher than current
+	/// canon chain difficulty.
 	BranchBecomingCanonChain {
+		/// Hash of the newest common ancestor with old canon chain.
 		ancestor: H256,
+		/// Hashes of the blocks between ancestor and this block.
 		route: Vec<H256>
 	}
 }

ethcore/src/blockchain/blockchain.rs

@@ -27,29 +27,12 @@ use blockchain::block_info::{BlockInfo, BlockLocation};
 use blockchain::best_block::BestBlock;
 use blockchain::bloom_indexer::BloomIndexer;
 use blockchain::tree_route::TreeRoute;
+use blockchain::update::ExtrasUpdate;
 use blockchain::CacheSize;
 
 const BLOOM_INDEX_SIZE: usize = 16;
 const BLOOM_LEVELS: u8 = 3;
 
-/// Blockchain update info.
-struct ExtrasUpdate {
-	/// Block info.
-	info: BlockInfo,
-	/// DB update batch.
-	batch: DBTransaction,
-	/// Numbers of blocks to update in block hashes cache.
-	block_numbers: HashSet<BlockNumber>,
-	/// Hashes of blocks to update in block details cache.
-	block_details_hashes: HashSet<H256>,
-	/// Hashes of receipts to update in block receipts cache.
-	block_receipts_hashes: HashSet<H256>,
-	/// Hashes of transactions to update in transactions addresses cache.
-	transactions_addresses_hashes: HashSet<H256>,
-	/// Changed blocks bloom location hashes.
-	bloom_hashes: HashSet<H256>,
-}
-
 /// Interface for querying blocks by hash and by number.
 pub trait BlockProvider {
 	/// Returns true if the given block is known
@@ -271,7 +254,7 @@ impl BlockChain {
 		let bc = BlockChain {
 			pref_cache_size: 1 << 14,
 			max_cache_size: 1 << 20,
-			best_block: RwLock::new(BestBlock::new()),
+			best_block: RwLock::new(BestBlock::default()),
 			blocks: RwLock::new(HashMap::new()),
 			block_details: RwLock::new(HashMap::new()),
 			block_hashes: RwLock::new(HashMap::new()),
@@ -376,8 +359,8 @@ impl BlockChain {
 		let mut from_branch = vec![];
 		let mut to_branch = vec![];
 
-		let mut from_details = self.block_details(&from).expect(&format!("Expected to find details for block {:?}", from));
+		let mut from_details = self.block_details(&from).expect(&format!("0. Expected to find details for block {:?}", from));
-		let mut to_details = self.block_details(&to).expect(&format!("Expected to find details for block {:?}", to));
+		let mut to_details = self.block_details(&to).expect(&format!("1. Expected to find details for block {:?}", to));
 		let mut current_from = from;
 		let mut current_to = to;
 
@@ -385,13 +368,13 @@ impl BlockChain {
 		while from_details.number > to_details.number {
 			from_branch.push(current_from);
 			current_from = from_details.parent.clone();
-			from_details = self.block_details(&from_details.parent).expect(&format!("1. Expected to find details for block {:?}", from_details.parent));
+			from_details = self.block_details(&from_details.parent).expect(&format!("2. Expected to find details for block {:?}", from_details.parent));
 		}
 
 		while to_details.number > from_details.number {
 			to_branch.push(current_to);
 			current_to = to_details.parent.clone();
-			to_details = self.block_details(&to_details.parent).expect(&format!("2. Expected to find details for block {:?}", to_details.parent));
+			to_details = self.block_details(&to_details.parent).expect(&format!("3. Expected to find details for block {:?}", to_details.parent));
 		}
 
 		assert_eq!(from_details.number, to_details.number);
@@ -400,11 +383,11 @@ impl BlockChain {
 		while current_from != current_to {
 			from_branch.push(current_from);
 			current_from = from_details.parent.clone();
-			from_details = self.block_details(&from_details.parent).expect(&format!("3. Expected to find details for block {:?}", from_details.parent));
+			from_details = self.block_details(&from_details.parent).expect(&format!("4. Expected to find details for block {:?}", from_details.parent));
 
 			to_branch.push(current_to);
 			current_to = to_details.parent.clone();
-			to_details = self.block_details(&to_details.parent).expect(&format!("4. Expected to find details for block {:?}", from_details.parent));
+			to_details = self.block_details(&to_details.parent).expect(&format!("5. Expected to find details for block {:?}", from_details.parent));
 		}
 
 		let index = from_branch.len();
@@ -1061,30 +1044,5 @@ mod tests {
 		assert_eq!(blocks_ba, vec![3]);
 	}
 
-	#[test]
-	fn test_bloom_indexer() {
-		use chainfilter::BloomIndex;
-		use blockchain::bloom_indexer::BloomIndexer;
-		use extras::BlocksBloomLocation;
 
-		let bi = BloomIndexer::new(16, 3);
-
-		let index = BloomIndex::new(0, 0);
-		assert_eq!(bi.location(&index), BlocksBloomLocation {
-			hash: H256::new(),
-			index: 0
-		});
-
-		let index = BloomIndex::new(1, 0);
-		assert_eq!(bi.location(&index), BlocksBloomLocation {
-			hash: H256::from_str("0000000000000000000000000000000000000000000000010000000000000000").unwrap(),
-			index: 0
-		});
-
-		let index = BloomIndex::new(0, 299_999);
-		assert_eq!(bi.location(&index), BlocksBloomLocation {
-			hash: H256::from_str("000000000000000000000000000000000000000000000000000000000000493d").unwrap(),
-			index: 15
-		});
-	}
 }

ethcore/src/blockchain/bloom_indexer.rs

@@ -1,13 +1,39 @@
+// Copyright 2015, 2016 Ethcore (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
 use util::hash::H256;
 use chainfilter::BloomIndex;
-use extras::BlocksBloomLocation;
 
+/// Represents location of block bloom in extras database.
+#[derive(Debug, PartialEq)]
+pub struct BlocksBloomLocation {
+	/// Unique hash of BlocksBloom
+	pub hash: H256,
+	/// Index within BlocksBloom
+	pub index: usize,
+}
+
+/// Should be used to localize blocks blooms in extras database.
 pub struct BloomIndexer {
 	index_size: usize,
 	levels: u8,
 }
 
 impl BloomIndexer {
+	/// Plain constructor.
 	pub fn new(index_size: usize, levels: u8) -> Self {
 		BloomIndexer {
 			index_size: index_size,
@@ -33,11 +59,44 @@ impl BloomIndexer {
 		}
 	}
 
+	/// Returns index size.
 	pub fn index_size(&self) -> usize {
 		self.index_size
 	}
 
+	/// Returns number of cache levels.
 	pub fn levels(&self) -> u8 {
 		self.levels
 	}
 }
+
+#[cfg(test)]
+mod tests {
+	use std::str::FromStr;
+	use util::hash::{H256, FixedHash};
+	use chainfilter::BloomIndex;
+	use blockchain::bloom_indexer::{BloomIndexer, BlocksBloomLocation};
+
+	#[test]
+	fn test_bloom_indexer() {
+		let bi = BloomIndexer::new(16, 3);
+
+		let index = BloomIndex::new(0, 0);
+		assert_eq!(bi.location(&index), BlocksBloomLocation {
+			hash: H256::new(),
+			index: 0
+		});
+
+		let index = BloomIndex::new(1, 0);
+		assert_eq!(bi.location(&index), BlocksBloomLocation {
+			hash: H256::from_str("0000000000000000000000000000000000000000000000010000000000000000").unwrap(),
+			index: 0
+		});
+
+		let index = BloomIndex::new(0, 299_999);
+		assert_eq!(bi.location(&index), BlocksBloomLocation {
+			hash: H256::from_str("000000000000000000000000000000000000000000000000000000000000493d").unwrap(),
+			index: 15
+		});
+	}
+}

ethcore/src/blockchain/cache.rs

@@ -1,4 +1,18 @@
+// Copyright 2015, 2016 Ethcore (UK) Ltd.
+// This file is part of Parity.
 
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
 /// Represents blockchain's in-memory cache size in bytes.
 #[derive(Debug)]

ethcore/src/blockchain/mod.rs

@@ -1,9 +1,28 @@
+// Copyright 2015, 2016 Ethcore (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Blockchain database.
+
 pub mod blockchain;
 mod best_block;
 mod block_info;
 mod bloom_indexer;
 mod cache;
 mod tree_route;
+mod update;
 
 pub use self::blockchain::{BlockProvider, BlockChain};
 pub use self::cache::CacheSize;

ethcore/src/blockchain/tree_route.rs

@@ -1,3 +1,19 @@
+// Copyright 2015, 2016 Ethcore (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
 use util::hash::H256;
 
 /// Represents a tree route between `from` block and `to` block:

ethcore/src/blockchain/update.rs

@@ -0,0 +1,23 @@
+use std::collections::HashSet;
+use util::hash::H256;
+use util::kvdb::DBTransaction;
+use header::BlockNumber;
+use blockchain::block_info::BlockInfo;
+
+/// Block extras update info.
+pub struct ExtrasUpdate {
+	/// Block info.
+	pub info: BlockInfo,
+	/// DB update batch.
+	pub batch: DBTransaction,
+	/// Numbers of blocks to update in block hashes cache.
+	pub block_numbers: HashSet<BlockNumber>,
+	/// Hashes of blocks to update in block details cache.
+	pub block_details_hashes: HashSet<H256>,
+	/// Hashes of receipts to update in block receipts cache.
+	pub block_receipts_hashes: HashSet<H256>,
+	/// Hashes of transactions to update in transactions addresses cache.
+	pub transactions_addresses_hashes: HashSet<H256>,
+	/// Changed blocks bloom location hashes.
+	pub bloom_hashes: HashSet<H256>,
+}

ethcore/src/extras.rs

@@ -262,15 +262,6 @@ impl Encodable for BlocksBlooms {
 	}
 }
 
-/// Represents location of bloom in database.
-#[derive(Debug, PartialEq)]
-pub struct BlocksBloomLocation {
-	/// Unique hash of BlocksBloom
-	pub hash: H256,
-	/// Index within BlocksBloom
-	pub index: usize,
-}
-
 /// Represents address of certain transaction within block
 #[derive(Clone)]
 pub struct TransactionAddress {