Merge branch 'master' into rpc_unit_tests

ethcore/src/blockchain/mod.rs

@@ -23,9 +23,9 @@ mod bloom_indexer;
 mod cache;
 mod tree_route;
 mod update;
+mod import_route;
 #[cfg(test)]
 mod generator;
-mod import_route;
 
 pub use self::blockchain::{BlockProvider, BlockChain, BlockChainConfig};
 pub use self::cache::CacheSize;

ethcore/src/client/client.rs

@@ -20,7 +20,6 @@ use std::marker::PhantomData;
 use std::sync::atomic::AtomicBool;
 use util::*;
 use util::panics::*;
-use blockchain::{BlockChain, BlockProvider};
 use views::BlockView;
 use error::*;
 use header::{BlockNumber};
@@ -28,7 +27,6 @@ use state::State;
 use spec::Spec;
 use engine::Engine;
 use views::HeaderView;
-use block_queue::BlockQueue;
 use service::{NetSyncMessage, SyncMessage};
 use env_info::LastHashes;
 use verification::*;
@@ -37,33 +35,10 @@ use transaction::LocalizedTransaction;
 use extras::TransactionAddress;
 use filter::Filter;
 use log_entry::LocalizedLogEntry;
-pub use block_queue::{BlockQueueConfig, BlockQueueInfo};
+use block_queue::{BlockQueue, BlockQueueInfo};
-pub use blockchain::{TreeRoute, BlockChainConfig, CacheSize as BlockChainCacheSize};
+use blockchain::{BlockChain, BlockProvider, TreeRoute};
-
+use client::{BlockId, TransactionId, ClientConfig, BlockChainClient};
-
+pub use blockchain::CacheSize as BlockChainCacheSize;
-/// Uniquely identifies block.
-#[derive(Debug, PartialEq, Clone)]
-pub enum BlockId {
-	/// Block's sha3.
-	/// Querying by hash is always faster.
-	Hash(H256),
-	/// Block number within canon blockchain.
-	Number(BlockNumber),
-	/// Earliest block (genesis).
-	Earliest,
-	/// Latest mined block.
-	Latest
-}
-
-/// Uniquely identifies transaction.
-#[derive(Debug, PartialEq, Clone)]
-pub enum TransactionId {
-	/// Transaction's sha3.
-	Hash(H256),
-	/// Block id and transaction index within this block.
-	/// Querying by block position is always faster.
-	Location(BlockId, usize)
-}
 
 /// General block status
 #[derive(Debug, Eq, PartialEq)]
@@ -78,30 +53,6 @@ pub enum BlockStatus {
 	Unknown,
 }
 
-/// Client configuration. Includes configs for all sub-systems.
-#[derive(Debug)]
-pub struct ClientConfig {
-	/// Block queue configuration.
-	pub queue: BlockQueueConfig,
-	/// Blockchain configuration.
-	pub blockchain: BlockChainConfig,
-	/// Prefer journal rather than archive.
-	pub prefer_journal: bool,
-	/// The name of the client instance.
-	pub name: String,
-}
-
-impl Default for ClientConfig {
-	fn default() -> ClientConfig {
-		ClientConfig {
-			queue: Default::default(),
-			blockchain: Default::default(),
-			prefer_journal: false,
-			name: Default::default(),
-		}
-	}
-}
-
 /// Information about the blockchain gathered together.
 #[derive(Debug)]
 pub struct BlockChainInfo {
@@ -123,79 +74,8 @@ impl fmt::Display for BlockChainInfo {
 	}
 }
 
