:Merge branch 'master' of github.com:ethcore/parity into ark

.gitmodules

@@ -1,3 +1,4 @@
 [submodule "res/ethereum/tests"]
 	path = res/ethereum/tests
 	url = git@github.com:ethereum/tests
+	branch = develop

bin/src/main.rs

@@ -53,19 +53,19 @@ fn setup_log(init: &str) {
 
 
 #[cfg(feature = "rpc")]
-fn setup_rpc_server(client: Arc<Client>) {
+fn setup_rpc_server(client: Arc<Client>, sync: Arc<EthSync>) {
 	use rpc::v1::*;
 	
 	let mut server = rpc::HttpServer::new(1);
 	server.add_delegate(Web3Client::new().to_delegate());
 	server.add_delegate(EthClient::new(client.clone()).to_delegate());
 	server.add_delegate(EthFilterClient::new(client).to_delegate());
-	server.add_delegate(NetClient::new().to_delegate());
+	server.add_delegate(NetClient::new(sync).to_delegate());
 	server.start_async("127.0.0.1:3030");
 }
 
 #[cfg(not(feature = "rpc"))]
-fn setup_rpc_server(_client: Arc<Client>) {
+fn setup_rpc_server(_client: Arc<Client>, _sync: Arc<EthSync>) {
 }
 
 fn main() {
@@ -81,7 +81,7 @@ fn main() {
 	let mut net_settings = NetworkConfiguration::new();
 	net_settings.boot_nodes = init_nodes;
 	let mut service = ClientService::start(spec, net_settings).unwrap();
-	setup_rpc_server(service.client());
+	setup_rpc_server(service.client(), service.sync());
 	let io_handler  = Arc::new(ClientIoHandler { client: service.client(), info: Default::default(), sync: service.sync() });
 	service.io().register_handler(io_handler).expect("Error registering IO handler");
 

res/ethereum/tests

@@ -1 +1 @@
-Subproject commit e838fd90998fc5502d0b7c9427a4c231f9a6953d
+Subproject commit c670b1d8c9f09593a6758ab2c099360e16c7c25b

rpc/src/lib.rs

@@ -13,10 +13,6 @@ extern crate ethcore;
 
 use self::jsonrpc_core::{IoHandler, IoDelegate};
 
-macro_rules! rpcerr {
-	() => (Err(Error::internal_error()))
-}
-
 pub mod v1;
 
 /// Http server.

rpc/src/v1/impls/net.rs

@@ -1,21 +1,29 @@
 //! Net rpc implementation.
+use std::sync::Arc;
 use jsonrpc_core::*;
+use ethcore::sync::EthSync;
 use v1::traits::Net;
 
 /// Net rpc implementation.
-pub struct NetClient;
+pub struct NetClient {
+	sync: Arc<EthSync>
+}
 
 impl NetClient {
 	/// Creates new NetClient.
-	pub fn new() -> Self { NetClient }
+	pub fn new(sync: Arc<EthSync>) -> Self { 
+		NetClient {
+			sync: sync
+		}
+	}
 }
 
 impl Net for NetClient {
 	fn version(&self, _: Params) -> Result<Value, Error> {
-		Ok(Value::U64(63))
+		Ok(Value::U64(self.sync.status().protocol_version as u64))
 	}
 
 	fn peer_count(&self, _params: Params) -> Result<Value, Error> {
-		Ok(Value::U64(0))
+		Ok(Value::U64(self.sync.status().num_peers as u64))
 	}
 }

rpc/src/v1/traits/eth.rs

@@ -5,41 +5,125 @@ use jsonrpc_core::*;
 /// Eth rpc interface.
 pub trait Eth: Sized + Send + Sync + 'static {
 	/// Returns protocol version.
-	fn protocol_version(&self, _: Params) -> Result<Value, Error> { rpcerr!() }
+	fn protocol_version(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
-
-	/// Returns block author.
-	fn author(&self, _: Params) -> Result<Value, Error> { rpcerr!() }
-
-	/// Returns current gas_price.
-	fn gas_price(&self, _: Params) -> Result<Value, Error> { rpcerr!() }
-
-	/// Returns highest block number.
-	fn block_number(&self, _: Params) -> Result<Value, Error> { rpcerr!() }
-
-	/// Returns block with given index / hash.
-	fn block(&self, _: Params) -> Result<Value, Error> { rpcerr!() }
-	
-	/// Returns true if client is actively mining new blocks.
-	fn is_mining(&self, _: Params) -> Result<Value, Error> { rpcerr!() }
 
 	/// Returns the number of hashes per second that the node is mining with.
-	fn hashrate(&self, _: Params) -> Result<Value, Error> { rpcerr!() }
+	fn hashrate(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+
+	/// Returns block author.
+	fn author(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+
+	/// Returns true if client is actively mining new blocks.
+	fn is_mining(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+
+	/// Returns current gas_price.
+	fn gas_price(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+
+	/// Returns accounts list.
+	fn accounts(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+
+	/// Returns highest block number.
+	fn block_number(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+
+	/// Returns balance of the given account.
+	fn balance(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+
+	/// Returns content of the storage at given address.
+	fn storage_at(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+
+	/// Returns block with given index / hash.
+	fn block(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+	
+	/// Returns the number of transactions sent from given address at given time (block number).
+	fn transaction_count(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
 
 	/// Returns the number of transactions in a block.
-	fn block_transaction_count(&self, _: Params) -> Result<Value, Error> { rpcerr!() }
+	fn block_transaction_count(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+
+	/// Returns the number of uncles in a given block.
+	fn block_uncles_count(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+
+	/// Returns the code at given address at given time (block number).
+	fn code_at(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+
+	/// Sends transaction.
+	fn send_transaction(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+
+	/// Call contract.
+	fn call(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+
+	/// Estimate gas needed for execution of given contract.
+	fn estimate_gas(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+
+	/// Returns transaction at given block and index.
+	fn transaction_at(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+
+	/// Returns transaction receipt.
+	fn transaction_receipt(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+
+	/// Returns an uncles at given block and index.
+	fn uncle_at(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+
+	/// Returns available compilers.
+	fn compilers(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+
+	/// Compiles lll code.
+	fn compile_lll(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+
+	/// Compiles solidity.
+	fn compile_solidity(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+
+	/// Compiles serpent.
+	fn compile_serpent(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+
+	/// Returns logs matching given filter object.
+	fn logs(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+
+	/// Returns the hash of the current block, the seedHash, and the boundary condition to be met.
+	fn work(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+
+	/// Used for submitting a proof-of-work solution.
+	fn submit_work(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+
+	/// Used for submitting mining hashrate.
+	fn submit_hashrate(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
 
 	/// Should be used to convert object to io delegate.
 	fn to_delegate(self) -> IoDelegate<Self> {
 		let mut delegate = IoDelegate::new(Arc::new(self));
 		delegate.add_method("eth_protocolVersion", Eth::protocol_version);
+		delegate.add_method("eth_hashrate", Eth::hashrate);
 		delegate.add_method("eth_coinbase", Eth::author);
+		delegate.add_method("eth_mining", Eth::is_mining);
 		delegate.add_method("eth_gasPrice", Eth::gas_price);
+		delegate.add_method("eth_accounts", Eth::accounts);
 		delegate.add_method("eth_blockNumber", Eth::block_number);
+		delegate.add_method("eth_balance", Eth::balance);
+		delegate.add_method("eth_getStorageAt", Eth::storage_at);
+		delegate.add_method("eth_getTransactionCount", Eth::transaction_count);
+		delegate.add_method("eth_getBlockTransactionCountByHash", Eth::block_transaction_count);
+		delegate.add_method("eth_getBlockTransactionCountByNumber", Eth::block_transaction_count);
+		delegate.add_method("eth_getUncleCountByBlockHash", Eth::block_uncles_count);
+		delegate.add_method("eth_getUncleCountByBlockNumber", Eth::block_uncles_count);
+		delegate.add_method("eth_code", Eth::code_at);
+		delegate.add_method("eth_sendTransaction", Eth::send_transaction);
+		delegate.add_method("eth_call", Eth::call);
+		delegate.add_method("eth_estimateGas", Eth::estimate_gas);
 		delegate.add_method("eth_getBlockByHash", Eth::block);
 		delegate.add_method("eth_getBlockByNumber", Eth::block);
-		delegate.add_method("eth_mining", Eth::is_mining);
+		delegate.add_method("eth_getTransactionByBlockHashAndIndex", Eth::transaction_at);
-		delegate.add_method("eth_hashrate", Eth::hashrate);
+		delegate.add_method("eth_getTransactionByBlockNumberAndIndex", Eth::transaction_at);
-		delegate.add_method("eth_getBlockTransactionCountByNumber", Eth::block_transaction_count);
+		delegate.add_method("eth_getTransactionReceipt", Eth::transaction_receipt);
+		delegate.add_method("eth_getUncleByBlockHashAndIndex", Eth::uncle_at);
+		delegate.add_method("eth_getUncleByBlockNumberAndIndex", Eth::uncle_at);
+		delegate.add_method("eth_getCompilers", Eth::compilers);
+		delegate.add_method("eth_compileLLL", Eth::compile_lll);
+		delegate.add_method("eth_compileSolidity", Eth::compile_solidity);
+		delegate.add_method("eth_compileSerpent", Eth::compile_serpent);
+		delegate.add_method("eth_getLogs", Eth::logs);
+		delegate.add_method("eth_getWork", Eth::work);
+		delegate.add_method("eth_submitWork", Eth::submit_work);
+		delegate.add_method("eth_submitHashrate", Eth::submit_hashrate);
 		delegate
 	}
 }
@@ -47,21 +131,33 @@ pub trait Eth: Sized + Send + Sync + 'static {
 /// Eth filters rpc api (polling).
 // TODO: do filters api properly
 pub trait EthFilter: Sized + Send + Sync + 'static {
-	/// Returns id of new block filter
+	/// Returns id of new filter.
-	fn new_block_filter(&self, _: Params) -> Result<Value, Error> { rpcerr!() }
+	fn new_filter(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
 
-	/// Returns id of new block filter
+	/// Returns id of new block filter.
-	fn new_pending_transaction_filter(&self, _: Params) -> Result<Value, Error> { rpcerr!() }
+	fn new_block_filter(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
 
-	/// Returns filter changes since last poll
+	/// Returns id of new block filter.
-	fn filter_changes(&self, _: Params) -> Result<Value, Error> { rpcerr!() }
+	fn new_pending_transaction_filter(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+
+	/// Returns filter changes since last poll.
+	fn filter_changes(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+
+	/// Returns filter logs.
+	fn filter_logs(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+
+	/// Uninstalls filter.
+	fn uninstall_filter(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
 
 	/// Should be used to convert object to io delegate.
 	fn to_delegate(self) -> IoDelegate<Self> {
 		let mut delegate = IoDelegate::new(Arc::new(self));
+		delegate.add_method("eth_newFilter", EthFilter::new_filter);
 		delegate.add_method("eth_newBlockFilter", EthFilter::new_block_filter);
 		delegate.add_method("eth_newPendingTransactionFilter", EthFilter::new_pending_transaction_filter);
 		delegate.add_method("eth_getFilterChanges", EthFilter::filter_changes);
+		delegate.add_method("eth_getFilterLogs", EthFilter::filter_logs);
+		delegate.add_method("eth_uninstallFilter", EthFilter::uninstall_filter);
 		delegate
 	}
 }

rpc/src/v1/traits/mod.rs

@@ -1,4 +1,9 @@
 //! Ethereum rpc interfaces.
+
+macro_rules! rpc_unimplemented {
+	() => (Err(Error::internal_error()))
+}
+
 pub mod web3;
 pub mod eth;
 pub mod net;

rpc/src/v1/traits/net.rs

@@ -5,16 +5,21 @@ use jsonrpc_core::*;
 /// Net rpc interface.
 pub trait Net: Sized + Send + Sync + 'static {
 	/// Returns protocol version.
-	fn version(&self, _: Params) -> Result<Value, Error> { rpcerr!() }
+	fn version(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
 
 	/// Returns number of peers connected to node.
-	fn peer_count(&self, _: Params) -> Result<Value, Error> { rpcerr!() }
+	fn peer_count(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
+
+	/// Returns true if client is actively listening for network connections.
+	/// Otherwise false.
+	fn is_listening(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
 
 	/// Should be used to convert object to io delegate.
 	fn to_delegate(self) -> IoDelegate<Self> {
 		let mut delegate = IoDelegate::new(Arc::new(self));
 		delegate.add_method("net_version", Net::version);
 		delegate.add_method("net_peerCount", Net::peer_count);
+		delegate.add_method("net_listening", Net::is_listening);
 		delegate
 	}
 }

rpc/src/v1/traits/web3.rs

@@ -5,7 +5,7 @@ use jsonrpc_core::*;
 /// Web3 rpc interface.
 pub trait Web3: Sized + Send + Sync + 'static {
 	/// Returns current client version.
-	fn client_version(&self, _: Params) -> Result<Value, Error> { rpcerr!() }
+	fn client_version(&self, _: Params) -> Result<Value, Error> { rpc_unimplemented!() }
 
 	/// Should be used to convert object to io delegate.
 	fn to_delegate(self) -> IoDelegate<Self> {

src/blockchain.rs

@@ -618,20 +618,18 @@ impl BlockChain {
 
 #[cfg(test)]
 mod tests {
-	use std::env;
 	use std::str::FromStr;
 	use rustc_serialize::hex::FromHex;
 	use util::hash::*;
 	use blockchain::*;
+	use tests::helpers::*;
 
 	#[test]
 	fn valid_tests_extra32() {
 		let genesis = "f901fcf901f7a00000000000000000000000000000000000000000000000000000000000000000a01dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347948888f1f195afa192cfee860698584c030f4c9db1a0925002c3260b44e44c3edebad1cc442142b03020209df1ab8bb86752edbd2cd7a056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421a056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421b90100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008302000080832fefd8808454c98c8142a0363659b251bf8b819179874c8cce7b9b983d7f3704cbb58a3b334431f7032871889032d09c281e1236c0c0".from_hex().unwrap();
 
-		let mut dir = env::temp_dir();
+		let temp = RandomTempPath::new();
-		dir.push(H32::random().hex());
+		let bc = BlockChain::new(&genesis, temp.as_path());
-
-		let bc = BlockChain::new(&genesis, &dir);
 
 		let genesis_hash = H256::from_str("3caa2203f3d7c136c0295ed128a7d31cea520b1ca5e27afe17d0853331798942").unwrap();
 
@@ -674,10 +672,8 @@ mod tests {
 		// b3a is a part of canon chain, whereas b3b is part of sidechain
 		let best_block_hash = H256::from_str("c208f88c9f5bf7e00840439742c12e5226d9752981f3ec0521bdcb6dd08af277").unwrap();
 
-		let mut dir = env::temp_dir();
+		let temp = RandomTempPath::new();
-		dir.push(H32::random().hex());
+		let bc = BlockChain::new(&genesis, temp.as_path());
-
-		let bc = BlockChain::new(&genesis, &dir);
 		bc.insert_block(&b1);
 		bc.insert_block(&b2);
 		bc.insert_block(&b3a);
@@ -754,18 +750,16 @@ mod tests {
 		let genesis_hash = H256::from_str("5716670833ec874362d65fea27a7cd35af5897d275b31a44944113111e4e96d2").unwrap();
 		let b1_hash = H256::from_str("437e51676ff10756fcfee5edd9159fa41dbcb1b2c592850450371cbecd54ee4f").unwrap();
 
-		let mut dir = env::temp_dir();
+		let temp = RandomTempPath::new();
-		dir.push(H32::random().hex());
-
 		{
-			let bc = BlockChain::new(&genesis, &dir);
+			let bc = BlockChain::new(&genesis, temp.as_path());
 			assert_eq!(bc.best_block_hash(), genesis_hash);
 			bc.insert_block(&b1);
 			assert_eq!(bc.best_block_hash(), b1_hash);
 		}
 
 		{
-			let bc = BlockChain::new(&genesis, &dir);
+			let bc = BlockChain::new(&genesis, temp.as_path());
 			assert_eq!(bc.best_block_hash(), b1_hash);
 		}
 	}

src/externalities.rs

@@ -215,7 +215,13 @@ impl<'a> Ext for Externalities<'a> {
 	fn suicide(&mut self, refund_address: &Address) {
 		let address = self.origin_info.address.clone();
 		let balance = self.balance(&address);
+		if &address == refund_address {
+			// TODO [todr] To be consisted with CPP client we set balance to 0 in that case.
+			self.state.sub_balance(&address, &balance);
+		} else {
+			trace!("Suiciding {} -> {} (xfer: {})", address, refund_address, balance);
 			self.state.transfer_balance(&address, refund_address, &balance);
+		}
 		self.substate.suicides.insert(address);
 	}
 

src/tests/chain.rs

@@ -1,11 +1,16 @@
-use std::env;
 use super::test_common::*;
 use client::{BlockChainClient,Client};
 use pod_state::*;
 use block::Block;
 use ethereum;
+use super::helpers::*;
 
-fn do_json_test(json_data: &[u8]) -> Vec<String> {
+pub enum ChainEra {
+	Frontier,
+	Homestead,
+}
+
+pub fn json_chain_test(json_data: &[u8], era: ChainEra) -> Vec<String> {
 	let json = Json::from_str(::std::str::from_utf8(json_data).unwrap()).expect("Json is invalid");
 	let mut failed = Vec::new();
 
@@ -22,16 +27,18 @@ fn do_json_test(json_data: &[u8]) -> Vec<String> {
 			flush(format!("   - {}...", name));
 
 			let blocks: Vec<(Bytes, bool)> = test["blocks"].as_array().unwrap().iter().map(|e| (xjson!(&e["rlp"]), e.find("blockHeader").is_some())).collect();
-			let mut spec = ethereum::new_frontier_like_test();
+			let mut spec = match era {
+				ChainEra::Frontier => ethereum::new_frontier_test(),
+				ChainEra::Homestead => ethereum::new_homestead_test(),
+			};
 			let s = PodState::from_json(test.find("pre").unwrap());
 			spec.set_genesis_state(s);
 			spec.overwrite_genesis(test.find("genesisBlockHeader").unwrap());
 			assert!(spec.is_state_root_valid());
 
-			let mut dir = env::temp_dir();
+			let temp = RandomTempPath::new();
-			dir.push(H32::random().hex());
 			{
-				let client = Client::new(spec, &dir, IoChannel::disconnected()).unwrap();
+				let client = Client::new(spec, temp.as_path(), IoChannel::disconnected()).unwrap();
 				for (b, is_valid) in blocks.into_iter() {
 					if Block::is_good(&b) {
 						let _ = client.import_block(b.clone());
@@ -42,7 +49,6 @@ fn do_json_test(json_data: &[u8]) -> Vec<String> {
 				}
 				fail_unless(client.chain_info().best_block_hash == H256::from_json(&test["lastblockhash"]));
 			}
-			fs::remove_dir_all(&dir).unwrap();
 		}
 		if !fail {
 			flush(format!("ok\n"));
@@ -52,6 +58,10 @@ fn do_json_test(json_data: &[u8]) -> Vec<String> {
 	failed
 }
 
+fn do_json_test(json_data: &[u8]) -> Vec<String> {
+	json_chain_test(json_data, ChainEra::Frontier)
+}
+
 declare_test!{BlockchainTests_bcBlockGasLimitTest, "BlockchainTests/bcBlockGasLimitTest"}
 declare_test!{BlockchainTests_bcForkBlockTest, "BlockchainTests/bcForkBlockTest"}
 declare_test!{BlockchainTests_bcForkStressTest, "BlockchainTests/bcForkStressTest"}
@@ -67,3 +77,6 @@ declare_test!{BlockchainTests_bcUncleHeaderValiditiy, "BlockchainTests/bcUncleHe
 declare_test!{BlockchainTests_bcUncleTest, "BlockchainTests/bcUncleTest"}
 declare_test!{BlockchainTests_bcValidBlockTest, "BlockchainTests/bcValidBlockTest"}
 declare_test!{BlockchainTests_bcWalletTest, "BlockchainTests/bcWalletTest"}
+
+declare_test!{BlockchainTests_RandomTests_bl10251623GO, "BlockchainTests/RandomTests/bl10251623GO"}
+declare_test!{BlockchainTests_RandomTests_bl201507071825GO, "BlockchainTests/RandomTests/bl201507071825GO"}

src/tests/homestead_chain.rs

@@ -0,0 +1,20 @@
+use super::test_common::*;
+use super::chain::{ChainEra, json_chain_test};
+
+fn do_json_test(json_data: &[u8]) -> Vec<String> {
+	json_chain_test(json_data, ChainEra::Homestead)
+}
+
+declare_test!{BlockchainTests_Homestead_bcBlockGasLimitTest, "BlockchainTests/Homestead/bcBlockGasLimitTest"}
+declare_test!{BlockchainTests_Homestead_bcForkStressTest, "BlockchainTests/Homestead/bcForkStressTest"}
+declare_test!{BlockchainTests_Homestead_bcGasPricerTest, "BlockchainTests/Homestead/bcGasPricerTest"}
+declare_test!{BlockchainTests_Homestead_bcInvalidHeaderTest, "BlockchainTests/Homestead/bcInvalidHeaderTest"}
+declare_test!{BlockchainTests_Homestead_bcInvalidRLPTest, "BlockchainTests/Homestead/bcInvalidRLPTest"}
+declare_test!{BlockchainTests_Homestead_bcMultiChainTest, "BlockchainTests/Homestead/bcMultiChainTest"}
+declare_test!{BlockchainTests_Homestead_bcRPC_API_Test, "BlockchainTests/Homestead/bcRPC_API_Test"}
+declare_test!{BlockchainTests_Homestead_bcStateTest, "BlockchainTests/Homestead/bcStateTest"}
+declare_test!{BlockchainTests_Homestead_bcTotalDifficultyTest, "BlockchainTests/Homestead/bcTotalDifficultyTest"}
+declare_test!{BlockchainTests_Homestead_bcUncleHeaderValiditiy, "BlockchainTests/Homestead/bcUncleHeaderValiditiy"}
+declare_test!{BlockchainTests_Homestead_bcUncleTest, "BlockchainTests/Homestead/bcUncleTest"}
+declare_test!{BlockchainTests_Homestead_bcValidBlockTest, "BlockchainTests/Homestead/bcValidBlockTest"}
+declare_test!{BlockchainTests_Homestead_bcWalletTest, "BlockchainTests/Homestead/bcWalletTest"}

src/tests/mod.rs

@@ -6,4 +6,5 @@ mod executive;
 mod state;
 mod client;
 mod chain;
-mod helpers;
+pub mod helpers;
+mod homestead_chain;