Merge branch 'master' into les-impl

ethcore/Cargo.toml

@@ -3,7 +3,7 @@ description = "Ethcore library"
 homepage = "http://ethcore.io"
 license = "GPL-3.0"
 name = "ethcore"
-version = "1.4.0"
+version = "1.5.0"
 authors = ["Ethcore <admin@ethcore.io>"]
 build = "build.rs"
 

ethcore/res/ethereum/classic.json

@@ -11,7 +11,13 @@
 				"blockReward": "0x4563918244F40000",
 				"registrar" : "0xc6d9d2cd449a754c494264e1809c50e34d64562b",
 				"homesteadTransition": "0x118c30",
-				"eip150Transition": "0x2625a0"
+				"eip150Transition": "0x2625a0",
+				"eip155Transition": "0x7fffffffffffffff",
+				"eip160Transition": "0x7fffffffffffffff",
+				"eip161abcTransition": "0x7fffffffffffffff",
+				"eip161dTransition": "0x7fffffffffffffff",
+				"ecip1010PauseTransition": "0x2dc6c0",
+				"ecip1010ContinueTransition": "0x4c4b40"
 			}
 		}
 	},

ethcore/res/ethereum/eip150_test.json

@@ -10,7 +10,11 @@
 				"blockReward": "0x4563918244F40000",
 				"registrar" : "0xc6d9d2cd449a754c494264e1809c50e34d64562b",
 				"homesteadTransition": "0x0",
-				"eip150Transition": "0x0"
+				"eip150Transition": "0x0",
+				"eip155Transition": "0x7fffffffffffffff",
+				"eip160Transition": "0x7fffffffffffffff",
+				"eip161abcTransition": "0x7fffffffffffffff",
+				"eip161dTransition": "0x7fffffffffffffff"
 			}
 		}
 	},

ethcore/res/ethereum/eip161_test.json

@@ -0,0 +1,47 @@
+{
+	"name": "Homestead (Test)",
+	"engine": {
+		"Ethash": {
+			"params": {
+				"gasLimitBoundDivisor": "0x0400",
+				"minimumDifficulty": "0x020000",
+				"difficultyBoundDivisor": "0x0800",
+				"durationLimit": "0x0d",
+				"blockReward": "0x4563918244F40000",
+				"registrar" : "0xc6d9d2cd449a754c494264e1809c50e34d64562b",
+				"homesteadTransition": "0x0",
+				"eip150Transition": "0x0",
+				"eip155Transition": "0x7fffffffffffffff",
+				"eip160Transition": "0x0",
+				"eip161abcTransition": "0x0",
+				"eip161dTransition": "0x0"
+			}
+		}
+	},
+	"params": {
+		"accountStartNonce": "0x00",
+		"maximumExtraDataSize": "0x20",
+		"minGasLimit": "0x1388",
+		"networkID" : "0x1"
+	},
+	"genesis": {
+		"seal": {
+			"ethereum": {
+				"nonce": "0x0000000000000042",
+				"mixHash": "0x0000000000000000000000000000000000000000000000000000000000000000"
+			}
+		},
+		"difficulty": "0x400000000",
+		"author": "0x0000000000000000000000000000000000000000",
+		"timestamp": "0x00",
+		"parentHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
+		"extraData": "0x11bbe8db4e347b4e8c937c1c8370e4b5ed33adb3db69cbdb7a38e1e50b1b82fa",
+		"gasLimit": "0x1388"
+	},
+	"accounts": {
+		"0000000000000000000000000000000000000001": { "balance": "1", "builtin": { "name": "ecrecover", "pricing": { "linear": { "base": 3000, "word": 0 } } } },
+		"0000000000000000000000000000000000000002": { "balance": "1", "builtin": { "name": "sha256", "pricing": { "linear": { "base": 60, "word": 12 } } } },
+		"0000000000000000000000000000000000000003": { "balance": "1", "builtin": { "name": "ripemd160", "pricing": { "linear": { "base": 600, "word": 120 } } } },
+		"0000000000000000000000000000000000000004": { "balance": "1", "builtin": { "name": "identity", "pricing": { "linear": { "base": 15, "word": 3 } } } }
+	}
+}

ethcore/res/ethereum/expanse.json

@@ -15,7 +15,11 @@
 				"difficultyHardforkTransition": "0x59d9",
 				"difficultyHardforkBoundDivisor": "0x0200",
 				"bombDefuseTransition": "0x30d40",
-				"eip150Transition": "0x7fffffffffffffff"				
+				"eip150Transition": "0x7fffffffffffffff",
+				"eip155Transition": "0x7fffffffffffffff",
+				"eip160Transition": "0x7fffffffffffffff",
+				"eip161abcTransition": "0x7fffffffffffffff",
+				"eip161dTransition": "0x7fffffffffffffff"
 			}
 		}
 	},

ethcore/res/ethereum/frontier.json

@@ -130,7 +130,11 @@
 					"0xbb9bc244d798123fde783fcc1c72d3bb8c189413",
 					"0x807640a13483f8ac783c557fcdf27be11ea4ac7a"
 				],
-				"eip150Transition": "0x259518"
+				"eip150Transition": "0x259518",
+				"eip155Transition": 2642462,
+				"eip160Transition": 2642462,
+				"eip161abcTransition": 2642462,
+				"eip161dTransition": 2642462
 			}
 		}
 	},

ethcore/res/ethereum/frontier_like_test.json

@@ -130,7 +130,11 @@
 					"0xbb9bc244d798123fde783fcc1c72d3bb8c189413",
 					"0x807640a13483f8ac783c557fcdf27be11ea4ac7a"
 				],
-				"eip150Transition": "0x7fffffffffffffff"
+				"eip150Transition": "0x7fffffffffffffff",
+				"eip155Transition": "0x7fffffffffffffff",
+				"eip160Transition": "0x7fffffffffffffff",
+				"eip161abcTransition": "0x7fffffffffffffff",
+				"eip161dTransition": "0x7fffffffffffffff"
 			}
 		}
 	},

ethcore/res/ethereum/frontier_test.json

@@ -10,7 +10,11 @@
 				"blockReward": "0x4563918244F40000",
 				"registrar" : "0xc6d9d2cd449a754c494264e1809c50e34d64562b",
 				"homesteadTransition": "0x7fffffffffffffff",
-				"eip150Transition": "0x7fffffffffffffff"
+				"eip150Transition": "0x7fffffffffffffff",
+				"eip155Transition": "0x7fffffffffffffff",
+				"eip160Transition": "0x7fffffffffffffff",
+				"eip161abcTransition": "0x7fffffffffffffff",
+				"eip161dTransition": "0x7fffffffffffffff"
 			}
 		}
 	},

ethcore/res/ethereum/homestead_test.json

@@ -10,7 +10,11 @@
 				"blockReward": "0x4563918244F40000",
 				"registrar" : "0xc6d9d2cd449a754c494264e1809c50e34d64562b",
 				"homesteadTransition": "0x0",
-				"eip150Transition": "0x7fffffffffffffff"
+				"eip150Transition": "0x7fffffffffffffff",
+				"eip155Transition": "0x7fffffffffffffff",
+				"eip160Transition": "0x7fffffffffffffff",
+				"eip161abcTransition": "0x7fffffffffffffff",
+				"eip161dTransition": "0x7fffffffffffffff"
 			}
 		}
 	},

ethcore/res/ethereum/morden.json

@@ -10,7 +10,11 @@
 				"blockReward": "0x4563918244F40000",
 				"registrar": "0x52dff57a8a1532e6afb3dc07e2af58bb9eb05b3d",
 				"homesteadTransition": "0x789b0",
-				"eip150Transition": "0x1b34d8"
+				"eip150Transition": "0x1b34d8",
+				"eip155Transition": "0x7fffffffffffffff",
+				"eip160Transition": "0x7fffffffffffffff",
+				"eip161abcTransition": "0x7fffffffffffffff",
+				"eip161dTransition": "0x7fffffffffffffff"
 			}
 		}
 	},

ethcore/res/ethereum/olympic.json

@@ -10,7 +10,11 @@
 				"blockReward": "0x14D1120D7B160000",
 				"registrar": "5e70c0bbcd5636e0f9f9316e9f8633feb64d4050",
 				"homesteadTransition": "0x7fffffffffffffff",
-				"eip150Transition": "0x7fffffffffffffff"
+				"eip150Transition": "0x7fffffffffffffff",
+				"eip155Transition": "0x7fffffffffffffff",
+				"eip160Transition": "0x7fffffffffffffff",
+				"eip161abcTransition": "0x7fffffffffffffff",
+				"eip161dTransition": "0x7fffffffffffffff"
 			}
 		}
 	},

ethcore/res/ethereum/transition_test.json

@@ -130,7 +130,11 @@
 					"0xbb9bc244d798123fde783fcc1c72d3bb8c189413",
 					"0x807640a13483f8ac783c557fcdf27be11ea4ac7a"
 				],
-				"eip150Transition": "0xa"
+				"eip150Transition": "0xa",
+				"eip155Transition": "0x7fffffffffffffff",
+				"eip160Transition": "0x7fffffffffffffff",
+				"eip161abcTransition": "0x7fffffffffffffff",
+				"eip161dTransition": "0x7fffffffffffffff"
 			}
 		}
 	},

ethcore/src/blockchain/blockchain.rs

@@ -1468,7 +1468,7 @@ mod tests {
 			action: Action::Create,
 			value: 100.into(),
 			data: "601080600c6000396000f3006000355415600957005b60203560003555".from_hex().unwrap(),
-		}.sign(&"".sha3());
+		}.sign(&"".sha3(), None);
 
 
 		let b1a = canon_chain
@@ -1532,7 +1532,7 @@ mod tests {
 			action: Action::Create,
 			value: 100.into(),
 			data: "601080600c6000396000f3006000355415600957005b60203560003555".from_hex().unwrap(),
-		}.sign(&"".sha3());
+		}.sign(&"".sha3(), None);
 
 		let t2 = Transaction {
 			nonce: 1.into(),
@@ -1541,7 +1541,7 @@ mod tests {
 			action: Action::Create,
 			value: 100.into(),
 			data: "601080600c6000396000f3006000355415600957005b60203560003555".from_hex().unwrap(),
-		}.sign(&"".sha3());
+		}.sign(&"".sha3(), None);
 
 		let t3 = Transaction {
 			nonce: 2.into(),
@@ -1550,7 +1550,7 @@ mod tests {
 			action: Action::Create,
 			value: 100.into(),
 			data: "601080600c6000396000f3006000355415600957005b60203560003555".from_hex().unwrap(),
-		}.sign(&"".sha3());
+		}.sign(&"".sha3(), None);
 
 		let b1a = canon_chain
 			.with_transaction(t1.clone())
@@ -1856,7 +1856,7 @@ mod tests {
 			action: Action::Create,
 			value: 101.into(),
 			data: "601080600c6000396000f3006000355415600957005b60203560003555".from_hex().unwrap(),
-		}.sign(&"".sha3());
+		}.sign(&"".sha3(), None);
 		let t2 = Transaction {
 			nonce: 0.into(),
 			gas_price: 0.into(),
@@ -1864,7 +1864,7 @@ mod tests {
 			action: Action::Create,
 			value: 102.into(),
 			data: "601080600c6000396000f3006000355415600957005b60203560003555".from_hex().unwrap(),
-		}.sign(&"".sha3());
+		}.sign(&"".sha3(), None);
 		let t3 = Transaction {
 			nonce: 0.into(),
 			gas_price: 0.into(),
@@ -1872,7 +1872,7 @@ mod tests {
 			action: Action::Create,
 			value: 103.into(),
 			data: "601080600c6000396000f3006000355415600957005b60203560003555".from_hex().unwrap(),
-		}.sign(&"".sha3());
+		}.sign(&"".sha3(), None);
 		let tx_hash1 = t1.hash();
 		let tx_hash2 = t2.hash();
 		let tx_hash3 = t3.hash();

ethcore/src/client/client.rs

@@ -33,7 +33,7 @@ use io::*;
 use views::{HeaderView, BodyView, BlockView};
 use error::{ImportError, ExecutionError, CallError, BlockError, ImportResult, Error as EthcoreError};
 use header::BlockNumber;
-use state::State;
+use state::{State, CleanupMode};
 use spec::Spec;
 use basic_types::Seal;
 use engines::Engine;
@@ -65,7 +65,7 @@ use evm::{Factory as EvmFactory, Schedule};
 use miner::{Miner, MinerService};
 use snapshot::{self, io as snapshot_io};
 use factory::Factories;
-use rlp::{View, UntrustedRlp};
+use rlp::{decode, View, UntrustedRlp};
 use state_db::StateDB;
 use rand::OsRng;
 
@@ -147,6 +147,7 @@ pub struct Client {
 	factories: Factories,
 	history: u64,
 	rng: Mutex<OsRng>,
+	on_mode_change: Mutex<Option<Box<FnMut(&Mode) + 'static + Send>>>,
 }
 
 impl Client {
@@ -211,7 +212,7 @@ impl Client {
 		let panic_handler = PanicHandler::new_in_arc();
 		panic_handler.forward_from(&block_queue);
 
-		let awake = match config.mode { Mode::Dark(..) => false, _ => true };
+		let awake = match config.mode { Mode::Dark(..) | Mode::Off => false, _ => true };
 
 		let factories = Factories {
 			vm: EvmFactory::new(config.vm_type.clone(), config.jump_table_size),
@@ -243,6 +244,7 @@ impl Client {
 			factories: factories,
 			history: history,
 			rng: Mutex::new(try!(OsRng::new().map_err(::util::UtilError::StdIo))),
+			on_mode_change: Mutex::new(None),
 		};
 		Ok(Arc::new(client))
 	}
@@ -260,6 +262,11 @@ impl Client {
 		}
 	}
 
+	/// Register an action to be done if a mode change happens. 
+	pub fn on_mode_change<F>(&self, f: F) where F: 'static + FnMut(&Mode) + Send {
+		*self.on_mode_change.lock() = Some(Box::new(f));
+	}
+
 	/// Flush the block import queue.
 	pub fn flush_queue(&self) {
 		self.block_queue.flush();
@@ -268,6 +275,22 @@ impl Client {
 		}
 	}
 