-/// Blockchain database client. Owns and manages a blockchain and a block queue.
-pub trait BlockChainClient : Sync + Send {
-	/// Get raw block header data by block id.
-	fn block_header(&self, id: BlockId) -> Option<Bytes>;
-
-	/// Get raw block body data by block id.
-	/// Block body is an RLP list of two items: uncles and transactions.
-	fn block_body(&self, id: BlockId) -> Option<Bytes>;
-
-	/// Get raw block data by block header hash.
-	fn block(&self, id: BlockId) -> Option<Bytes>;
-
-	/// Get block status by block header hash.
-	fn block_status(&self, id: BlockId) -> BlockStatus;
-
-	/// Get block total difficulty.
-	fn block_total_difficulty(&self, id: BlockId) -> Option<U256>;
-
-	/// Get address nonce.
-	fn nonce(&self, address: &Address) -> U256;
-
-	/// Get block hash.
-	fn block_hash(&self, id: BlockId) -> Option<H256>;
-
-	/// Get address code.
-	fn code(&self, address: &Address) -> Option<Bytes>;
-
-	/// Get transaction with given hash.
-	fn transaction(&self, id: TransactionId) -> Option<LocalizedTransaction>;
-
-	/// Get a tree route between `from` and `to`.
-	/// See `BlockChain::tree_route`.
-	fn tree_route(&self, from: &H256, to: &H256) -> Option<TreeRoute>;
-
-	/// Get latest state node
-	fn state_data(&self, hash: &H256) -> Option<Bytes>;
-
-	/// Get raw block receipts data by block header hash.
-	fn block_receipts(&self, hash: &H256) -> Option<Bytes>;
-
-	/// Import a block into the blockchain.
-	fn import_block(&self, bytes: Bytes) -> ImportResult;
-
-	/// Get block queue information.
-	fn queue_info(&self) -> BlockQueueInfo;
-
-	/// Clear block queue and abort all import activity.
-	fn clear_queue(&self);
-
-	/// Get blockchain information.
-	fn chain_info(&self) -> BlockChainInfo;
-
-	/// Get the best block header.
-	fn best_block_header(&self) -> Bytes {
-		self.block_header(BlockId::Hash(self.chain_info().best_block_hash)).unwrap()
-	}
-
-	/// Returns numbers of blocks containing given bloom.
-	fn blocks_with_bloom(&self, bloom: &H2048, from_block: BlockId, to_block: BlockId) -> Option<Vec<BlockNumber>>;
-
-	/// Returns logs matching given filter.
-	fn logs(&self, filter: Filter) -> Vec<LocalizedLogEntry>;
-
-	/// Grab the `ClosedBlock` that we want to be sealed. Comes as a mutex that you have to lock.
-	fn sealing_block(&self) -> &Mutex<Option<ClosedBlock>>;
-
-	/// Submit `seal` as a valid solution for the header of `pow_hash`.
-	/// Will check the seal, but not actually insert the block into the chain.
-	fn submit_seal(&self, pow_hash: H256, seal: Vec<Bytes>) -> Result<(), Error>;
-}
-
-#[derive(Default, Clone, Debug, Eq, PartialEq)]
 /// Report on the status of a client.
+#[derive(Default, Clone, Debug, Eq, PartialEq)]
 pub struct ClientReport {
 	/// How many blocks have been imported so far.
 	pub blocks_imported: usize,
@@ -630,6 +510,8 @@ impl<V> BlockChainClient for Client<V> where V: Verifier {
 	}
 
 	fn logs(&self, filter: Filter) -> Vec<LocalizedLogEntry> {
+		// TODO: lock blockchain only once
+
 		let mut blocks = filter.bloom_possibilities().iter()
 			.filter_map(|bloom| self.blocks_with_bloom(bloom, filter.from_block.clone(), filter.to_block.clone()))
 			.flat_map(|m| m)

ethcore/src/client/config.rs

@@ -0,0 +1,31 @@
+// 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/>.
+
+pub use block_queue::BlockQueueConfig;
+pub use blockchain::BlockChainConfig;
+
+/// Client configuration. Includes configs for all sub-systems.
+#[derive(Debug, Default)]
+pub struct ClientConfig {
+	/// Block queue configuration.
+	pub queue: BlockQueueConfig,
+	/// Blockchain configuration.
+	pub blockchain: BlockChainConfig,
+	/// Prefer journal rather than archive.
+	pub prefer_journal: bool,
+	/// The name of the client instance.
+	pub name: String,
+}

ethcore/src/client/ids.rs

@@ -0,0 +1,44 @@
+// 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/>.
+
+//! Unique identifiers.
+
+use util::hash::H256;
+use header::BlockNumber;
+
+/// Uniquely identifies block.
+#[derive(Debug, PartialEq, Clone)]
+pub enum BlockId {
+	/// Block's sha3.
+	/// Querying by hash is always faster.
+	Hash(H256),
+	/// Block number within canon blockchain.
+	Number(BlockNumber),
+	/// Earliest block (genesis).
+	Earliest,
+	/// Latest mined block.
+	Latest
+}
+
+/// Uniquely identifies transaction.
+#[derive(Debug, PartialEq, Clone)]
+pub enum TransactionId {
+	/// Transaction's sha3.
+	Hash(H256),
+	/// Block id and transaction index within this block.
+	/// Querying by block position is always faster.
+	Location(BlockId, usize)
+}

ethcore/src/client/mod.rs

@@ -0,0 +1,113 @@
+// 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 client.
+
+mod client;
+mod config;
+mod ids;
+mod test_client;
+
+pub use self::client::*;
+pub use self::config::{ClientConfig, BlockQueueConfig, BlockChainConfig};
+pub use self::ids::{BlockId, TransactionId};
+pub use self::test_client::{TestBlockChainClient, EachBlockWith};
+
+use std::sync::Mutex;
+use util::bytes::Bytes;
+use util::hash::{Address, H256, H2048};
+use util::numbers::U256;
+use blockchain::TreeRoute;
+use block_queue::BlockQueueInfo;
+use block::ClosedBlock;
+use header::BlockNumber;
+use transaction::LocalizedTransaction;
+use log_entry::LocalizedLogEntry;
+use filter::Filter;
+use error::{ImportResult, Error};
+
+/// Blockchain database client. Owns and manages a blockchain and a block queue.
+pub trait BlockChainClient : Sync + Send {
+	/// Get raw block header data by block id.
+	fn block_header(&self, id: BlockId) -> Option<Bytes>;
+
+	/// Get raw block body data by block id.
+	/// Block body is an RLP list of two items: uncles and transactions.
+	fn block_body(&self, id: BlockId) -> Option<Bytes>;
+
+	/// Get raw block data by block header hash.
+	fn block(&self, id: BlockId) -> Option<Bytes>;
+
+	/// Get block status by block header hash.
+	fn block_status(&self, id: BlockId) -> BlockStatus;
+
+	/// Get block total difficulty.
+	fn block_total_difficulty(&self, id: BlockId) -> Option<U256>;
+
+	/// Get address nonce.
+	fn nonce(&self, address: &Address) -> U256;
+
+	/// Get block hash.
+	fn block_hash(&self, id: BlockId) -> Option<H256>;
+
+	/// Get address code.
+	fn code(&self, address: &Address) -> Option<Bytes>;
+
+	/// Get transaction with given hash.
+	fn transaction(&self, id: TransactionId) -> Option<LocalizedTransaction>;
+
+	/// Get a tree route between `from` and `to`.
+	/// See `BlockChain::tree_route`.
+	fn tree_route(&self, from: &H256, to: &H256) -> Option<TreeRoute>;
+
+	/// Get latest state node
+	fn state_data(&self, hash: &H256) -> Option<Bytes>;
+
+	/// Get raw block receipts data by block header hash.
+	fn block_receipts(&self, hash: &H256) -> Option<Bytes>;
+
+	/// Import a block into the blockchain.
+	fn import_block(&self, bytes: Bytes) -> ImportResult;
+
+	/// Get block queue information.
+	fn queue_info(&self) -> BlockQueueInfo;
+
+	/// Clear block queue and abort all import activity.
+	fn clear_queue(&self);
+
+	/// Get blockchain information.
+	fn chain_info(&self) -> BlockChainInfo;
+
+	/// Get the best block header.
+	fn best_block_header(&self) -> Bytes {
+		// TODO: lock blockchain only once
+		self.block_header(BlockId::Hash(self.chain_info().best_block_hash)).unwrap()
+	}
+
+	/// Returns numbers of blocks containing given bloom.
+	fn blocks_with_bloom(&self, bloom: &H2048, from_block: BlockId, to_block: BlockId) -> Option<Vec<BlockNumber>>;
+
+	/// Returns logs matching given filter.
+	fn logs(&self, filter: Filter) -> Vec<LocalizedLogEntry>;
+
+	/// Grab the `ClosedBlock` that we want to be sealed. Comes as a mutex that you have to lock.
+	fn sealing_block(&self) -> &Mutex<Option<ClosedBlock>>;
+
+	/// Submit `seal` as a valid solution for the header of `pow_hash`.
+	/// Will check the seal, but not actually insert the block into the chain.
+	fn submit_seal(&self, pow_hash: H256, seal: Vec<Bytes>) -> Result<(), Error>;
+}
+

ethcore/src/client/test_client.rs

@@ -0,0 +1,336 @@
+// 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/>.
+
+//! Test client.
+
+use util::*;
+use transaction::{Transaction, LocalizedTransaction, Action};
+use blockchain::TreeRoute;
+use client::{BlockChainClient, BlockChainInfo, BlockStatus, BlockId, TransactionId};
+use header::{Header as BlockHeader, BlockNumber};
+use filter::Filter;
+use log_entry::LocalizedLogEntry;
+use receipt::Receipt;
+use error::{ImportResult, Error};
+use block_queue::BlockQueueInfo;
+use block::ClosedBlock;
+
+/// Test client.
+pub struct TestBlockChainClient {
+	/// Blocks.
+	pub blocks: RwLock<HashMap<H256, Bytes>>,
+	/// Mapping of numbers to hashes.
+ 	pub numbers: RwLock<HashMap<usize, H256>>,
+	/// Genesis block hash.
+	pub genesis_hash: H256,
+	/// Last block hash.
+	pub last_hash: RwLock<H256>,
+	/// Difficulty.
+	pub difficulty: RwLock<U256>,
+}
+
+#[derive(Clone)]
+/// Used for generating test client blocks.
+pub enum EachBlockWith {
+	/// Plain block.
+	Nothing,
+	/// Block with an uncle.
+	Uncle,
+	/// Block with a transaction.
+	Transaction,
+	/// Block with an uncle and transaction.
+	UncleAndTransaction
+}
+
+impl TestBlockChainClient {
+	/// Creates new test client.
+	pub fn new() -> TestBlockChainClient {
+
+		let mut client = TestBlockChainClient {
+			blocks: RwLock::new(HashMap::new()),
+			numbers: RwLock::new(HashMap::new()),
+			genesis_hash: H256::new(),
+			last_hash: RwLock::new(H256::new()),
+			difficulty: RwLock::new(From::from(0)),
+		};
+		client.add_blocks(1, EachBlockWith::Nothing); // add genesis block
+		client.genesis_hash = client.last_hash.read().unwrap().clone();
+		client
+	}
+
+	/// Add blocks to test client.
+	pub fn add_blocks(&mut self, count: usize, with: EachBlockWith) {
+		let len = self.numbers.read().unwrap().len();
+		for n in len..(len + count) {
+			let mut header = BlockHeader::new();
+			header.difficulty = From::from(n);
+			header.parent_hash = self.last_hash.read().unwrap().clone();
+			header.number = n as BlockNumber;
+			let uncles = match with {
+				EachBlockWith::Uncle | EachBlockWith::UncleAndTransaction => {
+					let mut uncles = RlpStream::new_list(1);
+					let mut uncle_header = BlockHeader::new();
+					uncle_header.difficulty = From::from(n);
+					uncle_header.parent_hash = self.last_hash.read().unwrap().clone();
+					uncle_header.number = n as BlockNumber;
+					uncles.append(&uncle_header);
+					header.uncles_hash = uncles.as_raw().sha3();
+					uncles
+				},
+				_ => RlpStream::new_list(0)
+			};
+			let txs = match with {
+				EachBlockWith::Transaction | EachBlockWith::UncleAndTransaction => {
+					let mut txs = RlpStream::new_list(1);
+					let keypair = KeyPair::create().unwrap();
+					let tx = Transaction {
+						action: Action::Create,
+						value: U256::from(100),
+						data: "3331600055".from_hex().unwrap(),
+						gas: U256::from(100_000),
+						gas_price: U256::one(),
+						nonce: U256::zero()
+					};
+					let signed_tx = tx.sign(&keypair.secret());
+					txs.append(&signed_tx);
+					txs.out()
+				},
+				_ => rlp::NULL_RLP.to_vec()
+			};
+
+			let mut rlp = RlpStream::new_list(3);
+			rlp.append(&header);
+			rlp.append_raw(&txs, 1);
+			rlp.append_raw(uncles.as_raw(), 1);
+			self.import_block(rlp.as_raw().to_vec()).unwrap();
+		}
+	}
+
+	/// TODO:
+	pub fn corrupt_block(&mut self, n: BlockNumber) {
+		let hash = self.block_hash(BlockId::Number(n)).unwrap();
+		let mut header: BlockHeader = decode(&self.block_header(BlockId::Number(n)).unwrap());
+		header.parent_hash = H256::new();
+		let mut rlp = RlpStream::new_list(3);
+		rlp.append(&header);
+		rlp.append_raw(&rlp::NULL_RLP, 1);
+		rlp.append_raw(&rlp::NULL_RLP, 1);
+		self.blocks.write().unwrap().insert(hash, rlp.out());
+	}
+
+	/// TODO:
+	pub fn block_hash_delta_minus(&mut self, delta: usize) -> H256 {
+		let blocks_read = self.numbers.read().unwrap();
+		let index = blocks_read.len() - delta;
+		blocks_read[&index].clone()
+	}
+
+	fn block_hash(&self, id: BlockId) -> Option<H256> {
+		match id {
+			BlockId::Hash(hash) => Some(hash),
+			BlockId::Number(n) => self.numbers.read().unwrap().get(&(n as usize)).cloned(),
+			BlockId::Earliest => self.numbers.read().unwrap().get(&0).cloned(),
+			BlockId::Latest => self.numbers.read().unwrap().get(&(self.numbers.read().unwrap().len() - 1)).cloned()
+		}
+	}
+}
+
+impl BlockChainClient for TestBlockChainClient {
+	fn block_total_difficulty(&self, _id: BlockId) -> Option<U256> {
+		Some(U256::zero())
+	}
+
+	fn block_hash(&self, _id: BlockId) -> Option<H256> {
+		unimplemented!();
+	}
+
+	fn nonce(&self, _address: &Address) -> U256 {
+		U256::zero()
+	}
+
+	fn code(&self, _address: &Address) -> Option<Bytes> {
+		unimplemented!();
+	}
+
+	fn transaction(&self, _id: TransactionId) -> Option<LocalizedTransaction> {
+		unimplemented!();
+	}
+
+	fn blocks_with_bloom(&self, _bloom: &H2048, _from_block: BlockId, _to_block: BlockId) -> Option<Vec<BlockNumber>> {
+		unimplemented!();
+	}
+
+	fn logs(&self, _filter: Filter) -> Vec<LocalizedLogEntry> {
+		unimplemented!();
+	}
+
+	fn sealing_block(&self) -> &Mutex<Option<ClosedBlock>> {
+		unimplemented!();
+	}
+
+	fn submit_seal(&self, _pow_hash: H256, _seal: Vec<Bytes>) -> Result<(), Error> {
+		unimplemented!();
+	}
+
+	fn block_header(&self, id: BlockId) -> Option<Bytes> {
+		self.block_hash(id).and_then(|hash| self.blocks.read().unwrap().get(&hash).map(|r| Rlp::new(r).at(0).as_raw().to_vec()))
+	}
+
+	fn block_body(&self, id: BlockId) -> Option<Bytes> {
+		self.block_hash(id).and_then(|hash| self.blocks.read().unwrap().get(&hash).map(|r| {
+			let mut stream = RlpStream::new_list(2);
+			stream.append_raw(Rlp::new(&r).at(1).as_raw(), 1);
+			stream.append_raw(Rlp::new(&r).at(2).as_raw(), 1);
+			stream.out()
+		}))
+	}
+
+	fn block(&self, id: BlockId) -> Option<Bytes> {
+		self.block_hash(id).and_then(|hash| self.blocks.read().unwrap().get(&hash).cloned())
+	}
+
+	fn block_status(&self, id: BlockId) -> BlockStatus {
+		match id {
+			BlockId::Number(number) if (number as usize) < self.blocks.read().unwrap().len() => BlockStatus::InChain,
+			BlockId::Hash(ref hash) if self.blocks.read().unwrap().get(hash).is_some() => BlockStatus::InChain,
+			_ => BlockStatus::Unknown
+		}
+	}
+
+	// works only if blocks are one after another 1 -> 2 -> 3
+	fn tree_route(&self, from: &H256, to: &H256) -> Option<TreeRoute> {
+		Some(TreeRoute {
+			ancestor: H256::new(),
+			index: 0,
+			blocks: {
+				let numbers_read = self.numbers.read().unwrap();
+				let mut adding = false;
+
+				let mut blocks = Vec::new();
+				for (_, hash) in numbers_read.iter().sort_by(|tuple1, tuple2| tuple1.0.cmp(tuple2.0)) {
+					if hash == to {
+						if adding {
+							blocks.push(hash.clone());
+						}
+						adding = false;
+						break;
+					}
+					if hash == from {
+						adding = true;
+					}
+					if adding {
+						blocks.push(hash.clone());
+					}
+				}
+				if adding { Vec::new() } else { blocks }
+			}
+		})
+	}
+
+	// TODO: returns just hashes instead of node state rlp(?)
+	fn state_data(&self, hash: &H256) -> Option<Bytes> {
+		// starts with 'f' ?
+		if *hash > H256::from("f000000000000000000000000000000000000000000000000000000000000000") {
+			let mut rlp = RlpStream::new();
+			rlp.append(&hash.clone());
+			return Some(rlp.out());
+		}
+		None
+	}
+
+	fn block_receipts(&self, hash: &H256) -> Option<Bytes> {
+		// starts with 'f' ?
+		if *hash > H256::from("f000000000000000000000000000000000000000000000000000000000000000") {
+			let receipt = Receipt::new(
+				H256::zero(),
+				U256::zero(),
+				vec![]);
+			let mut rlp = RlpStream::new();
+			rlp.append(&receipt);
+			return Some(rlp.out());
+		}
+		None
+	}
+
+	fn import_block(&self, b: Bytes) -> ImportResult {
+		let header = Rlp::new(&b).val_at::<BlockHeader>(0);
+		let h = header.hash();
+		let number: usize = header.number as usize;
+		if number > self.blocks.read().unwrap().len() {
+			panic!("Unexpected block number. Expected {}, got {}", self.blocks.read().unwrap().len(), number);
+		}
+		if number > 0 {
+			match self.blocks.read().unwrap().get(&header.parent_hash) {
+				Some(parent) => {
+					let parent = Rlp::new(parent).val_at::<BlockHeader>(0);
+					if parent.number != (header.number - 1) {
+						panic!("Unexpected block parent");
+					}
+				},
+				None => {
+					panic!("Unknown block parent {:?} for block {}", header.parent_hash, number);
+				}
+			}
+		}
+		let len = self.numbers.read().unwrap().len();
+		if number == len {
+			{
+				let mut difficulty = self.difficulty.write().unwrap();
+				*difficulty.deref_mut() = *difficulty.deref() + header.difficulty;
+			}
+			mem::replace(self.last_hash.write().unwrap().deref_mut(), h.clone());
+			self.blocks.write().unwrap().insert(h.clone(), b);
+			self.numbers.write().unwrap().insert(number, h.clone());
+			let mut parent_hash = header.parent_hash;
+			if number > 0 {
+				let mut n = number - 1;
+				while n > 0 && self.numbers.read().unwrap()[&n] != parent_hash {
+					*self.numbers.write().unwrap().get_mut(&n).unwrap() = parent_hash.clone();
+					n -= 1;
+					parent_hash = Rlp::new(&self.blocks.read().unwrap()[&parent_hash]).val_at::<BlockHeader>(0).parent_hash;
+				}
+			}
+		}
+		else {
+			self.blocks.write().unwrap().insert(h.clone(), b.to_vec());
+		}
+		Ok(h)
+	}
+
+	fn queue_info(&self) -> BlockQueueInfo {
+		BlockQueueInfo {
+			verified_queue_size: 0,
+			unverified_queue_size: 0,
+			verifying_queue_size: 0,
+			max_queue_size: 0,
+			max_mem_use: 0,
+			mem_used: 0,
+		}
+	}
+
+	fn clear_queue(&self) {
+	}
+
+	fn chain_info(&self) -> BlockChainInfo {
+		BlockChainInfo {
+			total_difficulty: *self.difficulty.read().unwrap(),
+			pending_total_difficulty: *self.difficulty.read().unwrap(),
+			genesis_hash: self.genesis_hash.clone(),
+			best_block_hash: self.last_hash.read().unwrap().clone(),
+			best_block_number: self.blocks.read().unwrap().len() as BlockNumber - 1,
+		}
+	}
+}

ethcore/src/lib.rs

@@ -86,6 +86,7 @@ extern crate crossbeam;
 #[cfg(feature = "jit" )] extern crate evmjit;
 
 pub mod block;
+pub mod block_queue;
 pub mod client;
 pub mod error;
 pub mod ethereum;
@@ -119,7 +120,6 @@ mod substate;
 mod executive;
 mod externalities;
 mod verification;
-mod block_queue;
 mod blockchain;
 
 #[cfg(test)]

sync/src/tests/chain.rs

@@ -15,7 +15,7 @@
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
 use util::*;
-use ethcore::client::{BlockChainClient, BlockId};
+use ethcore::client::{BlockChainClient, BlockId, EachBlockWith};
 use io::SyncIo;
 use chain::{SyncState};
 use super::helpers::*;

sync/src/tests/helpers.rs

@@ -15,309 +15,10 @@
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
 use util::*;
-use ethcore::client::{BlockChainClient, BlockStatus, TreeRoute, BlockChainInfo, TransactionId, BlockId, BlockQueueInfo};
+use ethcore::client::{TestBlockChainClient, BlockChainClient};
-use ethcore::header::{Header as BlockHeader, BlockNumber};
-use ethcore::error::*;
 use io::SyncIo;
 use chain::ChainSync;
 use ::SyncConfig;
-use ethcore::receipt::Receipt;
-use ethcore::transaction::{LocalizedTransaction, Transaction, Action};
-use ethcore::filter::Filter;
-use ethcore::log_entry::LocalizedLogEntry;
-use ethcore::block::ClosedBlock;
-
-pub struct TestBlockChainClient {
-	pub blocks: RwLock<HashMap<H256, Bytes>>,
- 	pub numbers: RwLock<HashMap<usize, H256>>,
-	pub genesis_hash: H256,
-	pub last_hash: RwLock<H256>,
-	pub difficulty: RwLock<U256>,
-}
-
-#[derive(Clone)]
-pub enum EachBlockWith {
-	Nothing,
-	Uncle,
-	Transaction,
-	UncleAndTransaction
-}
-
-impl TestBlockChainClient {
-	pub fn new() -> TestBlockChainClient {
-
-		let mut client = TestBlockChainClient {
-			blocks: RwLock::new(HashMap::new()),
-			numbers: RwLock::new(HashMap::new()),
-			genesis_hash: H256::new(),
-			last_hash: RwLock::new(H256::new()),
-			difficulty: RwLock::new(From::from(0)),
-		};
-		client.add_blocks(1, EachBlockWith::Nothing); // add genesis block
-		client.genesis_hash = client.last_hash.read().unwrap().clone();
-		client
-	}
-
-	pub fn add_blocks(&mut self, count: usize, with: EachBlockWith) {
-		let len = self.numbers.read().unwrap().len();
-		for n in len..(len + count) {
-			let mut header = BlockHeader::new();
-			header.difficulty = From::from(n);
-			header.parent_hash = self.last_hash.read().unwrap().clone();
-			header.number = n as BlockNumber;
-			let uncles = match with {
-				EachBlockWith::Uncle | EachBlockWith::UncleAndTransaction => {
-					let mut uncles = RlpStream::new_list(1);
-					let mut uncle_header = BlockHeader::new();
-					uncle_header.difficulty = From::from(n);
-					uncle_header.parent_hash = self.last_hash.read().unwrap().clone();
-					uncle_header.number = n as BlockNumber;
-					uncles.append(&uncle_header);
-					header.uncles_hash = uncles.as_raw().sha3();
-					uncles
-				},
-				_ => RlpStream::new_list(0)
-			};
-			let txs = match with {
-				EachBlockWith::Transaction | EachBlockWith::UncleAndTransaction => {
-					let mut txs = RlpStream::new_list(1);
-					let keypair = KeyPair::create().unwrap();
-					let tx = Transaction {
-						action: Action::Create,
-						value: U256::from(100),
-						data: "3331600055".from_hex().unwrap(),
-						gas: U256::from(100_000),
-						gas_price: U256::one(),
-						nonce: U256::zero()
-					};
-					let signed_tx = tx.sign(&keypair.secret());
-					txs.append(&signed_tx);
-					txs.out()
-				},
-				_ => rlp::NULL_RLP.to_vec()
-			};
-
-			let mut rlp = RlpStream::new_list(3);
-			rlp.append(&header);
-			rlp.append_raw(&txs, 1);
-			rlp.append_raw(uncles.as_raw(), 1);
-			self.import_block(rlp.as_raw().to_vec()).unwrap();
-		}
-	}
-
-	pub fn corrupt_block(&mut self, n: BlockNumber) {
-		let hash = self.block_hash(BlockId::Number(n)).unwrap();
-		let mut header: BlockHeader = decode(&self.block_header(BlockId::Number(n)).unwrap());
-		header.parent_hash = H256::new();
-		let mut rlp = RlpStream::new_list(3);
-		rlp.append(&header);
-		rlp.append_raw(&rlp::NULL_RLP, 1);
-		rlp.append_raw(&rlp::NULL_RLP, 1);
-		self.blocks.write().unwrap().insert(hash, rlp.out());
-	}
-
-	pub fn block_hash_delta_minus(&mut self, delta: usize) -> H256 {
-		let blocks_read = self.numbers.read().unwrap();
-		let index = blocks_read.len() - delta;
-		blocks_read[&index].clone()
-	}
-
-	fn block_hash(&self, id: BlockId) -> Option<H256> {
-		match id {
-			BlockId::Hash(hash) => Some(hash),
-			BlockId::Number(n) => self.numbers.read().unwrap().get(&(n as usize)).cloned(),
-			BlockId::Earliest => self.numbers.read().unwrap().get(&0).cloned(),
-			BlockId::Latest => self.numbers.read().unwrap().get(&(self.numbers.read().unwrap().len() - 1)).cloned()
-		}
-	}
-}
-
-impl BlockChainClient for TestBlockChainClient {
-	fn block_total_difficulty(&self, _id: BlockId) -> Option<U256> {
-		Some(U256::zero())
-	}
-
-	fn block_hash(&self, _id: BlockId) -> Option<H256> {
-		unimplemented!();
-	}
-
-	fn nonce(&self, _address: &Address) -> U256 {
-		U256::zero()
-	}
-
-	fn code(&self, _address: &Address) -> Option<Bytes> {
-		unimplemented!();
-	}
-
-	fn transaction(&self, _id: TransactionId) -> Option<LocalizedTransaction> {
-		unimplemented!();
-	}
-
-	fn blocks_with_bloom(&self, _bloom: &H2048, _from_block: BlockId, _to_block: BlockId) -> Option<Vec<BlockNumber>> {
-		unimplemented!();
-	}
-
-	fn logs(&self, _filter: Filter) -> Vec<LocalizedLogEntry> {
-		unimplemented!();
-	}
-
-	fn sealing_block(&self) -> &Mutex<Option<ClosedBlock>> {
-		unimplemented!();
-	}
-
-	fn submit_seal(&self, _pow_hash: H256, _seal: Vec<Bytes>) -> Result<(), Error> {
-		unimplemented!();
-	}
-
-	fn block_header(&self, id: BlockId) -> Option<Bytes> {
-		self.block_hash(id).and_then(|hash| self.blocks.read().unwrap().get(&hash).map(|r| Rlp::new(r).at(0).as_raw().to_vec()))
-	}
-
-	fn block_body(&self, id: BlockId) -> Option<Bytes> {
-		self.block_hash(id).and_then(|hash| self.blocks.read().unwrap().get(&hash).map(|r| {
-			let mut stream = RlpStream::new_list(2);
-			stream.append_raw(Rlp::new(&r).at(1).as_raw(), 1);
-			stream.append_raw(Rlp::new(&r).at(2).as_raw(), 1);
-			stream.out()
-		}))
-	}
-
-	fn block(&self, id: BlockId) -> Option<Bytes> {
-		self.block_hash(id).and_then(|hash| self.blocks.read().unwrap().get(&hash).cloned())
-	}
-
-	fn block_status(&self, id: BlockId) -> BlockStatus {
-		match id {
-			BlockId::Number(number) if (number as usize) < self.blocks.read().unwrap().len() => BlockStatus::InChain,
-			BlockId::Hash(ref hash) if self.blocks.read().unwrap().get(hash).is_some() => BlockStatus::InChain,
-			_ => BlockStatus::Unknown
-		}
-	}
-
-	// works only if blocks are one after another 1 -> 2 -> 3
-	fn tree_route(&self, from: &H256, to: &H256) -> Option<TreeRoute> {
-		Some(TreeRoute {
-			ancestor: H256::new(),
-			index: 0,
-			blocks: {
-				let numbers_read = self.numbers.read().unwrap();
-				let mut adding = false;
-
-				let mut blocks = Vec::new();
-				for (_, hash) in numbers_read.iter().sort_by(|tuple1, tuple2| tuple1.0.cmp(tuple2.0)) {
-					if hash == to {
-						if adding {
-							blocks.push(hash.clone());
-						}
-						adding = false;
-						break;
-					}
-					if hash == from {
-						adding = true;
-					}
-					if adding {
-						blocks.push(hash.clone());
-					}
-				}
-				if adding { Vec::new() } else { blocks }
-			}
-		})
-	}
-
-	// TODO: returns just hashes instead of node state rlp(?)
-	fn state_data(&self, hash: &H256) -> Option<Bytes> {
-		// starts with 'f' ?
-		if *hash > H256::from("f000000000000000000000000000000000000000000000000000000000000000") {
-			let mut rlp = RlpStream::new();
-			rlp.append(&hash.clone());
-			return Some(rlp.out());
-		}
-		None
-	}
-
-	fn block_receipts(&self, hash: &H256) -> Option<Bytes> {
-		// starts with 'f' ?
-		if *hash > H256::from("f000000000000000000000000000000000000000000000000000000000000000") {
-			let receipt = Receipt::new(
-				H256::zero(),
-				U256::zero(),
-				vec![]);
-			let mut rlp = RlpStream::new();
-			rlp.append(&receipt);
-			return Some(rlp.out());
-		}
-		None
-	}
-
-	fn import_block(&self, b: Bytes) -> ImportResult {
-		let header = Rlp::new(&b).val_at::<BlockHeader>(0);
-		let h = header.hash();
-		let number: usize = header.number as usize;
-		if number > self.blocks.read().unwrap().len() {
-			panic!("Unexpected block number. Expected {}, got {}", self.blocks.read().unwrap().len(), number);
-		}
-		if number > 0 {
-			match self.blocks.read().unwrap().get(&header.parent_hash) {
-				Some(parent) => {
-					let parent = Rlp::new(parent).val_at::<BlockHeader>(0);
-					if parent.number != (header.number - 1) {
-						panic!("Unexpected block parent");
-					}
-				},
-				None => {
-					panic!("Unknown block parent {:?} for block {}", header.parent_hash, number);
-				}
-			}
-		}
-		let len = self.numbers.read().unwrap().len();
-		if number == len {
-			{
-				let mut difficulty = self.difficulty.write().unwrap();
-				*difficulty.deref_mut() = *difficulty.deref() + header.difficulty;
-			}
-			mem::replace(self.last_hash.write().unwrap().deref_mut(), h.clone());
-			self.blocks.write().unwrap().insert(h.clone(), b);
-			self.numbers.write().unwrap().insert(number, h.clone());
-			let mut parent_hash = header.parent_hash;
-			if number > 0 {
-				let mut n = number - 1;
-				while n > 0 && self.numbers.read().unwrap()[&n] != parent_hash {
-					*self.numbers.write().unwrap().get_mut(&n).unwrap() = parent_hash.clone();
-					n -= 1;
-					parent_hash = Rlp::new(&self.blocks.read().unwrap()[&parent_hash]).val_at::<BlockHeader>(0).parent_hash;
-				}
-			}
-		}
-		else {
-			self.blocks.write().unwrap().insert(h.clone(), b.to_vec());
-		}
-		Ok(h)
-	}
-
-	fn queue_info(&self) -> BlockQueueInfo {
-		BlockQueueInfo {
-			verified_queue_size: 0,
-			unverified_queue_size: 0,
-			verifying_queue_size: 0,
-			max_queue_size: 0,
-			max_mem_use: 0,
-			mem_used: 0,
-		}
-	}
-
-	fn clear_queue(&self) {
-	}
-
-	fn chain_info(&self) -> BlockChainInfo {
-		BlockChainInfo {
-			total_difficulty: *self.difficulty.read().unwrap(),
-			pending_total_difficulty: *self.difficulty.read().unwrap(),
-			genesis_hash: self.genesis_hash.clone(),
-			best_block_hash: self.last_hash.read().unwrap().clone(),
-			best_block_number: self.blocks.read().unwrap().len() as BlockNumber - 1,
-		}
-	}
-}
 
 pub struct TestIo<'p> {
 	pub chain: &'p mut TestBlockChainClient,