+	/// The env info as of the best block.
+	fn latest_env_info(&self) -> EnvInfo {
+		let header_data = self.best_block_header();
+		let view = HeaderView::new(&header_data);
+
+		EnvInfo {
+			number: view.number(),
+			author: view.author(),
+			timestamp: view.timestamp(),
+			difficulty: view.difficulty(),
+			last_hashes: self.build_last_hashes(view.hash()),
+			gas_used: U256::default(),
+			gas_limit: view.gas_limit(),
+		}
+	}
+
 	fn build_last_hashes(&self, parent_hash: H256) -> Arc<LastHashes> {
 		{
 			let hashes = self.last_hashes.read();
@@ -790,7 +813,7 @@ impl BlockChainClient for Client {
 		let needed_balance = t.value + t.gas * t.gas_price;
 		if balance < needed_balance {
 			// give the sender a sufficient balance
-			state.add_balance(&sender, &(needed_balance - balance));
+			state.add_balance(&sender, &(needed_balance - balance), CleanupMode::NoEmpty);
 		}
 		let options = TransactOptions { tracing: analytics.transaction_tracing, vm_tracing: analytics.vm_tracing, check_nonce: false };
 		let mut ret = try!(Executive::new(&mut state, &env_info, &*self.engine, &self.factories.vm).transact(t, options));
@@ -840,18 +863,37 @@ impl BlockChainClient for Client {
 	}
 
 	fn keep_alive(&self) {
-		let mode = self.mode.lock().clone();
-		if mode != Mode::Active {
+		let should_wake = match &*self.mode.lock() {
+			&Mode::Dark(..) | &Mode::Passive(..) => true,
+			_ => false,
+		};
+		if should_wake {
 			self.wake_up();
 			(*self.sleep_state.lock()).last_activity = Some(Instant::now());
 		}
 	}
 
-	fn mode(&self) -> IpcMode { self.mode.lock().clone().into() }
+	fn mode(&self) -> IpcMode {
+		let r = self.mode.lock().clone().into();
+		trace!(target: "mode", "Asked for mode = {:?}. returning {:?}", &*self.mode.lock(), r);
+		r
+	}
 
-	fn set_mode(&self, mode: IpcMode) {
-		*self.mode.lock() = mode.clone().into();
-		match mode {
+	fn set_mode(&self, new_mode: IpcMode) {
+		trace!(target: "mode", "Client::set_mode({:?})", new_mode);
+		{
+			let mut mode = self.mode.lock();
+			*mode = new_mode.clone().into();
+			trace!(target: "mode", "Mode now {:?}", &*mode);
+			match *self.on_mode_change.lock() {
+				Some(ref mut f) => {
+					trace!(target: "mode", "Making callback...");
+					f(&*mode)
+				},
+				_ => {} 
+			}
+		}
+		match new_mode {
 			IpcMode::Active => self.wake_up(),
 			IpcMode::Off => self.sleep(),
 			_ => {(*self.sleep_state.lock()).last_activity = Some(Instant::now()); }
@@ -1008,7 +1050,9 @@ impl BlockChainClient for Client {
 							transaction_hash: transaction_hash.clone(),
 							transaction_index: transaction_index,
 							log_index: i
-						}).collect()
+						}).collect(),
+						log_bloom: receipt.log_bloom,
+						state_root: receipt.state_root,
 					})
 				},
 				_ => None
@@ -1167,24 +1211,28 @@ impl BlockChainClient for Client {
 	fn pending_transactions(&self) -> Vec<SignedTransaction> {
 		self.miner.pending_transactions(self.chain.read().best_block_number())
 	}
+
+	fn signing_network_id(&self) -> Option<u8> {
+		self.engine.signing_network_id(&self.latest_env_info())
+	}
+
+	fn block_extra_info(&self, id: BlockID) -> Option<BTreeMap<String, String>> {
+		self.block_header(id)
+			.map(|block| decode(&block))
+			.map(|header| self.engine.extra_info(&header))
+	}
+
+	fn uncle_extra_info(&self, id: UncleID) -> Option<BTreeMap<String, String>> {
+		self.uncle(id)
+			.map(|block| BlockView::new(&block).header())
+			.map(|header| self.engine.extra_info(&header))
+	}
 }
 
 impl MiningBlockChainClient for Client {
 
 	fn latest_schedule(&self) -> Schedule {
-		let header_data = self.best_block_header();
-		let view = HeaderView::new(&header_data);
-
-		let env_info = EnvInfo {
-			number: view.number(),
-			author: view.author(),
-			timestamp: view.timestamp(),
-			difficulty: view.difficulty(),
-			last_hashes: self.build_last_hashes(view.hash()),
-			gas_used: U256::default(),
-			gas_limit: view.gas_limit(),
-		};
-		self.engine.schedule(&env_info)
+		self.engine.schedule(&self.latest_env_info())
 	}
 
 	fn prepare_open_block(&self, author: Address, gas_range_target: (U256, U256), extra_data: Bytes) -> OpenBlock {

ethcore/src/client/config.rs

@@ -16,6 +16,7 @@
 
 use std::str::FromStr;
 use std::path::Path;
+use std::fmt::{Display, Formatter, Error as FmtError};
 pub use std::time::Duration;
 pub use blockchain::Config as BlockChainConfig;
 pub use trace::Config as TraceConfig;
@@ -86,6 +87,17 @@ impl Default for Mode {
 	}
 }
 
+impl Display for Mode {
+	fn fmt(&self, f: &mut Formatter) -> Result<(), FmtError> {
+		match *self {
+			Mode::Active => write!(f, "active"),
+			Mode::Passive(..) => write!(f, "passive"),
+			Mode::Dark(..) => write!(f, "dark"),
+			Mode::Off => write!(f, "offline"),
+		}
+	}
+}
+
 /// Client configuration. Includes configs for all sub-systems.
 #[derive(Debug, PartialEq, Default)]
 pub struct ClientConfig {

ethcore/src/client/test_client.rs

@@ -38,6 +38,7 @@ use evm::{Factory as EvmFactory, VMType, Schedule};
 use miner::{Miner, MinerService, TransactionImportResult};
 use spec::Spec;
 use types::mode::Mode;
+use views::BlockView;
 
 use verification::queue::QueueInfo;
 use block::{OpenBlock, SealedBlock};
@@ -227,7 +228,7 @@ impl TestBlockChainClient {
 						gas_price: U256::one(),
 						nonce: U256::zero()
 					};
-					let signed_tx = tx.sign(keypair.secret());
+					let signed_tx = tx.sign(keypair.secret(), None);
 					txs.append(&signed_tx);
 					txs.out()
 				},
@@ -293,7 +294,7 @@ impl TestBlockChainClient {
 			gas_price: U256::one(),
 			nonce: U256::zero()
 		};
-		let signed_tx = tx.sign(keypair.secret());
+		let signed_tx = tx.sign(keypair.secret(), None);
 		self.set_balance(signed_tx.sender().unwrap(), 10_000_000.into());
 		let res = self.miner.import_external_transactions(self, vec![signed_tx]);
 		let res = res.into_iter().next().unwrap().expect("Successful import");
@@ -314,7 +315,7 @@ pub fn get_temp_state_db() -> GuardedTempResult<StateDB> {
 
 impl MiningBlockChainClient for TestBlockChainClient {
 	fn latest_schedule(&self) -> Schedule {
-		Schedule::new_homestead_gas_fix()
+		Schedule::new_post_eip150(true, true, true)
 	}
 
 	fn prepare_open_block(&self, author: Address, gas_range_target: (U256, U256), extra_data: Bytes) -> OpenBlock {
@@ -417,6 +418,10 @@ impl BlockChainClient for TestBlockChainClient {
 		None	// Simple default.
 	}
 
+	fn uncle_extra_info(&self, _id: UncleID) -> Option<BTreeMap<String, String>> {
+		None
+	}
+
 	fn transaction_receipt(&self, id: TransactionID) -> Option<LocalizedReceipt> {
 		self.receipts.read().get(&id).cloned()
 	}
@@ -459,6 +464,13 @@ impl BlockChainClient for TestBlockChainClient {
 		self.block_hash(id).and_then(|hash| self.blocks.read().get(&hash).cloned())
 	}
 
+	fn block_extra_info(&self, id: BlockID) -> Option<BTreeMap<String, String>> {
+		self.block(id)
+			.map(|block| BlockView::new(&block).header())
+			.map(|header| self.spec.engine.extra_info(&header))
+	}
+
+
 	fn block_status(&self, id: BlockID) -> BlockStatus {
 		match id {
 			BlockID::Number(number) if (number as usize) < self.blocks.read().len() => BlockStatus::InChain,
@@ -633,6 +645,8 @@ impl BlockChainClient for TestBlockChainClient {
 		self.miner.pending_transactions(self.chain_info().best_block_number)
 	}
 
+	fn signing_network_id(&self) -> Option<u8> { None }
+
 	fn mode(&self) -> Mode { Mode::Active }
 
 	fn set_mode(&self, _: Mode) { unimplemented!(); }

ethcore/src/client/traits.rs

@@ -29,13 +29,13 @@ use error::{ImportResult, CallError};
 use receipt::LocalizedReceipt;
 use trace::LocalizedTrace;
 use evm::{Factory as EvmFactory, Schedule};
-use types::ids::*;
-use types::trace_filter::Filter as TraceFilter;
 use executive::Executed;
 use env_info::LastHashes;
-use types::call_analytics::CallAnalytics;
 use block_import_error::BlockImportError;
 use ipc::IpcConfig;
+use types::ids::*;
+use types::trace_filter::Filter as TraceFilter;
+use types::call_analytics::CallAnalytics;
 use types::blockchain_info::BlockChainInfo;
 use types::block_status::BlockStatus;
 use types::mode::Mode;
@@ -215,7 +215,7 @@ pub trait BlockChainClient : Sync + Send {
 	/// Calculate median gas price from recent blocks if they have any transactions.
 	fn gas_price_median(&self, sample_size: usize) -> Option<U256> {
 		let corpus = self.gas_price_corpus(sample_size);
-		corpus.get(corpus.len()/2).cloned()
+		corpus.get(corpus.len() / 2).cloned()
 	}
 
 	/// Get the gas price distribution based on recent blocks if they have any transactions.
@@ -223,13 +223,24 @@ pub trait BlockChainClient : Sync + Send {
 		let raw_corpus = self.gas_price_corpus(sample_size);
 		let raw_len = raw_corpus.len();
 		// Throw out outliers.
-		let (corpus, _) = raw_corpus.split_at(raw_len-raw_len/40);
+		let (corpus, _) = raw_corpus.split_at(raw_len - raw_len / 40);
 		Histogram::new(corpus, bucket_number)
 	}
 
+	/// Get the preferred network ID to sign on
+	fn signing_network_id(&self) -> Option<u8>;
+
+	/// Get the mode.
 	fn mode(&self) -> Mode;
 
+	/// Set the mode.
 	fn set_mode(&self, mode: Mode);
+
+	/// Returns engine-related extra info for `BlockID`.
+	fn block_extra_info(&self, id: BlockID) -> Option<BTreeMap<String, String>>;
+
+	/// Returns engine-related extra info for `UncleID`.
+	fn uncle_extra_info(&self, id: UncleID) -> Option<BTreeMap<String, String>>;
 }
 
 /// Extended client interface used for mining

ethcore/src/engines/basic_authority.rs

@@ -81,7 +81,7 @@ impl Engine for BasicAuthority {
 	fn builtins(&self) -> &BTreeMap<Address, Builtin> { &self.builtins }
 
 	/// Additional engine-specific information for the user/developer concerning `header`.
-	fn extra_info(&self, _header: &Header) -> HashMap<String, String> { hash_map!["signature".to_owned() => "TODO".to_owned()] }
+	fn extra_info(&self, _header: &Header) -> BTreeMap<String, String> { map!["signature".to_owned() => "TODO".to_owned()] }
 
 	fn schedule(&self, _env_info: &EnvInfo) -> Schedule {
 		Schedule::new_homestead()

ethcore/src/engines/mod.rs

@@ -47,7 +47,7 @@ pub trait Engine : Sync + Send {
 	fn seal_fields(&self) -> usize { 0 }
 
 	/// Additional engine-specific information for the user/developer concerning `header`.
-	fn extra_info(&self, _header: &Header) -> HashMap<String, String> { HashMap::new() }
+	fn extra_info(&self, _header: &Header) -> BTreeMap<String, String> { BTreeMap::new() }
 
 	/// Additional information.
 	fn additional_params(&self) -> HashMap<String, String> { HashMap::new() }
@@ -108,6 +108,9 @@ pub trait Engine : Sync + Send {
 	/// Verify a particular transaction is valid.
 	fn verify_transaction(&self, _t: &SignedTransaction, _header: &Header) -> Result<(), Error> { Ok(()) }
 
+	/// The network ID that transactions should be signed with.
+	fn signing_network_id(&self, _env_info: &EnvInfo) -> Option<u8> { None }
+
 	/// Verify the seal of a block. This is an auxilliary method that actually just calls other `verify_` methods
 	/// to get the job done. By default it must pass `verify_basic` and `verify_block_unordered`. If more or fewer
 	/// methods are needed for an Engine, this may be overridden.

ethcore/src/error.rs

@@ -76,6 +76,8 @@ pub enum TransactionError {
 	RecipientBanned,
 	/// Contract creation code is banned.
 	CodeBanned,
+	/// Invalid network ID given.
+	InvalidNetworkId,
 }
 
 impl fmt::Display for TransactionError {
@@ -99,6 +101,7 @@ impl fmt::Display for TransactionError {
 			SenderBanned => "Sender is temporarily banned.".into(),
 			RecipientBanned => "Recipient is temporarily banned.".into(),
 			CodeBanned => "Contract code is temporarily banned.".into(),
+			InvalidNetworkId => "Transaction of this network ID is not allowed on this chain.".into(),
 		};
 
 		f.write_fmt(format_args!("Transaction error ({})", msg))

ethcore/src/ethereum/ethash.rs

@@ -14,13 +14,14 @@
 // You should have received a copy of the GNU General Public License
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
-use ethash::{quick_get_difficulty, slow_get_seedhash, EthashManager, H256 as EH256};
+use ethash::{quick_get_difficulty, slow_get_seedhash, EthashManager};
 use util::*;
 use block::*;
 use builtin::Builtin;
 use env_info::EnvInfo;
-use error::{BlockError, Error};
+use error::{BlockError, TransactionError, Error};
 use header::Header;
+use state::CleanupMode;
 use spec::CommonParams;
 use transaction::SignedTransaction;
 use engines::Engine;
@@ -59,8 +60,20 @@ pub struct EthashParams {
 	pub difficulty_hardfork_bound_divisor: U256,
 	/// Block on which there is no additional difficulty from the exponential bomb.
 	pub bomb_defuse_transition: u64,
-	/// Bad gas transition block number.
+	/// Number of first block where EIP-150 rules begin.
 	pub eip150_transition: u64,
+	/// Number of first block where EIP-155 rules begin.
+	pub eip155_transition: u64,
+	/// Number of first block where EIP-160 rules begin.
+	pub eip160_transition: u64,
+	/// Number of first block where EIP-161.abc begin.
+	pub eip161abc_transition: u64,
+	/// Number of first block where EIP-161.d begins.
+	pub eip161d_transition: u64,
+	/// Number of first block where ECIP-1010 begins.
+	pub ecip1010_pause_transition: u64,
+	/// Number of first block where ECIP-1010 ends.
+	pub ecip1010_continue_transition: u64
 }
 
 impl From<ethjson::spec::EthashParams> for EthashParams {
@@ -81,6 +94,12 @@ impl From<ethjson::spec::EthashParams> for EthashParams {
 			difficulty_hardfork_bound_divisor: p.difficulty_hardfork_bound_divisor.map_or(p.difficulty_bound_divisor.into(), Into::into),
 			bomb_defuse_transition: p.bomb_defuse_transition.map_or(0x7fffffffffffffff, Into::into),
 			eip150_transition: p.eip150_transition.map_or(0, Into::into),
+			eip155_transition: p.eip155_transition.map_or(0, Into::into),
+			eip160_transition: p.eip160_transition.map_or(0, Into::into),
+			eip161abc_transition: p.eip161abc_transition.map_or(0, Into::into),
+			eip161d_transition: p.eip161d_transition.map_or(0x7fffffffffffffff, Into::into),
+			ecip1010_pause_transition: p.ecip1010_pause_transition.map_or(0x7fffffffffffffff, Into::into),
+			ecip1010_continue_transition: p.ecip1010_continue_transition.map_or(0x7fffffffffffffff, Into::into),
 		}
 	}
 }
@@ -120,8 +139,8 @@ impl Engine for Ethash {
 	}
 
 	/// Additional engine-specific information for the user/developer concerning `header`.
-	fn extra_info(&self, header: &Header) -> HashMap<String, String> {
-		hash_map!["nonce".to_owned() => format!("0x{}", header.nonce().hex()), "mixHash".to_owned() => format!("0x{}", header.mix_hash().hex())]
+	fn extra_info(&self, header: &Header) -> BTreeMap<String, String> {
+		map!["nonce".to_owned() => format!("0x{}", header.nonce().hex()), "mixHash".to_owned() => format!("0x{}", header.mix_hash().hex())]
 	}
 
 	fn schedule(&self, env_info: &EnvInfo) -> Schedule {
@@ -132,7 +151,19 @@ impl Engine for Ethash {
 		} else if env_info.number < self.ethash_params.eip150_transition {
 			Schedule::new_homestead()
 		} else {
-			Schedule::new_homestead_gas_fix()
+			Schedule::new_post_eip150(
+				env_info.number >= self.ethash_params.eip160_transition,
+				env_info.number >= self.ethash_params.eip161abc_transition,
+				env_info.number >= self.ethash_params.eip161d_transition
+			)
+		}
+	}
+
+	fn signing_network_id(&self, env_info: &EnvInfo) -> Option<u8> {
+		if env_info.number >= self.ethash_params.eip155_transition && self.params().network_id < 127 {
+			Some(self.params().network_id as u8)
+		} else {
+			None
 		}
 	}
 
@@ -169,7 +200,7 @@ impl Engine for Ethash {
 				let mut state = block.fields_mut().state;
 				for child in &self.ethash_params.dao_hardfork_accounts {
 					let b = state.balance(child);
-					state.transfer_balance(child, &self.ethash_params.dao_hardfork_beneficiary, &b);
+					state.transfer_balance(child, &self.ethash_params.dao_hardfork_beneficiary, &b, CleanupMode::NoEmpty);
 				}
 //			}
 		}
@@ -182,12 +213,12 @@ impl Engine for Ethash {
 		let fields = block.fields_mut();
 
 		// Bestow block reward
-		fields.state.add_balance(fields.header.author(), &(reward + reward / U256::from(32) * U256::from(fields.uncles.len())));
+		fields.state.add_balance(fields.header.author(), &(reward + reward / U256::from(32) * U256::from(fields.uncles.len())), CleanupMode::NoEmpty);
 
 		// Bestow uncle rewards
 		let current_number = fields.header.number();
 		for u in fields.uncles.iter() {
-			fields.state.add_balance(u.author(), &(reward * U256::from(8 + u.number() - current_number) / U256::from(8)));
+			fields.state.add_balance(u.author(), &(reward * U256::from(8 + u.number() - current_number) / U256::from(8)), CleanupMode::NoEmpty);
 		}
 
 		// Commit state so that we can actually figure out the state root.
@@ -212,10 +243,10 @@ impl Engine for Ethash {
 			return Err(From::from(BlockError::DifficultyOutOfBounds(OutOfBounds { min: Some(min_difficulty), max: None, found: header.difficulty().clone() })))
 		}
 
-		let difficulty = Ethash::boundary_to_difficulty(&Ethash::from_ethash(quick_get_difficulty(
-			&Ethash::to_ethash(header.bare_hash()),
+		let difficulty = Ethash::boundary_to_difficulty(&H256(quick_get_difficulty(
+			&header.bare_hash().0,
 			header.nonce().low_u64(),
-			&Ethash::to_ethash(header.mix_hash())
+			&header.mix_hash().0
 		)));
 		if &difficulty < header.difficulty() {
 			return Err(From::from(BlockError::InvalidProofOfWork(OutOfBounds { min: Some(header.difficulty().clone()), max: None, found: difficulty })));
@@ -240,10 +271,10 @@ impl Engine for Ethash {
 				Mismatch { expected: self.seal_fields(), found: header.seal().len() }
 			)));
 		}
-		let result = self.pow.compute_light(header.number() as u64, &Ethash::to_ethash(header.bare_hash()), header.nonce().low_u64());
-		let mix = Ethash::from_ethash(result.mix_hash);
-		let difficulty = Ethash::boundary_to_difficulty(&Ethash::from_ethash(result.value));
-		trace!(target: "miner", "num: {}, seed: {}, h: {}, non: {}, mix: {}, res: {}" , header.number() as u64, Ethash::from_ethash(slow_get_seedhash(header.number() as u64)), header.bare_hash(), header.nonce().low_u64(), Ethash::from_ethash(result.mix_hash), Ethash::from_ethash(result.value));
+		let result = self.pow.compute_light(header.number() as u64, &header.bare_hash().0, header.nonce().low_u64());
+		let mix = H256(result.mix_hash);
+		let difficulty = Ethash::boundary_to_difficulty(&H256(result.value));
+		trace!(target: "miner", "num: {}, seed: {}, h: {}, non: {}, mix: {}, res: {}" , header.number() as u64, H256(slow_get_seedhash(header.number() as u64)), header.bare_hash(), header.nonce().low_u64(), H256(result.mix_hash), H256(result.value));
 		if mix != header.mix_hash() {
 			return Err(From::from(BlockError::MismatchedH256SealElement(Mismatch { expected: mix, found: header.mix_hash() })));
 		}
@@ -277,6 +308,13 @@ impl Engine for Ethash {
 		if header.number() >= self.ethash_params.homestead_transition {
 			try!(t.check_low_s());
 		}
+
+		if let Some(n) = t.network_id() {
+			if header.number() < self.ethash_params.eip155_transition || n as usize != self.params().network_id {
+				return Err(TransactionError::InvalidNetworkId.into())
+			}
+		}
+
 		Ok(())
 	}
 
@@ -285,7 +323,7 @@ impl Engine for Ethash {
 	}
 }
 
-#[cfg_attr(feature="dev", allow(wrong_self_convention))] // to_ethash should take self
+#[cfg_attr(feature="dev", allow(wrong_self_convention))]
 impl Ethash {
 	fn calculate_difficulty(&self, header: &Header, parent: &Header) -> U256 {
 		const EXP_DIFF_PERIOD: u64 = 100000;
@@ -321,9 +359,20 @@ impl Ethash {
 		};
 		target = max(min_difficulty, target);
 		if header.number() < self.ethash_params.bomb_defuse_transition {
-			let period = ((parent.number() + 1) / EXP_DIFF_PERIOD) as usize;
-			if period > 1 {
-				target = max(min_difficulty, target + (U256::from(1) << (period - 2)));
+			if header.number() < self.ethash_params.ecip1010_pause_transition {
+				let period = ((parent.number() + 1) / EXP_DIFF_PERIOD) as usize;
+				if period > 1 {
+					target = max(min_difficulty, target + (U256::from(1) << (period - 2)));
+				}
+			}
+			else if header.number() < self.ethash_params.ecip1010_continue_transition {
+				let fixed_difficulty = ((self.ethash_params.ecip1010_pause_transition / EXP_DIFF_PERIOD) - 2) as usize;
+				target = max(min_difficulty, target + (U256::from(1) << fixed_difficulty));
+			}
+			else {
+				let period = ((parent.number() + 1) / EXP_DIFF_PERIOD) as usize;
+				let delay = ((self.ethash_params.ecip1010_continue_transition - self.ethash_params.ecip1010_pause_transition) / EXP_DIFF_PERIOD) as usize;
+				target = max(min_difficulty, target + (U256::from(1) << (period - delay - 2)));
 			}
 		}
 		target
@@ -347,14 +396,6 @@ impl Ethash {
 			(((U256::one() << 255) / *difficulty) << 1).into()
 		}
 	}
-
-	fn to_ethash(hash: H256) -> EH256 {
-		unsafe { mem::transmute(hash) }
-	}
-
-	fn from_ethash(hash: EH256) -> H256 {
-		unsafe { mem::transmute(hash) }
-	}
 }
 
 impl Header {
@@ -382,8 +423,8 @@ mod tests {
 	use env_info::EnvInfo;
 	use error::{BlockError, Error};
 	use header::Header;
-	use super::super::new_morden;
-	use super::Ethash;
+	use super::super::{new_morden, new_homestead_test};
+	use super::{Ethash, EthashParams};
 	use rlp;
 
 	#[test]
@@ -605,5 +646,122 @@ mod tests {
 		assert_eq!(Ethash::difficulty_to_boundary(&U256::from(32)), H256::from_str("0800000000000000000000000000000000000000000000000000000000000000").unwrap());
 	}
 
-	// TODO: difficulty test
+	#[test]
+	fn difficulty_frontier() {
+		let spec = new_homestead_test();
+		let ethparams = get_default_ethash_params();
+		let ethash = Ethash::new(spec.params, ethparams, BTreeMap::new());
+
+		let mut parent_header = Header::default();
+		parent_header.set_number(1000000);
+		parent_header.set_difficulty(U256::from_str("b69de81a22b").unwrap());
+		parent_header.set_timestamp(1455404053);
+		let mut header = Header::default();
+		header.set_number(parent_header.number() + 1);
+		header.set_timestamp(1455404058);
+
+		let difficulty = ethash.calculate_difficulty(&header, &parent_header);
+		assert_eq!(U256::from_str("b6b4bbd735f").unwrap(), difficulty);
+	}
+
+	#[test]
+	fn difficulty_homestead() {
+		let spec = new_homestead_test();
+		let ethparams = get_default_ethash_params();
+		let ethash = Ethash::new(spec.params, ethparams, BTreeMap::new());
+
+		let mut parent_header = Header::default();
+		parent_header.set_number(1500000);
+		parent_header.set_difficulty(U256::from_str("1fd0fd70792b").unwrap());
+		parent_header.set_timestamp(1463003133);
+		let mut header = Header::default();
+		header.set_number(parent_header.number() + 1);
+		header.set_timestamp(1463003177);
+
+		let difficulty = ethash.calculate_difficulty(&header, &parent_header);
+		assert_eq!(U256::from_str("1fc50f118efe").unwrap(), difficulty);
+	}
+
+	#[test]
+	fn difficulty_classic_bomb_delay() {
+		let spec = new_homestead_test();
+		let ethparams = EthashParams {
+			ecip1010_pause_transition: 3000000,
+			..get_default_ethash_params()
+		};
+		let ethash = Ethash::new(spec.params, ethparams, BTreeMap::new());
+
+		let mut parent_header = Header::default();
+		parent_header.set_number(3500000);
+		parent_header.set_difficulty(U256::from_str("6F62EAF8D3C").unwrap());
+		parent_header.set_timestamp(1452838500);
+		let mut header = Header::default();
+		header.set_number(parent_header.number() + 1);
+
+		header.set_timestamp(parent_header.timestamp() + 20);
+		assert_eq!(
+			U256::from_str("6F55FE9B74B").unwrap(),
+			ethash.calculate_difficulty(&header, &parent_header)
+		);
+		header.set_timestamp(parent_header.timestamp() + 5);
+		assert_eq!(
+			U256::from_str("6F71D75632D").unwrap(),
+			ethash.calculate_difficulty(&header, &parent_header)
+		);
+		header.set_timestamp(parent_header.timestamp() + 80);
+		assert_eq!(
+			U256::from_str("6F02746B3A5").unwrap(),
+			ethash.calculate_difficulty(&header, &parent_header)
+		);
+	}
+
+	#[test]
+	fn test_difficulty_bomb_continue() {
+		let spec = new_homestead_test();
+		let ethparams = EthashParams {
+			ecip1010_pause_transition: 3000000,
+			ecip1010_continue_transition: 5000000,
+			..get_default_ethash_params()
+		};
+		let ethash = Ethash::new(spec.params, ethparams, BTreeMap::new());
+
+		let mut parent_header = Header::default();
+		parent_header.set_number(5000102);
+		parent_header.set_difficulty(U256::from_str("14944397EE8B").unwrap());
+		parent_header.set_timestamp(1513175023);
+		let mut header = Header::default();
+		header.set_number(parent_header.number() + 1);
+		header.set_timestamp(parent_header.timestamp() + 6);
+		assert_eq!(
+			U256::from_str("1496E6206188").unwrap(),
+			ethash.calculate_difficulty(&header, &parent_header)
+		);
+		parent_header.set_number(5100123);
+		parent_header.set_difficulty(U256::from_str("14D24B39C7CF").unwrap());
+		parent_header.set_timestamp(1514609324);
+		header.set_number(parent_header.number() + 1);
+		header.set_timestamp(parent_header.timestamp() + 41);
+		assert_eq!(
+			U256::from_str("14CA9C5D9227").unwrap(),
+			ethash.calculate_difficulty(&header, &parent_header)
+		);
+		parent_header.set_number(6150001);
+		parent_header.set_difficulty(U256::from_str("305367B57227").unwrap());
+		parent_header.set_timestamp(1529664575);
+		header.set_number(parent_header.number() + 1);
+		header.set_timestamp(parent_header.timestamp() + 105);
+		assert_eq!(
+			U256::from_str("309D09E0C609").unwrap(),
+			ethash.calculate_difficulty(&header, &parent_header)
+		);
+		parent_header.set_number(8000000);
+		parent_header.set_difficulty(U256::from_str("1180B36D4CE5B6A").unwrap());
+		parent_header.set_timestamp(1535431724);
+		header.set_number(parent_header.number() + 1);
+		header.set_timestamp(parent_header.timestamp() + 420);
+		assert_eq!(
+			U256::from_str("5126FFD5BCBB9E7").unwrap(),
+			ethash.calculate_difficulty(&header, &parent_header)
+		);
+	}
 }

ethcore/src/ethereum/mod.rs

@@ -54,6 +54,9 @@ pub fn new_homestead_test() -> Spec { load(include_bytes!("../../res/ethereum/ho
 /// Create a new Homestead-EIP150 chain spec as though it never changed from Homestead/Frontier.
 pub fn new_eip150_test() -> Spec { load(include_bytes!("../../res/ethereum/eip150_test.json")) }
 
+/// Create a new Homestead-EIP150 chain spec as though it never changed from Homestead/Frontier.
+pub fn new_eip161_test() -> Spec { load(include_bytes!("../../res/ethereum/eip161_test.json")) }
+
 /// Create a new Frontier/Homestead/DAO chain spec with transition points at #5 and #8.
 pub fn new_transition_test() -> Spec { load(include_bytes!("../../res/ethereum/transition_test.json")) }
 

ethcore/src/evm/ext.rs

@@ -52,6 +52,12 @@ pub trait Ext {
 	/// Determine whether an account exists.
 	fn exists(&self, address: &Address) -> bool;
 
+	/// Determine whether an account exists and is not null (zero balance/nonce, no code).
+	fn exists_and_not_null(&self, address: &Address) -> bool;
+
+	/// Balance of the origin account.
+	fn origin_balance(&self) -> U256;
+
 	/// Returns address balance.
 	fn balance(&self, address: &Address) -> U256;
 

ethcore/src/evm/interpreter/gasometer.rs

@@ -146,8 +146,13 @@ impl<Gas: CostType> Gasometer<Gas> {
 			instructions::SUICIDE => {
 				let mut gas = Gas::from(schedule.suicide_gas);
 
+				let is_value_transfer = !ext.origin_balance().is_zero();
 				let address = u256_to_address(stack.peek(0));
-				if !ext.exists(&address) {
+				if (
+					!schedule.no_empty && !ext.exists(&address)
+				) || (
+					schedule.no_empty && is_value_transfer && !ext.exists_and_not_null(&address)
+				) {
 					gas = overflowing!(gas.overflow_add(schedule.suicide_to_new_account_cost.into()));
 				}
 
@@ -190,12 +195,19 @@ impl<Gas: CostType> Gasometer<Gas> {
 				);
 
 				let address = u256_to_address(stack.peek(1));
+				let is_value_transfer = !stack.peek(2).is_zero();
 
-				if instruction == instructions::CALL && !ext.exists(&address) {
-					gas = overflowing!(gas.overflow_add(schedule.call_new_account_gas.into()));
+				if instruction == instructions::CALL {
+					if (
+						!schedule.no_empty && !ext.exists(&address)
+					) || (
+						schedule.no_empty && is_value_transfer && !ext.exists_and_not_null(&address)
+					) {
+						gas = overflowing!(gas.overflow_add(schedule.call_new_account_gas.into()));
+					}
 				};
 
-				if !stack.peek(2).is_zero() {
+				if is_value_transfer {
 					gas = overflowing!(gas.overflow_add(schedule.call_value_transfer_gas.into()));
 				};
 

ethcore/src/evm/schedule.rs

@@ -93,6 +93,10 @@ pub struct Schedule {
 	/// If Some(x): let limit = GAS * (x - 1) / x; let CALL's gas = min(requested, limit). let CREATE's gas = limit.
 	/// If None: let CALL's gas = (requested > GAS ? [OOG] : GAS). let CREATE's gas = GAS
 	pub sub_gas_cap_divisor: Option<usize>,
+	/// Don't ever make empty accounts; contracts start with nonce=1. Also, don't charge 25k when sending/suicide zero-value.
+	pub no_empty: bool,
+	/// Kill empty accounts if touched.
+	pub kill_empty: bool,
 }
 
 impl Schedule {
@@ -106,16 +110,16 @@ impl Schedule {
 		Self::new(true, true, 53000)
 	}
 
-	/// Schedule for the Homestead-era of the Ethereum main net.
-	pub fn new_homestead_gas_fix() -> Schedule {
-		Schedule{
+	/// Schedule for the post-EIP-150-era of the Ethereum main net.
+	pub fn new_post_eip150(fix_exp: bool, no_empty: bool, kill_empty: bool) -> Schedule {
+		Schedule {
 			exceptional_failed_code_deposit: true,
 			have_delegate_call: true,
 			stack_limit: 1024,
 			max_depth: 1024,
 			tier_step_gas: [0, 2, 3, 5, 8, 10, 20, 0],
 			exp_gas: 10,
-			exp_byte_gas: 10,
+			exp_byte_gas: if fix_exp {50} else {10},
 			sha3_gas: 30,
 			sha3_word_gas: 6,
 			sload_gas: 200,
@@ -146,11 +150,13 @@ impl Schedule {
 			suicide_gas: 5000,
 			suicide_to_new_account_cost: 25000,
 			sub_gas_cap_divisor: Some(64),
+			no_empty: no_empty,
+			kill_empty: kill_empty,
 		}
 	}
 
 	fn new(efcd: bool, hdc: bool, tcg: usize) -> Schedule {
-		Schedule{
+		Schedule {
 			exceptional_failed_code_deposit: efcd,
 			have_delegate_call: hdc,
 			stack_limit: 1024,
@@ -188,6 +194,8 @@ impl Schedule {
 			suicide_gas: 0,
 			suicide_to_new_account_cost: 0,
 			sub_gas_cap_divisor: None,
+			no_empty: false,
+			kill_empty: false,
 		}
 	}
 }

ethcore/src/evm/tests.rs

@@ -94,6 +94,14 @@ impl Ext for FakeExt {
 		self.balances.contains_key(address)
 	}
 
+	fn exists_and_not_null(&self, address: &Address) -> bool {
+		self.balances.get(address).map_or(false, |b| !b.is_zero()) 
+	}
+
+	fn origin_balance(&self) -> U256 {
+		unimplemented!()
+	}
+
 	fn balance(&self, address: &Address) -> U256 {
 		*self.balances.get(address).unwrap()
 	}

ethcore/src/executive.rs

@@ -17,7 +17,7 @@
 //! Transaction Execution environment.
 use util::*;
 use action_params::{ActionParams, ActionValue};
-use state::{State, Substate};
+use state::{State, Substate, CleanupMode};
 use engines::Engine;
 use types::executed::CallType;
 use env_info::EnvInfo;
@@ -256,9 +256,11 @@ impl<'a> Executive<'a> {
 		// backup used in case of running out of gas
 		self.state.checkpoint();
 
+		let schedule = self.engine.schedule(self.info);
+
 		// at first, transfer value to destination
 		if let ActionValue::Transfer(val) = params.value {
-			self.state.transfer_balance(&params.sender, &params.address, &val);
+			self.state.transfer_balance(&params.sender, &params.address, &val, substate.to_cleanup_mode(&schedule));
 		}
 		trace!("Executive::call(params={:?}) self.env_info={:?}", params, self.info);
 
@@ -364,12 +366,14 @@ impl<'a> Executive<'a> {
 		let mut unconfirmed_substate = Substate::new();
 
 		// create contract and transfer value to it if necessary
+		let schedule = self.engine.schedule(self.info);
+		let nonce_offset = if schedule.no_empty {1} else {0}.into();
 		let prev_bal = self.state.balance(&params.address);
 		if let ActionValue::Transfer(val) = params.value {
 			self.state.sub_balance(&params.sender, &val);
-			self.state.new_contract(&params.address, val + prev_bal);
+			self.state.new_contract(&params.address, val + prev_bal, nonce_offset);
 		} else {
-			self.state.new_contract(&params.address, prev_bal);
+			self.state.new_contract(&params.address, prev_bal, nonce_offset);
 		}
 
 		let trace_info = tracer.prepare_trace_create(&params);
@@ -405,7 +409,7 @@ impl<'a> Executive<'a> {
 	fn finalize(
 		&mut self,
 		t: &SignedTransaction,
-		substate: Substate,
+		mut substate: Substate,
 		result: evm::Result<U256>,
 		output: Bytes,
 		trace: Vec<FlatTrace>,
@@ -440,15 +444,23 @@ impl<'a> Executive<'a> {
 		};
 
 		trace!("exec::finalize: Refunding refund_value={}, sender={}\n", refund_value, sender);
-		self.state.add_balance(&sender, &refund_value);
+		// Below: NoEmpty is safe since the sender must already be non-null to have sent this transaction
+		self.state.add_balance(&sender, &refund_value, CleanupMode::NoEmpty);  
 		trace!("exec::finalize: Compensating author: fees_value={}, author={}\n", fees_value, &self.info.author);
-		self.state.add_balance(&self.info.author, &fees_value);
+		self.state.add_balance(&self.info.author, &fees_value, substate.to_cleanup_mode(&schedule));
 
 		// perform suicides
 		for address in &substate.suicides {
 			self.state.kill_account(address);
 		}
 
+		// perform garbage-collection
+		for address in &substate.garbage {
+			if self.state.exists(address) && !self.state.exists_and_not_null(address) {
+				self.state.kill_account(address);
+			}
+		}
+
 		match result {
 			Err(evm::Error::Internal) => Err(ExecutionError::Internal),
 			Err(_) => {
@@ -509,7 +521,7 @@ mod tests {
 	use env_info::EnvInfo;
 	use evm::{Factory, VMType};
 	use error::ExecutionError;
-	use state::Substate;
+	use state::{Substate, CleanupMode};
 	use tests::helpers::*;
 	use trace::trace;
 	use trace::{FlatTrace, Tracer, NoopTracer, ExecutiveTracer};
@@ -538,7 +550,7 @@ mod tests {
 		params.value = ActionValue::Transfer(U256::from(0x7));
 		let mut state_result = get_temp_state();
 		let mut state = state_result.reference_mut();
-		state.add_balance(&sender, &U256::from(0x100u64));
+		state.add_balance(&sender, &U256::from(0x100u64), CleanupMode::NoEmpty);
 		let info = EnvInfo::default();
 		let engine = TestEngine::new(0);
 		let mut substate = Substate::new();
@@ -597,7 +609,7 @@ mod tests {
 		params.value = ActionValue::Transfer(U256::from(100));
 		let mut state_result = get_temp_state();
 		let mut state = state_result.reference_mut();
-		state.add_balance(&sender, &U256::from(100));
+		state.add_balance(&sender, &U256::from(100), CleanupMode::NoEmpty);
 		let info = EnvInfo::default();
 		let engine = TestEngine::new(0);
 		let mut substate = Substate::new();
@@ -656,7 +668,7 @@ mod tests {
 		params.call_type = CallType::Call;
 		let mut state_result = get_temp_state();
 		let mut state = state_result.reference_mut();
-		state.add_balance(&sender, &U256::from(100));
+		state.add_balance(&sender, &U256::from(100), CleanupMode::NoEmpty);
 		let info = EnvInfo::default();
 		let engine = TestEngine::new(5);
 		let mut substate = Substate::new();
@@ -767,7 +779,7 @@ mod tests {
 		params.value = ActionValue::Transfer(100.into());
 		let mut state_result = get_temp_state();
 		let mut state = state_result.reference_mut();
-		state.add_balance(&sender, &U256::from(100));
+		state.add_balance(&sender, &U256::from(100), CleanupMode::NoEmpty);
 		let info = EnvInfo::default();
 		let engine = TestEngine::new(5);
 		let mut substate = Substate::new();
@@ -855,7 +867,7 @@ mod tests {
 		params.value = ActionValue::Transfer(U256::from(100));
 		let mut state_result = get_temp_state();
 		let mut state = state_result.reference_mut();
-		state.add_balance(&sender, &U256::from(100));
+		state.add_balance(&sender, &U256::from(100), CleanupMode::NoEmpty);
 		let info = EnvInfo::default();
 		let engine = TestEngine::new(0);
 		let mut substate = Substate::new();
@@ -907,7 +919,7 @@ mod tests {
 		params.value = ActionValue::Transfer(U256::from(100));
 		let mut state_result = get_temp_state();
 		let mut state = state_result.reference_mut();
-		state.add_balance(&sender, &U256::from(100));
+		state.add_balance(&sender, &U256::from(100), CleanupMode::NoEmpty);
 		let info = EnvInfo::default();
 		let engine = TestEngine::new(1024);
 		let mut substate = Substate::new();
@@ -967,7 +979,7 @@ mod tests {
 		let mut state = state_result.reference_mut();
 		state.init_code(&address_a, code_a.clone());
 		state.init_code(&address_b, code_b.clone());
-		state.add_balance(&sender, &U256::from(100_000));
+		state.add_balance(&sender, &U256::from(100_000), CleanupMode::NoEmpty);
 
 		let info = EnvInfo::default();
 		let engine = TestEngine::new(0);
@@ -1040,13 +1052,13 @@ mod tests {
 			gas: U256::from(100_000),
 			gas_price: U256::zero(),
 			nonce: U256::zero()
-		}.sign(keypair.secret());
+		}.sign(keypair.secret(), None);
 		let sender = t.sender().unwrap();
 		let contract = contract_address(&sender, &U256::zero());
 
 		let mut state_result = get_temp_state();
 		let mut state = state_result.reference_mut();
-		state.add_balance(&sender, &U256::from(18));
+		state.add_balance(&sender, &U256::from(18), CleanupMode::NoEmpty);
 		let mut info = EnvInfo::default();
 		info.gas_limit = U256::from(100_000);
 		let engine = TestEngine::new(0);
@@ -1107,12 +1119,12 @@ mod tests {
 			gas: U256::from(100_000),
 			gas_price: U256::zero(),
 			nonce: U256::one()
-		}.sign(keypair.secret());
+		}.sign(keypair.secret(), None);
 		let sender = t.sender().unwrap();
 
 		let mut state_result = get_temp_state();
 		let mut state = state_result.reference_mut();
-		state.add_balance(&sender, &U256::from(17));
+		state.add_balance(&sender, &U256::from(17), CleanupMode::NoEmpty);
 		let mut info = EnvInfo::default();
 		info.gas_limit = U256::from(100_000);
 		let engine = TestEngine::new(0);
@@ -1140,12 +1152,12 @@ mod tests {
 			gas: U256::from(80_001),
 			gas_price: U256::zero(),
 			nonce: U256::zero()
-		}.sign(keypair.secret());
+		}.sign(keypair.secret(), None);
 		let sender = t.sender().unwrap();
 
 		let mut state_result = get_temp_state();
 		let mut state = state_result.reference_mut();
-		state.add_balance(&sender, &U256::from(17));
+		state.add_balance(&sender, &U256::from(17), CleanupMode::NoEmpty);
 		let mut info = EnvInfo::default();
 		info.gas_used = U256::from(20_000);
 		info.gas_limit = U256::from(100_000);
@@ -1175,12 +1187,12 @@ mod tests {
 			gas: U256::from(100_000),
 			gas_price: U256::one(),
 			nonce: U256::zero()
-		}.sign(keypair.secret());
+		}.sign(keypair.secret(), None);
 		let sender = t.sender().unwrap();
 
 		let mut state_result = get_temp_state();
 		let mut state = state_result.reference_mut();
-		state.add_balance(&sender, &U256::from(100_017));
+		state.add_balance(&sender, &U256::from(100_017), CleanupMode::NoEmpty);
 		let mut info = EnvInfo::default();
 		info.gas_limit = U256::from(100_000);
 		let engine = TestEngine::new(0);
@@ -1215,7 +1227,7 @@ mod tests {
 		params.value = ActionValue::Transfer(U256::from_str("0de0b6b3a7640000").unwrap());
 		let mut state_result = get_temp_state();
 		let mut state = state_result.reference_mut();
-		state.add_balance(&sender, &U256::from_str("152d02c7e14af6800000").unwrap());
+		state.add_balance(&sender, &U256::from_str("152d02c7e14af6800000").unwrap(), CleanupMode::NoEmpty);
 		let info = EnvInfo::default();
 		let engine = TestEngine::new(0);
 		let mut substate = Substate::new();

ethcore/src/externalities.rs

@@ -114,6 +114,12 @@ impl<'a, T, V> Ext for Externalities<'a, T, V> where T: 'a + Tracer, V: 'a + VMT
 		self.state.exists(address)
 	}
 
+	fn exists_and_not_null(&self, address: &Address) -> bool {
+		self.state.exists_and_not_null(address)
+	}
+
+	fn origin_balance(&self) -> U256 { self.balance(&self.origin_info.address) }
+
 	fn balance(&self, address: &Address) -> U256 {
 		self.state.balance(address)
 	}
@@ -269,11 +275,11 @@ impl<'a, T, V> Ext for Externalities<'a, T, V> where T: 'a + Tracer, V: 'a + VMT
 		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.
+			// TODO [todr] To be consistent 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);
+			trace!(target: "ext", "Suiciding {} -> {} (xfer: {})", address, refund_address, balance);
+			self.state.transfer_balance(&address, refund_address, &balance, self.substate.to_cleanup_mode(&self.schedule));
 		}
 
 		self.tracer.trace_suicide(address, balance, refund_address.clone());

ethcore/src/json_tests/chain.rs

@@ -49,6 +49,7 @@ pub fn json_chain_test(json_data: &[u8], era: ChainEra) -> Vec<String> {
 					ChainEra::Frontier => ethereum::new_frontier_test(),
 					ChainEra::Homestead => ethereum::new_homestead_test(),
 					ChainEra::Eip150 => ethereum::new_eip150_test(),
+					ChainEra::Eip161 => ethereum::new_eip161_test(),
 					ChainEra::TransitionTest => ethereum::new_transition_test(),
 				};
 				spec.set_genesis_state(state);

ethcore/src/json_tests/eip161_state.rs

@@ -0,0 +1,51 @@
+// 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 super::test_common::*;
+use tests::helpers::*;
+use super::state::json_chain_test;
+
+fn do_json_test(json_data: &[u8]) -> Vec<String> {
+	json_chain_test(json_data, ChainEra::Eip161)
+}
+
+declare_test!{StateTests_EIP158_stEIP158SpecificTest, "StateTests/EIP158/stEIP158SpecificTest"}
+declare_test!{StateTests_EIP158_stNonZeroCallsTest, "StateTests/EIP158/stNonZeroCallsTest"}
+declare_test!{StateTests_EIP158_stZeroCallsTest, "StateTests/EIP158/stZeroCallsTest"}
+
+declare_test!{StateTests_EIP158_EIP150_stMemExpandingEIPCalls, "StateTests/EIP158/EIP150/stMemExpandingEIPCalls"}
+declare_test!{StateTests_EIP158_EIP150_stEIPSpecificTest, "StateTests/EIP158/EIP150/stEIPSpecificTest"}
+declare_test!{StateTests_EIP158_EIP150_stEIPsingleCodeGasPrices, "StateTests/EIP158/EIP150/stEIPsingleCodeGasPrices"}
+declare_test!{StateTests_EIP158_EIP150_stChangedTests, "StateTests/EIP158/EIP150/stChangedTests"}
+
+declare_test!{StateTests_EIP158_Homestead_stBoundsTest, "StateTests/EIP158/Homestead/stBoundsTest"}
+declare_test!{StateTests_EIP158_Homestead_stCallCodes, "StateTests/EIP158/Homestead/stCallCodes"}
+declare_test!{StateTests_EIP158_Homestead_stCallCreateCallCodeTest, "StateTests/EIP158/Homestead/stCallCreateCallCodeTest"}
+declare_test!{StateTests_EIP158_Homestead_stCallDelegateCodes, "StateTests/EIP158/Homestead/stCallDelegateCodes"}
+declare_test!{StateTests_EIP158_Homestead_stCallDelegateCodesCallCode, "StateTests/EIP158/Homestead/stCallDelegateCodesCallCode"}
+declare_test!{StateTests_EIP158_Homestead_stDelegatecallTest, "StateTests/EIP158/Homestead/stDelegatecallTest"}
+declare_test!{StateTests_EIP158_Homestead_stHomeSteadSpecific, "StateTests/EIP158/Homestead/stHomeSteadSpecific"}
+declare_test!{StateTests_EIP158_Homestead_stInitCodeTest, "StateTests/EIP158/Homestead/stInitCodeTest"}
+declare_test!{StateTests_EIP158_Homestead_stLogTests, "StateTests/EIP158/Homestead/stLogTests"}
+declare_test!{heavy => StateTests_EIP158_Homestead_stMemoryTest, "StateTests/EIP158/Homestead/stMemoryTest"}
+declare_test!{StateTests_EIP158_Homestead_stPreCompiledContracts, "StateTests/EIP158/Homestead/stPreCompiledContracts"}
+declare_test!{heavy => StateTests_EIP158_Homestead_stQuadraticComplexityTest, "StateTests/EIP158/Homestead/stQuadraticComplexityTest"}
+declare_test!{StateTests_EIP158_Homestead_stRecursiveCreate, "StateTests/EIP158/Homestead/stRecursiveCreate"}
+declare_test!{StateTests_EIP158_Homestead_stRefundTest, "StateTests/EIP158/Homestead/stRefundTest"}
+declare_test!{StateTests_EIP158_Homestead_stSpecialTest, "StateTests/EIP158/Homestead/stSpecialTest"}
+declare_test!{StateTests_EIP158_Homestead_stSystemOperationsTest, "StateTests/EIP158/Homestead/stSystemOperationsTest"}
+declare_test!{StateTests_EIP158_Homestead_stTransactionTest, "StateTests/EIP158/Homestead/stTransactionTest"}
+declare_test!{StateTests_EIP158_Homestead_stWalletTest, "StateTests/EIP158/Homestead/stWalletTest"}

ethcore/src/json_tests/executive.rs

@@ -92,10 +92,18 @@ impl<'a, T, V> Ext for TestExt<'a, T, V> where T: Tracer, V: VMTracer {
 		self.ext.exists(address)
 	}
 
+	fn exists_and_not_null(&self, address: &Address) -> bool {
+		self.ext.exists_and_not_null(address)
+	}
+
 	fn balance(&self, address: &Address) -> U256 {
 		self.ext.balance(address)
 	}
 
+	fn origin_balance(&self) -> U256 {
+		self.ext.origin_balance()
+	}
+
 	fn blockhash(&self, number: &U256) -> H256 {
 		self.ext.blockhash(number)
 	}

ethcore/src/json_tests/mod.rs

@@ -24,4 +24,5 @@ mod chain;
 mod homestead_state;
 mod homestead_chain;
 mod eip150_state;
+mod eip161_state;
 mod trie;

ethcore/src/json_tests/state.rs

@@ -29,6 +29,7 @@ pub fn json_chain_test(json_data: &[u8], era: ChainEra) -> Vec<String> {
 		ChainEra::Frontier => ethereum::new_mainnet_like().engine,
 		ChainEra::Homestead => ethereum::new_homestead_test().engine,
 		ChainEra::Eip150 => ethereum::new_eip150_test().engine,
+		ChainEra::Eip161 => ethereum::new_eip161_test().engine,
 		ChainEra::TransitionTest => ethereum::new_transition_test().engine,
 	};
 

ethcore/src/json_tests/transaction.rs

@@ -35,17 +35,24 @@ fn do_json_test(json_data: &[u8]) -> Vec<String> {
 			Some(x) if x < 1_150_000 => &old_schedule,
 			Some(_) => &new_schedule
 		};
+		let allow_network_id_of_one = number.map_or(false, |n| n > 2600000); 
 
 		let rlp: Vec<u8> = test.rlp.into();
 		let res = UntrustedRlp::new(&rlp)
 			.as_val()
 			.map_err(From::from)
-			.and_then(|t: SignedTransaction| t.validate(schedule, schedule.have_delegate_call));
+			.and_then(|t: SignedTransaction| t.validate(schedule, schedule.have_delegate_call, allow_network_id_of_one));
 
 		fail_unless(test.transaction.is_none() == res.is_err());
 		if let (Some(tx), Some(sender)) = (test.transaction, test.sender) {
 			let t = res.unwrap();
 			fail_unless(t.sender().unwrap() == sender.into());
+			let is_acceptable_network_id = match t.network_id() {
+				None => true,
+				Some(1) if allow_network_id_of_one => true,
+				_ => false,
+			};
+			fail_unless(is_acceptable_network_id);
 			let data: Vec<u8> = tx.data.into();
 			fail_unless(t.data == data);
 			fail_unless(t.gas_price == tx.gas_price.into());

ethcore/src/miner/banning_queue.rs

@@ -245,7 +245,7 @@ mod tests {
 			gas: U256::from(100_000),
 			gas_price: U256::from(10),
 			nonce: U256::from(0),
-		}.sign(keypair.secret())
+		}.sign(keypair.secret(), None)
 	}
 
 	fn unwrap_err(res: Result<TransactionImportResult, Error>) -> TransactionError {

ethcore/src/miner/miner.rs

@@ -21,7 +21,7 @@ use util::*;
 use util::using_queue::{UsingQueue, GetAction};
 use account_provider::AccountProvider;
 use views::{BlockView, HeaderView};
-use state::State;
+use state::{State, CleanupMode};
 use client::{MiningBlockChainClient, Executive, Executed, EnvInfo, TransactOptions, BlockID, CallAnalytics};
 use executive::contract_address;
 use block::{ClosedBlock, SealedBlock, IsBlock, Block};
@@ -650,7 +650,7 @@ impl MinerService for Miner {
 				let needed_balance = t.value + t.gas * t.gas_price;
 				if balance < needed_balance {
 					// give the sender a sufficient balance
-					state.add_balance(&sender, &(needed_balance - balance));
+					state.add_balance(&sender, &(needed_balance - balance), CleanupMode::NoEmpty);
 				}
 				let options = TransactOptions { tracing: analytics.transaction_tracing, vm_tracing: analytics.vm_tracing, check_nonce: false };
 				let mut ret = try!(Executive::new(&mut state, &env_info, &*self.engine, chain.vm_factory()).transact(t, options));
@@ -935,6 +935,8 @@ impl MinerService for Miner {
 								}
 							},
 							logs: receipt.logs.clone(),
+							log_bloom: receipt.log_bloom,
+							state_root: receipt.state_root,
 						}
 					})
 			}
@@ -1173,7 +1175,7 @@ mod tests {
 			gas: U256::from(100_000),
 			gas_price: U256::zero(),
 			nonce: U256::zero(),
-		}.sign(keypair.secret())
+		}.sign(keypair.secret(), None)
 	}
 
 	#[test]

ethcore/src/miner/transaction_queue.rs

@@ -42,8 +42,8 @@
 //!		let t2 = Transaction { action: Action::Create, value: U256::from(100), data: "3331600055".from_hex().unwrap(),
 //!			gas: U256::from(100_000), gas_price: U256::one(), nonce: U256::from(11) };
 //!
-//!		let st1 = t1.sign(&key.secret());
-//!		let st2 = t2.sign(&key.secret());
+//!		let st1 = t1.sign(&key.secret(), None);
+//!		let st2 = t2.sign(&key.secret(), None);
 //!		let default_account_details = |_a: &Address| AccountDetails {
 //!			nonce: U256::from(10),
 //!			balance: U256::from(1_000_000),
@@ -1104,12 +1104,12 @@ mod test {
 
 	fn new_tx(nonce: U256, gas_price: U256) -> SignedTransaction {
 		let keypair = Random.generate().unwrap();
-		new_unsigned_tx(nonce, default_gas_val(), gas_price).sign(keypair.secret())
+		new_unsigned_tx(nonce, default_gas_val(), gas_price).sign(keypair.secret(), None)
 	}
 
 	fn new_tx_with_gas(gas: U256, gas_price: U256) -> SignedTransaction {
 		let keypair = Random.generate().unwrap();
-		new_unsigned_tx(default_nonce(), gas, gas_price).sign(keypair.secret())
+		new_unsigned_tx(default_nonce(), gas, gas_price).sign(keypair.secret(), None)
 	}
 
 	fn new_tx_default() -> SignedTransaction {
@@ -1133,7 +1133,7 @@ mod test {
 
 		let keypair = Random.generate().unwrap();
 		let secret = &keypair.secret();
-		(tx1.sign(secret), tx2.sign(secret))
+		(tx1.sign(secret, None), tx2.sign(secret, None))
 	}
 
 	/// Returns two consecutive transactions, both with increased gas price
@@ -1144,7 +1144,7 @@ mod test {
 
 		let keypair = Random.generate().unwrap();
 		let secret = &keypair.secret();
-		(tx1.sign(secret), tx2.sign(secret))
+		(tx1.sign(secret, None), tx2.sign(secret, None))
 	}
 
 	fn new_tx_pair_default(nonce_increment: U256, gas_price_increment: U256) -> (SignedTransaction, SignedTransaction) {
@@ -1798,9 +1798,9 @@ mod test {
 		let mut txq = TransactionQueue::default();
 		let kp = Random.generate().unwrap();
 		let secret = kp.secret();
-		let tx = new_unsigned_tx(123.into(), default_gas_val(), 1.into()).sign(secret);
-		let tx1 = new_unsigned_tx(124.into(), default_gas_val(), 1.into()).sign(secret);
-		let tx2 = new_unsigned_tx(125.into(), default_gas_val(), 1.into()).sign(secret);
+		let tx = new_unsigned_tx(123.into(), default_gas_val(), 1.into()).sign(secret, None);
+		let tx1 = new_unsigned_tx(124.into(), default_gas_val(), 1.into()).sign(secret, None);
+		let tx2 = new_unsigned_tx(125.into(), default_gas_val(), 1.into()).sign(secret, None);
 
 		txq.add(tx, TransactionOrigin::External, &default_account_details, &gas_estimator).unwrap();
 		assert_eq!(txq.status().pending, 1);
@@ -2038,11 +2038,11 @@ mod test {
 		// given
 		let mut txq = TransactionQueue::default();
 		let keypair = Random.generate().unwrap();
-		let tx = new_unsigned_tx(123.into(), default_gas_val(), 1.into()).sign(keypair.secret());
+		let tx = new_unsigned_tx(123.into(), default_gas_val(), 1.into()).sign(keypair.secret(), None);
 		let tx2 = {
 			let mut tx2 = (*tx).clone();
 			tx2.gas_price = U256::from(200);
-			tx2.sign(keypair.secret())
+			tx2.sign(keypair.secret(), None)
 		};
 
 		// when
@@ -2061,16 +2061,16 @@ mod test {
 		// given
 		let mut txq = TransactionQueue::default();
 		let keypair = Random.generate().unwrap();
-		let tx0 = new_unsigned_tx(123.into(), default_gas_val(), 1.into()).sign(keypair.secret());
+		let tx0 = new_unsigned_tx(123.into(), default_gas_val(), 1.into()).sign(keypair.secret(), None);
 		let tx1 = {
 			let mut tx1 = (*tx0).clone();
 			tx1.nonce = U256::from(124);
-			tx1.sign(keypair.secret())
+			tx1.sign(keypair.secret(), None)
 		};
 		let tx2 = {
 			let mut tx2 = (*tx1).clone();
 			tx2.gas_price = U256::from(200);
-			tx2.sign(keypair.secret())
+			tx2.sign(keypair.secret(), None)
 		};
 
 		// when
@@ -2223,7 +2223,7 @@ mod test {
 			let tx3 = new_unsigned_tx(nonce + 2.into(), gas, 1.into());
 
 
-			(tx.sign(secret), tx2.sign(secret), tx2_2.sign(secret), tx3.sign(secret))
+			(tx.sign(secret, None), tx2.sign(secret, None), tx2_2.sign(secret, None), tx3.sign(secret, None))
 		};
 		let sender = tx1.sender().unwrap();
 		txq.add(tx1, TransactionOrigin::Local, &default_account_details, &gas_estimator).unwrap();

ethcore/src/spec/spec.rs

@@ -38,7 +38,7 @@ pub struct CommonParams {
 	/// Maximum size of extra data.
 	pub maximum_extra_data_size: usize,
 	/// Network id.
-	pub network_id: U256,
+	pub network_id: usize,
 	/// Main subprotocol name.
 	pub subprotocol_name: String,
 	/// Minimum gas limit.
@@ -160,7 +160,7 @@ impl Spec {
 	pub fn nodes(&self) -> &[String] { &self.nodes }
 
 	/// Get the configured Network ID.
-	pub fn network_id(&self) -> U256 { self.params.network_id }
+	pub fn network_id(&self) -> usize { self.params.network_id }
 
 	/// Get the configured Network ID.
 	pub fn subprotocol_name(&self) -> String { self.params.subprotocol_name.clone() }
@@ -250,7 +250,7 @@ impl Spec {
 			}
 			trace!(target: "spec", "ensure_db_good: Populated sec trie; root is {}", root);
 			for (address, account) in self.genesis_state.get().iter() {
-				db.note_account_bloom(address);
+				db.note_non_null_account(address);
 				account.insert_additional(&mut AccountDBMut::new(db.as_hashdb_mut(), address));
 			}
 			assert!(db.as_hashdb().contains(&self.state_root()));

ethcore/src/state/account.rs

@@ -300,11 +300,17 @@ impl Account {
 	pub fn storage_is_clean(&self) -> bool { self.storage_changes.is_empty() }
 
 	/// Check if account has zero nonce, balance, no code and no storage.
+	///
+	/// NOTE: Will panic if `!self.storage_is_clean()`
 	pub fn is_empty(&self) -> bool {
-		self.storage_changes.is_empty() &&
+		assert!(self.storage_is_clean(), "Account::is_empty() may only legally be called when storage is clean.");
+		self.is_null() && self.storage_root == SHA3_NULL_RLP
+	}
+
+	/// Check if account has zero nonce, balance, no code.
+	pub fn is_null(&self) -> bool {
 		self.balance.is_zero() &&
 		self.nonce.is_zero() &&
-		self.storage_root == SHA3_NULL_RLP &&
 		self.code_hash == SHA3_EMPTY
 	}
 

ethcore/src/state/mod.rs

@@ -199,6 +199,13 @@ enum RequireCache {
 	Code,
 }
 
+#[derive(PartialEq)]
+pub enum CleanupMode<'a> {
+	ForceCreate,
+	NoEmpty,
+	KillEmpty(&'a mut HashSet<Address>),
+}
+
 const SEC_TRIE_DB_UNWRAP_STR: &'static str = "A state can only be created with valid root. Creating a SecTrieDB with a valid root will not fail. \
 			 Therefore creating a SecTrieDB with this state's root will not fail.";
 
@@ -329,8 +336,8 @@ impl State {
 
 	/// Create a new contract at address `contract`. If there is already an account at the address
 	/// it will have its code reset, ready for `init_code()`.
-	pub fn new_contract(&mut self, contract: &Address, balance: U256) {
-		self.insert_cache(contract, AccountEntry::new_dirty(Some(Account::new_contract(balance, self.account_start_nonce))));
+	pub fn new_contract(&mut self, contract: &Address, balance: U256, nonce_offset: U256) {
+		self.insert_cache(contract, AccountEntry::new_dirty(Some(Account::new_contract(balance, self.account_start_nonce + nonce_offset))));
 	}
 
 	/// Remove an existing account.
@@ -341,10 +348,15 @@ impl State {
 	/// Determine whether an account exists.
 	pub fn exists(&self, a: &Address) -> bool {
 		// Bloom filter does not contain empty accounts, so it is important here to
-		// check if account exists in the database directly before EIP-158 is in effect.
+		// check if account exists in the database directly before EIP-161 is in effect.
 		self.ensure_cached(a, RequireCache::None, false, |a| a.is_some())
 	}
 
+	/// Determine whether an account exists and if not empty.
+	pub fn exists_and_not_null(&self, a: &Address) -> bool {
+		self.ensure_cached(a, RequireCache::None, false, |a| a.map_or(false, |a| !a.is_null()))
+	}
+
 	/// Get the balance of account `a`.
 	pub fn balance(&self, a: &Address) -> U256 {
 		self.ensure_cached(a, RequireCache::None, true,
@@ -399,7 +411,7 @@ impl State {
 		}
 
 		// check bloom before any requests to trie
-		if !self.db.check_account_bloom(address) { return H256::zero() }
+		if !self.db.check_non_null_bloom(address) { return H256::zero() }
 
 		// account is not found in the global cache, get from the DB and insert into local
 		let db = self.factories.trie.readonly(self.db.as_hashdb(), &self.root).expect(SEC_TRIE_DB_UNWRAP_STR);
@@ -433,10 +445,18 @@ impl State {
 	}
 
 	/// Add `incr` to the balance of account `a`.
-	pub fn add_balance(&mut self, a: &Address, incr: &U256) {
+	pub fn add_balance(&mut self, a: &Address, incr: &U256, cleanup_mode: CleanupMode) {
 		trace!(target: "state", "add_balance({}, {}): {}", a, incr, self.balance(a));
-		if !incr.is_zero() || !self.exists(a) {
+		let is_value_transfer = !incr.is_zero();
+		if is_value_transfer || (cleanup_mode == CleanupMode::ForceCreate && !self.exists(a)) {
 			self.require(a, false).add_balance(incr);
+		} else {
+			match cleanup_mode {
+				CleanupMode::KillEmpty(set) => if !is_value_transfer && self.exists(a) && !self.exists_and_not_null(a) {
+					set.insert(a.clone());
+				},
+				_ => {}
+			}
 		}
 	}
 
@@ -449,9 +469,9 @@ impl State {
 	}
 
 	/// Subtracts `by` from the balance of `from` and adds it to that of `to`.
-	pub fn transfer_balance(&mut self, from: &Address, to: &Address, by: &U256) {
+	pub fn transfer_balance(&mut self, from: &Address, to: &Address, by: &U256, cleanup_mode: CleanupMode) {
 		self.sub_balance(from, by);
-		self.add_balance(to, by);
+		self.add_balance(to, by, cleanup_mode);
 	}
 
 	/// Increment the nonce of account `a` by 1.
@@ -507,13 +527,15 @@ impl State {
 		// first, commit the sub trees.
 		for (address, ref mut a) in accounts.iter_mut().filter(|&(_, ref a)| a.is_dirty()) {
 			if let Some(ref mut account) = a.account {
-				if !account.is_empty() {
-					db.note_account_bloom(address);
-				}
 				let addr_hash = account.address_hash(address);
-				let mut account_db = factories.accountdb.create(db.as_hashdb_mut(), addr_hash);
-				account.commit_storage(&factories.trie, account_db.as_hashdb_mut());
-				account.commit_code(account_db.as_hashdb_mut());
+				{
+					let mut account_db = factories.accountdb.create(db.as_hashdb_mut(), addr_hash);
+					account.commit_storage(&factories.trie, account_db.as_hashdb_mut());
+					account.commit_code(account_db.as_hashdb_mut());
+				}
+				if !account.is_empty() {
+					db.note_non_null_account(address);
+				}
 			}
 		}
 
@@ -653,7 +675,7 @@ impl State {
 			Some(r) => r,
 			None => {
 				// first check bloom if it is not in database for sure
-				if check_bloom && !self.db.check_account_bloom(a) { return f(None); }
+				if check_bloom && !self.db.check_non_null_bloom(a) { return f(None); }
 
 				// not found in the global cache, get from the DB and insert into local
 				let db = self.factories.trie.readonly(self.db.as_hashdb(), &self.root).expect(SEC_TRIE_DB_UNWRAP_STR);
@@ -687,7 +709,7 @@ impl State {
 			match self.db.get_cached_account(a) {
 				Some(acc) => self.insert_cache(a, AccountEntry::new_clean_cached(acc)),
 				None => {
-					let maybe_acc = if self.db.check_account_bloom(a) {
+					let maybe_acc = if self.db.check_non_null_bloom(a) {
 						let db = self.factories.trie.readonly(self.db.as_hashdb(), &self.root).expect(SEC_TRIE_DB_UNWRAP_STR);
 						match db.get(a) {
 							Ok(Some(acc)) => AccountEntry::new_clean(Some(Account::from_rlp(&acc))),
@@ -793,9 +815,9 @@ fn should_apply_create_transaction() {
 		action: Action::Create,
 		value: 100.into(),
 		data: FromHex::from_hex("601080600c6000396000f3006000355415600957005b60203560003555").unwrap(),
-	}.sign(&"".sha3());
+	}.sign(&"".sha3(), None);
 
-	state.add_balance(t.sender().as_ref().unwrap(), &(100.into()));
+	state.add_balance(t.sender().as_ref().unwrap(), &(100.into()), CleanupMode::NoEmpty);
 	let result = state.apply(&info, &engine, &t, true).unwrap();
 	let expected_trace = vec![FlatTrace {
 		trace_address: Default::default(),
@@ -853,9 +875,9 @@ fn should_trace_failed_create_transaction() {
 		action: Action::Create,
 		value: 100.into(),
 		data: FromHex::from_hex("5b600056").unwrap(),
-	}.sign(&"".sha3());
+	}.sign(&"".sha3(), None);
 
-	state.add_balance(t.sender().as_ref().unwrap(), &(100.into()));
+	state.add_balance(t.sender().as_ref().unwrap(), &(100.into()), CleanupMode::NoEmpty);
 	let result = state.apply(&info, &engine, &t, true).unwrap();
 	let expected_trace = vec![FlatTrace {
 		trace_address: Default::default(),
@@ -890,10 +912,10 @@ fn should_trace_call_transaction() {
 		action: Action::Call(0xa.into()),
 		value: 100.into(),
 		data: vec![],
-	}.sign(&"".sha3());
+	}.sign(&"".sha3(), None);
 
 	state.init_code(&0xa.into(), FromHex::from_hex("6000").unwrap());
-	state.add_balance(t.sender().as_ref().unwrap(), &(100.into()));
+	state.add_balance(t.sender().as_ref().unwrap(), &(100.into()), CleanupMode::NoEmpty);
 	let result = state.apply(&info, &engine, &t, true).unwrap();
 	let expected_trace = vec![FlatTrace {
 		trace_address: Default::default(),
@@ -933,9 +955,9 @@ fn should_trace_basic_call_transaction() {
 		action: Action::Call(0xa.into()),
 		value: 100.into(),
 		data: vec![],
-	}.sign(&"".sha3());
+	}.sign(&"".sha3(), None);
 
-	state.add_balance(t.sender().as_ref().unwrap(), &(100.into()));
+	state.add_balance(t.sender().as_ref().unwrap(), &(100.into()), CleanupMode::NoEmpty);
 	let result = state.apply(&info, &engine, &t, true).unwrap();
 	let expected_trace = vec![FlatTrace {
 		trace_address: Default::default(),
@@ -975,7 +997,7 @@ fn should_trace_call_transaction_to_builtin() {
 		action: Action::Call(0x1.into()),
 		value: 0.into(),
 		data: vec![],
-	}.sign(&"".sha3());
+	}.sign(&"".sha3(), None);
 
 	let result = state.apply(&info, engine, &t, true).unwrap();
 
@@ -1017,7 +1039,7 @@ fn should_not_trace_subcall_transaction_to_builtin() {
 		action: Action::Call(0xa.into()),
 		value: 0.into(),
 		data: vec![],
-	}.sign(&"".sha3());
+	}.sign(&"".sha3(), None);
 
 	state.init_code(&0xa.into(), FromHex::from_hex("600060006000600060006001610be0f1").unwrap());
 	let result = state.apply(&info, engine, &t, true).unwrap();
@@ -1060,7 +1082,7 @@ fn should_not_trace_callcode() {
 		action: Action::Call(0xa.into()),
 		value: 0.into(),
 		data: vec![],
-	}.sign(&"".sha3());
+	}.sign(&"".sha3(), None);
 
 	state.init_code(&0xa.into(), FromHex::from_hex("60006000600060006000600b611000f2").unwrap());
 	state.init_code(&0xb.into(), FromHex::from_hex("6000").unwrap());
@@ -1122,7 +1144,7 @@ fn should_not_trace_delegatecall() {
 		action: Action::Call(0xa.into()),
 		value: 0.into(),
 		data: vec![],
-	}.sign(&"".sha3());
+	}.sign(&"".sha3(), None);
 
 	state.init_code(&0xa.into(), FromHex::from_hex("6000600060006000600b618000f4").unwrap());
 	state.init_code(&0xb.into(), FromHex::from_hex("6000").unwrap());
@@ -1181,10 +1203,10 @@ fn should_trace_failed_call_transaction() {
 		action: Action::Call(0xa.into()),
 		value: 100.into(),
 		data: vec![],
-	}.sign(&"".sha3());
+	}.sign(&"".sha3(), None);
 
 	state.init_code(&0xa.into(), FromHex::from_hex("5b600056").unwrap());
-	state.add_balance(t.sender().as_ref().unwrap(), &(100.into()));
+	state.add_balance(t.sender().as_ref().unwrap(), &(100.into()), CleanupMode::NoEmpty);
 	let result = state.apply(&info, &engine, &t, true).unwrap();
 	let expected_trace = vec![FlatTrace {
 		trace_address: Default::default(),
@@ -1221,11 +1243,11 @@ fn should_trace_call_with_subcall_transaction() {
 		action: Action::Call(0xa.into()),
 		value: 100.into(),
 		data: vec![],
-	}.sign(&"".sha3());
+	}.sign(&"".sha3(), None);
 
 	state.init_code(&0xa.into(), FromHex::from_hex("60006000600060006000600b602b5a03f1").unwrap());
 	state.init_code(&0xb.into(), FromHex::from_hex("6000").unwrap());
-	state.add_balance(t.sender().as_ref().unwrap(), &(100.into()));
+	state.add_balance(t.sender().as_ref().unwrap(), &(100.into()), CleanupMode::NoEmpty);
 	let result = state.apply(&info, &engine, &t, true).unwrap();
 
 	let expected_trace = vec![FlatTrace {
@@ -1281,10 +1303,10 @@ fn should_trace_call_with_basic_subcall_transaction() {
 		action: Action::Call(0xa.into()),
 		value: 100.into(),
 		data: vec![],
-	}.sign(&"".sha3());
+	}.sign(&"".sha3(), None);
 
 	state.init_code(&0xa.into(), FromHex::from_hex("60006000600060006045600b6000f1").unwrap());
-	state.add_balance(t.sender().as_ref().unwrap(), &(100.into()));
+	state.add_balance(t.sender().as_ref().unwrap(), &(100.into()), CleanupMode::NoEmpty);
 	let result = state.apply(&info, &engine, &t, true).unwrap();
 	let expected_trace = vec![FlatTrace {
 		trace_address: Default::default(),
@@ -1336,10 +1358,10 @@ fn should_not_trace_call_with_invalid_basic_subcall_transaction() {
 		action: Action::Call(0xa.into()),
 		value: 100.into(),
 		data: vec![],
-	}.sign(&"".sha3());
+	}.sign(&"".sha3(), None);
 
 	state.init_code(&0xa.into(), FromHex::from_hex("600060006000600060ff600b6000f1").unwrap());	// not enough funds.
-	state.add_balance(t.sender().as_ref().unwrap(), &(100.into()));
+	state.add_balance(t.sender().as_ref().unwrap(), &(100.into()), CleanupMode::NoEmpty);
 	let result = state.apply(&info, &engine, &t, true).unwrap();
 	let expected_trace = vec![FlatTrace {
 		trace_address: Default::default(),
@@ -1379,11 +1401,11 @@ fn should_trace_failed_subcall_transaction() {
 		action: Action::Call(0xa.into()),
 		value: 100.into(),
 		data: vec![],//600480600b6000396000f35b600056
-	}.sign(&"".sha3());
+	}.sign(&"".sha3(), None);
 
 	state.init_code(&0xa.into(), FromHex::from_hex("60006000600060006000600b602b5a03f1").unwrap());
 	state.init_code(&0xb.into(), FromHex::from_hex("5b600056").unwrap());
-	state.add_balance(t.sender().as_ref().unwrap(), &(100.into()));
+	state.add_balance(t.sender().as_ref().unwrap(), &(100.into()), CleanupMode::NoEmpty);
 	let result = state.apply(&info, &engine, &t, true).unwrap();
 	let expected_trace = vec![FlatTrace {
 		trace_address: Default::default(),
@@ -1435,12 +1457,12 @@ fn should_trace_call_with_subcall_with_subcall_transaction() {
 		action: Action::Call(0xa.into()),
 		value: 100.into(),
 		data: vec![],
-	}.sign(&"".sha3());
+	}.sign(&"".sha3(), None);
 
 	state.init_code(&0xa.into(), FromHex::from_hex("60006000600060006000600b602b5a03f1").unwrap());
 	state.init_code(&0xb.into(), FromHex::from_hex("60006000600060006000600c602b5a03f1").unwrap());
 	state.init_code(&0xc.into(), FromHex::from_hex("6000").unwrap());
-	state.add_balance(t.sender().as_ref().unwrap(), &(100.into()));
+	state.add_balance(t.sender().as_ref().unwrap(), &(100.into()), CleanupMode::NoEmpty);
 	let result = state.apply(&info, &engine, &t, true).unwrap();
 	let expected_trace = vec![FlatTrace {
 		trace_address: Default::default(),
@@ -1510,12 +1532,12 @@ fn should_trace_failed_subcall_with_subcall_transaction() {
 		action: Action::Call(0xa.into()),
 		value: 100.into(),
 		data: vec![],//600480600b6000396000f35b600056
-	}.sign(&"".sha3());
+	}.sign(&"".sha3(), None);
 
 	state.init_code(&0xa.into(), FromHex::from_hex("60006000600060006000600b602b5a03f1").unwrap());
 	state.init_code(&0xb.into(), FromHex::from_hex("60006000600060006000600c602b5a03f1505b601256").unwrap());
 	state.init_code(&0xc.into(), FromHex::from_hex("6000").unwrap());
-	state.add_balance(t.sender().as_ref().unwrap(), &(100.into()));
+	state.add_balance(t.sender().as_ref().unwrap(), &(100.into()), CleanupMode::NoEmpty);
 	let result = state.apply(&info, &engine, &t, true).unwrap();
 
 	let expected_trace = vec![FlatTrace {
@@ -1583,11 +1605,11 @@ fn should_trace_suicide() {
 		action: Action::Call(0xa.into()),
 		value: 100.into(),
 		data: vec![],
-	}.sign(&"".sha3());
+	}.sign(&"".sha3(), None);
 
 	state.init_code(&0xa.into(), FromHex::from_hex("73000000000000000000000000000000000000000bff").unwrap());
-	state.add_balance(&0xa.into(), &50.into());
-	state.add_balance(t.sender().as_ref().unwrap(), &100.into());
+	state.add_balance(&0xa.into(), &50.into(), CleanupMode::NoEmpty);
+	state.add_balance(t.sender().as_ref().unwrap(), &100.into(), CleanupMode::NoEmpty);
 	let result = state.apply(&info, &engine, &t, true).unwrap();
 	let expected_trace = vec![FlatTrace {
 		trace_address: Default::default(),
@@ -1658,7 +1680,7 @@ fn get_from_database() {
 	let (root, db) = {
 		let mut state = get_temp_state_in(temp.as_path());
 		state.inc_nonce(&a);
-		state.add_balance(&a, &U256::from(69u64));
+		state.add_balance(&a, &U256::from(69u64), CleanupMode::NoEmpty);
 		state.commit().unwrap();
 		assert_eq!(state.balance(&a), U256::from(69u64));
 		state.drop()
@@ -1675,27 +1697,47 @@ fn remove() {
 	let mut state_result = get_temp_state();
 	let mut state = state_result.reference_mut();
 	assert_eq!(state.exists(&a), false);
+	assert_eq!(state.exists_and_not_null(&a), false);
 	state.inc_nonce(&a);
 	assert_eq!(state.exists(&a), true);
+	assert_eq!(state.exists_and_not_null(&a), true);
 	assert_eq!(state.nonce(&a), U256::from(1u64));
 	state.kill_account(&a);
 	assert_eq!(state.exists(&a), false);
+	assert_eq!(state.exists_and_not_null(&a), false);
 	assert_eq!(state.nonce(&a), U256::from(0u64));
 }
 
 #[test]
-fn empty_account_exists() {
+fn empty_account_is_not_created() {
 	let a = Address::zero();
 	let path = RandomTempPath::new();
 	let db = get_temp_state_db_in(path.as_path());
 	let (root, db) = {
 		let mut state = State::new(db, U256::from(0), Default::default());
-		state.add_balance(&a, &U256::default()); // create an empty account
+		state.add_balance(&a, &U256::default(), CleanupMode::NoEmpty); // create an empty account
+		state.commit().unwrap();
+		state.drop()
+	};
+	let state = State::from_existing(db, root, U256::from(0u8), Default::default()).unwrap();
+	assert!(!state.exists(&a));
+	assert!(!state.exists_and_not_null(&a));
+}
+
+#[test]
+fn empty_account_exists_when_creation_forced() {
+	let a = Address::zero();
+	let path = RandomTempPath::new();
+	let db = get_temp_state_db_in(path.as_path());
+	let (root, db) = {
+		let mut state = State::new(db, U256::from(0), Default::default());
+		state.add_balance(&a, &U256::default(), CleanupMode::ForceCreate); // create an empty account
 		state.commit().unwrap();
 		state.drop()
 	};
 	let state = State::from_existing(db, root, U256::from(0u8), Default::default()).unwrap();
 	assert!(state.exists(&a));
+	assert!(!state.exists_and_not_null(&a));
 }
 
 #[test]
@@ -1733,7 +1775,7 @@ fn alter_balance() {
 	let mut state = state_result.reference_mut();
 	let a = Address::zero();
 	let b = 1u64.into();
-	state.add_balance(&a, &U256::from(69u64));
+	state.add_balance(&a, &U256::from(69u64), CleanupMode::NoEmpty);
 	assert_eq!(state.balance(&a), U256::from(69u64));
 	state.commit().unwrap();
 	assert_eq!(state.balance(&a), U256::from(69u64));
@@ -1741,7 +1783,7 @@ fn alter_balance() {
 	assert_eq!(state.balance(&a), U256::from(27u64));
 	state.commit().unwrap();
 	assert_eq!(state.balance(&a), U256::from(27u64));
-	state.transfer_balance(&a, &b, &U256::from(18u64));
+	state.transfer_balance(&a, &b, &U256::from(18u64), CleanupMode::NoEmpty);
 	assert_eq!(state.balance(&a), U256::from(9u64));
 	assert_eq!(state.balance(&b), U256::from(18u64));
 	state.commit().unwrap();
@@ -1794,12 +1836,12 @@ fn checkpoint_basic() {
 	let mut state = state_result.reference_mut();
 	let a = Address::zero();
 	state.checkpoint();
-	state.add_balance(&a, &U256::from(69u64));
+	state.add_balance(&a, &U256::from(69u64), CleanupMode::NoEmpty);
 	assert_eq!(state.balance(&a), U256::from(69u64));
 	state.discard_checkpoint();
 	assert_eq!(state.balance(&a), U256::from(69u64));
 	state.checkpoint();
-	state.add_balance(&a, &U256::from(1u64));
+	state.add_balance(&a, &U256::from(1u64), CleanupMode::NoEmpty);
 	assert_eq!(state.balance(&a), U256::from(70u64));
 	state.revert_to_checkpoint();
 	assert_eq!(state.balance(&a), U256::from(69u64));
@@ -1812,7 +1854,7 @@ fn checkpoint_nested() {
 	let a = Address::zero();
 	state.checkpoint();
 	state.checkpoint();
-	state.add_balance(&a, &U256::from(69u64));
+	state.add_balance(&a, &U256::from(69u64), CleanupMode::NoEmpty);
 	assert_eq!(state.balance(&a), U256::from(69u64));
 	state.discard_checkpoint();
 	assert_eq!(state.balance(&a), U256::from(69u64));
@@ -1835,7 +1877,7 @@ fn should_not_panic_on_state_diff_with_storage() {
 
 	let a: Address = 0xa.into();
 	state.init_code(&a, b"abcdefg".to_vec());
-	state.add_balance(&a, &256.into());
+	state.add_balance(&a, &256.into(), CleanupMode::NoEmpty);
 	state.set_storage(&a, 0xb.into(), 0xc.into());
 
 	let mut new_state = state.clone();

ethcore/src/state/substate.rs

@@ -18,6 +18,8 @@
 use std::collections::HashSet;
 use util::{Address, U256};
 use log_entry::LogEntry;
+use evm::Schedule;
+use super::CleanupMode;
 
 /// State changes which should be applied in finalize,
 /// after transaction is fully executed.
@@ -26,6 +28,9 @@ pub struct Substate {
 	/// Any accounts that have suicided.
 	pub suicides: HashSet<Address>,
 
+	/// Any accounts that are tagged for garbage collection.
+	pub garbage: HashSet<Address>,
+
 	/// Any logs.
 	pub logs: Vec<LogEntry>,
 
@@ -45,10 +50,20 @@ impl Substate {
 	/// Merge secondary substate `s` into self, accruing each element correspondingly.
 	pub fn accrue(&mut self, s: Substate) {
 		self.suicides.extend(s.suicides.into_iter());
+		self.garbage.extend(s.garbage.into_iter());
 		self.logs.extend(s.logs.into_iter());
 		self.sstore_clears_count = self.sstore_clears_count + s.sstore_clears_count;
 		self.contracts_created.extend(s.contracts_created.into_iter());
 	}
+
+	/// Get the cleanup mode object from this.
+	pub fn to_cleanup_mode(&mut self, schedule: &Schedule) -> CleanupMode {
+		match (schedule.no_empty, schedule.kill_empty) {
+			(false, _) => CleanupMode::ForceCreate,
+			(true, false) => CleanupMode::NoEmpty,
+			(true, true) => CleanupMode::KillEmpty(&mut self.garbage),
+		}
+	}
 }
 
 #[cfg(test)]

ethcore/src/state_db.rs

@@ -165,13 +165,13 @@ impl StateDB {
 		bloom
 	}
 
-	pub fn check_account_bloom(&self, address: &Address) -> bool {
+	pub fn check_non_null_bloom(&self, address: &Address) -> bool {
 		trace!(target: "account_bloom", "Check account bloom: {:?}", address);
 		let bloom = self.account_bloom.lock();
 		bloom.check(&*address.sha3())
 	}
 
-	pub fn note_account_bloom(&self, address: &Address) {
+	pub fn note_non_null_account(&self, address: &Address) {
 		trace!(target: "account_bloom", "Note account bloom: {:?}", address);
 		let mut bloom = self.account_bloom.lock();
 		bloom.set(&*address.sha3());

ethcore/src/tests/client.rs

@@ -16,6 +16,7 @@
 
 use io::IoChannel;
 use client::{BlockChainClient, MiningBlockChainClient, Client, ClientConfig, BlockID};
+use state::CleanupMode;
 use ethereum;
 use block::IsBlock;
 use tests::helpers::*;
@@ -217,7 +218,7 @@ fn can_generate_gas_price_histogram() {
 	let client = client_result.reference();
 
 	let hist = client.gas_price_histogram(20, 5).unwrap();
-	let correct_hist = Histogram { bucket_bounds: vec_into![643,2293,3943,5593,7243,8893], counts: vec![4,2,4,6,3] };
+	let correct_hist = Histogram { bucket_bounds: vec_into![643, 2294, 3945, 5596, 7247, 8898], counts: vec![4,2,4,6,4] };
 	assert_eq!(hist, correct_hist);
 }
 
@@ -272,7 +273,7 @@ fn change_history_size() {
 		let client = Client::new(ClientConfig::default(), &test_spec, dir.as_path(), Arc::new(Miner::with_spec(&test_spec)), IoChannel::disconnected(), &db_config).unwrap();
 		for _ in 0..20 {
 			let mut b = client.prepare_open_block(Address::default(), (3141562.into(), 31415620.into()), vec![]);
-			b.block_mut().fields_mut().state.add_balance(&address, &5.into());
+			b.block_mut().fields_mut().state.add_balance(&address, &5.into(), CleanupMode::NoEmpty);
 			b.block_mut().fields_mut().state.commit().unwrap();
 			let b = b.close_and_lock().seal(&*test_spec.engine, vec![]).unwrap();
 			client.import_sealed_block(b).unwrap(); // account change is in the journal overlay

ethcore/src/tests/helpers.rs

@@ -28,6 +28,7 @@ use evm::Schedule;
 use engines::Engine;
 use env_info::EnvInfo;
 use ethereum;
+use ethereum::ethash::EthashParams;
 use devtools::*;
 use miner::Miner;
 use header::Header;
@@ -40,6 +41,7 @@ pub enum ChainEra {
 	Frontier,
 	Homestead,
 	Eip150,
+	Eip161,
 	TransitionTest,
 }
 
@@ -194,7 +196,7 @@ pub fn generate_dummy_client_with_spec_and_data<F>(get_test_spec: F, block_numbe
 				action: Action::Create,
 				data: vec![],
 				value: U256::zero(),
-			}.sign(kp.secret()), None).unwrap();
+			}.sign(kp.secret(), None), None).unwrap();
 			n += 1;
 		}
 
@@ -420,3 +422,29 @@ pub fn get_bad_state_dummy_block() -> Bytes {
 
 	create_test_block(&block_header)
 }
+
+pub fn get_default_ethash_params() -> EthashParams{
+	EthashParams {
+		gas_limit_bound_divisor: U256::from(1024),
+		minimum_difficulty: U256::from(131072),
+		difficulty_bound_divisor: U256::from(2048),
+		difficulty_increment_divisor: 10,
+		duration_limit: 13,
+		block_reward: U256::from(0),
+		registrar: "0000000000000000000000000000000000000001".into(),
+		homestead_transition: 1150000,
+		dao_hardfork_transition: 0x7fffffffffffffff,
+		dao_hardfork_beneficiary: "0000000000000000000000000000000000000001".into(),
+		dao_hardfork_accounts: vec![],
+		difficulty_hardfork_transition: 0x7fffffffffffffff,
+		difficulty_hardfork_bound_divisor: U256::from(0),
+		bomb_defuse_transition: 0x7fffffffffffffff,
+		eip150_transition: 0x7fffffffffffffff,
+		eip155_transition: 0x7fffffffffffffff,
+		eip160_transition: 0x7fffffffffffffff,
+		eip161abc_transition: 0x7fffffffffffffff,
+		eip161d_transition: 0x7fffffffffffffff,
+		ecip1010_pause_transition: 0x7fffffffffffffff,
+		ecip1010_continue_transition: 0x7fffffffffffffff
+	}
+}

ethcore/src/types/ids.rs

@@ -55,7 +55,7 @@ pub struct TraceId {
 }
 
 /// Uniquely identifies Uncle.
-#[derive(Debug, Binary)]
+#[derive(Debug, PartialEq, Eq, Copy, Clone, Binary)]
 pub struct UncleID {
 	/// Block id.
 	pub block: BlockID,

ethcore/src/types/mode.rs

@@ -20,7 +20,7 @@ pub use std::time::Duration;
 use client::Mode as ClientMode;
 
 /// IPC-capable shadow-type for client::config::Mode
-#[derive(Clone, Binary)]
+#[derive(Clone, Binary, Debug)]
 pub enum Mode {
 	/// Same as ClientMode::Off.
 	Off,

ethcore/src/types/receipt.rs

@@ -93,6 +93,10 @@ pub struct RichReceipt {
 	pub contract_address: Option<Address>,
 	/// Logs
 	pub logs: Vec<LogEntry>,
+	/// Logs bloom
+	pub log_bloom: LogBloom,
+	/// State root
+	pub state_root: H256,
 }
 
 /// Receipt with additional info.
@@ -114,6 +118,10 @@ pub struct LocalizedReceipt {
 	pub contract_address: Option<Address>,
 	/// Logs
 	pub logs: Vec<LocalizedLogEntry>,
+	/// Logs bloom
+	pub log_bloom: LogBloom,
+	/// State root
+	pub state_root: H256,
 }
 
 #[test]

ethcore/src/types/transaction.rs

@@ -72,8 +72,8 @@ pub struct Transaction {
 
 impl Transaction {
 	/// Append object with a without signature into RLP stream
-	pub fn rlp_append_unsigned_transaction(&self, s: &mut RlpStream) {
-		s.begin_list(6);
+	pub fn rlp_append_unsigned_transaction(&self, s: &mut RlpStream, network_id: Option<u8>) {
+		s.begin_list(if let None = network_id { 6 } else { 9 });
 		s.append(&self.nonce);
 		s.append(&self.gas_price);
 		s.append(&self.gas);
@@ -83,6 +83,11 @@ impl Transaction {
 		};
 		s.append(&self.value);
 		s.append(&self.data);
+		if let Some(n) = network_id {
+			s.append(&n);
+			s.append(&0u8);
+			s.append(&0u8);
+		}
 	}
 }
 
@@ -105,7 +110,7 @@ impl From<ethjson::state::Transaction> for SignedTransaction {
 			},
 			value: t.value.into(),
 			data: t.data.into(),
-		}.sign(&t.secret.into())
+		}.sign(&t.secret.into(), None)
 	}
 }
 
@@ -135,26 +140,26 @@ impl From<ethjson::transaction::Transaction> for SignedTransaction {
 
 impl Transaction {
 	/// The message hash of the transaction.
-	pub fn hash(&self) -> H256 {
+	pub fn hash(&self, network_id: Option<u8>) -> H256 {
 		let mut stream = RlpStream::new();
-		self.rlp_append_unsigned_transaction(&mut stream);
+		self.rlp_append_unsigned_transaction(&mut stream, network_id);
 		stream.out().sha3()
 	}
 
 	/// Signs the transaction as coming from `sender`.
-	pub fn sign(self, secret: &Secret) -> SignedTransaction {
-		let sig = ::ethkey::sign(secret, &self.hash())
+	pub fn sign(self, secret: &Secret, network_id: Option<u8>) -> SignedTransaction {
+		let sig = ::ethkey::sign(secret, &self.hash(network_id))
 			.expect("data is valid and context has signing capabilities; qed");
-		self.with_signature(sig)
+		self.with_signature(sig, network_id)
 	}
 
 	/// Signs the transaction with signature.
-	pub fn with_signature(self, sig: Signature) -> SignedTransaction {
+	pub fn with_signature(self, sig: Signature, network_id: Option<u8>) -> SignedTransaction {
 		SignedTransaction {
 			unsigned: self,
 			r: sig.r().into(),
 			s: sig.s().into(),
-			v: sig.v() + 27,
+			v: sig.v() + if let Some(n) = network_id { 35 + n * 2 } else { 27 },
 			hash: Cell::new(None),
 			sender: Cell::new(None),
 		}
@@ -204,7 +209,8 @@ impl Transaction {
 pub struct SignedTransaction {
 	/// Plain Transaction.
 	unsigned: Transaction,
-	/// The V field of the signature, either 27 or 28; helps describe the point on the curve.
+	/// The V field of the signature; the LS bit described which half of the curve our point falls
+	/// in. The MS bits describe which network this transaction is for. If 27/28, its for all networks.  
 	v: u8,
 	/// The R field of the signature; helps describe the point on the curve.
 	r: U256,
@@ -266,7 +272,7 @@ impl HeapSizeOf for SignedTransaction {
 
 impl SignedTransaction {
 	/// Append object with a signature into RLP stream
-	pub fn rlp_append_sealed_transaction(&self, s: &mut RlpStream) {
+	fn rlp_append_sealed_transaction(&self, s: &mut RlpStream) {
 		s.begin_list(9);
 		s.append(&self.nonce);
 		s.append(&self.gas_price);
@@ -295,8 +301,16 @@ impl SignedTransaction {
 		}
 	}
 
-	/// 0 is `v` is 27, 1 if 28, and 4 otherwise.
-	pub fn standard_v(&self) -> u8 { match self.v { 27 => 0, 28 => 1, _ => 4 } }
+	/// 0 if `v` would have been 27 under "Electrum" notation, 1 if 28 or 4 if invalid.
+	pub fn standard_v(&self) -> u8 { match self.v { v if v == 27 || v == 28 || v > 36 => (v - 1) % 2, _ => 4 } }
+
+	/// The network ID, or `None` if this is a global transaction. 
+	pub fn network_id(&self) -> Option<u8> {
+		match self.v {
+			v if v > 36 => Some((v - 35) / 2),
+			_ => None,
+		}
+	}
 
 	/// Construct a signature object from the sig.
 	pub fn signature(&self) -> Signature {
@@ -327,20 +341,25 @@ impl SignedTransaction {
 
 	/// Returns the public key of the sender.
 	pub fn public_key(&self) -> Result<Public, Error> {
-		Ok(try!(recover(&self.signature(), &self.unsigned.hash())))
+		Ok(try!(recover(&self.signature(), &self.unsigned.hash(self.network_id()))))
 	}
 
 	/// Do basic validation, checking for valid signature and minimum gas,
 	// TODO: consider use in block validation.
 	#[cfg(test)]
 	#[cfg(feature = "json-tests")]
-	pub fn validate(self, schedule: &Schedule, require_low: bool) -> Result<SignedTransaction, Error> {
+	pub fn validate(self, schedule: &Schedule, require_low: bool, allow_network_id_of_one: bool) -> Result<SignedTransaction, Error> {
 		if require_low && !self.signature().is_low_s() {
 			return Err(EthkeyError::InvalidSignature.into())
 		}
+		match self.network_id() {
+			None => {},
+			Some(1) if allow_network_id_of_one => {},
+			_ => return Err(TransactionError::InvalidNetworkId.into()),
+		}
 		try!(self.sender());
 		if self.gas < U256::from(self.gas_required(&schedule)) {
-			Err(From::from(TransactionError::InvalidGasLimit(::util::OutOfBounds{min: Some(U256::from(self.gas_required(&schedule))), max: None, found: self.gas})))
+			Err(TransactionError::InvalidGasLimit(::util::OutOfBounds{min: Some(U256::from(self.gas_required(&schedule))), max: None, found: self.gas}).into())
 		} else {
 			Ok(self)
 		}
@@ -380,6 +399,7 @@ fn sender_test() {
 	} else { panic!(); }
 	assert_eq!(t.value, U256::from(0x0au64));
 	assert_eq!(t.sender().unwrap(), "0f65fe9276bc9a24ae7083ae28e2660ef72df99e".into());
+	assert_eq!(t.network_id(), None);
 }
 
 #[test]
@@ -394,8 +414,9 @@ fn signing() {
 		gas: U256::from(50_000),
 		value: U256::from(1),
 		data: b"Hello!".to_vec()
-	}.sign(&key.secret());
+	}.sign(&key.secret(), None);
 	assert_eq!(Address::from(key.public().sha3()), t.sender().unwrap());
+	assert_eq!(t.network_id(), None);
 }
 
 #[test]
@@ -409,7 +430,48 @@ fn fake_signing() {
 		data: b"Hello!".to_vec()
 	}.fake_sign(Address::from(0x69));
 	assert_eq!(Address::from(0x69), t.sender().unwrap());
+	assert_eq!(t.network_id(), None);
 
 	let t = t.clone();
 	assert_eq!(Address::from(0x69), t.sender().unwrap());
+	assert_eq!(t.network_id(), None);
 }
+
+#[test]
+fn should_recover_from_network_specific_signing() {
+	use ethkey::{Random, Generator};
+	let key = Random.generate().unwrap();
+	let t = Transaction {
+		action: Action::Create,
+		nonce: U256::from(42),
+		gas_price: U256::from(3000),
+		gas: U256::from(50_000),
+		value: U256::from(1),
+		data: b"Hello!".to_vec()
+	}.sign(&key.secret(), Some(69));
+	assert_eq!(Address::from(key.public().sha3()), t.sender().unwrap());
+	assert_eq!(t.network_id(), Some(69));
+}
+
+#[test]
+fn should_agree_with_vitalik() {
+	use rustc_serialize::hex::FromHex;
+
+	let test_vector = |tx_data: &str, address: &'static str| {
+		let signed: SignedTransaction = decode(&FromHex::from_hex(tx_data).unwrap());
+		signed.check_low_s().unwrap();
+		assert_eq!(signed.sender().unwrap(), address.into());
+		flushln!("networkid: {:?}", signed.network_id()); 
+	};
+
+	test_vector("f864808504a817c800825208943535353535353535353535353535353535353535808025a0044852b2a670ade5407e78fb2863c51de9fcb96542a07186fe3aeda6bb8a116da0044852b2a670ade5407e78fb2863c51de9fcb96542a07186fe3aeda6bb8a116d", "0xf0f6f18bca1b28cd68e4357452947e021241e9ce")
+	test_vector("f864018504a817c80182a410943535353535353535353535353535353535353535018025a0489efdaa54c0f20c7adf612882df0950f5a951637e0307cdcb4c672f298b8bcaa0489efdaa54c0f20c7adf612882df0950f5a951637e0307cdcb4c672f298b8bc6", "0x23ef145a395ea3fa3deb533b8a9e1b4c6c25d112")
+	test_vector("f864028504a817c80282f618943535353535353535353535353535353535353535088025a02d7c5bef027816a800da1736444fb58a807ef4c9603b7848673f7e3a68eb14a5a02d7c5bef027816a800da1736444fb58a807ef4c9603b7848673f7e3a68eb14a5", "0x2e485e0c23b4c3c542628a5f672eeab0ad4888be")
+	test_vector("f865038504a817c803830148209435353535353535353535353535353535353535351b8025a02a80e1ef1d7842f27f2e6be0972bb708b9a135c38860dbe73c27c3486c34f4e0a02a80e1ef1d7842f27f2e6be0972bb708b9a135c38860dbe73c27c3486c34f4de", "0x82a88539669a3fd524d669e858935de5e5410cf0")
+	test_vector("f865048504a817c80483019a28943535353535353535353535353535353535353535408025a013600b294191fc92924bb3ce4b969c1e7e2bab8f4c93c3fc6d0a51733df3c063a013600b294191fc92924bb3ce4b969c1e7e2bab8f4c93c3fc6d0a51733df3c060", "0xf9358f2538fd5ccfeb848b64a96b743fcc930554")
+	test_vector("f865058504a817c8058301ec309435353535353535353535353535353535353535357d8025a04eebf77a833b30520287ddd9478ff51abbdffa30aa90a8d655dba0e8a79ce0c1a04eebf77a833b30520287ddd9478ff51abbdffa30aa90a8d655dba0e8a79ce0c1", "0xa8f7aba377317440bc5b26198a363ad22af1f3a4")
+	test_vector("f866068504a817c80683023e3894353535353535353535353535353535353535353581d88025a06455bf8ea6e7463a1046a0b52804526e119b4bf5136279614e0b1e8e296a4e2fa06455bf8ea6e7463a1046a0b52804526e119b4bf5136279614e0b1e8e296a4e2d", "0xf1f571dc362a0e5b2696b8e775f8491d3e50de35")
+	test_vector("f867078504a817c807830290409435353535353535353535353535353535353535358201578025a052f1a9b320cab38e5da8a8f97989383aab0a49165fc91c737310e4f7e9821021a052f1a9b320cab38e5da8a8f97989383aab0a49165fc91c737310e4f7e9821021", "0xd37922162ab7cea97c97a87551ed02c9a38b7332")
+	test_vector("f867088504a817c8088302e2489435353535353535353535353535353535353535358202008025a064b1702d9298fee62dfeccc57d322a463ad55ca201256d01f62b45b2e1c21c12a064b1702d9298fee62dfeccc57d322a463ad55ca201256d01f62b45b2e1c21c10", "0x9bddad43f934d313c2b79ca28a432dd2b7281029")
+	test_vector("f867098504a817c809830334509435353535353535353535353535353535353535358202d98025a052f8f61201b2b11a78d6e866abc9c3db2ae8631fa656bfe5cb53668255367afba052f8f61201b2b11a78d6e866abc9c3db2ae8631fa656bfe5cb53668255367afb", "0x3c24d7329e92f84f08556ceb6df1cdb0104ca49f")
+}

ethcore/src/verification/verification.rs

@@ -395,7 +395,7 @@ mod tests {
 			gas: U256::from(30_000),
 			gas_price: U256::from(40_000),
 			nonce: U256::one()
-		}.sign(keypair.secret());
+		}.sign(keypair.secret(), None);
 
 		let tr2 = Transaction {
 			action: Action::Create,
@@ -404,7 +404,7 @@ mod tests {
 			gas: U256::from(30_000),
 			gas_price: U256::from(40_000),
 			nonce: U256::from(2)
-		}.sign(keypair.secret());
+		}.sign(keypair.secret(), None);
 
 		let good_transactions = [ tr1.clone(), tr2.clone() ];