Merge pull request #1782 from ethcore/beta-staging

BETA: fixed trace_transaction crash when block contained suicide

Cargo.lock

@@ -1,6 +1,6 @@
 [root]
 name = "parity"
-version = "1.3.0"
+version = "1.2.3"
 dependencies = [
  "ansi_term 0.7.2 (registry+https://github.com/rust-lang/crates.io-index)",
  "clippy 0.0.77 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -8,16 +8,16 @@ dependencies = [
  "daemonize 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
  "docopt 0.6.80 (registry+https://github.com/rust-lang/crates.io-index)",
  "env_logger 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
- "ethcore 1.3.0",
- "ethcore-dapps 1.3.0",
- "ethcore-devtools 1.3.0",
- "ethcore-ipc 1.3.0",
- "ethcore-ipc-codegen 1.3.0",
- "ethcore-ipc-nano 1.3.0",
- "ethcore-rpc 1.3.0",
- "ethcore-signer 1.3.0",
- "ethcore-util 1.3.0",
- "ethsync 1.3.0",
+ "ethcore 1.2.0",
+ "ethcore-dapps 1.2.0",
+ "ethcore-devtools 1.2.0",
+ "ethcore-ipc 1.2.0",
+ "ethcore-ipc-codegen 1.2.0",
+ "ethcore-ipc-nano 1.2.0",
+ "ethcore-rpc 1.2.0",
+ "ethcore-signer 1.2.0",
+ "ethcore-util 1.2.3",
+ "ethsync 1.2.0",
  "fdlimit 0.1.0",
  "hyper 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)",
  "json-ipc-server 0.2.4 (git+https://github.com/ethcore/json-ipc-server.git)",
@@ -238,7 +238,7 @@ dependencies = [
 
 [[package]]
 name = "ethash"
-version = "1.3.0"
+version = "1.2.0"
 dependencies = [
  "log 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
  "primal 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -247,17 +247,17 @@ dependencies = [
 
 [[package]]
 name = "ethcore"
-version = "1.3.0"
+version = "1.2.0"
 dependencies = [
  "bloomchain 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "clippy 0.0.77 (registry+https://github.com/rust-lang/crates.io-index)",
  "crossbeam 0.2.9 (registry+https://github.com/rust-lang/crates.io-index)",
  "env_logger 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
- "ethash 1.3.0",
- "ethcore-devtools 1.3.0",
- "ethcore-ipc 1.3.0",
- "ethcore-ipc-codegen 1.3.0",
- "ethcore-util 1.3.0",
+ "ethash 1.2.0",
+ "ethcore-devtools 1.2.0",
+ "ethcore-ipc 1.2.0",
+ "ethcore-ipc-codegen 1.2.0",
+ "ethcore-util 1.2.3",
  "ethjson 0.1.0",
  "ethstore 0.1.0",
  "heapsize 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -274,20 +274,20 @@ dependencies = [
 
 [[package]]
 name = "ethcore-dapps"
-version = "1.3.0"
+version = "1.2.0"
 dependencies = [
  "clippy 0.0.77 (registry+https://github.com/rust-lang/crates.io-index)",
- "ethcore-rpc 1.3.0",
- "ethcore-util 1.3.0",
+ "ethcore-rpc 1.2.0",
+ "ethcore-util 1.2.3",
  "hyper 0.9.4 (git+https://github.com/ethcore/hyper)",
  "jsonrpc-core 2.0.7 (registry+https://github.com/rust-lang/crates.io-index)",
  "jsonrpc-http-server 5.1.0 (git+https://github.com/ethcore/jsonrpc-http-server.git)",
  "log 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
  "mime_guess 1.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
- "parity-dapps 0.3.0 (git+https://github.com/ethcore/parity-dapps-rs.git)",
- "parity-dapps-builtins 0.5.2 (git+https://github.com/ethcore/parity-dapps-builtins-rs.git)",
- "parity-dapps-status 0.5.1 (git+https://github.com/ethcore/parity-dapps-status-rs.git)",
- "parity-dapps-wallet 0.6.1 (git+https://github.com/ethcore/parity-dapps-wallet-rs.git)",
+ "parity-dapps 0.6.0 (git+https://github.com/ethcore/parity-ui.git)",
+ "parity-dapps-home 0.6.0 (git+https://github.com/ethcore/parity-ui.git)",
+ "parity-dapps-status 0.6.0 (git+https://github.com/ethcore/parity-ui.git)",
+ "parity-dapps-wallet 0.6.0 (git+https://github.com/ethcore/parity-ui.git)",
  "rustc-serialize 0.3.19 (registry+https://github.com/rust-lang/crates.io-index)",
  "serde 0.7.9 (registry+https://github.com/rust-lang/crates.io-index)",
  "serde_codegen 0.7.9 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -298,24 +298,24 @@ dependencies = [
 
 [[package]]
 name = "ethcore-devtools"
-version = "1.3.0"
+version = "1.2.0"
 dependencies = [
  "rand 0.3.14 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
 name = "ethcore-ipc"
-version = "1.3.0"
+version = "1.2.0"
 dependencies = [
- "ethcore-devtools 1.3.0",
- "ethcore-util 1.3.0",
+ "ethcore-devtools 1.2.0",
+ "ethcore-util 1.2.3",
  "nanomsg 0.5.1 (git+https://github.com/ethcore/nanomsg.rs.git)",
  "semver 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
 name = "ethcore-ipc-codegen"
-version = "1.3.0"
+version = "1.2.0"
 dependencies = [
  "aster 0.17.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "quasi 0.11.0 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -326,9 +326,9 @@ dependencies = [
 
 [[package]]
 name = "ethcore-ipc-nano"
-version = "1.3.0"
+version = "1.2.0"
 dependencies = [
- "ethcore-ipc 1.3.0",
+ "ethcore-ipc 1.2.0",
  "jsonrpc-core 2.0.7 (registry+https://github.com/rust-lang/crates.io-index)",
  "log 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
  "nanomsg 0.5.1 (git+https://github.com/ethcore/nanomsg.rs.git)",
@@ -336,15 +336,15 @@ dependencies = [
 
 [[package]]
 name = "ethcore-rpc"
-version = "1.3.0"
+version = "1.2.0"
 dependencies = [
  "clippy 0.0.77 (registry+https://github.com/rust-lang/crates.io-index)",
- "ethash 1.3.0",
- "ethcore 1.3.0",
- "ethcore-devtools 1.3.0",
- "ethcore-util 1.3.0",
+ "ethash 1.2.0",
+ "ethcore 1.2.0",
+ "ethcore-devtools 1.2.0",
+ "ethcore-util 1.2.3",
  "ethjson 0.1.0",
- "ethsync 1.3.0",
+ "ethsync 1.2.0",
  "json-ipc-server 0.2.4 (git+https://github.com/ethcore/json-ipc-server.git)",
  "jsonrpc-core 2.0.7 (registry+https://github.com/rust-lang/crates.io-index)",
  "jsonrpc-http-server 5.1.0 (git+https://github.com/ethcore/jsonrpc-http-server.git)",
@@ -359,15 +359,15 @@ dependencies = [
 
 [[package]]
 name = "ethcore-signer"
-version = "1.3.0"
+version = "1.2.0"
 dependencies = [
  "clippy 0.0.77 (registry+https://github.com/rust-lang/crates.io-index)",
  "env_logger 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
- "ethcore-rpc 1.3.0",
- "ethcore-util 1.3.0",
+ "ethcore-rpc 1.2.0",
+ "ethcore-util 1.2.3",
  "jsonrpc-core 2.0.7 (registry+https://github.com/rust-lang/crates.io-index)",
  "log 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
- "parity-minimal-sysui 0.2.0 (git+https://github.com/ethcore/parity-dapps-minimal-sysui-rs.git)",
+ "parity-dapps-signer 0.6.0 (git+https://github.com/ethcore/parity-ui.git)",
  "rand 0.3.14 (registry+https://github.com/rust-lang/crates.io-index)",
  "rustc_version 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
  "ws 0.5.0 (git+https://github.com/ethcore/ws-rs.git?branch=stable)",
@@ -375,7 +375,7 @@ dependencies = [
 
 [[package]]
 name = "ethcore-util"
-version = "1.3.0"
+version = "1.2.3"
 dependencies = [
  "ansi_term 0.7.2 (registry+https://github.com/rust-lang/crates.io-index)",
  "arrayvec 0.3.16 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -386,7 +386,7 @@ dependencies = [
  "elastic-array 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "env_logger 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
  "eth-secp256k1 0.5.4 (git+https://github.com/ethcore/rust-secp256k1)",
- "ethcore-devtools 1.3.0",
+ "ethcore-devtools 1.2.0",
  "heapsize 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
  "igd 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
  "itertools 0.4.13 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -414,7 +414,7 @@ dependencies = [
 name = "ethjson"
 version = "0.1.0"
 dependencies = [
- "ethcore-util 1.3.0",
+ "ethcore-util 1.2.3",
  "rustc-serialize 0.3.19 (registry+https://github.com/rust-lang/crates.io-index)",
  "serde 0.7.9 (registry+https://github.com/rust-lang/crates.io-index)",
  "serde_codegen 0.7.9 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -451,12 +451,12 @@ dependencies = [
 
 [[package]]
 name = "ethsync"
-version = "1.3.0"
+version = "1.2.0"
 dependencies = [
  "clippy 0.0.77 (registry+https://github.com/rust-lang/crates.io-index)",
  "env_logger 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
- "ethcore 1.3.0",
- "ethcore-util 1.3.0",
+ "ethcore 1.2.0",
+ "ethcore-util 1.2.3",
  "heapsize 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
  "log 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
  "rand 0.3.14 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -597,7 +597,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 [[package]]
 name = "json-ipc-server"
 version = "0.2.4"
-source = "git+https://github.com/ethcore/json-ipc-server.git#902b031b8f50a59ecb4f389cbec1d264a98556bc"
+source = "git+https://github.com/ethcore/json-ipc-server.git#7a02a0f8b249fda100b9bab5f90b2081d410d8cf"
 dependencies = [
  "bytes 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "env_logger 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -897,8 +897,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 
 [[package]]
 name = "parity-dapps"
-version = "0.3.0"
-source = "git+https://github.com/ethcore/parity-dapps-rs.git#8cc812c26c903cf5764ce0f4cc3f2a7c3ddb0dc2"
+version = "0.6.0"
+source = "git+https://github.com/ethcore/parity-ui.git#7120546d08d4d9eb648e255c04935002223d362f"
 dependencies = [
  "aster 0.17.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "glob 0.2.11 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -910,34 +910,37 @@ dependencies = [
 ]
 
 [[package]]
-name = "parity-dapps-builtins"
-version = "0.5.2"
-source = "git+https://github.com/ethcore/parity-dapps-builtins-rs.git#01af2091d5d70dfe0aecbfd96308f0ae79fc61e6"
+name = "parity-dapps-home"
+version = "0.6.0"
+source = "git+https://github.com/ethcore/parity-ui.git#7120546d08d4d9eb648e255c04935002223d362f"
 dependencies = [
- "parity-dapps 0.3.0 (git+https://github.com/ethcore/parity-dapps-rs.git)",
+ "parity-dapps 0.6.0 (git+https://github.com/ethcore/parity-ui.git)",
+]
+
+[[package]]
+name = "parity-dapps-signer"
+version = "0.6.0"
+source = "git+https://github.com/ethcore/parity-ui.git#7120546d08d4d9eb648e255c04935002223d362f"
+dependencies = [
+ "parity-dapps 0.6.0 (git+https://github.com/ethcore/parity-ui.git)",
 ]
 
 [[package]]
 name = "parity-dapps-status"
-version = "0.5.1"
-source = "git+https://github.com/ethcore/parity-dapps-status-rs.git#110ef2e66142ec8dc15fc40b8ddda5ed3bcfc1fb"
+version = "0.6.0"
+source = "git+https://github.com/ethcore/parity-ui.git#7120546d08d4d9eb648e255c04935002223d362f"
 dependencies = [
- "parity-dapps 0.3.0 (git+https://github.com/ethcore/parity-dapps-rs.git)",
+ "parity-dapps 0.6.0 (git+https://github.com/ethcore/parity-ui.git)",
 ]
 
 [[package]]
 name = "parity-dapps-wallet"
-version = "0.6.1"
-source = "git+https://github.com/ethcore/parity-dapps-wallet-rs.git#867994fe25038f000f1cc09cd024a83700a03930"
+version = "0.6.0"
+source = "git+https://github.com/ethcore/parity-ui.git#7120546d08d4d9eb648e255c04935002223d362f"
 dependencies = [
- "parity-dapps 0.3.0 (git+https://github.com/ethcore/parity-dapps-rs.git)",
+ "parity-dapps 0.6.0 (git+https://github.com/ethcore/parity-ui.git)",
 ]
 
-[[package]]
-name = "parity-minimal-sysui"
-version = "0.2.0"
-source = "git+https://github.com/ethcore/parity-dapps-minimal-sysui-rs.git#996c9f3f0ebedc727aecb4ece191154e956ae292"
-
 [[package]]
 name = "phf"
 version = "0.7.14"
@@ -1079,7 +1082,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 [[package]]
 name = "rocksdb"
 version = "0.4.5"
-source = "git+https://github.com/ethcore/rust-rocksdb#9be41e05923616dfa28741c58b22776d479751e6"
+source = "git+https://github.com/ethcore/rust-rocksdb#6472a9dce16c267a3acec2ee6fd01d1bf8de4913"
 dependencies = [
  "libc 0.2.12 (registry+https://github.com/rust-lang/crates.io-index)",
  "rocksdb-sys 0.3.0 (git+https://github.com/ethcore/rust-rocksdb)",
@@ -1088,7 +1091,7 @@ dependencies = [
 [[package]]
 name = "rocksdb-sys"
 version = "0.3.0"
-source = "git+https://github.com/ethcore/rust-rocksdb#9be41e05923616dfa28741c58b22776d479751e6"
+source = "git+https://github.com/ethcore/rust-rocksdb#6472a9dce16c267a3acec2ee6fd01d1bf8de4913"
 dependencies = [
  "gcc 0.3.28 (registry+https://github.com/rust-lang/crates.io-index)",
  "libc 0.2.12 (registry+https://github.com/rust-lang/crates.io-index)",

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 description = "Ethcore client."
 name = "parity"
-version = "1.3.0"
+version = "1.2.3"
 license = "GPL-3.0"
 authors = ["Ethcore <admin@ethcore.io>"]
 build = "build.rs"
@@ -47,9 +47,11 @@ version = "0.8"
 default-features = false
 
 [features]
-default = ["rpc", "dapps", "ethcore-signer"]
-rpc = ["ethcore-rpc"]
+default = ["rpc", "ethcore-signer", "ui", "use-precompiled-js"]
+ui = ["dapps", "ethcore-signer/ui"]
+use-precompiled-js = ["ethcore-dapps/use-precompiled-js", "ethcore-signer/use-precompiled-js"]
 dapps = ["ethcore-dapps"]
+rpc = ["ethcore-rpc"]
 dev = ["clippy", "ethcore/dev", "ethcore-util/dev", "ethsync/dev", "ethcore-rpc/dev",
 "ethcore-dapps/dev", "ethcore-signer/dev"]
 travis-beta = ["ethcore/json-tests"]

appveyor.yml

@@ -40,6 +40,10 @@ after_test:
 artifacts:
   - path: nsis\installer.exe
     name: Windows Installer (x86_64)
+  - path: target\release\parity.exe
+    name: Windows Executable (x86_64)
+  - path: target\release\parity.pdb
+    name: Windows Executable Debug Symbols (x86_64)
 
 cache:
   - target

dapps/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 description = "Parity Dapps crate"
 name = "ethcore-dapps"
-version = "1.3.0"
+version = "1.2.0"
 license = "GPL-3.0"
 authors = ["Ethcore <admin@ethcore.io"]
 build = "build.rs"
@@ -20,13 +20,11 @@ serde_json = "0.7.0"
 serde_macros = { version = "0.7.0", optional = true }
 ethcore-rpc = { path = "../rpc" }
 ethcore-util = { path = "../util" }
-parity-dapps = { git = "https://github.com/ethcore/parity-dapps-rs.git", version = "0.3" }
+parity-dapps = { git = "https://github.com/ethcore/parity-ui.git", version = "0.6" }
 # List of apps
-parity-dapps-status = { git = "https://github.com/ethcore/parity-dapps-status-rs.git", version = "0.5.1" }
-parity-dapps-builtins = { git = "https://github.com/ethcore/parity-dapps-builtins-rs.git", version = "0.5.2" }
-parity-dapps-wallet = { git = "https://github.com/ethcore/parity-dapps-wallet-rs.git", version = "0.6.0", optional = true }
-parity-dapps-dao = { git = "https://github.com/ethcore/parity-dapps-dao-rs.git", version = "0.4.0", optional = true }
-parity-dapps-makerotc = { git = "https://github.com/ethcore/parity-dapps-makerotc-rs.git", version = "0.3.0", optional = true }
+parity-dapps-status = { git = "https://github.com/ethcore/parity-ui.git", version = "0.6" }
+parity-dapps-home = { git = "https://github.com/ethcore/parity-ui.git", version = "0.6" }
+parity-dapps-wallet = { git = "https://github.com/ethcore/parity-ui.git", version = "0.6", optional = true }
 mime_guess = { version = "1.6.1" }
 clippy = { version = "0.0.77", optional = true}
 
@@ -39,3 +37,9 @@ default = ["serde_codegen", "extra-dapps"]
 extra-dapps = ["parity-dapps-wallet"]
 nightly = ["serde_macros"]
 dev = ["clippy", "ethcore-rpc/dev", "ethcore-util/dev"]
+
+use-precompiled-js = [
+	"parity-dapps-status/use-precompiled-js",
+	"parity-dapps-home/use-precompiled-js",
+	"parity-dapps-wallet/use-precompiled-js"
+]

dapps/src/apps/mod.rs

@@ -22,7 +22,7 @@ use parity_dapps::WebApp;
 mod fs;
 
 extern crate parity_dapps_status;
-extern crate parity_dapps_builtins;
+extern crate parity_dapps_home;
 
 pub const DAPPS_DOMAIN : &'static str = ".parity";
 pub const RPC_PATH : &'static str =  "rpc";
@@ -34,7 +34,7 @@ pub fn main_page() -> &'static str {
 }
 
 pub fn utils() -> Box<Endpoint> {
-	Box::new(PageEndpoint::with_prefix(parity_dapps_builtins::App::default(), UTILS_PATH.to_owned()))
+	Box::new(PageEndpoint::with_prefix(parity_dapps_home::App::default(), UTILS_PATH.to_owned()))
 }
 
 pub fn all_endpoints(dapps_path: String) -> Endpoints {
@@ -44,7 +44,7 @@ pub fn all_endpoints(dapps_path: String) -> Endpoints {
 	// because we use Cross-Origin LocalStorage.
 	// TODO [ToDr] Account naming should be moved to parity.
 	pages.insert("home".into(), Box::new(
-		PageEndpoint::new_safe_to_embed(parity_dapps_builtins::App::default())
+		PageEndpoint::new_safe_to_embed(parity_dapps_home::App::default())
 	));
 	pages.insert("proxy".into(), ProxyPac::boxed());
 	insert::<parity_dapps_status::App>(&mut pages, "parity");
@@ -52,8 +52,6 @@ pub fn all_endpoints(dapps_path: String) -> Endpoints {
 
 	// Optional dapps
 	wallet_page(&mut pages);
-	daodapp_page(&mut pages);
-	makerotc_page(&mut pages);
 
 	pages
 }
@@ -66,22 +64,6 @@ fn wallet_page(pages: &mut Endpoints) {
 #[cfg(not(feature = "parity-dapps-wallet"))]
 fn wallet_page(_pages: &mut Endpoints) {}
 
-#[cfg(feature = "parity-dapps-dao")]
-fn daodapp_page(pages: &mut Endpoints) {
-	extern crate parity_dapps_dao;
-	insert::<parity_dapps_dao::App>(pages, "dao");
-}
-#[cfg(not(feature = "parity-dapps-dao"))]
-fn daodapp_page(_pages: &mut Endpoints) {}
-
-#[cfg(feature = "parity-dapps-makerotc")]
-fn makerotc_page(pages: &mut Endpoints) {
-	extern crate parity_dapps_makerotc;
-	insert::<parity_dapps_makerotc::App>(pages, "makerotc");
-}
-#[cfg(not(feature = "parity-dapps-makerotc"))]
-fn makerotc_page(_pages: &mut Endpoints) {}
-
 fn insert<T : WebApp + Default + 'static>(pages: &mut Endpoints, id: &str) {
 	pages.insert(id.to_owned(), Box::new(PageEndpoint::new(T::default())));
 }

db/Cargo.toml

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

devtools/Cargo.toml

@@ -3,7 +3,7 @@ description = "Ethcore development/test/build tools"
 homepage = "http://ethcore.io"
 license = "GPL-3.0"
 name = "ethcore-devtools"
-version = "1.3.0"
+version = "1.2.0"
 authors = ["Ethcore <admin@ethcore.io>"]
 
 [dependencies]

ethash/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ethash"
-version = "1.3.0"
+version = "1.2.0"
 authors = ["arkpar <arkadiy@ethcore.io"]
 
 [lib]

ethcore/Cargo.toml

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

ethcore/res/ethereum/daohardfork_test.json

@@ -0,0 +1,162 @@
+{
+	"name": "DAO hard-fork consensus test",
+	"engine": {
+		"Ethash": {
+			"params": {
+				"gasLimitBoundDivisor": "0x0400",
+				"minimumDifficulty": "0x020000",
+				"difficultyBoundDivisor": "0x0800",
+				"durationLimit": "0x0d",
+				"blockReward": "0x4563918244F40000",
+				"registrar" : "0xc6d9d2cd449a754c494264e1809c50e34d64562b",
+				"frontierCompatibilityModeLimit": "0x5",
+				"daoHardforkTransition": "0x8",
+				"daoHardforkBeneficiary": "0xbf4ed7b27f1d666546e30d74d50d173d20bca754",
+				"daoHardforkAccounts": [  
+					"0xd4fe7bc31cedb7bfb8a345f31e668033056b2728",
+					"0xb3fb0e5aba0e20e5c49d252dfd30e102b171a425",
+					"0x2c19c7f9ae8b751e37aeb2d93a699722395ae18f",
+					"0xecd135fa4f61a655311e86238c92adcd779555d2",
+					"0x1975bd06d486162d5dc297798dfc41edd5d160a7",
+					"0xa3acf3a1e16b1d7c315e23510fdd7847b48234f6",
+					"0x319f70bab6845585f412ec7724b744fec6095c85",
+					"0x06706dd3f2c9abf0a21ddcc6941d9b86f0596936",
+					"0x5c8536898fbb74fc7445814902fd08422eac56d0",
+					"0x6966ab0d485353095148a2155858910e0965b6f9",
+					"0x779543a0491a837ca36ce8c635d6154e3c4911a6",
+					"0x2a5ed960395e2a49b1c758cef4aa15213cfd874c",
+					"0x5c6e67ccd5849c0d29219c4f95f1a7a93b3f5dc5",
+					"0x9c50426be05db97f5d64fc54bf89eff947f0a321",
+					"0x200450f06520bdd6c527622a273333384d870efb",
+					"0xbe8539bfe837b67d1282b2b1d61c3f723966f049",
+					"0x6b0c4d41ba9ab8d8cfb5d379c69a612f2ced8ecb",
+					"0xf1385fb24aad0cd7432824085e42aff90886fef5",
+					"0xd1ac8b1ef1b69ff51d1d401a476e7e612414f091",
+					"0x8163e7fb499e90f8544ea62bbf80d21cd26d9efd",
+					"0x51e0ddd9998364a2eb38588679f0d2c42653e4a6",
+					"0x627a0a960c079c21c34f7612d5d230e01b4ad4c7",
+					"0xf0b1aa0eb660754448a7937c022e30aa692fe0c5",
+					"0x24c4d950dfd4dd1902bbed3508144a54542bba94",
+					"0x9f27daea7aca0aa0446220b98d028715e3bc803d",
+					"0xa5dc5acd6a7968a4554d89d65e59b7fd3bff0f90",
+					"0xd9aef3a1e38a39c16b31d1ace71bca8ef58d315b",
+					"0x63ed5a272de2f6d968408b4acb9024f4cc208ebf",
+					"0x6f6704e5a10332af6672e50b3d9754dc460dfa4d",
+					"0x77ca7b50b6cd7e2f3fa008e24ab793fd56cb15f6",
+					"0x492ea3bb0f3315521c31f273e565b868fc090f17",
+					"0x0ff30d6de14a8224aa97b78aea5388d1c51c1f00",
+					"0x9ea779f907f0b315b364b0cfc39a0fde5b02a416",
+					"0xceaeb481747ca6c540a000c1f3641f8cef161fa7",
+					"0xcc34673c6c40e791051898567a1222daf90be287",
+					"0x579a80d909f346fbfb1189493f521d7f48d52238",
+					"0xe308bd1ac5fda103967359b2712dd89deffb7973",
+					"0x4cb31628079fb14e4bc3cd5e30c2f7489b00960c",
+					"0xac1ecab32727358dba8962a0f3b261731aad9723",
+					"0x4fd6ace747f06ece9c49699c7cabc62d02211f75",
+					"0x440c59b325d2997a134c2c7c60a8c61611212bad",
+					"0x4486a3d68fac6967006d7a517b889fd3f98c102b",
+					"0x9c15b54878ba618f494b38f0ae7443db6af648ba",
+					"0x27b137a85656544b1ccb5a0f2e561a5703c6a68f",
+					"0x21c7fdb9ed8d291d79ffd82eb2c4356ec0d81241",
+					"0x23b75c2f6791eef49c69684db4c6c1f93bf49a50",
+					"0x1ca6abd14d30affe533b24d7a21bff4c2d5e1f3b",
+					"0xb9637156d330c0d605a791f1c31ba5890582fe1c",
+					"0x6131c42fa982e56929107413a9d526fd99405560",
+					"0x1591fc0f688c81fbeb17f5426a162a7024d430c2",
+					"0x542a9515200d14b68e934e9830d91645a980dd7a",
+					"0xc4bbd073882dd2add2424cf47d35213405b01324",
+					"0x782495b7b3355efb2833d56ecb34dc22ad7dfcc4",
+					"0x58b95c9a9d5d26825e70a82b6adb139d3fd829eb",
+					"0x3ba4d81db016dc2890c81f3acec2454bff5aada5",
+					"0xb52042c8ca3f8aa246fa79c3feaa3d959347c0ab",
+					"0xe4ae1efdfc53b73893af49113d8694a057b9c0d1",
+					"0x3c02a7bc0391e86d91b7d144e61c2c01a25a79c5",
+					"0x0737a6b837f97f46ebade41b9bc3e1c509c85c53",
+					"0x97f43a37f595ab5dd318fb46e7a155eae057317a",
+					"0x52c5317c848ba20c7504cb2c8052abd1fde29d03",
+					"0x4863226780fe7c0356454236d3b1c8792785748d",
+					"0x5d2b2e6fcbe3b11d26b525e085ff818dae332479",
+					"0x5f9f3392e9f62f63b8eac0beb55541fc8627f42c",
+					"0x057b56736d32b86616a10f619859c6cd6f59092a",
+					"0x9aa008f65de0b923a2a4f02012ad034a5e2e2192",
+					"0x304a554a310c7e546dfe434669c62820b7d83490",
+					"0x914d1b8b43e92723e64fd0a06f5bdb8dd9b10c79",
+					"0x4deb0033bb26bc534b197e61d19e0733e5679784",
+					"0x07f5c1e1bc2c93e0402f23341973a0e043f7bf8a",
+					"0x35a051a0010aba705c9008d7a7eff6fb88f6ea7b",
+					"0x4fa802324e929786dbda3b8820dc7834e9134a2a",
+					"0x9da397b9e80755301a3b32173283a91c0ef6c87e",
+					"0x8d9edb3054ce5c5774a420ac37ebae0ac02343c6",
+					"0x0101f3be8ebb4bbd39a2e3b9a3639d4259832fd9",
+					"0x5dc28b15dffed94048d73806ce4b7a4612a1d48f",
+					"0xbcf899e6c7d9d5a215ab1e3444c86806fa854c76",
+					"0x12e626b0eebfe86a56d633b9864e389b45dcb260",
+					"0xa2f1ccba9395d7fcb155bba8bc92db9bafaeade7",
+					"0xec8e57756626fdc07c63ad2eafbd28d08e7b0ca5",
+					"0xd164b088bd9108b60d0ca3751da4bceb207b0782",
+					"0x6231b6d0d5e77fe001c2a460bd9584fee60d409b",
+					"0x1cba23d343a983e9b5cfd19496b9a9701ada385f",
+					"0xa82f360a8d3455c5c41366975bde739c37bfeb8a",
+					"0x9fcd2deaff372a39cc679d5c5e4de7bafb0b1339",
+					"0x005f5cee7a43331d5a3d3eec71305925a62f34b6",
+					"0x0e0da70933f4c7849fc0d203f5d1d43b9ae4532d",
+					"0xd131637d5275fd1a68a3200f4ad25c71a2a9522e",
+					"0xbc07118b9ac290e4622f5e77a0853539789effbe",
+					"0x47e7aa56d6bdf3f36be34619660de61275420af8",
+					"0xacd87e28b0c9d1254e868b81cba4cc20d9a32225",
+					"0xadf80daec7ba8dcf15392f1ac611fff65d94f880",
+					"0x5524c55fb03cf21f549444ccbecb664d0acad706",
+					"0x40b803a9abce16f50f36a77ba41180eb90023925",
+					"0xfe24cdd8648121a43a7c86d289be4dd2951ed49f",
+					"0x17802f43a0137c506ba92291391a8a8f207f487d",
+					"0x253488078a4edf4d6f42f113d1e62836a942cf1a",
+					"0x86af3e9626fce1957c82e88cbf04ddf3a2ed7915",
+					"0xb136707642a4ea12fb4bae820f03d2562ebff487",
+					"0xdbe9b615a3ae8709af8b93336ce9b477e4ac0940",
+					"0xf14c14075d6c4ed84b86798af0956deef67365b5",
+					"0xca544e5c4687d109611d0f8f928b53a25af72448",
+					"0xaeeb8ff27288bdabc0fa5ebb731b6f409507516c",
+					"0xcbb9d3703e651b0d496cdefb8b92c25aeb2171f7",
+					"0x6d87578288b6cb5549d5076a207456a1f6a63dc0",
+					"0xb2c6f0dfbb716ac562e2d85d6cb2f8d5ee87603e",
+					"0xaccc230e8a6e5be9160b8cdf2864dd2a001c28b6",
+					"0x2b3455ec7fedf16e646268bf88846bd7a2319bb2",
+					"0x4613f3bca5c44ea06337a9e439fbc6d42e501d0a",
+					"0xd343b217de44030afaa275f54d31a9317c7f441e",
+					"0x84ef4b2357079cd7a7c69fd7a37cd0609a679106",
+					"0xda2fef9e4a3230988ff17df2165440f37e8b1708",
+					"0xf4c64518ea10f995918a454158c6b61407ea345c",
+					"0x7602b46df5390e432ef1c307d4f2c9ff6d65cc97",
+					"0xbb9bc244d798123fde783fcc1c72d3bb8c189413",
+					"0x807640a13483f8ac783c557fcdf27be11ea4ac7a"
+				]
+			}
+		}
+	},
+	"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": { "builtin": { "name": "ecrecover", "pricing": { "linear": { "base": 3000, "word": 0 } } } },
+		"0000000000000000000000000000000000000002": { "builtin": { "name": "sha256", "pricing": { "linear": { "base": 60, "word": 12 } } } },
+		"0000000000000000000000000000000000000003": { "builtin": { "name": "ripemd160", "pricing": { "linear": { "base": 600, "word": 120 } } } },
+		"0000000000000000000000000000000000000004": { "builtin": { "name": "identity", "pricing": { "linear": { "base": 15, "word": 3 } } } }
+	}
+}

ethcore/res/ethereum/frontier-dogmatic.json

@@ -9,8 +9,7 @@
 				"durationLimit": "0x0d",
 				"blockReward": "0x4563918244F40000",
 				"registrar" : "0xc6d9d2cd449a754c494264e1809c50e34d64562b",
-				"frontierCompatibilityModeLimit": "0x118c30",
-				"daoRescueSoftFork": true
+				"frontierCompatibilityModeLimit": "0x118c30"
 			}
 		}
 	},
@@ -18,7 +17,9 @@
 		"accountStartNonce": "0x00",
 		"maximumExtraDataSize": "0x20",
 		"minGasLimit": "0x1388",
-		"networkID" : "0x1"
+		"networkID" : "0x1",
+		"forkBlock": "0x1d4c00",
+		"forkCanonHash": "0x94365e3a8c0b35089c1d1195081fe7489b528a84b22199c916180db8b28ade7f"
 	},
 	"genesis": {
 		"seal": {

ethcore/res/ethereum/frontier.json

@@ -10,7 +10,126 @@
 				"blockReward": "0x4563918244F40000",
 				"registrar" : "0xc6d9d2cd449a754c494264e1809c50e34d64562b",
 				"frontierCompatibilityModeLimit": "0x118c30",
-				"daoRescueSoftFork": false
+				"daoHardforkTransition": "0x1d4c00",
+				"daoHardforkBeneficiary": "0xbf4ed7b27f1d666546e30d74d50d173d20bca754",
+				"daoHardforkAccounts": [  
+					"0xd4fe7bc31cedb7bfb8a345f31e668033056b2728",
+					"0xb3fb0e5aba0e20e5c49d252dfd30e102b171a425",
+					"0x2c19c7f9ae8b751e37aeb2d93a699722395ae18f",
+					"0xecd135fa4f61a655311e86238c92adcd779555d2",
+					"0x1975bd06d486162d5dc297798dfc41edd5d160a7",
+					"0xa3acf3a1e16b1d7c315e23510fdd7847b48234f6",
+					"0x319f70bab6845585f412ec7724b744fec6095c85",
+					"0x06706dd3f2c9abf0a21ddcc6941d9b86f0596936",
+					"0x5c8536898fbb74fc7445814902fd08422eac56d0",
+					"0x6966ab0d485353095148a2155858910e0965b6f9",
+					"0x779543a0491a837ca36ce8c635d6154e3c4911a6",
+					"0x2a5ed960395e2a49b1c758cef4aa15213cfd874c",
+					"0x5c6e67ccd5849c0d29219c4f95f1a7a93b3f5dc5",
+					"0x9c50426be05db97f5d64fc54bf89eff947f0a321",
+					"0x200450f06520bdd6c527622a273333384d870efb",
+					"0xbe8539bfe837b67d1282b2b1d61c3f723966f049",
+					"0x6b0c4d41ba9ab8d8cfb5d379c69a612f2ced8ecb",
+					"0xf1385fb24aad0cd7432824085e42aff90886fef5",
+					"0xd1ac8b1ef1b69ff51d1d401a476e7e612414f091",
+					"0x8163e7fb499e90f8544ea62bbf80d21cd26d9efd",
+					"0x51e0ddd9998364a2eb38588679f0d2c42653e4a6",
+					"0x627a0a960c079c21c34f7612d5d230e01b4ad4c7",
+					"0xf0b1aa0eb660754448a7937c022e30aa692fe0c5",
+					"0x24c4d950dfd4dd1902bbed3508144a54542bba94",
+					"0x9f27daea7aca0aa0446220b98d028715e3bc803d",
+					"0xa5dc5acd6a7968a4554d89d65e59b7fd3bff0f90",
+					"0xd9aef3a1e38a39c16b31d1ace71bca8ef58d315b",
+					"0x63ed5a272de2f6d968408b4acb9024f4cc208ebf",
+					"0x6f6704e5a10332af6672e50b3d9754dc460dfa4d",
+					"0x77ca7b50b6cd7e2f3fa008e24ab793fd56cb15f6",
+					"0x492ea3bb0f3315521c31f273e565b868fc090f17",
+					"0x0ff30d6de14a8224aa97b78aea5388d1c51c1f00",
+					"0x9ea779f907f0b315b364b0cfc39a0fde5b02a416",
+					"0xceaeb481747ca6c540a000c1f3641f8cef161fa7",
+					"0xcc34673c6c40e791051898567a1222daf90be287",
+					"0x579a80d909f346fbfb1189493f521d7f48d52238",
+					"0xe308bd1ac5fda103967359b2712dd89deffb7973",
+					"0x4cb31628079fb14e4bc3cd5e30c2f7489b00960c",
+					"0xac1ecab32727358dba8962a0f3b261731aad9723",
+					"0x4fd6ace747f06ece9c49699c7cabc62d02211f75",
+					"0x440c59b325d2997a134c2c7c60a8c61611212bad",
+					"0x4486a3d68fac6967006d7a517b889fd3f98c102b",
+					"0x9c15b54878ba618f494b38f0ae7443db6af648ba",
+					"0x27b137a85656544b1ccb5a0f2e561a5703c6a68f",
+					"0x21c7fdb9ed8d291d79ffd82eb2c4356ec0d81241",
+					"0x23b75c2f6791eef49c69684db4c6c1f93bf49a50",
+					"0x1ca6abd14d30affe533b24d7a21bff4c2d5e1f3b",
+					"0xb9637156d330c0d605a791f1c31ba5890582fe1c",
+					"0x6131c42fa982e56929107413a9d526fd99405560",
+					"0x1591fc0f688c81fbeb17f5426a162a7024d430c2",
+					"0x542a9515200d14b68e934e9830d91645a980dd7a",
+					"0xc4bbd073882dd2add2424cf47d35213405b01324",
+					"0x782495b7b3355efb2833d56ecb34dc22ad7dfcc4",
+					"0x58b95c9a9d5d26825e70a82b6adb139d3fd829eb",
+					"0x3ba4d81db016dc2890c81f3acec2454bff5aada5",
+					"0xb52042c8ca3f8aa246fa79c3feaa3d959347c0ab",
+					"0xe4ae1efdfc53b73893af49113d8694a057b9c0d1",
+					"0x3c02a7bc0391e86d91b7d144e61c2c01a25a79c5",
+					"0x0737a6b837f97f46ebade41b9bc3e1c509c85c53",
+					"0x97f43a37f595ab5dd318fb46e7a155eae057317a",
+					"0x52c5317c848ba20c7504cb2c8052abd1fde29d03",
+					"0x4863226780fe7c0356454236d3b1c8792785748d",
+					"0x5d2b2e6fcbe3b11d26b525e085ff818dae332479",
+					"0x5f9f3392e9f62f63b8eac0beb55541fc8627f42c",
+					"0x057b56736d32b86616a10f619859c6cd6f59092a",
+					"0x9aa008f65de0b923a2a4f02012ad034a5e2e2192",
+					"0x304a554a310c7e546dfe434669c62820b7d83490",
+					"0x914d1b8b43e92723e64fd0a06f5bdb8dd9b10c79",
+					"0x4deb0033bb26bc534b197e61d19e0733e5679784",
+					"0x07f5c1e1bc2c93e0402f23341973a0e043f7bf8a",
+					"0x35a051a0010aba705c9008d7a7eff6fb88f6ea7b",
+					"0x4fa802324e929786dbda3b8820dc7834e9134a2a",
+					"0x9da397b9e80755301a3b32173283a91c0ef6c87e",
+					"0x8d9edb3054ce5c5774a420ac37ebae0ac02343c6",
+					"0x0101f3be8ebb4bbd39a2e3b9a3639d4259832fd9",
+					"0x5dc28b15dffed94048d73806ce4b7a4612a1d48f",
+					"0xbcf899e6c7d9d5a215ab1e3444c86806fa854c76",
+					"0x12e626b0eebfe86a56d633b9864e389b45dcb260",
+					"0xa2f1ccba9395d7fcb155bba8bc92db9bafaeade7",
+					"0xec8e57756626fdc07c63ad2eafbd28d08e7b0ca5",
+					"0xd164b088bd9108b60d0ca3751da4bceb207b0782",
+					"0x6231b6d0d5e77fe001c2a460bd9584fee60d409b",
+					"0x1cba23d343a983e9b5cfd19496b9a9701ada385f",
+					"0xa82f360a8d3455c5c41366975bde739c37bfeb8a",
+					"0x9fcd2deaff372a39cc679d5c5e4de7bafb0b1339",
+					"0x005f5cee7a43331d5a3d3eec71305925a62f34b6",
+					"0x0e0da70933f4c7849fc0d203f5d1d43b9ae4532d",
+					"0xd131637d5275fd1a68a3200f4ad25c71a2a9522e",
+					"0xbc07118b9ac290e4622f5e77a0853539789effbe",
+					"0x47e7aa56d6bdf3f36be34619660de61275420af8",
+					"0xacd87e28b0c9d1254e868b81cba4cc20d9a32225",
+					"0xadf80daec7ba8dcf15392f1ac611fff65d94f880",
+					"0x5524c55fb03cf21f549444ccbecb664d0acad706",
+					"0x40b803a9abce16f50f36a77ba41180eb90023925",
+					"0xfe24cdd8648121a43a7c86d289be4dd2951ed49f",
+					"0x17802f43a0137c506ba92291391a8a8f207f487d",
+					"0x253488078a4edf4d6f42f113d1e62836a942cf1a",
+					"0x86af3e9626fce1957c82e88cbf04ddf3a2ed7915",
+					"0xb136707642a4ea12fb4bae820f03d2562ebff487",
+					"0xdbe9b615a3ae8709af8b93336ce9b477e4ac0940",
+					"0xf14c14075d6c4ed84b86798af0956deef67365b5",
+					"0xca544e5c4687d109611d0f8f928b53a25af72448",
+					"0xaeeb8ff27288bdabc0fa5ebb731b6f409507516c",
+					"0xcbb9d3703e651b0d496cdefb8b92c25aeb2171f7",
+					"0x6d87578288b6cb5549d5076a207456a1f6a63dc0",
+					"0xb2c6f0dfbb716ac562e2d85d6cb2f8d5ee87603e",
+					"0xaccc230e8a6e5be9160b8cdf2864dd2a001c28b6",
+					"0x2b3455ec7fedf16e646268bf88846bd7a2319bb2",
+					"0x4613f3bca5c44ea06337a9e439fbc6d42e501d0a",
+					"0xd343b217de44030afaa275f54d31a9317c7f441e",
+					"0x84ef4b2357079cd7a7c69fd7a37cd0609a679106",
+					"0xda2fef9e4a3230988ff17df2165440f37e8b1708",
+					"0xf4c64518ea10f995918a454158c6b61407ea345c",
+					"0x7602b46df5390e432ef1c307d4f2c9ff6d65cc97",
+					"0xbb9bc244d798123fde783fcc1c72d3bb8c189413",
+					"0x807640a13483f8ac783c557fcdf27be11ea4ac7a"
+				]
 			}
 		}
 	},
@@ -18,7 +137,9 @@
 		"accountStartNonce": "0x00",
 		"maximumExtraDataSize": "0x20",
 		"minGasLimit": "0x1388",
-		"networkID" : "0x1"
+		"networkID" : "0x1",
+		"forkBlock": "0x1d4c00",
+		"forkCanonHash": "0x4985f5ca3d2afbec36529aa96f74de3cc10a2a4a6c44f2157a57d2c6059a11bb"
 	},
 	"genesis": {
 		"seal": {

ethcore/res/ethereum/frontier_like_test.json

@@ -10,7 +10,126 @@
 				"blockReward": "0x4563918244F40000",
 				"registrar" : "0xc6d9d2cd449a754c494264e1809c50e34d64562b",
 				"frontierCompatibilityModeLimit": "0x118c30",
-				"daoRescueSoftFork": false
+				"daoHardforkTransition": "0x1d4c00",
+				"daoHardforkBeneficiary": "0xbf4ed7b27f1d666546e30d74d50d173d20bca754",
+				"daoHardforkAccounts": [  
+					"0xd4fe7bc31cedb7bfb8a345f31e668033056b2728",
+					"0xb3fb0e5aba0e20e5c49d252dfd30e102b171a425",
+					"0x2c19c7f9ae8b751e37aeb2d93a699722395ae18f",
+					"0xecd135fa4f61a655311e86238c92adcd779555d2",
+					"0x1975bd06d486162d5dc297798dfc41edd5d160a7",
+					"0xa3acf3a1e16b1d7c315e23510fdd7847b48234f6",
+					"0x319f70bab6845585f412ec7724b744fec6095c85",
+					"0x06706dd3f2c9abf0a21ddcc6941d9b86f0596936",
+					"0x5c8536898fbb74fc7445814902fd08422eac56d0",
+					"0x6966ab0d485353095148a2155858910e0965b6f9",
+					"0x779543a0491a837ca36ce8c635d6154e3c4911a6",
+					"0x2a5ed960395e2a49b1c758cef4aa15213cfd874c",
+					"0x5c6e67ccd5849c0d29219c4f95f1a7a93b3f5dc5",
+					"0x9c50426be05db97f5d64fc54bf89eff947f0a321",
+					"0x200450f06520bdd6c527622a273333384d870efb",
+					"0xbe8539bfe837b67d1282b2b1d61c3f723966f049",
+					"0x6b0c4d41ba9ab8d8cfb5d379c69a612f2ced8ecb",
+					"0xf1385fb24aad0cd7432824085e42aff90886fef5",
+					"0xd1ac8b1ef1b69ff51d1d401a476e7e612414f091",
+					"0x8163e7fb499e90f8544ea62bbf80d21cd26d9efd",
+					"0x51e0ddd9998364a2eb38588679f0d2c42653e4a6",
+					"0x627a0a960c079c21c34f7612d5d230e01b4ad4c7",
+					"0xf0b1aa0eb660754448a7937c022e30aa692fe0c5",
+					"0x24c4d950dfd4dd1902bbed3508144a54542bba94",
+					"0x9f27daea7aca0aa0446220b98d028715e3bc803d",
+					"0xa5dc5acd6a7968a4554d89d65e59b7fd3bff0f90",
+					"0xd9aef3a1e38a39c16b31d1ace71bca8ef58d315b",
+					"0x63ed5a272de2f6d968408b4acb9024f4cc208ebf",
+					"0x6f6704e5a10332af6672e50b3d9754dc460dfa4d",
+					"0x77ca7b50b6cd7e2f3fa008e24ab793fd56cb15f6",
+					"0x492ea3bb0f3315521c31f273e565b868fc090f17",
+					"0x0ff30d6de14a8224aa97b78aea5388d1c51c1f00",
+					"0x9ea779f907f0b315b364b0cfc39a0fde5b02a416",
+					"0xceaeb481747ca6c540a000c1f3641f8cef161fa7",
+					"0xcc34673c6c40e791051898567a1222daf90be287",
+					"0x579a80d909f346fbfb1189493f521d7f48d52238",
+					"0xe308bd1ac5fda103967359b2712dd89deffb7973",
+					"0x4cb31628079fb14e4bc3cd5e30c2f7489b00960c",
+					"0xac1ecab32727358dba8962a0f3b261731aad9723",
+					"0x4fd6ace747f06ece9c49699c7cabc62d02211f75",
+					"0x440c59b325d2997a134c2c7c60a8c61611212bad",
+					"0x4486a3d68fac6967006d7a517b889fd3f98c102b",
+					"0x9c15b54878ba618f494b38f0ae7443db6af648ba",
+					"0x27b137a85656544b1ccb5a0f2e561a5703c6a68f",
+					"0x21c7fdb9ed8d291d79ffd82eb2c4356ec0d81241",
+					"0x23b75c2f6791eef49c69684db4c6c1f93bf49a50",
+					"0x1ca6abd14d30affe533b24d7a21bff4c2d5e1f3b",
+					"0xb9637156d330c0d605a791f1c31ba5890582fe1c",
+					"0x6131c42fa982e56929107413a9d526fd99405560",
+					"0x1591fc0f688c81fbeb17f5426a162a7024d430c2",
+					"0x542a9515200d14b68e934e9830d91645a980dd7a",
+					"0xc4bbd073882dd2add2424cf47d35213405b01324",
+					"0x782495b7b3355efb2833d56ecb34dc22ad7dfcc4",
+					"0x58b95c9a9d5d26825e70a82b6adb139d3fd829eb",
+					"0x3ba4d81db016dc2890c81f3acec2454bff5aada5",
+					"0xb52042c8ca3f8aa246fa79c3feaa3d959347c0ab",
+					"0xe4ae1efdfc53b73893af49113d8694a057b9c0d1",
+					"0x3c02a7bc0391e86d91b7d144e61c2c01a25a79c5",
+					"0x0737a6b837f97f46ebade41b9bc3e1c509c85c53",
+					"0x97f43a37f595ab5dd318fb46e7a155eae057317a",
+					"0x52c5317c848ba20c7504cb2c8052abd1fde29d03",
+					"0x4863226780fe7c0356454236d3b1c8792785748d",
+					"0x5d2b2e6fcbe3b11d26b525e085ff818dae332479",
+					"0x5f9f3392e9f62f63b8eac0beb55541fc8627f42c",
+					"0x057b56736d32b86616a10f619859c6cd6f59092a",
+					"0x9aa008f65de0b923a2a4f02012ad034a5e2e2192",
+					"0x304a554a310c7e546dfe434669c62820b7d83490",
+					"0x914d1b8b43e92723e64fd0a06f5bdb8dd9b10c79",
+					"0x4deb0033bb26bc534b197e61d19e0733e5679784",
+					"0x07f5c1e1bc2c93e0402f23341973a0e043f7bf8a",
+					"0x35a051a0010aba705c9008d7a7eff6fb88f6ea7b",
+					"0x4fa802324e929786dbda3b8820dc7834e9134a2a",
+					"0x9da397b9e80755301a3b32173283a91c0ef6c87e",
+					"0x8d9edb3054ce5c5774a420ac37ebae0ac02343c6",
+					"0x0101f3be8ebb4bbd39a2e3b9a3639d4259832fd9",
+					"0x5dc28b15dffed94048d73806ce4b7a4612a1d48f",
+					"0xbcf899e6c7d9d5a215ab1e3444c86806fa854c76",
+					"0x12e626b0eebfe86a56d633b9864e389b45dcb260",
+					"0xa2f1ccba9395d7fcb155bba8bc92db9bafaeade7",
+					"0xec8e57756626fdc07c63ad2eafbd28d08e7b0ca5",
+					"0xd164b088bd9108b60d0ca3751da4bceb207b0782",
+					"0x6231b6d0d5e77fe001c2a460bd9584fee60d409b",
+					"0x1cba23d343a983e9b5cfd19496b9a9701ada385f",
+					"0xa82f360a8d3455c5c41366975bde739c37bfeb8a",
+					"0x9fcd2deaff372a39cc679d5c5e4de7bafb0b1339",
+					"0x005f5cee7a43331d5a3d3eec71305925a62f34b6",
+					"0x0e0da70933f4c7849fc0d203f5d1d43b9ae4532d",
+					"0xd131637d5275fd1a68a3200f4ad25c71a2a9522e",
+					"0xbc07118b9ac290e4622f5e77a0853539789effbe",
+					"0x47e7aa56d6bdf3f36be34619660de61275420af8",
+					"0xacd87e28b0c9d1254e868b81cba4cc20d9a32225",
+					"0xadf80daec7ba8dcf15392f1ac611fff65d94f880",
+					"0x5524c55fb03cf21f549444ccbecb664d0acad706",
+					"0x40b803a9abce16f50f36a77ba41180eb90023925",
+					"0xfe24cdd8648121a43a7c86d289be4dd2951ed49f",
+					"0x17802f43a0137c506ba92291391a8a8f207f487d",
+					"0x253488078a4edf4d6f42f113d1e62836a942cf1a",
+					"0x86af3e9626fce1957c82e88cbf04ddf3a2ed7915",
+					"0xb136707642a4ea12fb4bae820f03d2562ebff487",
+					"0xdbe9b615a3ae8709af8b93336ce9b477e4ac0940",
+					"0xf14c14075d6c4ed84b86798af0956deef67365b5",
+					"0xca544e5c4687d109611d0f8f928b53a25af72448",
+					"0xaeeb8ff27288bdabc0fa5ebb731b6f409507516c",
+					"0xcbb9d3703e651b0d496cdefb8b92c25aeb2171f7",
+					"0x6d87578288b6cb5549d5076a207456a1f6a63dc0",
+					"0xb2c6f0dfbb716ac562e2d85d6cb2f8d5ee87603e",
+					"0xaccc230e8a6e5be9160b8cdf2864dd2a001c28b6",
+					"0x2b3455ec7fedf16e646268bf88846bd7a2319bb2",
+					"0x4613f3bca5c44ea06337a9e439fbc6d42e501d0a",
+					"0xd343b217de44030afaa275f54d31a9317c7f441e",
+					"0x84ef4b2357079cd7a7c69fd7a37cd0609a679106",
+					"0xda2fef9e4a3230988ff17df2165440f37e8b1708",
+					"0xf4c64518ea10f995918a454158c6b61407ea345c",
+					"0x7602b46df5390e432ef1c307d4f2c9ff6d65cc97",
+					"0xbb9bc244d798123fde783fcc1c72d3bb8c189413",
+					"0x807640a13483f8ac783c557fcdf27be11ea4ac7a"
+				]
 			}
 		}
 	},

ethcore/res/ethereum/frontier_like_test_dao_rescue.json

@@ -1,43 +0,0 @@
-{
-	"name": "Frontier (Test)",
-	"engine": {
-		"Ethash": {
-			"params": {
-				"gasLimitBoundDivisor": "0x0400",
-				"minimumDifficulty": "0x020000",
-				"difficultyBoundDivisor": "0x0800",
-				"durationLimit": "0x0d",
-				"blockReward": "0x4563918244F40000",
-				"registrar" : "0xc6d9d2cd449a754c494264e1809c50e34d64562b",
-				"frontierCompatibilityModeLimit": "0x118c30",
-				"daoRescueSoftFork": true
-			}
-		}
-	},
-	"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": { "builtin": { "name": "ecrecover", "pricing": { "linear": { "base": 3000, "word": 0 } } } },
-		"0000000000000000000000000000000000000002": { "builtin": { "name": "sha256", "pricing": { "linear": { "base": 60, "word": 12 } } } },
-		"0000000000000000000000000000000000000003": { "builtin": { "name": "ripemd160", "pricing": { "linear": { "base": 600, "word": 120 } } } },
-		"0000000000000000000000000000000000000004": { "builtin": { "name": "identity", "pricing": { "linear": { "base": 15, "word": 3 } } } }
-	}
-}

ethcore/res/ethereum/frontier_test.json

@@ -9,8 +9,7 @@
 				"durationLimit": "0x0d",
 				"blockReward": "0x4563918244F40000",
 				"registrar" : "0xc6d9d2cd449a754c494264e1809c50e34d64562b",
-				"frontierCompatibilityModeLimit": "0xffffffffffffffff",
-				"daoRescueSoftFork": false
+				"frontierCompatibilityModeLimit": "0xffffffffffffffff"
 			}
 		}
 	},

ethcore/res/ethereum/homestead_test.json

@@ -9,8 +9,7 @@
 				"durationLimit": "0x0d",
 				"blockReward": "0x4563918244F40000",
 				"registrar" : "0xc6d9d2cd449a754c494264e1809c50e34d64562b",
-				"frontierCompatibilityModeLimit": 0,
-				"daoRescueSoftFork": false
+				"frontierCompatibilityModeLimit": "0x0"
 			}
 		}
 	},

ethcore/res/ethereum/homestead_test_dao_rescue.json

@@ -1,43 +0,0 @@
-{
-	"name": "Homestead (Test)",
-	"engine": {
-		"Ethash": {
-			"params": {
-				"gasLimitBoundDivisor": "0x0400",
-				"minimumDifficulty": "0x020000",
-				"difficultyBoundDivisor": "0x0800",
-				"durationLimit": "0x0d",
-				"blockReward": "0x4563918244F40000",
-				"registrar" : "0xc6d9d2cd449a754c494264e1809c50e34d64562b",
-				"frontierCompatibilityModeLimit": 0,
-				"daoRescueSoftFork": true
-			}
-		}
-	},
-	"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/morden.json

@@ -9,8 +9,7 @@
 				"durationLimit": "0x0d",
 				"blockReward": "0x4563918244F40000",
 				"registrar": "",
-				"frontierCompatibilityModeLimit": "0x789b0",
-				"daoRescueSoftFork": false
+				"frontierCompatibilityModeLimit": "0x789b0"
 			}
 		}
 	},

ethcore/res/ethereum/olympic.json

@@ -8,9 +8,7 @@
 				"difficultyBoundDivisor": "0x0800",
 				"durationLimit": "0x08",
 				"blockReward": "0x14D1120D7B160000",
-				"registrar": "5e70c0bbcd5636e0f9f9316e9f8633feb64d4050",
-				"frontierCompatibilityModeLimit": "0xffffffffffffffff",
-				"daoRescueSoftFork": false
+				"registrar": "5e70c0bbcd5636e0f9f9316e9f8633feb64d4050"
 			}
 		}
 	},

ethcore/src/account.rs

@@ -58,8 +58,8 @@ impl Account {
 			nonce: pod.nonce,
 			storage_root: SHA3_NULL_RLP,
 			storage_overlay: RefCell::new(pod.storage.into_iter().map(|(k, v)| (k, (Filth::Dirty, v))).collect()),
-			code_hash: Some(pod.code.sha3()),
-			code_cache: pod.code
+			code_hash: pod.code.as_ref().map(|c| c.sha3()),
+			code_cache: pod.code.as_ref().map_or_else(|| { warn!("POD account with unknown code is being created! Assuming no code."); vec![] }, |c| c.clone()),
 		}
 	}
 

ethcore/src/action_params.rs

@@ -17,6 +17,7 @@
 //! Evm input params.
 use common::*;
 use ethjson;
+use types::executed::CallType;
 
 /// Transaction value
 #[derive(Clone, Debug)]
@@ -58,7 +59,10 @@ pub struct ActionParams {
 	/// Code being executed.
 	pub code: Option<Bytes>,
 	/// Input data.
-	pub data: Option<Bytes>
+	pub data: Option<Bytes>,
+	/// Type of call
+	pub call_type: CallType,
+
 }
 
 impl Default for ActionParams {
@@ -73,16 +77,18 @@ impl Default for ActionParams {
 			gas_price: U256::zero(),
 			value: ActionValue::Transfer(U256::zero()),
 			code: None,
-			data: None
+			data: None,
+			call_type: CallType::None,
 		}
 	}
 }
 
 impl From<ethjson::vm::Transaction> for ActionParams {
 	fn from(t: ethjson::vm::Transaction) -> Self {
+		let address: Address = t.address.into();
 		ActionParams {
 			code_address: Address::new(),
-			address: t.address.into(),
+			address: address,
 			sender: t.sender.into(),
 			origin: t.origin.into(),
 			code: Some(t.code.into()),
@@ -90,6 +96,7 @@ impl From<ethjson::vm::Transaction> for ActionParams {
 			gas: t.gas.into(),
 			gas_price: t.gas_price.into(),
 			value: ActionValue::Transfer(t.value.into()),
+			call_type: match address.is_zero() { true => CallType::None, false => CallType::Call },	// TODO @debris is this correct?
 		}
 	}
 }

ethcore/src/basic_authority.rs

@@ -203,7 +203,6 @@ mod tests {
 			timestamp: 0,
 			difficulty: 0.into(),
 			last_hashes: vec![],
-			dao_rescue_block_gas_limit: None,
 			gas_used: 0.into(),
 			gas_limit: 0.into(),
 		});
@@ -254,7 +253,7 @@ mod tests {
 		spec.ensure_db_good(db.as_hashdb_mut());
 		let last_hashes = vec![genesis_header.hash()];
 		let vm_factory = Default::default();
-		let b = OpenBlock::new(engine.deref(), &vm_factory, false, db, &genesis_header, last_hashes, None, addr, (3141562.into(), 31415620.into()), vec![]).unwrap();
+		let b = OpenBlock::new(engine.deref(), &vm_factory, false, db, &genesis_header, last_hashes, addr, (3141562.into(), 31415620.into()), vec![]).unwrap();
 		let b = b.close_and_lock();
 		let seal = engine.generate_seal(b.block(), Some(&tap)).unwrap();
 		assert!(b.try_seal(engine.deref(), seal).is_ok());

ethcore/src/block.rs

@@ -22,7 +22,7 @@ use common::*;
 use engine::*;
 use state::*;
 use verification::PreverifiedBlock;
-use trace::Trace;
+use trace::FlatTrace;
 use evm::Factory as EvmFactory;
 
 /// A block, encoded as it is on the block chain.
@@ -41,8 +41,18 @@ impl Block {
 	pub fn is_good(b: &[u8]) -> bool {
 		UntrustedRlp::new(b).as_val::<Block>().is_ok()
 	}
+
+	/// Get the RLP-encoding of the block without the seal.
+	pub fn rlp_bytes(&self, seal: Seal) -> Bytes {
+		let mut block_rlp = RlpStream::new_list(3);
+		self.header.stream_rlp(&mut block_rlp, seal);
+		block_rlp.append(&self.transactions);
+		block_rlp.append(&self.uncles);
+		block_rlp.out()
+	}
 }
 
+
 impl Decodable for Block {
 	fn decode<D>(decoder: &D) -> Result<Self, DecoderError> where D: Decoder {
 		if decoder.as_raw().len() != try!(decoder.as_rlp().payload_info()).total() {
@@ -68,7 +78,7 @@ pub struct ExecutedBlock {
 	receipts: Vec<Receipt>,
 	transactions_set: HashSet<H256>,
 	state: State,
-	traces: Option<Vec<Trace>>,
+	traces: Option<Vec<Vec<FlatTrace>>>,
 }
 
 /// A set of references to `ExecutedBlock` fields that are publicly accessible.
@@ -84,7 +94,7 @@ pub struct BlockRefMut<'a> {
 	/// State.
 	pub state: &'a mut State,
 	/// Traces.
-	pub traces: &'a Option<Vec<Trace>>,
+	pub traces: &'a Option<Vec<Vec<FlatTrace>>>,
 }
 
 /// A set of immutable references to `ExecutedBlock` fields that are publicly accessible.
@@ -100,7 +110,7 @@ pub struct BlockRef<'a> {
 	/// State.
 	pub state: &'a State,
 	/// Traces.
-	pub traces: &'a Option<Vec<Trace>>,
+	pub traces: &'a Option<Vec<Vec<FlatTrace>>>,
 }
 
 impl ExecutedBlock {
@@ -142,9 +152,12 @@ impl ExecutedBlock {
 
 /// Trait for a object that is a `ExecutedBlock`.
 pub trait IsBlock {
-	/// Get the block associated with this object.
+	/// Get the `ExecutedBlock` associated with this object.
 	fn block(&self) -> &ExecutedBlock;
 
+	/// Get the base `Block` object associated with this.
+	fn base(&self) -> &Block { &self.block().base }
+
 	/// Get the header associated with this object's block.
 	fn header(&self) -> &Header { &self.block().base.header }
 
@@ -158,7 +171,7 @@ pub trait IsBlock {
 	fn receipts(&self) -> &Vec<Receipt> { &self.block().receipts }
 
 	/// Get all information concerning transaction tracing in this block.
-	fn traces(&self) -> &Option<Vec<Trace>> { &self.block().traces }
+	fn traces(&self) -> &Option<Vec<Vec<FlatTrace>>> { &self.block().traces }
 
 	/// Get all uncles in this block.
 	fn uncles(&self) -> &Vec<Header> { &self.block().base.uncles }
@@ -183,7 +196,6 @@ pub struct OpenBlock<'x> {
 	engine: &'x Engine,
 	vm_factory: &'x EvmFactory,
 	last_hashes: LastHashes,
-	dao_rescue_block_gas_limit: Option<U256>,
 }
 
 /// Just like `OpenBlock`, except that we've applied `Engine::on_close_block`, finished up the non-seal header fields,
@@ -195,7 +207,6 @@ pub struct ClosedBlock {
 	block: ExecutedBlock,
 	uncle_bytes: Bytes,
 	last_hashes: LastHashes,
-	dao_rescue_block_gas_limit: Option<U256>,
 	unclosed_state: State,
 }
 
@@ -226,7 +237,6 @@ impl<'x> OpenBlock<'x> {
 		db: Box<JournalDB>,
 		parent: &Header,
 		last_hashes: LastHashes,
-		dao_rescue_block_gas_limit: Option<U256>,
 		author: Address,
 		gas_range_target: (U256, U256),
 		extra_data: Bytes,
@@ -237,7 +247,6 @@ impl<'x> OpenBlock<'x> {
 			engine: engine,
 			vm_factory: vm_factory,
 			last_hashes: last_hashes,
-			dao_rescue_block_gas_limit: dao_rescue_block_gas_limit,
 		};
 
 		r.block.base.header.parent_hash = parent.hash();
@@ -294,7 +303,6 @@ impl<'x> OpenBlock<'x> {
 	/// Get the environment info concerning this block.
 	pub fn env_info(&self) -> EnvInfo {
 		// TODO: memoise.
-		const SOFT_FORK_BLOCK: u64 = 1_800_000;
 		EnvInfo {
 			number: self.block.base.header.number,
 			author: self.block.base.header.author.clone(),
@@ -303,7 +311,6 @@ impl<'x> OpenBlock<'x> {
 			last_hashes: self.last_hashes.clone(),		// TODO: should be a reference.
 			gas_used: self.block.receipts.last().map_or(U256::zero(), |r| r.gas_used),
 			gas_limit: self.block.base.header.gas_limit.clone(),
-			dao_rescue_block_gas_limit: if self.block.base.header.number == SOFT_FORK_BLOCK { Some(self.block.base.header.gas_limit) } else { self.dao_rescue_block_gas_limit },
 		}
 	}
 
@@ -322,7 +329,7 @@ impl<'x> OpenBlock<'x> {
 				self.block.transactions_set.insert(h.unwrap_or_else(||t.hash()));
 				self.block.base.transactions.push(t);
 				let t = outcome.trace;
-				self.block.traces.as_mut().map(|traces| traces.push(t.expect("self.block.traces.is_some(): so we must be tracing: qed")));
+				self.block.traces.as_mut().map(|traces| traces.push(t));
 				self.block.receipts.push(outcome.receipt);
 				Ok(&self.block.receipts.last().unwrap())
 			}
@@ -350,7 +357,6 @@ impl<'x> OpenBlock<'x> {
 			block: s.block,
 			uncle_bytes: uncle_bytes,
 			last_hashes: s.last_hashes,
-			dao_rescue_block_gas_limit: s.dao_rescue_block_gas_limit,
 			unclosed_state: unclosed_state,
 		}
 	}
@@ -410,7 +416,6 @@ impl ClosedBlock {
 			engine: engine,
 			vm_factory: vm_factory,
 			last_hashes: self.last_hashes,
-			dao_rescue_block_gas_limit: self.dao_rescue_block_gas_limit,
 		}
 	}
 }
@@ -480,7 +485,6 @@ pub fn enact(
 	db: Box<JournalDB>,
 	parent: &Header,
 	last_hashes: LastHashes,
-	dao_rescue_block_gas_limit: Option<U256>,
 	vm_factory: &EvmFactory
 ) -> Result<LockedBlock, Error> {
 	{
@@ -490,10 +494,12 @@ pub fn enact(
 		}
 	}
 
-	let mut b = try!(OpenBlock::new(engine, vm_factory, tracing, db, parent, last_hashes, dao_rescue_block_gas_limit, header.author().clone(), (3141562.into(), 31415620.into()), header.extra_data().clone()));
+	let mut b = try!(OpenBlock::new(engine, vm_factory, tracing, db, parent, last_hashes, Address::new(), (3141562.into(), 31415620.into()), vec![]));
 	b.set_difficulty(*header.difficulty());
 	b.set_gas_limit(*header.gas_limit());
 	b.set_timestamp(header.timestamp());
+	b.set_author(header.author().clone());
+	b.set_extra_data(header.extra_data().clone()).unwrap_or_else(|e| warn!("Couldn't set extradata: {}. Ignoring.", e));
 	for t in transactions { try!(b.push_transaction(t.clone(), None)); }
 	for u in uncles { try!(b.push_uncle(u.clone())); }
 	Ok(b.close_and_lock())
@@ -508,12 +514,11 @@ pub fn enact_bytes(
 	db: Box<JournalDB>,
 	parent: &Header,
 	last_hashes: LastHashes,
-	dao_rescue_block_gas_limit: Option<U256>,
 	vm_factory: &EvmFactory
 ) -> Result<LockedBlock, Error> {
 	let block = BlockView::new(block_bytes);
 	let header = block.header();
-	enact(&header, &block.transactions(), &block.uncles(), engine, tracing, db, parent, last_hashes, dao_rescue_block_gas_limit, vm_factory)
+	enact(&header, &block.transactions(), &block.uncles(), engine, tracing, db, parent, last_hashes, vm_factory)
 }
 
 /// Enact the block given by `block_bytes` using `engine` on the database `db` with given `parent` block header
@@ -525,11 +530,10 @@ pub fn enact_verified(
 	db: Box<JournalDB>,
 	parent: &Header,
 	last_hashes: LastHashes,
-	dao_rescue_block_gas_limit: Option<U256>,
 	vm_factory: &EvmFactory
 ) -> Result<LockedBlock, Error> {
 	let view = BlockView::new(&block.bytes);
-	enact(&block.header, &block.transactions, &view.uncles(), engine, tracing, db, parent, last_hashes, dao_rescue_block_gas_limit, vm_factory)
+	enact(&block.header, &block.transactions, &view.uncles(), engine, tracing, db, parent, last_hashes, vm_factory)
 }
 
 /// Enact the block given by `block_bytes` using `engine` on the database `db` with given `parent` block header. Seal the block aferwards
@@ -541,11 +545,10 @@ pub fn enact_and_seal(
 	db: Box<JournalDB>,
 	parent: &Header,
 	last_hashes: LastHashes,
-	dao_rescue_block_gas_limit: Option<U256>,
 	vm_factory: &EvmFactory
 ) -> Result<SealedBlock, Error> {
 	let header = BlockView::new(block_bytes).header_view();
-	Ok(try!(try!(enact_bytes(block_bytes, engine, tracing, db, parent, last_hashes, dao_rescue_block_gas_limit, vm_factory)).seal(engine, header.seal())))
+	Ok(try!(try!(enact_bytes(block_bytes, engine, tracing, db, parent, last_hashes, vm_factory)).seal(engine, header.seal())))
 }
 
 #[cfg(test)]
@@ -565,7 +568,7 @@ mod tests {
 		spec.ensure_db_good(db.as_hashdb_mut());
 		let last_hashes = vec![genesis_header.hash()];
 		let vm_factory = Default::default();
-		let b = OpenBlock::new(engine.deref(), &vm_factory, false, db, &genesis_header, last_hashes, None, Address::zero(), (3141562.into(), 31415620.into()), vec![]).unwrap();
+		let b = OpenBlock::new(engine.deref(), &vm_factory, false, db, &genesis_header, last_hashes, Address::zero(), (3141562.into(), 31415620.into()), vec![]).unwrap();
 		let b = b.close_and_lock();
 		let _ = b.seal(engine.deref(), vec![]);
 	}
@@ -581,7 +584,7 @@ mod tests {
 		let mut db = db_result.take();
 		spec.ensure_db_good(db.as_hashdb_mut());
 		let vm_factory = Default::default();
-		let b = OpenBlock::new(engine.deref(), &vm_factory, false, db, &genesis_header, vec![genesis_header.hash()], None, Address::zero(), (3141562.into(), 31415620.into()), vec![]).unwrap()
+		let b = OpenBlock::new(engine.deref(), &vm_factory, false, db, &genesis_header, vec![genesis_header.hash()], Address::zero(), (3141562.into(), 31415620.into()), vec![]).unwrap()
 			.close_and_lock().seal(engine.deref(), vec![]).unwrap();
 		let orig_bytes = b.rlp_bytes();
 		let orig_db = b.drain();
@@ -589,7 +592,7 @@ mod tests {
 		let mut db_result = get_temp_journal_db();
 		let mut db = db_result.take();
 		spec.ensure_db_good(db.as_hashdb_mut());
-		let e = enact_and_seal(&orig_bytes, engine.deref(), false, db, &genesis_header, vec![genesis_header.hash()], None, &Default::default()).unwrap();
+		let e = enact_and_seal(&orig_bytes, engine.deref(), false, db, &genesis_header, vec![genesis_header.hash()], &Default::default()).unwrap();
 
 		assert_eq!(e.rlp_bytes(), orig_bytes);
 
@@ -609,7 +612,7 @@ mod tests {
 		let mut db = db_result.take();
 		spec.ensure_db_good(db.as_hashdb_mut());
 		let vm_factory = Default::default();
-		let mut open_block = OpenBlock::new(engine.deref(), &vm_factory, false, db, &genesis_header, vec![genesis_header.hash()], None, Address::zero(), (3141562.into(), 31415620.into()), vec![]).unwrap();
+		let mut open_block = OpenBlock::new(engine.deref(), &vm_factory, false, db, &genesis_header, vec![genesis_header.hash()], Address::zero(), (3141562.into(), 31415620.into()), vec![]).unwrap();
 		let mut uncle1_header = Header::new();
 		uncle1_header.extra_data = b"uncle1".to_vec();
 		let mut uncle2_header = Header::new();
@@ -624,7 +627,7 @@ mod tests {
 		let mut db_result = get_temp_journal_db();
 		let mut db = db_result.take();
 		spec.ensure_db_good(db.as_hashdb_mut());
-		let e = enact_and_seal(&orig_bytes, engine.deref(), false, db, &genesis_header, vec![genesis_header.hash()], None, &Default::default()).unwrap();
+		let e = enact_and_seal(&orig_bytes, engine.deref(), false, db, &genesis_header, vec![genesis_header.hash()], &Default::default()).unwrap();
 
 		let bytes = e.rlp_bytes();
 		assert_eq!(bytes, orig_bytes);

ethcore/src/blockchain/blockchain.rs

@@ -30,7 +30,7 @@ use blockchain::best_block::BestBlock;
 use types::tree_route::TreeRoute;
 use blockchain::update::ExtrasUpdate;
 use blockchain::{CacheSize, ImportRoute, Config};
-use db::{Writable, Readable, CacheUpdatePolicy};
+use db::{Writable, Readable, CacheUpdatePolicy, Key};
 
 const LOG_BLOOMS_LEVELS: usize = 3;
 const LOG_BLOOMS_ELEMENTS_PER_INDEX: usize = 16;
@@ -295,7 +295,34 @@ impl BlockChain {
 
 		// load best block
 		let best_block_hash = match bc.extras_db.get(b"best").unwrap() {
-			Some(best) => H256::from_slice(&best),
+			Some(best) => {
+				let best = H256::from_slice(&best);
+				let mut b = best.clone();
+				let mut removed = 0;
+				let mut best_num = 0;
+				while !bc.blocks_db.get(&b).unwrap().is_some() {
+					// track back to the best block we have in the blocks database
+					let extras: BlockDetails = bc.extras_db.read(&b).unwrap();
+					type DetailsKey = Key<BlockDetails, Target=H264>;
+					bc.extras_db.delete(&(DetailsKey::key(&b))).unwrap();
+					b = extras.parent;
+					best_num = extras.number;
+					removed += 1;
+				}
+				if b != best {
+					let batch = DBTransaction::new();
+					let range = (best_num + 1) as bc::Number .. (best_num + removed) as bc::Number;
+					let chain = bc::group::BloomGroupChain::new(bc.blooms_config, &bc);
+					let changes = chain.replace(&range, vec![]);
+					for (k, v) in changes.into_iter() {
+						batch.write(&LogGroupPosition::from(k), &BloomGroup::from(v));
+					}
+					batch.put(b"best", &b).unwrap();
+					bc.extras_db.write(batch).unwrap();
+					info!("Restored mismatched best block. Was: {}, new: {}", best.hex(), b.hex());
+				}
+				b
+			}
 			None => {
 				// best block does not exist
 				// we need to insert genesis into the cache
@@ -461,7 +488,6 @@ impl BlockChain {
 	/// Applies extras update.
 	fn apply_update(&self, update: ExtrasUpdate) {
 		let batch = DBTransaction::new();
-		batch.put(b"best", &update.info.hash).unwrap();
 
 		{
 			for hash in update.block_details.keys().cloned() {
@@ -484,14 +510,12 @@ impl BlockChain {
 
 		// These cached values must be updated last and togeterh
 		{
-			let mut best_block = self.best_block.write().unwrap();
-			let mut write_hashes = self.block_hashes.write().unwrap();
-			let mut write_txs = self.transaction_addresses.write().unwrap();
-
 			// update best block
 			match update.info.location {
 				BlockLocation::Branch => (),
 				_ => {
+					batch.put(b"best", &update.info.hash).unwrap();
+					let mut best_block = self.best_block.write().unwrap();
 					*best_block = BestBlock {
 						hash: update.info.hash,
 						number: update.info.number,
@@ -500,8 +524,11 @@ impl BlockChain {
 				}
 			}
 
-			batch.extend_with_cache(write_hashes.deref_mut(), update.block_hashes, CacheUpdatePolicy::Remove);
-			batch.extend_with_cache(write_txs.deref_mut(), update.transactions_addresses, CacheUpdatePolicy::Remove);
+			let mut write_hashes = self.block_hashes.write().unwrap();
+			let mut write_txs = self.transaction_addresses.write().unwrap();
+
+			batch.extend_with_cache(&mut *write_hashes, update.block_hashes, CacheUpdatePolicy::Remove);
+			batch.extend_with_cache(&mut *write_txs, update.transactions_addresses, CacheUpdatePolicy::Remove);
 
 			// update extras database
 			self.extras_db.write(batch).unwrap();
@@ -1162,4 +1189,31 @@ mod tests {
 		assert_eq!(blocks_b2, vec![2]);
 		assert_eq!(blocks_ba, vec![3]);
 	}
+
+	#[test]
+	fn test_best_block_update() {
+		let mut canon_chain = ChainGenerator::default();
+		let mut finalizer = BlockFinalizer::default();
+		let genesis = canon_chain.generate(&mut finalizer).unwrap();
+
+		let temp = RandomTempPath::new();
+
+		{
+			let bc = BlockChain::new(Config::default(), &genesis, temp.as_path());
+			let uncle = canon_chain.fork(1).generate(&mut finalizer.fork()).unwrap();
+
+			// create a longer fork
+			for _ in 0..5 {
+				let canon_block = canon_chain.generate(&mut finalizer).unwrap();
+				bc.insert_block(&canon_block, vec![]);
+			}
+
+			assert_eq!(bc.best_block_number(), 5);
+			bc.insert_block(&uncle, vec![]);
+		}
+
+		// re-loading the blockchain should load the correct best block.
+		let bc = BlockChain::new(Config::default(), &genesis, temp.as_path());
+		assert_eq!(bc.best_block_number(), 5);
+	}
 }

ethcore/src/blooms/bloom.rs

@@ -20,7 +20,7 @@ use util::HeapSizeOf;
 use basic_types::LogBloom;
 
 /// Helper structure representing bloom of the trace.
-#[derive(Clone)]
+#[derive(Debug, Clone)]
 pub struct Bloom(LogBloom);
 
 impl From<LogBloom> for Bloom {

ethcore/src/blooms/bloom_group.rs

@@ -20,7 +20,7 @@ use util::HeapSizeOf;
 use super::Bloom;
 
 /// Represents group of X consecutive blooms.
-#[derive(Clone)]
+#[derive(Debug, Clone)]
 pub struct BloomGroup {
 	blooms: Vec<Bloom>,
 }

ethcore/src/client/client.rs

@@ -21,10 +21,11 @@ use std::sync::atomic::{AtomicUsize, Ordering as AtomicOrdering};
 use util::*;
 use util::panics::*;
 use views::BlockView;
-use error::{Error, ImportError, ExecutionError, BlockError, ImportResult};
+use error::{ImportError, ExecutionError, BlockError, ImportResult};
 use header::{BlockNumber, Header};
 use state::State;
 use spec::Spec;
+use basic_types::Seal;
 use engine::Engine;
 use views::HeaderView;
 use service::{NetSyncMessage, SyncMessage};
@@ -38,7 +39,8 @@ use filter::Filter;
 use log_entry::LocalizedLogEntry;
 use block_queue::{BlockQueue, BlockQueueInfo};
 use blockchain::{BlockChain, BlockProvider, TreeRoute, ImportRoute};
-use client::{BlockID, TransactionID, UncleID, TraceId, ClientConfig, DatabaseCompactionProfile, BlockChainClient, MiningBlockChainClient, TraceFilter, CallAnalytics};
+use client::{BlockID, TransactionID, UncleID, TraceId, ClientConfig, DatabaseCompactionProfile,
+	BlockChainClient, MiningBlockChainClient, TraceFilter, CallAnalytics };
 use client::Error as ClientError;
 use env_info::EnvInfo;
 use executive::{Executive, Executed, TransactOptions, contract_address};
@@ -46,10 +48,13 @@ use receipt::LocalizedReceipt;
 pub use blockchain::CacheSize as BlockChainCacheSize;
 use trace::{TraceDB, ImportRequest as TraceImportRequest, LocalizedTrace, Database as TraceDatabase};
 use trace;
+use trace::FlatTransactionTraces;
+
+// re-export
 pub use types::blockchain_info::BlockChainInfo;
 pub use types::block_status::BlockStatus;
 use evm::Factory as EvmFactory;
-use miner::{Miner, MinerService, TransactionImportResult, AccountDetails};
+use miner::{Miner, MinerService};
 
 const MAX_TX_QUEUE_SIZE: usize = 4096;
 
@@ -233,7 +238,7 @@ impl Client {
 		let last_hashes = self.build_last_hashes(header.parent_hash.clone());
 		let db = self.state_db.lock().unwrap().boxed_clone();
 
-		let enact_result = enact_verified(&block, engine, self.tracedb.tracing_enabled(), db, &parent, last_hashes, self.dao_rescue_block_gas_limit(header.parent_hash.clone()), &self.vm_factory);
+		let enact_result = enact_verified(&block, engine, self.tracedb.tracing_enabled(), db, &parent, last_hashes, &self.vm_factory);
 		if let Err(e) = enact_result {
 			warn!(target: "client", "Block import failed for #{} ({})\nError: {:?}", header.number(), header.hash(), e);
 			return Err(());
@@ -287,8 +292,6 @@ impl Client {
 		let _timer = PerfTimer::new("import_verified_blocks");
 		let blocks = self.block_queue.drain(max_blocks_to_import);
 
-		let original_best = self.chain_info().best_block_hash;
-
 		for block in blocks {
 			let header = &block.header;
 
@@ -341,10 +344,6 @@ impl Client {
 			}
 		}
 
-		if self.chain_info().best_block_hash != original_best {
-			self.miner.update_sealing(self);
-		}
-
 		imported
 	}
 
@@ -359,8 +358,13 @@ impl Client {
 		};
 
 		// Commit results
-		let receipts = block.receipts().clone();
-		let traces = From::from(block.traces().clone().unwrap_or_else(Vec::new));
+		let receipts = block.receipts().to_owned();
+		let traces = block.traces().clone().unwrap_or_else(Vec::new);
+		let traces: Vec<FlatTransactionTraces> = traces.into_iter()
+			.map(Into::into)
+			.collect();
+
+		//let traces = From::from(block.traces().clone().unwrap_or_else(Vec::new));
 
 		// CHECK! I *think* this is fine, even if the state_root is equal to another
 		// already-imported block of the same number.
@@ -371,7 +375,7 @@ impl Client {
 		// (when something is in chain but you are not able to fetch details)
 		let route = self.chain.insert_block(block_data, receipts);
 		self.tracedb.import(TraceImportRequest {
-			traces: traces,
+			traces: traces.into(),
 			block_hash: hash.clone(),
 			block_number: number,
 			enacted: route.enacted.clone(),
@@ -384,12 +388,8 @@ impl Client {
 	pub fn import_queued_transactions(&self, transactions: &[Bytes]) -> usize {
 		let _timer = PerfTimer::new("import_queued_transactions");
 		self.queue_transactions.fetch_sub(transactions.len(), AtomicOrdering::SeqCst);
-		let fetch_account = |a: &Address| AccountDetails {
-			nonce: self.latest_nonce(a),
-			balance: self.latest_balance(a),
-		};
-		let tx = transactions.iter().filter_map(|bytes| UntrustedRlp::new(&bytes).as_val().ok()).collect();
-		let results = self.miner.import_transactions(self, tx, fetch_account);
+		let txs = transactions.iter().filter_map(|bytes| UntrustedRlp::new(&bytes).as_val().ok()).collect();
+		let results = self.miner.import_external_transactions(self, txs);
 		results.len()
 	}
 
@@ -399,8 +399,10 @@ impl Client {
 	/// Otherwise, this can fail (but may not) if the DB prunes state.
 	pub fn state_at(&self, id: BlockID) -> Option<State> {
 		// fast path for latest state.
-		if let BlockID::Latest = id.clone() {
-			return Some(self.state())
+		match id.clone() {
+			BlockID::Pending => return self.miner.pending_state().or_else(|| Some(self.state())),
+			BlockID::Latest => return Some(self.state()),
+			_ => {},
 		}
 
 		let block_number = match self.block_number(id.clone()) {
@@ -457,7 +459,7 @@ impl Client {
 			BlockID::Number(number) => Some(number),
 			BlockID::Hash(ref hash) => self.chain.block_number(hash),
 			BlockID::Earliest => Some(0),
-			BlockID::Latest => Some(self.chain.best_block_number())
+			BlockID::Latest | BlockID::Pending => Some(self.chain.best_block_number()),
 		}
 	}
 
@@ -466,7 +468,7 @@ impl Client {
 			BlockID::Hash(hash) => Some(hash),
 			BlockID::Number(number) => chain.block_hash(number),
 			BlockID::Earliest => chain.block_hash(0),
-			BlockID::Latest => Some(chain.best_block_hash())
+			BlockID::Latest | BlockID::Pending => Some(chain.best_block_hash()),
 		}
 	}
 
@@ -494,7 +496,6 @@ impl BlockChainClient for Client {
 			last_hashes: last_hashes,
 			gas_used: U256::zero(),
 			gas_limit: U256::max_value(),
-			dao_rescue_block_gas_limit: self.dao_rescue_block_gas_limit(view.parent_hash()),
 		};
 		// that's just a copy of the state.
 		let mut state = self.state();
@@ -538,6 +539,11 @@ impl BlockChainClient for Client {
 	}
 
 	fn block(&self, id: BlockID) -> Option<Bytes> {
+		if let &BlockID::Pending = &id {
+			if let Some(block) = self.miner.pending_block() { 
+				return Some(block.rlp_bytes(Seal::Without));
+			}
+		}
 		Self::block_hash(&self.chain, id).and_then(|hash| {
 			self.chain.block(&hash)
 		})
@@ -552,6 +558,11 @@ impl BlockChainClient for Client {
 	}
 
 	fn block_total_difficulty(&self, id: BlockID) -> Option<U256> {
+		if let &BlockID::Pending = &id {
+			if let Some(block) = self.miner.pending_block() {
+				return Some(*block.header.difficulty() + self.block_total_difficulty(BlockID::Latest).expect("blocks in chain have details; qed"));
+			} 
+		}
 		Self::block_hash(&self.chain, id).and_then(|hash| self.chain.block_details(&hash)).map(|d| d.total_difficulty)
 	}
 
@@ -772,14 +783,6 @@ impl BlockChainClient for Client {
 		self.build_last_hashes(self.chain.best_block_hash())
 	}
 
-	fn import_transactions(&self, transactions: Vec<SignedTransaction>) -> Vec<Result<TransactionImportResult, Error>> {
-		let fetch_account = |a: &Address| AccountDetails {
-			nonce: self.latest_nonce(a),
-			balance: self.latest_balance(a),
-		};
-		self.miner.import_transactions(self, transactions, fetch_account)
-	}
-
 	fn queue_transactions(&self, transactions: Vec<Bytes>) {
 		if self.queue_transactions.load(AtomicOrdering::Relaxed) > MAX_TX_QUEUE_SIZE {
 			debug!("Ignoring {} transactions: queue is full", transactions.len());
@@ -813,7 +816,6 @@ impl MiningBlockChainClient for Client {
 			self.state_db.lock().unwrap().boxed_clone(),
 			&self.chain.block_header(&h).expect("h is best block hash: so it's header must exist: qed"),
 			self.build_last_hashes(h.clone()),
-			self.dao_rescue_block_gas_limit(h.clone()),
 			author,
 			gas_range_target,
 			extra_data,
@@ -840,8 +842,6 @@ impl MiningBlockChainClient for Client {
 		let _import_lock = self.import_lock.lock();
 		let _timer = PerfTimer::new("import_sealed_block");
 
-		let original_best = self.chain_info().best_block_hash;
-
 		let h = block.header().hash();
 		let number = block.header().number();
 
@@ -862,10 +862,6 @@ impl MiningBlockChainClient for Client {
 			})).unwrap_or_else(|e| warn!("Error sending IO notification: {:?}", e));
 		}
 
-		if self.chain_info().best_block_hash != original_best {
-			self.miner.update_sealing(self);
-		}
-
 		Ok(h)
 	}
 }

ethcore/src/client/mod.rs

@@ -42,13 +42,11 @@ use header::{BlockNumber, Header};
 use transaction::{LocalizedTransaction, SignedTransaction};
 use log_entry::LocalizedLogEntry;
 use filter::Filter;
-use views::{HeaderView, BlockView};
+use views::{BlockView};
 use error::{ImportResult, ExecutionError};
 use receipt::LocalizedReceipt;
 use trace::LocalizedTrace;
 use evm::Factory as EvmFactory;
-use miner::{TransactionImportResult};
-use error::Error as EthError;
 
 /// Options concerning what analytics we run on the call.
 #[derive(Eq, PartialEq, Default, Clone, Copy, Debug)]
@@ -187,9 +185,6 @@ pub trait BlockChainClient : Sync + Send {
 	/// Get last hashes starting from best block.
 	fn last_hashes(&self) -> LastHashes;
 
-	/// import transactions from network/other 3rd party
-	fn import_transactions(&self, transactions: Vec<SignedTransaction>) -> Vec<Result<TransactionImportResult, EthError>>;
-
 	/// Queue transactions for importing.
 	fn queue_transactions(&self, transactions: Vec<Bytes>);
 
@@ -221,28 +216,6 @@ pub trait BlockChainClient : Sync + Send {
 			Err(())
 		}
 	}
-
-	/// Get `Some` gas limit of SOFT_FORK_BLOCK, or `None` if chain is not yet that long.
-	fn dao_rescue_block_gas_limit(&self, chain_hash: H256) -> Option<U256> {
-		const SOFT_FORK_BLOCK: u64 = 1800000;
-		// shortcut if the canon chain is already known.
-		if self.chain_info().best_block_number > SOFT_FORK_BLOCK + 1000 {
-			return self.block_header(BlockID::Number(SOFT_FORK_BLOCK)).map(|header| HeaderView::new(&header).gas_limit());
-		}
-		// otherwise check according to `chain_hash`.
-		if let Some(mut header) = self.block_header(BlockID::Hash(chain_hash)) {
-			if HeaderView::new(&header).number() < SOFT_FORK_BLOCK {
-				None
-			} else {
-				while HeaderView::new(&header).number() != SOFT_FORK_BLOCK {
-					header = self.block_header(BlockID::Hash(HeaderView::new(&header).parent_hash())).expect("chain is complete; parent of chain entry must be in chain; qed");
-				}
-				Some(HeaderView::new(&header).gas_limit())
-			}
-		} else {
-			None
-		}
-	}
 }
 
 /// Extended client interface used for mining

ethcore/src/client/test_client.rs

@@ -20,7 +20,8 @@ use std::sync::atomic::{AtomicUsize, Ordering as AtomicOrder};
 use util::*;
 use transaction::{Transaction, LocalizedTransaction, SignedTransaction, Action};
 use blockchain::TreeRoute;
-use client::{BlockChainClient, MiningBlockChainClient, BlockChainInfo, BlockStatus, BlockID, TransactionID, UncleID, TraceId, TraceFilter, LastHashes, CallAnalytics};
+use client::{BlockChainClient, MiningBlockChainClient, BlockChainInfo, BlockStatus, BlockID,
+	TransactionID, UncleID, TraceId, TraceFilter, LastHashes, CallAnalytics };
 use header::{Header as BlockHeader, BlockNumber};
 use filter::Filter;
 use log_entry::LocalizedLogEntry;
@@ -37,9 +38,6 @@ use executive::Executed;
 use error::{ExecutionError};
 use trace::LocalizedTrace;
 
-use miner::{TransactionImportResult, AccountDetails};
-use error::Error as EthError;
-
 /// Test client.
 pub struct TestBlockChainClient {
 	/// Blocks.
@@ -235,7 +233,7 @@ impl TestBlockChainClient {
 			BlockID::Hash(hash) => Some(hash),
 			BlockID::Number(n) => self.numbers.read().unwrap().get(&(n as usize)).cloned(),
 			BlockID::Earliest => self.numbers.read().unwrap().get(&0).cloned(),
-			BlockID::Latest => self.numbers.read().unwrap().get(&(self.numbers.read().unwrap().len() - 1)).cloned()
+			BlockID::Latest | BlockID::Pending => self.numbers.read().unwrap().get(&(self.numbers.read().unwrap().len() - 1)).cloned()
 		}
 	}
 }
@@ -274,6 +272,10 @@ impl BlockChainClient for TestBlockChainClient {
 		}
 	}
 
+	fn latest_nonce(&self, address: &Address) -> U256 {
+		self.nonce(address, BlockID::Latest).unwrap()
+	}
+
 	fn code(&self, address: &Address) -> Option<Bytes> {
 		self.code.read().unwrap().get(address).cloned()
 	}
@@ -286,6 +288,10 @@ impl BlockChainClient for TestBlockChainClient {
 		}
 	}
 
+	fn latest_balance(&self, address: &Address) -> U256 {
+		self.balance(address, BlockID::Latest).unwrap()
+	}
+
 	fn storage_at(&self, address: &Address, position: &H256, id: BlockID) -> Option<H256> {
 		if let BlockID::Latest = id {
 			Some(self.storage.read().unwrap().get(&(address.clone(), position.clone())).cloned().unwrap_or_else(H256::new))
@@ -487,21 +493,10 @@ impl BlockChainClient for TestBlockChainClient {
 		unimplemented!();
 	}
 
-	fn import_transactions(&self, transactions: Vec<SignedTransaction>) -> Vec<Result<TransactionImportResult, EthError>> {
-		let nonces = self.nonces.read().unwrap();
-		let balances = self.balances.read().unwrap();
-		let fetch_account = |a: &Address| AccountDetails {
-			nonce: nonces[a],
-			balance: balances[a],
-		};
-
-		self.miner.import_transactions(self, transactions, &fetch_account)
-	}
-
 	fn queue_transactions(&self, transactions: Vec<Bytes>) {
 		// import right here
-		let tx = transactions.into_iter().filter_map(|bytes| UntrustedRlp::new(&bytes).as_val().ok()).collect();
-		self.import_transactions(tx);
+		let txs = transactions.into_iter().filter_map(|bytes| UntrustedRlp::new(&bytes).as_val().ok()).collect();
+		self.miner.import_external_transactions(self, txs);
 	}
 
 	fn pending_transactions(&self) -> Vec<SignedTransaction> {

ethcore/src/env_info.rs

@@ -39,9 +39,6 @@ pub struct EnvInfo {
 	pub last_hashes: LastHashes,
 	/// The gas used.
 	pub gas_used: U256,
-
-	/// Block gas limit at DAO rescue block SOFT_FORK_BLOCK or None if not yet there.
-	pub dao_rescue_block_gas_limit: Option<U256>,
 }
 
 impl Default for EnvInfo {
@@ -54,7 +51,6 @@ impl Default for EnvInfo {
 			gas_limit: 0.into(),
 			last_hashes: vec![],
 			gas_used: 0.into(),
-			dao_rescue_block_gas_limit: None,
 		}
 	}
 }
@@ -70,7 +66,6 @@ impl From<ethjson::vm::Env> for EnvInfo {
 			timestamp: e.timestamp.into(),
 			last_hashes: (1..cmp::min(number + 1, 257)).map(|i| format!("{}", number - i).as_bytes().sha3()).collect(),
 			gas_used: U256::zero(),
-			dao_rescue_block_gas_limit: None,
 		}
 	}
 }

ethcore/src/error.rs

@@ -58,8 +58,6 @@ pub enum TransactionError {
 	},
 	/// Transaction's gas limit (aka gas) is invalid.
 	InvalidGasLimit(OutOfBounds<U256>),
-	/// Transaction is invalid for some other reason.
-	DAORescue,
 }
 
 impl fmt::Display for TransactionError {
@@ -78,7 +76,6 @@ impl fmt::Display for TransactionError {
 			GasLimitExceeded { limit, got } =>
 				format!("Gas limit exceeded. Limit={}, Given={}", limit, got),
 			InvalidGasLimit(ref err) => format!("Invalid gas limit. {}", err),
-			DAORescue => "Transaction is invalid due to the DAO rescue.".into(),
 		};
 
 		f.write_fmt(format_args!("Transaction error ({})", msg))

ethcore/src/ethereum/ethash.rs

@@ -39,8 +39,12 @@ pub struct EthashParams {
 	pub registrar: Address,
 	/// Homestead transition block number.
 	pub frontier_compatibility_mode_limit: u64,
-	/// Enable the soft-fork logic.
-	pub dao_rescue_soft_fork: bool,
+	/// DAO hard-fork transition block (X).
+	pub dao_hardfork_transition: u64,
+	/// DAO hard-fork refund contract address (C).
+	pub dao_hardfork_beneficiary: Address,
+	/// DAO hard-fork DAO accounts list (L) 
+	pub dao_hardfork_accounts: Vec<Address>,
 }
 
 impl From<ethjson::spec::EthashParams> for EthashParams {
@@ -51,9 +55,11 @@ impl From<ethjson::spec::EthashParams> for EthashParams {
 			difficulty_bound_divisor: p.difficulty_bound_divisor.into(),
 			duration_limit: p.duration_limit.into(),
 			block_reward: p.block_reward.into(),
-			registrar: p.registrar.into(),
-			frontier_compatibility_mode_limit: p.frontier_compatibility_mode_limit.into(),
-			dao_rescue_soft_fork: p.dao_rescue_soft_fork.into(),
+			registrar: p.registrar.map(Into::into).unwrap_or(Address::new()),
+			frontier_compatibility_mode_limit: p.frontier_compatibility_mode_limit.map(Into::into).unwrap_or(0),
+			dao_hardfork_transition: p.dao_hardfork_transition.map(Into::into).unwrap_or(0x7fffffffffffffff),
+			dao_hardfork_beneficiary: p.dao_hardfork_beneficiary.map(Into::into).unwrap_or(Address::new()),
+			dao_hardfork_accounts: p.dao_hardfork_accounts.unwrap_or(vec![]).into_iter().map(Into::into).collect(),
 		}
 	}
 }
@@ -102,11 +108,7 @@ impl Engine for Ethash {
 		if env_info.number < self.ethash_params.frontier_compatibility_mode_limit {
 			Schedule::new_frontier()
 		} else {
-			let mut s = Schedule::new_homestead();
-			if self.ethash_params.dao_rescue_soft_fork {
-				s.reject_dao_transactions = env_info.dao_rescue_block_gas_limit.map_or(false, |x| x <= 4_000_000.into());
-			}
-			s
+			Schedule::new_homestead()
 		}
 	}
 
@@ -126,10 +128,27 @@ impl Engine for Ethash {
 							(header.gas_used * 6.into() / 5.into()) / bound_divisor))
 			}
 		};
+		if header.number >= self.ethash_params.dao_hardfork_transition &&
+			header.number <= self.ethash_params.dao_hardfork_transition + 9 {
+			header.extra_data = b"dao-hard-fork"[..].to_owned();
+		}  
 		header.note_dirty();
 //		info!("ethash: populate_from_parent #{}: difficulty={} and gas_limit={}", header.number, header.difficulty, header.gas_limit);
 	}
 
+	fn on_new_block(&self, block: &mut ExecutedBlock) {
+		if block.fields().header.number == self.ethash_params.dao_hardfork_transition {
+			// TODO: enable trigger function maybe?
+//			if block.fields().header.gas_limit <= 4_000_000.into() {
+				let mut state = block.fields_mut().state;
+				for child in self.ethash_params.dao_hardfork_accounts.iter() {
+					let b = state.balance(child);
+					state.transfer_balance(child, &self.ethash_params.dao_hardfork_beneficiary, &b);
+				}
+//			}
+		}
+	}
+
 	/// Apply the block reward on finalisation of the block.
 	/// This assumes that all uncles are valid uncles (i.e. of at least one generation before the current).
 	fn on_close_block(&self, block: &mut ExecutedBlock) {
@@ -171,6 +190,17 @@ impl Engine for Ethash {
 		if difficulty < header.difficulty {
 			return Err(From::from(BlockError::InvalidProofOfWork(OutOfBounds { min: Some(header.difficulty), max: None, found: difficulty })));
 		}
+
+		if header.number >= self.ethash_params.dao_hardfork_transition &&
+			header.number <= self.ethash_params.dao_hardfork_transition + 9 &&
+			header.extra_data[..] != b"dao-hard-fork"[..] {
+			return Err(From::from(BlockError::ExtraDataOutOfBounds(OutOfBounds { min: None, max: None, found: 0 })));
+		}
+
+		if header.gas_limit > 0x7fffffffffffffffu64.into() {
+			return Err(From::from(BlockError::InvalidGasLimit(OutOfBounds { min: None, max: Some(0x7fffffffffffffffu64.into()), found: header.gas_limit })));
+		}  
+		
 		Ok(())
 	}
 
@@ -325,7 +355,7 @@ mod tests {
 		spec.ensure_db_good(db.as_hashdb_mut());
 		let last_hashes = vec![genesis_header.hash()];
 		let vm_factory = Default::default();
-		let b = OpenBlock::new(engine.deref(), &vm_factory, false, db, &genesis_header, last_hashes, None, Address::zero(), (3141562.into(), 31415620.into()), vec![]).unwrap();
+		let b = OpenBlock::new(engine.deref(), &vm_factory, false, db, &genesis_header, last_hashes, Address::zero(), (3141562.into(), 31415620.into()), vec![]).unwrap();
 		let b = b.close();
 		assert_eq!(b.state().balance(&Address::zero()), U256::from_str("4563918244f40000").unwrap());
 	}
@@ -340,7 +370,7 @@ mod tests {
 		spec.ensure_db_good(db.as_hashdb_mut());
 		let last_hashes = vec![genesis_header.hash()];
 		let vm_factory = Default::default();
-		let mut b = OpenBlock::new(engine.deref(), &vm_factory, false, db, &genesis_header, last_hashes, None, Address::zero(), (3141562.into(), 31415620.into()), vec![]).unwrap();
+		let mut b = OpenBlock::new(engine.deref(), &vm_factory, false, db, &genesis_header, last_hashes, Address::zero(), (3141562.into(), 31415620.into()), vec![]).unwrap();
 		let mut uncle = Header::new();
 		let uncle_author = address_from_hex("ef2d6d194084c2de36e0dabfce45d046b37d1106");
 		uncle.author = uncle_author.clone();
@@ -369,7 +399,6 @@ mod tests {
 			last_hashes: vec![],
 			gas_used: 0.into(),
 			gas_limit: 0.into(),
-			dao_rescue_block_gas_limit: None,
 		});
 
 		assert!(schedule.stack_limit > 0);
@@ -382,7 +411,6 @@ mod tests {
 			last_hashes: vec![],
 			gas_used: 0.into(),
 			gas_limit: 0.into(),
-			dao_rescue_block_gas_limit: None,
 		});
 
 		assert!(!schedule.have_delegate_call);

ethcore/src/ethereum/mod.rs

@@ -33,11 +33,13 @@ use super::spec::*;
 pub fn new_olympic() -> Spec { Spec::load(include_bytes!("../../res/ethereum/olympic.json")) }
 
 /// Create a new Frontier mainnet chain spec.
-pub fn new_frontier(dao_rescue: bool) -> Spec {
-	Spec::load(match dao_rescue {
-		true => include_bytes!("../../res/ethereum/frontier_dao_rescue.json"),
-		false => include_bytes!("../../res/ethereum/frontier.json"),
-	})
+pub fn new_frontier() -> Spec {
+	Spec::load(include_bytes!("../../res/ethereum/frontier.json"))
+}
+
+/// Create a new Frontier mainnet chain spec without the DAO hardfork.
+pub fn new_frontier_dogmatic() -> Spec {
+	Spec::load(include_bytes!("../../res/ethereum/frontier-dogmatic.json"))
 }
 
 /// Create a new Frontier chain spec as though it never changes to Homestead.
@@ -46,6 +48,9 @@ pub fn new_frontier_test() -> Spec { Spec::load(include_bytes!("../../res/ethere
 /// Create a new Homestead chain spec as though it never changed from Frontier.
 pub fn new_homestead_test() -> Spec { Spec::load(include_bytes!("../../res/ethereum/homestead_test.json")) }
 
+/// Create a new Frontier/Homestead/DAO chain spec with transition points at #5 and #8.
+pub fn new_daohardfork_test() -> Spec { Spec::load(include_bytes!("../../res/ethereum/daohardfork_test.json")) }
+
 /// Create a new Frontier main net chain spec without genesis accounts.
 pub fn new_mainnet_like() -> Spec { Spec::load(include_bytes!("../../res/ethereum/frontier_like_test.json")) }
 
@@ -89,7 +94,7 @@ mod tests {
 
 	#[test]
 	fn frontier() {
-		let frontier = new_frontier(true);
+		let frontier = new_frontier();
 
 		assert_eq!(frontier.state_root(), H256::from_str("d7f8974fb5ac78d9ac099b9ad5018bedc2ce0a72dad1827a1709da30580f0544").unwrap());
 		let genesis = frontier.genesis_block();

ethcore/src/evm/ext.rs

@@ -18,6 +18,7 @@
 
 use util::common::*;
 use evm::{self, Schedule};
+use types::executed::CallType;
 use env_info::*;
 
 /// Result of externalities create function.
@@ -69,13 +70,15 @@ pub trait Ext {
 	/// and true if subcall was successfull.
 	#[cfg_attr(feature="dev", allow(too_many_arguments))]
 	fn call(&mut self,
-			gas: &U256,
-			sender_address: &Address,
-			receive_address: &Address,
-			value: Option<U256>,
-			data: &[u8],
-			code_address: &Address,
-			output: &mut [u8]) -> MessageCallResult;
+		gas: &U256,
+		sender_address: &Address,
+		receive_address: &Address,
+		value: Option<U256>,
+		data: &[u8],
+		code_address: &Address,
+		output: &mut [u8],
+		call_type: CallType
+	) -> MessageCallResult;
 
 	/// Returns code at given address
 	fn extcode(&self, address: &Address) -> Bytes;

ethcore/src/evm/interpreter.rs

@@ -20,6 +20,7 @@ use common::*;
 use super::instructions as instructions;
 use super::instructions::{Instruction, get_info};
 use std::marker::Copy;
+use types::executed::CallType;
 use evm::{self, MessageCallResult, ContractCreateResult, GasLeft};
 
 #[cfg(not(feature = "evm-debug"))]
@@ -648,16 +649,16 @@ impl Interpreter {
 				});
 
 				// Get sender & receive addresses, check if we have balance
-				let (sender_address, receive_address, has_balance) = match instruction {
+				let (sender_address, receive_address, has_balance, call_type) = match instruction {
 					instructions::CALL => {
 						let has_balance = ext.balance(&params.address) >= value.unwrap();
-						(&params.address, &code_address, has_balance)
+						(&params.address, &code_address, has_balance, CallType::Call)
 					},
 					instructions::CALLCODE => {
 						let has_balance = ext.balance(&params.address) >= value.unwrap();
-						(&params.address, &params.address, has_balance)
+						(&params.address, &params.address, has_balance, CallType::CallCode)
 					},
-					instructions::DELEGATECALL => (&params.sender, &params.address, true),
+					instructions::DELEGATECALL => (&params.sender, &params.address, true, CallType::DelegateCall),
 					_ => panic!(format!("Unexpected instruction {} in CALL branch.", instruction))
 				};
 
@@ -672,7 +673,7 @@ impl Interpreter {
 					// and we don't want to copy
 					let input = unsafe { ::std::mem::transmute(self.mem.read_slice(in_off, in_size)) };
 					let output = self.mem.writeable_slice(out_off, out_size);
-					ext.call(&call_gas, sender_address, receive_address, value, input, &code_address, output)
+					ext.call(&call_gas, sender_address, receive_address, value, input, &code_address, output, call_type)
 				};
 
 				return match call_result {

ethcore/src/evm/schedule.rs

@@ -80,8 +80,6 @@ pub struct Schedule {
 	pub tx_data_non_zero_gas: usize,
 	/// Gas price for copying memory
 	pub copy_gas: usize,
-	/// DAO Rescue softfork block
-	pub reject_dao_transactions: bool,
 }
 
 impl Schedule {
@@ -128,7 +126,6 @@ impl Schedule {
 			tx_data_zero_gas: 4,
 			tx_data_non_zero_gas: 68,
 			copy_gas: 3,	
-			reject_dao_transactions: false,
 		}
 	}
 }

ethcore/src/evm/tests.rs

@@ -15,6 +15,7 @@
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
 use common::*;
+use types::executed::CallType;
 use evm::{self, Ext, Schedule, Factory, GasLeft, VMType, ContractCreateResult, MessageCallResult};
 use std::fmt::Debug;
 
@@ -36,7 +37,7 @@ struct FakeCall {
 	receive_address: Option<Address>,
 	value: Option<U256>,
 	data: Bytes,
-	code_address: Option<Address>
+	code_address: Option<Address>,
 }
 
 /// Fake externalities test structure.
@@ -119,7 +120,9 @@ impl Ext for FakeExt {
 			value: Option<U256>,
 			data: &[u8],
 			code_address: &Address,
-			_output: &mut [u8]) -> MessageCallResult {
+			_output: &mut [u8],
+			_call_type: CallType
+		) -> MessageCallResult {
 
 		self.calls.insert(FakeCall {
 			call_type: FakeCallType::Call,

ethcore/src/executive.rs

@@ -18,10 +18,11 @@
 use common::*;
 use state::*;
 use engine::*;
+use types::executed::CallType;
 use evm::{self, Ext, Factory, Finalize};
 use externalities::*;
 use substate::*;
-use trace::{Trace, Tracer, NoopTracer, ExecutiveTracer, VMTrace, VMTracer, ExecutiveVMTracer, NoopVMTracer};
+use trace::{FlatTrace, Tracer, NoopTracer, ExecutiveTracer, VMTrace, VMTracer, ExecutiveVMTracer, NoopVMTracer};
 use crossbeam;
 pub use types::executed::{Executed, ExecutionResult};
 
@@ -173,6 +174,7 @@ impl<'a> Executive<'a> {
 					value: ActionValue::Transfer(t.value),
 					code: Some(t.data.clone()),
 					data: None,
+					call_type: CallType::None,
 				};
 				(self.create(params, &mut substate, &mut tracer, &mut vm_tracer), vec![])
 			},
@@ -187,6 +189,7 @@ impl<'a> Executive<'a> {
 					value: ActionValue::Transfer(t.value),
 					code: self.state.code(address),
 					data: Some(t.data.clone()),
+					call_type: CallType::Call,
 				};
 				// TODO: move output upstream
 				let mut out = vec![];
@@ -195,7 +198,7 @@ impl<'a> Executive<'a> {
 		};
 
 		// finalize here!
-		Ok(try!(self.finalize(t, substate, gas_left, output, tracer.traces().pop(), vm_tracer.drain())))
+		Ok(try!(self.finalize(t, substate, gas_left, output, tracer.traces(), vm_tracer.drain())))
 	}
 
 	fn exec_vm<T, V>(
@@ -248,8 +251,6 @@ impl<'a> Executive<'a> {
 		}
 		trace!("Executive::call(params={:?}) self.env_info={:?}", params, self.info);
 
-		let delegate_call = params.code_address != params.address;
-
 		if self.engine.is_builtin(&params.code_address) {
 			// if destination is builtin, try to execute it
 
@@ -275,20 +276,15 @@ impl<'a> Executive<'a> {
 							trace_info,
 							cost,
 							trace_output,
-							self.depth,
-							vec![],
-							delegate_call
+							vec![]
 						);
 					}
-
 					Ok(params.gas - cost)
 				},
 				// just drain the whole gas
 				false => {
 					self.state.revert_snapshot();
-
-					tracer.trace_failed_call(trace_info, self.depth, vec![], delegate_call);
-
+					tracer.trace_failed_call(trace_info, vec![]);
 					Err(evm::Error::OutOfGas)
 				}
 			}
@@ -320,11 +316,9 @@ impl<'a> Executive<'a> {
 						trace_info,
 						gas - gas_left,
 						trace_output,
-						self.depth,
-						traces,
-						delegate_call
+						traces
 					),
-					_ => tracer.trace_failed_call(trace_info, self.depth, traces, delegate_call),
+					_ => tracer.trace_failed_call(trace_info, traces),
 				};
 
 				trace!(target: "executive", "substate={:?}; unconfirmed_substate={:?}\n", substate, unconfirmed_substate);
@@ -336,7 +330,7 @@ impl<'a> Executive<'a> {
 				// otherwise it's just a basic transaction, only do tracing, if necessary.
 				self.state.clear_snapshot();
 
-				tracer.trace_call(trace_info, U256::zero(), trace_output, self.depth, vec![], delegate_call);
+				tracer.trace_call(trace_info, U256::zero(), trace_output, vec![]);
 				Ok(params.gas)
 			}
 		}
@@ -387,10 +381,9 @@ impl<'a> Executive<'a> {
 				gas - gas_left,
 				trace_output,
 				created,
-				self.depth,
 				subtracer.traces()
 			),
-			_ => tracer.trace_failed_create(trace_info, self.depth, subtracer.traces())
+			_ => tracer.trace_failed_create(trace_info, subtracer.traces())
 		};
 
 		self.enact_result(&res, substate, unconfirmed_substate);
@@ -404,7 +397,7 @@ impl<'a> Executive<'a> {
 		substate: Substate,
 		result: evm::Result<U256>,
 		output: Bytes,
-		trace: Option<Trace>,
+		trace: Vec<FlatTrace>,
 		vm_trace: Option<VMTrace>
 	) -> ExecutionResult {
 		let schedule = self.engine.schedule(self.info);
@@ -496,8 +489,9 @@ mod tests {
 	use substate::*;
 	use tests::helpers::*;
 	use trace::trace;
-	use trace::{Trace, Tracer, NoopTracer, ExecutiveTracer};
+	use trace::{FlatTrace, Tracer, NoopTracer, ExecutiveTracer};
 	use trace::{VMTrace, VMOperation, VMExecutedOperation, MemoryDiff, StorageDiff, VMTracer, NoopVMTracer, ExecutiveVMTracer};
+	use types::executed::CallType;
 
 	#[test]
 	fn test_contract_address() {
@@ -631,6 +625,7 @@ mod tests {
 		params.gas = U256::from(100_000);
 		params.code = Some(code.clone());
 		params.value = ActionValue::Transfer(U256::from(100));
+		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));
@@ -648,35 +643,37 @@ mod tests {
 
 		assert_eq!(gas_left, U256::from(44_752));
 
-		let expected_trace = vec![ Trace {
-			depth: 0,
+		let expected_trace = vec![FlatTrace {
+			trace_address: Default::default(),
+			subtraces: 1,
 			action: trace::Action::Call(trace::Call {
 				from: "cd1722f3947def4cf144679da39c4c32bdc35681".into(),
 				to: "b010143a42d5980c7e5ef0e4a4416dc098a4fed3".into(),
 				value: 100.into(),
 				gas: 100000.into(),
 				input: vec![],
+				call_type: CallType::Call,
 			}),
 			result: trace::Res::Call(trace::CallResult {
 				gas_used: U256::from(55_248),
 				output: vec![],
 			}),
-			subs: vec![Trace {
-				depth: 1,
-				action: trace::Action::Create(trace::Create {
-					from: "b010143a42d5980c7e5ef0e4a4416dc098a4fed3".into(),
-					value: 23.into(),
-					gas: 67979.into(),
-					init: vec![96, 16, 128, 96, 12, 96, 0, 57, 96, 0, 243, 0, 96, 0, 53, 84, 21, 96, 9, 87, 0, 91, 96, 32, 53, 96, 0, 53, 85]
-				}),
-				result: trace::Res::Create(trace::CreateResult {
-					gas_used: U256::from(3224),
-					address: Address::from_str("c6d80f262ae5e0f164e5fde365044d7ada2bfa34").unwrap(),
-					code: vec![96, 0, 53, 84, 21, 96, 9, 87, 0, 91, 96, 32, 53, 96, 0, 53]
-				}),
-				subs: vec![]
-			}]
+		}, FlatTrace {
+			trace_address: vec![0].into_iter().collect(),
+			subtraces: 0,
+			action: trace::Action::Create(trace::Create {
+				from: "b010143a42d5980c7e5ef0e4a4416dc098a4fed3".into(),
+				value: 23.into(),
+				gas: 67979.into(),
+				init: vec![96, 16, 128, 96, 12, 96, 0, 57, 96, 0, 243, 0, 96, 0, 53, 84, 21, 96, 9, 87, 0, 91, 96, 32, 53, 96, 0, 53, 85]
+			}),
+			result: trace::Res::Create(trace::CreateResult {
+				gas_used: U256::from(3224),
+				address: Address::from_str("c6d80f262ae5e0f164e5fde365044d7ada2bfa34").unwrap(),
+				code: vec![96, 0, 53, 84, 21, 96, 9, 87, 0, 91, 96, 32, 53, 96, 0, 53]
+			}),
 		}];
+
 		assert_eq!(tracer.traces(), expected_trace);
 
 		let expected_vm_trace = VMTrace {
@@ -754,8 +751,9 @@ mod tests {
 
 		assert_eq!(gas_left, U256::from(96_776));
 
-		let expected_trace = vec![Trace {
-			depth: 0,
+		let expected_trace = vec![FlatTrace {
+			trace_address: Default::default(),
+			subtraces: 0,
 			action: trace::Action::Create(trace::Create {
 				from: params.sender,
 				value: 100.into(),
@@ -767,8 +765,8 @@ mod tests {
 				address: params.address,
 				code: vec![96, 0, 53, 84, 21, 96, 9, 87, 0, 91, 96, 32, 53, 96, 0, 53]
 			}),
-			subs: vec![]
 		}];
+
 		assert_eq!(tracer.traces(), expected_trace);
 
 		let expected_vm_trace = VMTrace {

ethcore/src/externalities.rs

@@ -21,6 +21,7 @@ use engine::*;
 use executive::*;
 use evm::{self, Schedule, Ext, ContractCreateResult, MessageCallResult, Factory};
 use substate::*;
+use types::executed::CallType;
 use trace::{Tracer, VMTracer};
 
 /// Policy for handling output data on `RETURN` opcode.
@@ -148,6 +149,7 @@ impl<'a, T, V> Ext for Externalities<'a, T, V> where T: 'a + Tracer, V: 'a + VMT
 			value: ActionValue::Transfer(*value),
 			code: Some(code.to_vec()),
 			data: None,
+			call_type: CallType::None,
 		};
 
 		self.state.inc_nonce(&self.origin_info.address);
@@ -170,7 +172,8 @@ impl<'a, T, V> Ext for Externalities<'a, T, V> where T: 'a + Tracer, V: 'a + VMT
 		value: Option<U256>,
 		data: &[u8],
 		code_address: &Address,
-		output: &mut [u8]
+		output: &mut [u8],
+		call_type: CallType
 	) -> MessageCallResult {
 		trace!(target: "externalities", "call");
 
@@ -184,6 +187,7 @@ impl<'a, T, V> Ext for Externalities<'a, T, V> where T: 'a + Tracer, V: 'a + VMT
 			gas_price: self.origin_info.gas_price,
 			code: self.state.code(code_address),
 			data: Some(data.to_vec()),
+			call_type: call_type,
 		};
 
 		if let Some(value) = value {
@@ -262,6 +266,8 @@ impl<'a, T, V> Ext for Externalities<'a, T, V> where T: 'a + Tracer, V: 'a + VMT
 			trace!("Suiciding {} -> {} (xfer: {})", address, refund_address, balance);
 			self.state.transfer_balance(&address, refund_address, &balance);
 		}
+
+		self.tracer.trace_suicide(address, balance, refund_address.clone());
 		self.substate.suicides.insert(address);
 	}
 
@@ -300,6 +306,7 @@ mod tests {
 	use tests::helpers::*;
 	use super::*;
 	use trace::{NoopTracer, NoopVMTracer};
+	use types::executed::CallType;
 
 	fn get_test_origin() -> OriginInfo {
 		OriginInfo {
@@ -319,7 +326,6 @@ mod tests {
 			last_hashes: vec![],
 			gas_used: 0.into(),
 			gas_limit: 0.into(),
-			dao_rescue_block_gas_limit: None,
 		}
 	}
 
@@ -419,7 +425,9 @@ mod tests {
 			Some(U256::from_str("0000000000000000000000000000000000000000000000000000000000150000").unwrap()),
 			&[],
 			&Address::new(),
-			&mut output);
+			&mut output,
+			CallType::Call
+		);
 	}
 
 	#[test]

ethcore/src/json_tests/chain.rs

@@ -48,6 +48,7 @@ pub fn json_chain_test(json_data: &[u8], era: ChainEra) -> Vec<String> {
 				let mut spec = match era {
 					ChainEra::Frontier => ethereum::new_frontier_test(),
 					ChainEra::Homestead => ethereum::new_homestead_test(),
+					ChainEra::DaoHardfork => ethereum::new_daohardfork_test(),
 				};
 				spec.set_genesis_state(state);
 				spec.overwrite_genesis_params(genesis);
@@ -84,26 +85,43 @@ pub fn json_chain_test(json_data: &[u8], era: ChainEra) -> Vec<String> {
 	failed
 }
 
-fn do_json_test(json_data: &[u8]) -> Vec<String> {
-	json_chain_test(json_data, ChainEra::Frontier)
+mod frontier_era_tests {
+	use tests::helpers::*;
+	use super::json_chain_test;
+
+	fn do_json_test(json_data: &[u8]) -> Vec<String> {
+		json_chain_test(json_data, ChainEra::Frontier)
+	}
+
+	declare_test!{BlockchainTests_bcBlockGasLimitTest, "BlockchainTests/bcBlockGasLimitTest"}
+	declare_test!{BlockchainTests_bcForkBlockTest, "BlockchainTests/bcForkBlockTest"}
+	declare_test!{BlockchainTests_bcForkStressTest, "BlockchainTests/bcForkStressTest"}
+	declare_test!{BlockchainTests_bcForkUncle, "BlockchainTests/bcForkUncle"}
+	declare_test!{BlockchainTests_bcGasPricerTest, "BlockchainTests/bcGasPricerTest"}
+	declare_test!{BlockchainTests_bcInvalidHeaderTest, "BlockchainTests/bcInvalidHeaderTest"}
+	// TODO [ToDr] Ignored because of incorrect JSON (https://github.com/ethereum/tests/pull/113)
+	declare_test!{ignore => BlockchainTests_bcInvalidRLPTest, "BlockchainTests/bcInvalidRLPTest"}
+	declare_test!{BlockchainTests_bcMultiChainTest, "BlockchainTests/bcMultiChainTest"}
+	declare_test!{BlockchainTests_bcRPC_API_Test, "BlockchainTests/bcRPC_API_Test"}
+	declare_test!{BlockchainTests_bcStateTest, "BlockchainTests/bcStateTest"}
+	declare_test!{BlockchainTests_bcTotalDifficultyTest, "BlockchainTests/bcTotalDifficultyTest"}
+	declare_test!{BlockchainTests_bcUncleHeaderValiditiy, "BlockchainTests/bcUncleHeaderValiditiy"}
+	declare_test!{BlockchainTests_bcUncleTest, "BlockchainTests/bcUncleTest"}
+	declare_test!{BlockchainTests_bcValidBlockTest, "BlockchainTests/bcValidBlockTest"}
+	declare_test!{BlockchainTests_bcWalletTest, "BlockchainTests/bcWalletTest"}
+
+	declare_test!{BlockchainTests_RandomTests_bl10251623GO, "BlockchainTests/RandomTests/bl10251623GO"}
+	declare_test!{BlockchainTests_RandomTests_bl201507071825GO, "BlockchainTests/RandomTests/bl201507071825GO"}
 }
 
-declare_test!{BlockchainTests_bcBlockGasLimitTest, "BlockchainTests/bcBlockGasLimitTest"}
-declare_test!{BlockchainTests_bcForkBlockTest, "BlockchainTests/bcForkBlockTest"}
-declare_test!{BlockchainTests_bcForkStressTest, "BlockchainTests/bcForkStressTest"}
-declare_test!{BlockchainTests_bcForkUncle, "BlockchainTests/bcForkUncle"}
-declare_test!{BlockchainTests_bcGasPricerTest, "BlockchainTests/bcGasPricerTest"}
-declare_test!{BlockchainTests_bcInvalidHeaderTest, "BlockchainTests/bcInvalidHeaderTest"}
-// TODO [ToDr] Ignored because of incorrect JSON (https://github.com/ethereum/tests/pull/113)
-declare_test!{ignore => BlockchainTests_bcInvalidRLPTest, "BlockchainTests/bcInvalidRLPTest"}
-declare_test!{BlockchainTests_bcMultiChainTest, "BlockchainTests/bcMultiChainTest"}
-declare_test!{BlockchainTests_bcRPC_API_Test, "BlockchainTests/bcRPC_API_Test"}
-declare_test!{BlockchainTests_bcStateTest, "BlockchainTests/bcStateTest"}
-declare_test!{BlockchainTests_bcTotalDifficultyTest, "BlockchainTests/bcTotalDifficultyTest"}
-declare_test!{BlockchainTests_bcUncleHeaderValiditiy, "BlockchainTests/bcUncleHeaderValiditiy"}
-declare_test!{BlockchainTests_bcUncleTest, "BlockchainTests/bcUncleTest"}
-declare_test!{BlockchainTests_bcValidBlockTest, "BlockchainTests/bcValidBlockTest"}
-declare_test!{BlockchainTests_bcWalletTest, "BlockchainTests/bcWalletTest"}
+mod daohardfork_tests {
+	use tests::helpers::*;
+	use super::json_chain_test;
 
-declare_test!{BlockchainTests_RandomTests_bl10251623GO, "BlockchainTests/RandomTests/bl10251623GO"}
-declare_test!{BlockchainTests_RandomTests_bl201507071825GO, "BlockchainTests/RandomTests/bl201507071825GO"}
+	fn do_json_test(json_data: &[u8]) -> Vec<String> {
+		json_chain_test(json_data, ChainEra::DaoHardfork)
+	}
+
+	declare_test!{BlockchainTests_TestNetwork_bcSimpleTransitionTest, "BlockchainTests/TestNetwork/bcSimpleTransitionTest"}
+	declare_test!{BlockchainTests_TestNetwork_bcTheDaoTest, "BlockchainTests/TestNetwork/bcTheDaoTest"}
+}

ethcore/src/json_tests/executive.rs

@@ -22,6 +22,7 @@ use evm;
 use evm::{Schedule, Ext, Factory, Finalize, VMType, ContractCreateResult, MessageCallResult};
 use externalities::*;
 use substate::*;
+use types::executed::CallType;
 use tests::helpers::*;
 use ethjson;
 use trace::{Tracer, NoopTracer};
@@ -109,13 +110,15 @@ impl<'a, T, V> Ext for TestExt<'a, T, V> where T: Tracer, V: VMTracer {
 	}
 
 	fn call(&mut self,
-			gas: &U256,
-			_sender_address: &Address,
-			receive_address: &Address,
-			value: Option<U256>,
-			data: &[u8],
-			_code_address: &Address,
-			_output: &mut [u8]) -> MessageCallResult {
+		gas: &U256,
+		_sender_address: &Address,
+		receive_address: &Address,
+		value: Option<U256>,
+		data: &[u8],
+		_code_address: &Address,
+		_output: &mut [u8],
+		_call_type: CallType
+	) -> MessageCallResult {
 		self.callcreates.push(CallCreate {
 			data: data.to_vec(),
 			destination: Some(receive_address.clone()),

ethcore/src/json_tests/state.rs

@@ -30,8 +30,9 @@ pub fn json_chain_test(json_data: &[u8], era: ChainEra) -> Vec<String> {
 	let mut failed = Vec::new();
 	let engine = match era {
 		ChainEra::Frontier => ethereum::new_mainnet_like().engine,
-		ChainEra::Homestead => ethereum::new_homestead_test().engine
-	};
+		ChainEra::Homestead => ethereum::new_homestead_test().engine,
+		ChainEra::DaoHardfork => ethereum::new_daohardfork_test().engine,
+};
 
 	for (name, test) in tests.into_iter() {
 		let mut fail = false;

ethcore/src/miner/miner.rs

@@ -15,15 +15,15 @@
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
 use rayon::prelude::*;
-use std::sync::atomic::AtomicBool;
 use std::time::{Instant, Duration};
 
 use util::*;
 use util::Colour::White;
 use account_provider::AccountProvider;
 use views::{BlockView, HeaderView};
+use state::State;
 use client::{MiningBlockChainClient, Executive, Executed, EnvInfo, TransactOptions, BlockID, CallAnalytics};
-use block::{ClosedBlock, IsBlock};
+use block::{ClosedBlock, IsBlock, Block};
 use error::*;
 use transaction::SignedTransaction;
 use receipt::{Receipt};
@@ -86,15 +86,20 @@ impl Default for MinerOptions {
 	}
 }
 
+struct SealingWork {
+	queue: UsingQueue<ClosedBlock>,
+	enabled: bool,
+}
+
 /// Keeps track of transactions using priority queue and holds currently mined block.
 pub struct Miner {
 	// NOTE [ToDr]  When locking always lock in this order!
 	transaction_queue: Mutex<TransactionQueue>,
-	sealing_work: Mutex<UsingQueue<ClosedBlock>>,
+	sealing_work: Mutex<SealingWork>,
 
 	// for sealing...
 	options: MinerOptions,
-	sealing_enabled: AtomicBool,
+	
 	next_allowed_reseal: Mutex<Instant>,
 	sealing_block_last_request: Mutex<u64>,
 	gas_range_target: RwLock<(U256, U256)>,
@@ -112,10 +117,9 @@ impl Miner {
 		Miner {
 			transaction_queue: Mutex::new(TransactionQueue::new()),
 			options: Default::default(),
-			sealing_enabled: AtomicBool::new(false),
 			next_allowed_reseal: Mutex::new(Instant::now()),
 			sealing_block_last_request: Mutex::new(0),
-			sealing_work: Mutex::new(UsingQueue::new(20)),
+			sealing_work: Mutex::new(SealingWork{queue: UsingQueue::new(20), enabled: false}),
 			gas_range_target: RwLock::new((U256::zero(), U256::zero())),
 			author: RwLock::new(Address::default()),
 			extra_data: RwLock::new(Vec::new()),
@@ -130,10 +134,9 @@ impl Miner {
 		let work_poster = if !options.new_work_notify.is_empty() { Some(WorkPoster::new(&options.new_work_notify)) } else { None };
 		Arc::new(Miner {
 			transaction_queue: Mutex::new(TransactionQueue::with_limits(options.tx_queue_size, options.tx_gas_limit)),
-			sealing_enabled: AtomicBool::new(options.force_sealing || !options.new_work_notify.is_empty()),
 			next_allowed_reseal: Mutex::new(Instant::now()),
 			sealing_block_last_request: Mutex::new(0),
-			sealing_work: Mutex::new(UsingQueue::new(options.work_queue_size)),
+			sealing_work: Mutex::new(SealingWork{queue: UsingQueue::new(options.work_queue_size), enabled: options.force_sealing || !options.new_work_notify.is_empty()}),
 			gas_range_target: RwLock::new((U256::zero(), U256::zero())),
 			author: RwLock::new(Address::default()),
 			extra_data: RwLock::new(Vec::new()),
@@ -152,6 +155,16 @@ impl Miner {
 		self.options.force_sealing || !self.options.new_work_notify.is_empty()
 	}
 
+	/// Get `Some` `clone()` of the current pending block's state or `None` if we're not sealing.
+	pub fn pending_state(&self) -> Option<State> {
+		self.sealing_work.lock().unwrap().queue.peek_last_ref().map(|b| b.block().fields().state.clone())
+	}
+
+	/// Get `Some` `clone()` of the current pending block's state or `None` if we're not sealing.
+	pub fn pending_block(&self) -> Option<Block> {
+		self.sealing_work.lock().unwrap().queue.peek_last_ref().map(|b| b.base().clone())
+	}
+
 	/// Prepares new block for sealing including top transactions from queue.
 	#[cfg_attr(feature="dev", allow(match_same_arms))]
 	#[cfg_attr(feature="dev", allow(cyclomatic_complexity))]
@@ -161,7 +174,7 @@ impl Miner {
 		let (transactions, mut open_block, original_work_hash) = {
 			let transactions = {self.transaction_queue.lock().unwrap().top_transactions()};
 			let mut sealing_work = self.sealing_work.lock().unwrap();
-			let last_work_hash = sealing_work.peek_last_ref().map(|pb| pb.block().fields().header.hash());
+			let last_work_hash = sealing_work.queue.peek_last_ref().map(|pb| pb.block().fields().header.hash());
 			let best_hash = chain.best_block_header().sha3();
 /*
 			// check to see if last ClosedBlock in would_seals is actually same parent block.
@@ -171,7 +184,7 @@ impl Miner {
 			//   otherwise, leave everything alone.
 			// otherwise, author a fresh block.
 */
-			let open_block = match sealing_work.pop_if(|b| b.block().fields().header.parent_hash() == &best_hash) {
+			let open_block = match sealing_work.queue.pop_if(|b| b.block().fields().header.parent_hash() == &best_hash) {
 				Some(old_block) => {
 					trace!(target: "miner", "Already have previous work; updating and returning");
 					// add transactions to old_block
@@ -198,17 +211,23 @@ impl Miner {
 			let hash = tx.hash();
 			match open_block.push_transaction(tx, None) {
 				Err(Error::Execution(ExecutionError::BlockGasLimitReached { gas_limit, gas_used, .. })) => {
-					trace!(target: "miner", "Skipping adding transaction to block because of gas limit: {:?}", hash);
+					debug!(target: "miner", "Skipping adding transaction to block because of gas limit: {:?}", hash);
 					// Exit early if gas left is smaller then min_tx_gas
 					let min_tx_gas: U256 = 21000.into();	// TODO: figure this out properly.
 					if gas_limit - gas_used < min_tx_gas {
 						break;
 					}
 				},
-				Err(Error::Transaction(TransactionError::AlreadyImported)) => {}	// already have transaction - ignore
+				// Invalid nonce error can happen only if previous transaction is skipped because of gas limit.
+				// If there is errornous state of transaction queue it will be fixed when next block is imported.
+				Err(Error::Execution(ExecutionError::InvalidNonce { .. })) => {
+					debug!(target: "miner", "Skipping adding transaction to block because of invalid nonce: {:?}", hash);
+				},
+				// already have transaction - ignore
+				Err(Error::Transaction(TransactionError::AlreadyImported)) => {},
 				Err(e) => {
 					invalid_transactions.insert(hash);
-					trace!(target: "miner",
+					debug!(target: "miner",
 						   "Error adding transaction to block: number={}. transaction_hash={:?}, Error: {:?}",
 						   block_number, hash, e);
 				},
@@ -256,7 +275,7 @@ impl Miner {
 
 		let (work, is_new) = {
 			let mut sealing_work = self.sealing_work.lock().unwrap();
-			let last_work_hash = sealing_work.peek_last_ref().map(|pb| pb.block().fields().header.hash());
+			let last_work_hash = sealing_work.queue.peek_last_ref().map(|pb| pb.block().fields().header.hash());
 			trace!(target: "miner", "Checking whether we need to reseal: orig={:?} last={:?}, this={:?}", original_work_hash, last_work_hash, block.block().fields().header.hash());
 			let (work, is_new) = if last_work_hash.map_or(true, |h| h != block.block().fields().header.hash()) {
 				trace!(target: "miner", "Pushing a new, refreshed or borrowed pending {}...", block.block().fields().header.hash());
@@ -264,12 +283,16 @@ impl Miner {
 				let number = block.block().fields().header.number();
 				let difficulty = *block.block().fields().header.difficulty();
 				let is_new = original_work_hash.map_or(true, |h| block.block().fields().header.hash() != h);
-				sealing_work.push(block);
+				sealing_work.queue.push(block);
+				// If push notifications are enabled we assume all work items are used.
+				if self.work_poster.is_some() && is_new {
+					sealing_work.queue.use_last_ref();
+				}
 				(Some((pow_hash, difficulty, number)), is_new)
 			} else {
 				(None, false)
 			};
-			trace!(target: "miner", "prepare_sealing: leaving (last={:?})", sealing_work.peek_last_ref().map(|b| b.block().fields().header.hash()));
+			trace!(target: "miner", "prepare_sealing: leaving (last={:?})", sealing_work.queue.peek_last_ref().map(|b| b.block().fields().header.hash()));
 			(work, is_new)
 		};
 		if is_new {
@@ -286,10 +309,22 @@ impl Miner {
 	/// Returns true if we had to prepare new pending block
 	fn enable_and_prepare_sealing(&self, chain: &MiningBlockChainClient) -> bool {
 		trace!(target: "miner", "enable_and_prepare_sealing: entering");
-		let have_work = self.sealing_work.lock().unwrap().peek_last_ref().is_some();
-		trace!(target: "miner", "enable_and_prepare_sealing: have_work={}", have_work);
-		if !have_work {
-			self.sealing_enabled.store(true, atomic::Ordering::Relaxed);
+		let prepare_new = {
+			let mut sealing_work = self.sealing_work.lock().unwrap();
+			let have_work = sealing_work.queue.peek_last_ref().is_some();
+			trace!(target: "miner", "enable_and_prepare_sealing: have_work={}", have_work);
+			if !have_work {
+				sealing_work.enabled = true;
+				true
+			} else {
+				false
+			}
+		};
+		if prepare_new {
+			// --------------------------------------------------------------------------
+			// | NOTE Code below requires transaction_queue and sealing_work locks.     |
+			// | Make sure to release the locks before calling that method.             |
+			// --------------------------------------------------------------------------
 			self.prepare_sealing(chain);
 		}
 		let mut sealing_block_last_request = self.sealing_block_last_request.lock().unwrap();
@@ -299,8 +334,21 @@ impl Miner {
 			*sealing_block_last_request = best_number;
 		}
 
-		// Return if
-		!have_work
+		// Return if we restarted 
+		prepare_new
+	}
+
+	fn add_transactions_to_queue(&self, chain: &MiningBlockChainClient, transactions: Vec<SignedTransaction>, origin: TransactionOrigin, transaction_queue: &mut TransactionQueue) ->
+		Vec<Result<TransactionImportResult, Error>> {
+
+		let fetch_account = |a: &Address| AccountDetails {
+			nonce: chain.latest_nonce(a),
+			balance: chain.latest_balance(a),
+		};
+
+		transactions.into_iter()
+			.map(|tx| transaction_queue.add(tx, &fetch_account, origin))
+			.collect()
 	}
 
 	/// Are we allowed to do a non-mandatory reseal?
@@ -313,6 +361,10 @@ impl MinerService for Miner {
 
 	fn clear_and_reset(&self, chain: &MiningBlockChainClient) {
 		self.transaction_queue.lock().unwrap().clear();
+		// --------------------------------------------------------------------------
+		// | NOTE Code below requires transaction_queue and sealing_work locks.     |
+		// | Make sure to release the locks before calling that method.             |
+		// --------------------------------------------------------------------------
 		self.update_sealing(chain);
 	}
 
@@ -322,13 +374,13 @@ impl MinerService for Miner {
 		MinerStatus {
 			transactions_in_pending_queue: status.pending,
 			transactions_in_future_queue: status.future,
-			transactions_in_pending_block: sealing_work.peek_last_ref().map_or(0, |b| b.transactions().len()),
+			transactions_in_pending_block: sealing_work.queue.peek_last_ref().map_or(0, |b| b.transactions().len()),
 		}
 	}
 
 	fn call(&self, chain: &MiningBlockChainClient, t: &SignedTransaction, analytics: CallAnalytics) -> Result<Executed, ExecutionError> {
 		let sealing_work = self.sealing_work.lock().unwrap();
-		match sealing_work.peek_last_ref() {
+		match sealing_work.queue.peek_last_ref() {
 			Some(work) => {
 				let block = work.block();
 
@@ -343,7 +395,6 @@ impl MinerService for Miner {
 					last_hashes: last_hashes,
 					gas_used: U256::zero(),
 					gas_limit: U256::max_value(),
-					dao_rescue_block_gas_limit: chain.dao_rescue_block_gas_limit(header.parent_hash().clone()),
 				};
 				// that's just a copy of the state.
 				let mut state = block.state().clone();
@@ -376,7 +427,7 @@ impl MinerService for Miner {
 
 	fn balance(&self, chain: &MiningBlockChainClient, address: &Address) -> U256 {
 		let sealing_work = self.sealing_work.lock().unwrap();
-		sealing_work.peek_last_ref().map_or_else(
+		sealing_work.queue.peek_last_ref().map_or_else(
 			|| chain.latest_balance(address),
 			|b| b.block().fields().state.balance(address)
 		)
@@ -384,7 +435,7 @@ impl MinerService for Miner {
 
 	fn storage_at(&self, chain: &MiningBlockChainClient, address: &Address, position: &H256) -> H256 {
 		let sealing_work = self.sealing_work.lock().unwrap();
-		sealing_work.peek_last_ref().map_or_else(
+		sealing_work.queue.peek_last_ref().map_or_else(
 			|| chain.latest_storage_at(address, position),
 			|b| b.block().fields().state.storage_at(address, position)
 		)
@@ -392,12 +443,12 @@ impl MinerService for Miner {
 
 	fn nonce(&self, chain: &MiningBlockChainClient, address: &Address) -> U256 {
 		let sealing_work = self.sealing_work.lock().unwrap();
-		sealing_work.peek_last_ref().map_or_else(|| chain.latest_nonce(address), |b| b.block().fields().state.nonce(address))
+		sealing_work.queue.peek_last_ref().map_or_else(|| chain.latest_nonce(address), |b| b.block().fields().state.nonce(address))
 	}
 
 	fn code(&self, chain: &MiningBlockChainClient, address: &Address) -> Option<Bytes> {
 		let sealing_work = self.sealing_work.lock().unwrap();
-		sealing_work.peek_last_ref().map_or_else(|| chain.code(address), |b| b.block().fields().state.code(address))
+		sealing_work.queue.peek_last_ref().map_or_else(|| chain.code(address), |b| b.block().fields().state.code(address))
 	}
 
 	fn set_author(&self, author: Address) {
@@ -466,27 +517,31 @@ impl MinerService for Miner {
 		self.gas_range_target.read().unwrap().1
 	}
 
-	fn import_transactions<T>(&self, chain: &MiningBlockChainClient, transactions: Vec<SignedTransaction>, fetch_account: T) ->
-		Vec<Result<TransactionImportResult, Error>>
-		where T: Fn(&Address) -> AccountDetails {
-		let results: Vec<Result<TransactionImportResult, Error>> = {
+	fn import_external_transactions(&self, chain: &MiningBlockChainClient, transactions: Vec<SignedTransaction>) ->
+		Vec<Result<TransactionImportResult, Error>> {
+
+		let results = {
 			let mut transaction_queue = self.transaction_queue.lock().unwrap();
-			transactions.into_iter()
-				.map(|tx| transaction_queue.add(tx, &fetch_account, TransactionOrigin::External))
-				.collect()
+			self.add_transactions_to_queue(
+				chain, transactions, TransactionOrigin::External, &mut transaction_queue
+			)
 		};
-		if !results.is_empty() && self.options.reseal_on_external_tx && 	self.tx_reseal_allowed() {
+
+		if !results.is_empty() && self.options.reseal_on_external_tx &&	self.tx_reseal_allowed() {
+			// --------------------------------------------------------------------------
+			// | NOTE Code below requires transaction_queue and sealing_work locks.     |
+			// | Make sure to release the locks before calling that method.             |
+			// --------------------------------------------------------------------------
 			self.update_sealing(chain);
 		}
 		results
 	}
 
-	fn import_own_transaction<T>(
+	fn import_own_transaction(
 		&self,
 		chain: &MiningBlockChainClient,
 		transaction: SignedTransaction,
-		fetch_account: T
-	) -> Result<TransactionImportResult, Error> where T: Fn(&Address) -> AccountDetails {
+	) -> Result<TransactionImportResult, Error> {
 
 		let hash = transaction.hash();
 		trace!(target: "own_tx", "Importing transaction: {:?}", transaction);
@@ -494,7 +549,7 @@ impl MinerService for Miner {
 		let imported = {
 			// Be sure to release the lock before we call enable_and_prepare_sealing
 			let mut transaction_queue = self.transaction_queue.lock().unwrap();
-			let import = transaction_queue.add(transaction, &fetch_account, TransactionOrigin::Local);
+			let import = self.add_transactions_to_queue(chain, vec![transaction], TransactionOrigin::Local, &mut transaction_queue).pop().unwrap();
 
 			match import {
 				Ok(ref res) => {
@@ -510,6 +565,10 @@ impl MinerService for Miner {
 			import
 		};
 
+		// --------------------------------------------------------------------------
+		// | NOTE Code below requires transaction_queue and sealing_work locks.     |
+		// | Make sure to release the locks before calling that method.             |
+		// --------------------------------------------------------------------------
 		if imported.is_ok() && self.options.reseal_on_own_tx && self.tx_reseal_allowed() {
 			// Make sure to do it after transaction is imported and lock is droped.
 			// We need to create pending block and enable sealing
@@ -533,8 +592,8 @@ impl MinerService for Miner {
 		let queue = self.transaction_queue.lock().unwrap();
 		let sw = self.sealing_work.lock().unwrap();
 		// TODO: should only use the sealing_work when it's current (it could be an old block)
-		let sealing_set = match self.sealing_enabled.load(atomic::Ordering::Relaxed) {
-			true => sw.peek_last_ref(),
+		let sealing_set = match sw.enabled {
+			true => sw.queue.peek_last_ref(),
 			false => None,
 		};
 		match (&self.options.pending_set, sealing_set) {
@@ -546,8 +605,8 @@ impl MinerService for Miner {
 	fn pending_transactions_hashes(&self) -> Vec<H256> {
 		let queue = self.transaction_queue.lock().unwrap();
 		let sw = self.sealing_work.lock().unwrap();
-		let sealing_set = match self.sealing_enabled.load(atomic::Ordering::Relaxed) {
-			true => sw.peek_last_ref(),
+		let sealing_set = match sw.enabled {
+			true => sw.queue.peek_last_ref(),
 			false => None,
 		};
 		match (&self.options.pending_set, sealing_set) {
@@ -559,8 +618,8 @@ impl MinerService for Miner {
 	fn transaction(&self, hash: &H256) -> Option<SignedTransaction> {
 		let queue = self.transaction_queue.lock().unwrap();
 		let sw = self.sealing_work.lock().unwrap();
-		let sealing_set = match self.sealing_enabled.load(atomic::Ordering::Relaxed) {
-			true => sw.peek_last_ref(),
+		let sealing_set = match sw.enabled {
+			true => sw.queue.peek_last_ref(),
 			false => None,
 		};
 		match (&self.options.pending_set, sealing_set) {
@@ -570,7 +629,8 @@ impl MinerService for Miner {
 	}
 
 	fn pending_receipts(&self) -> BTreeMap<H256, Receipt> {
-		match (self.sealing_enabled.load(atomic::Ordering::Relaxed), self.sealing_work.lock().unwrap().peek_last_ref()) {
+		let sealing_work = self.sealing_work.lock().unwrap();
+		match (sealing_work.enabled, sealing_work.queue.peek_last_ref()) {
 			(true, Some(pending)) => {
 				let hashes = pending.transactions()
 					.iter()
@@ -589,23 +649,43 @@ impl MinerService for Miner {
 	}
 
 	fn update_sealing(&self, chain: &MiningBlockChainClient) {
-		if self.sealing_enabled.load(atomic::Ordering::Relaxed) {
-			let current_no = chain.chain_info().best_block_number;
-			let has_local_transactions = self.transaction_queue.lock().unwrap().has_local_pending_transactions();
-			let last_request = *self.sealing_block_last_request.lock().unwrap();
-			let should_disable_sealing = !self.forced_sealing()
-				&& !has_local_transactions
-				&& current_no > last_request
-				&& current_no - last_request > SEALING_TIMEOUT_IN_BLOCKS;
+		trace!(target: "miner", "update_sealing");
+		let requires_reseal = {
+			let mut sealing_work = self.sealing_work.lock().unwrap();
+			if sealing_work.enabled {
+				trace!(target: "miner", "update_sealing: sealing enabled");
+				let current_no = chain.chain_info().best_block_number;
+				let has_local_transactions = self.transaction_queue.lock().unwrap().has_local_pending_transactions();
+				let last_request = *self.sealing_block_last_request.lock().unwrap();
+				let should_disable_sealing = !self.forced_sealing()
+					&& !has_local_transactions
+					&& current_no > last_request
+					&& current_no - last_request > SEALING_TIMEOUT_IN_BLOCKS;
 
-			if should_disable_sealing {
-				trace!(target: "miner", "Miner sleeping (current {}, last {})", current_no, last_request);
-				self.sealing_enabled.store(false, atomic::Ordering::Relaxed);
-				self.sealing_work.lock().unwrap().reset();
+				trace!(target: "miner", "update_sealing: should_disable_sealing={}; current_no={}, last_request={}", should_disable_sealing, current_no, last_request);
+
+				if should_disable_sealing {
+					trace!(target: "miner", "Miner sleeping (current {}, last {})", current_no, last_request);
+					sealing_work.enabled = false;
+					sealing_work.queue.reset();
+					false
+				} else {
+					// sealing enabled and we don't want to sleep.
+					*self.next_allowed_reseal.lock().unwrap() = Instant::now() + self.options.reseal_min_period;
+					true
+				}
 			} else {
-				*self.next_allowed_reseal.lock().unwrap() = Instant::now() + self.options.reseal_min_period;
-				self.prepare_sealing(chain);
+				// sealing is disabled.
+				false
 			}
+		};
+		
+		if requires_reseal {
+			// --------------------------------------------------------------------------
+			// | NOTE Code below requires transaction_queue and sealing_work locks.     |
+			// | Make sure to release the locks before calling that method.             |
+			// --------------------------------------------------------------------------
+			self.prepare_sealing(chain);
 		}
 	}
 
@@ -614,13 +694,13 @@ impl MinerService for Miner {
 		self.enable_and_prepare_sealing(chain);
 		trace!(target: "miner", "map_sealing_work: sealing prepared");
 		let mut sealing_work = self.sealing_work.lock().unwrap();
-		let ret = sealing_work.use_last_ref();
+		let ret = sealing_work.queue.use_last_ref();
 		trace!(target: "miner", "map_sealing_work: leaving use_last_ref={:?}", ret.as_ref().map(|b| b.block().fields().header.hash()));
 		ret.map(f)
 	}
 
 	fn submit_seal(&self, chain: &MiningBlockChainClient, pow_hash: H256, seal: Vec<Bytes>) -> Result<(), Error> {
-		let result = if let Some(b) = self.sealing_work.lock().unwrap().get_used_if(if self.options.enable_resubmission { GetAction::Clone } else { GetAction::Take }, |b| &b.hash() == &pow_hash) {
+		let result = if let Some(b) = self.sealing_work.lock().unwrap().queue.get_used_if(if self.options.enable_resubmission { GetAction::Clone } else { GetAction::Take }, |b| &b.hash() == &pow_hash) {
 			b.lock().try_seal(self.engine(), seal).or_else(|_| {
 				warn!(target: "miner", "Mined solution rejected: Invalid.");
 				Err(Error::PowInvalid)
@@ -639,13 +719,20 @@ impl MinerService for Miner {
 	}
 
 	fn chain_new_blocks(&self, chain: &MiningBlockChainClient, _imported: &[H256], _invalid: &[H256], enacted: &[H256], retracted: &[H256]) {
+		trace!(target: "miner", "chain_new_blocks");
+
 		fn fetch_transactions(chain: &MiningBlockChainClient, hash: &H256) -> Vec<SignedTransaction> {
 			let block = chain
 				.block(BlockID::Hash(*hash))
 				// Client should send message after commit to db and inserting to chain.
 				.expect("Expected in-chain blocks.");
 			let block = BlockView::new(&block);
-			block.transactions()
+			let txs = block.transactions();
+			// populate sender
+			for tx in &txs {
+				let _sender = tx.sender();
+			}
+			txs
 		}
 
 		// 1. We ignore blocks that were `imported` (because it means that they are not in canon-chain, and transactions
@@ -662,14 +749,9 @@ impl MinerService for Miner {
 				.par_iter()
 				.map(|h| fetch_transactions(chain, h));
 			out_of_chain.for_each(|txs| {
-				// populate sender
-				for tx in &txs {
-					let _sender = tx.sender();
-				}
-				let _ = self.import_transactions(chain, txs, |a| AccountDetails {
-					nonce: chain.latest_nonce(a),
-					balance: chain.latest_balance(a),
-				});
+				let mut transaction_queue = self.transaction_queue.lock().unwrap();
+				let _ = self.add_transactions_to_queue(chain, txs, TransactionOrigin::External,
+													   &mut transaction_queue);
 			});
 		}
 
@@ -693,7 +775,13 @@ impl MinerService for Miner {
 			});
 		}
 
-		self.update_sealing(chain);
+		if enacted.len() > 0 {
+			// --------------------------------------------------------------------------
+			// | NOTE Code below requires transaction_queue and sealing_work locks.     |
+			// | Make sure to release the locks before calling that method.             |
+			// --------------------------------------------------------------------------
+			self.update_sealing(chain);
+		}
 	}
 }
 

ethcore/src/miner/mod.rs

@@ -33,7 +33,7 @@
 //! use ethcore::miner::{Miner, MinerService};
 //!
 //! fn main() {
-//!		let miner: Miner = Miner::with_spec(ethereum::new_frontier(true));
+//!		let miner: Miner = Miner::with_spec(ethereum::new_frontier());
 //!		// get status
 //!		assert_eq!(miner.status().transactions_in_pending_queue, 0);
 //!
@@ -106,14 +106,12 @@ pub trait MinerService : Send + Sync {
 	fn set_tx_gas_limit(&self, limit: U256);
 
 	/// Imports transactions to transaction queue.
-	fn import_transactions<T>(&self, chain: &MiningBlockChainClient, transactions: Vec<SignedTransaction>, fetch_account: T) ->
-		Vec<Result<TransactionImportResult, Error>>
-		where T: Fn(&Address) -> AccountDetails, Self: Sized;
+	fn import_external_transactions(&self, chain: &MiningBlockChainClient, transactions: Vec<SignedTransaction>) ->
+		Vec<Result<TransactionImportResult, Error>>;
 
 	/// Imports own (node owner) transaction to queue.
-	fn import_own_transaction<T>(&self, chain: &MiningBlockChainClient, transaction: SignedTransaction, fetch_account: T) ->
-		Result<TransactionImportResult, Error>
-		where T: Fn(&Address) -> AccountDetails, Self: Sized;
+	fn import_own_transaction(&self, chain: &MiningBlockChainClient, transaction: SignedTransaction) ->
+		Result<TransactionImportResult, Error>;
 
 	/// Returns hashes of transactions currently in pending
 	fn pending_transactions_hashes(&self) -> Vec<H256>;

ethcore/src/miner/transaction_queue.rs

@@ -439,10 +439,10 @@ impl TransactionQueue {
 	pub fn add<T>(&mut self, tx: SignedTransaction, fetch_account: &T, origin: TransactionOrigin) -> Result<TransactionImportResult, Error>
 	where T: Fn(&Address) -> AccountDetails {
 
-		trace!(target: "miner", "Importing: {:?}", tx.hash());
+		trace!(target: "txqueue", "Importing: {:?}", tx.hash());
 
 		if tx.gas_price < self.minimal_gas_price && origin != TransactionOrigin::Local {
-			trace!(target: "miner",
+			trace!(target: "txqueue",
 				"Dropping transaction below minimal gas price threshold: {:?} (gp: {} < {})",
 				tx.hash(),
 				tx.gas_price,
@@ -458,7 +458,7 @@ impl TransactionQueue {
 		try!(tx.check_low_s());
 
 		if tx.gas > self.gas_limit || tx.gas > self.tx_gas_limit {
-			trace!(target: "miner",
+			trace!(target: "txqueue",
 				"Dropping transaction above gas limit: {:?} ({} > min({}, {}))",
 				tx.hash(),
 				tx.gas,
@@ -477,7 +477,7 @@ impl TransactionQueue {
 
 		let cost = vtx.transaction.value + vtx.transaction.gas_price * vtx.transaction.gas;
 		if client_account.balance < cost {
-			trace!(target: "miner",
+			trace!(target: "txqueue",
 				"Dropping transaction without sufficient balance: {:?} ({} < {})",
 				vtx.hash(),
 				client_account.balance,
@@ -565,7 +565,7 @@ impl TransactionQueue {
 			if k >= current_nonce {
 				self.future.insert(*sender, k, order.update_height(k, current_nonce));
 			} else {
-				trace!(target: "miner", "Removing old transaction: {:?} (nonce: {} < {})", order.hash, k, current_nonce);
+				trace!(target: "txqueue", "Removing old transaction: {:?} (nonce: {} < {})", order.hash, k, current_nonce);
 				// Remove the transaction completely
 				self.by_hash.remove(&order.hash).expect("All transactions in `future` are also in `by_hash`");
 			}
@@ -586,7 +586,7 @@ impl TransactionQueue {
 			if k >= current_nonce {
 				self.future.insert(*sender, k, order.update_height(k, current_nonce));
 			} else {
-				trace!(target: "miner", "Removing old transaction: {:?} (nonce: {} < {})", order.hash, k, current_nonce);
+				trace!(target: "txqueue", "Removing old transaction: {:?} (nonce: {} < {})", order.hash, k, current_nonce);
 				self.by_hash.remove(&order.hash).expect("All transactions in `future` are also in `by_hash`");
 			}
 		}
@@ -674,7 +674,7 @@ impl TransactionQueue {
 
 		if self.by_hash.get(&tx.hash()).is_some() {
 			// Transaction is already imported.
-			trace!(target: "miner", "Dropping already imported transaction: {:?}", tx.hash());
+			trace!(target: "txqueue", "Dropping already imported transaction: {:?}", tx.hash());
 			return Err(TransactionError::AlreadyImported);
 		}
 
@@ -691,7 +691,7 @@ impl TransactionQueue {
 		// nonce height would result in overflow.
 		if nonce < state_nonce {
 			// Droping transaction
-			trace!(target: "miner", "Dropping old transaction: {:?} (nonce: {} < {})", tx.hash(), nonce, next_nonce);
+			trace!(target: "txqueue", "Dropping old transaction: {:?} (nonce: {} < {})", tx.hash(), nonce, next_nonce);
 			return Err(TransactionError::Old);
 		} else if nonce > next_nonce {
 			// We have a gap - put to future.
@@ -727,7 +727,7 @@ impl TransactionQueue {
 		// Trigger error if the transaction we are importing was removed.
 		try!(check_if_removed(&address, &nonce, removed));
 
-		trace!(target: "miner", "status: {:?}", self.status());
+		trace!(target: "txqueue", "status: {:?}", self.status());
 		Ok(TransactionImportResult::Current)
 	}
 

ethcore/src/pod_account.rs

@@ -28,8 +28,8 @@ pub struct PodAccount {
 	pub balance: U256,
 	/// The nonce of the account.
 	pub nonce: U256,
-	/// The code of the account.
-	pub code: Bytes,
+	/// The code of the account or `None` in the special case that it is unknown.
+	pub code: Option<Bytes>,
 	/// The storage of the account.
 	pub storage: BTreeMap<H256, H256>,
 }
@@ -38,7 +38,7 @@ impl PodAccount {
 	/// Construct new object.
 	#[cfg(test)]
 	pub fn new(balance: U256, nonce: U256, code: Bytes, storage: BTreeMap<H256, H256>) -> PodAccount {
-		PodAccount { balance: balance, nonce: nonce, code: code, storage: storage }
+		PodAccount { balance: balance, nonce: nonce, code: Some(code), storage: storage }
 	}
 
 	/// Convert Account to a PodAccount.
@@ -48,7 +48,7 @@ impl PodAccount {
 			balance: *acc.balance(),
 			nonce: *acc.nonce(),
 			storage: acc.storage_overlay().iter().fold(BTreeMap::new(), |mut m, (k, &(_, ref v))| {m.insert(k.clone(), v.clone()); m}),
-			code: acc.code().unwrap().to_vec(),
+			code: acc.code().map(|x| x.to_vec()),
 		}
 	}
 
@@ -58,14 +58,15 @@ impl PodAccount {
 		stream.append(&self.nonce);
 		stream.append(&self.balance);
 		stream.append(&sec_trie_root(self.storage.iter().map(|(k, v)| (k.to_vec(), encode(&U256::from(v.as_slice())).to_vec())).collect()));
-		stream.append(&self.code.sha3());
+		stream.append(&self.code.as_ref().unwrap_or(&vec![]).sha3());
 		stream.out()
 	}
 
 	/// Place additional data into given hash DB.
 	pub fn insert_additional(&self, db: &mut AccountDBMut) {
-		if !self.code.is_empty() {
-			db.insert(&self.code);
+		match self.code {
+			Some(ref c) if !c.is_empty() => { db.insert(c); }
+			_ => {}
 		}
 		let mut r = H256::new();
 		let mut t = SecTrieDBMut::new(db, &mut r);
@@ -80,7 +81,7 @@ impl From<ethjson::blockchain::Account> for PodAccount {
 		PodAccount {
 			balance: a.balance.into(),
 			nonce: a.nonce.into(),
-			code: a.code.into(),
+			code: Some(a.code.into()),
 			storage: a.storage.into_iter().map(|(key, value)| {
 				let key: U256 = key.into();
 				let value: U256 = value.into();
@@ -95,7 +96,7 @@ impl From<ethjson::spec::Account> for PodAccount {
 		PodAccount {
 			balance: a.balance.map_or_else(U256::zero, Into::into),
 			nonce: a.nonce.map_or_else(U256::zero, Into::into),
-			code: vec![],
+			code: Some(vec![]),
 			storage: BTreeMap::new()
 		}
 	}
@@ -103,7 +104,13 @@ impl From<ethjson::spec::Account> for PodAccount {
 
 impl fmt::Display for PodAccount {
 	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-		write!(f, "(bal={}; nonce={}; code={} bytes, #{}; storage={} items)", self.balance, self.nonce, self.code.len(), self.code.sha3(), self.storage.len())
+		write!(f, "(bal={}; nonce={}; code={} bytes, #{}; storage={} items)",
+			self.balance,
+			self.nonce,
+			self.code.as_ref().map_or(0, |c| c.len()),
+			self.code.as_ref().map_or_else(H256::new, |c| c.sha3()),
+			self.storage.len()
+		)
 	}
 }
 
@@ -114,13 +121,13 @@ pub fn diff_pod(pre: Option<&PodAccount>, post: Option<&PodAccount>) -> Option<A
 		(None, Some(x)) => Some(AccountDiff {
 			balance: Diff::Born(x.balance),
 			nonce: Diff::Born(x.nonce),
-			code: Diff::Born(x.code.clone()),
+			code: Diff::Born(x.code.as_ref().expect("account is newly created; newly created accounts must be given code; all caches should remain in place; qed").clone()),
 			storage: x.storage.iter().map(|(k, v)| (k.clone(), Diff::Born(v.clone()))).collect(),
 		}),
 		(Some(x), None) => Some(AccountDiff {
 			balance: Diff::Died(x.balance),
 			nonce: Diff::Died(x.nonce),
-			code: Diff::Died(x.code.clone()),
+			code: Diff::Died(x.code.as_ref().expect("account is deleted; only way to delete account is running SUICIDE; account must have had own code cached to make operation; all caches should remain in place; qed").clone()),
 			storage: x.storage.iter().map(|(k, v)| (k.clone(), Diff::Died(v.clone()))).collect(),
 		}),
 		(Some(pre), Some(post)) => {
@@ -130,7 +137,10 @@ pub fn diff_pod(pre: Option<&PodAccount>, post: Option<&PodAccount>) -> Option<A
 			let r = AccountDiff {
 				balance: Diff::new(pre.balance, post.balance),
 				nonce: Diff::new(pre.nonce, post.nonce),
-				code: Diff::new(pre.code.clone(), post.code.clone()),
+				code: match (pre.code.clone(), post.code.clone()) {
+					(Some(pre_code), Some(post_code)) => Diff::new(pre_code, post_code),
+					_ => Diff::Same,
+				},
 				storage: storage.into_iter().map(|k|
 					(k.clone(), Diff::new(
 						pre.storage.get(&k).cloned().unwrap_or_else(H256::new),
@@ -156,7 +166,7 @@ mod test {
 
 	#[test]
 	fn existence() {
-		let a = PodAccount{balance: 69.into(), nonce: 0.into(), code: vec![], storage: map![]};
+		let a = PodAccount{balance: 69.into(), nonce: 0.into(), code: Some(vec![]), storage: map![]};
 		assert_eq!(diff_pod(Some(&a), Some(&a)), None);
 		assert_eq!(diff_pod(None, Some(&a)), Some(AccountDiff{
 			balance: Diff::Born(69.into()),
@@ -168,8 +178,8 @@ mod test {
 
 	#[test]
 	fn basic() {
-		let a = PodAccount{balance: 69.into(), nonce: 0.into(), code: vec![], storage: map![]};
-		let b = PodAccount{balance: 42.into(), nonce: 1.into(), code: vec![], storage: map![]};
+		let a = PodAccount{balance: 69.into(), nonce: 0.into(), code: Some(vec![]), storage: map![]};
+		let b = PodAccount{balance: 42.into(), nonce: 1.into(), code: Some(vec![]), storage: map![]};
 		assert_eq!(diff_pod(Some(&a), Some(&b)), Some(AccountDiff {
 			balance: Diff::Changed(69.into(), 42.into()),
 			nonce: Diff::Changed(0.into(), 1.into()),
@@ -180,8 +190,8 @@ mod test {
 
 	#[test]
 	fn code() {
-		let a = PodAccount{balance: 0.into(), nonce: 0.into(), code: vec![], storage: map![]};
-		let b = PodAccount{balance: 0.into(), nonce: 1.into(), code: vec![0], storage: map![]};
+		let a = PodAccount{balance: 0.into(), nonce: 0.into(), code: Some(vec![]), storage: map![]};
+		let b = PodAccount{balance: 0.into(), nonce: 1.into(), code: Some(vec![0]), storage: map![]};
 		assert_eq!(diff_pod(Some(&a), Some(&b)), Some(AccountDiff {
 			balance: Diff::Same,
 			nonce: Diff::Changed(0.into(), 1.into()),
@@ -195,13 +205,13 @@ mod test {
 		let a = PodAccount {
 			balance: 0.into(),
 			nonce: 0.into(),
-			code: vec![],
+			code: Some(vec![]),
 			storage: map_into![1 => 1, 2 => 2, 3 => 3, 4 => 4, 5 => 0, 6 => 0, 7 => 0]
 		};
 		let b = PodAccount {
 			balance: 0.into(),
 			nonce: 0.into(),
-			code: vec![],
+			code: Some(vec![]),
 			storage: map_into![1 => 1, 2 => 3, 3 => 0, 5 => 0, 7 => 7, 8 => 0, 9 => 9]
 		};
 		assert_eq!(diff_pod(Some(&a), Some(&b)), Some(AccountDiff {

ethcore/src/spec/spec.rs

@@ -38,6 +38,8 @@ pub struct CommonParams {
 	pub network_id: U256,
 	/// Minimum gas limit.
 	pub min_gas_limit: U256,
+	/// Fork block to check.
+	pub fork_block: Option<(BlockNumber, H256)>,
 }
 
 impl From<ethjson::spec::Params> for CommonParams {
@@ -47,6 +49,7 @@ impl From<ethjson::spec::Params> for CommonParams {
 			maximum_extra_data_size: p.maximum_extra_data_size.into(),
 			network_id: p.network_id.into(),
 			min_gas_limit: p.min_gas_limit.into(),
+			fork_block: if let (Some(n), Some(h)) = (p.fork_block, p.fork_hash) { Some((n.into(), h.into())) } else { None },
 		}
 	}
 }
@@ -148,6 +151,9 @@ impl Spec {
 	/// Get the configured Network ID.
 	pub fn network_id(&self) -> U256 { self.params.network_id }
 
+	/// Get the configured network fork block.
+	pub fn fork_block(&self) -> Option<(BlockNumber, H256)> { self.params.fork_block }
+
 	/// Get the header of the genesis block.
 	pub fn genesis_header(&self) -> Header {
 		Header {

ethcore/src/state.rs

@@ -19,7 +19,7 @@ use engine::Engine;
 use executive::{Executive, TransactOptions};
 use evm::Factory as EvmFactory;
 use account_db::*;
-use trace::Trace;
+use trace::FlatTrace;
 use pod_account::*;
 use pod_state::{self, PodState};
 use types::state_diff::StateDiff;
@@ -29,7 +29,7 @@ pub struct ApplyOutcome {
 	/// The receipt for the applied transaction.
 	pub receipt: Receipt,
 	/// The trace for the applied transaction, if None if tracing is disabled.
-	pub trace: Option<Trace>,
+	pub trace: Vec<FlatTrace>,
 }
 
 /// Result type for the execution ("application") of a transaction.
@@ -217,7 +217,7 @@ impl State {
 	/// Reset the code of account `a` so that it is `code`.
 	pub fn reset_code(&mut self, a: &Address, code: Bytes) {
 		self.require_or_from(a, true, || Account::new_contract(0.into(), self.account_start_nonce), |_|{}).reset_code(code);
-	}	
+	}
 
 	/// Execute a given transaction.
 	/// This will change the state accordingly.
@@ -227,30 +227,6 @@ impl State {
 		let options = TransactOptions { tracing: tracing, vm_tracing: false, check_nonce: true };
 		let e = try!(Executive::new(self, env_info, engine, vm_factory).transact(t, options));
 
-		let broken_dao = H256::from("6a5d24750f78441e56fec050dc52fe8e911976485b7472faac7464a176a67caa");
-
-		// dao attack soft fork
-		if engine.schedule(&env_info).reject_dao_transactions {
-			let whitelisted = if let Action::Call(to) = t.action {
-				to == Address::from("Da4a4626d3E16e094De3225A751aAb7128e96526") ||
-				to == Address::from("2ba9D006C1D72E67A70b5526Fc6b4b0C0fd6D334")
-			} else { false };
-			if !whitelisted {
-				// collect all the addresses which have changed.
-				let addresses = self.cache.borrow().iter().map(|(addr, _)| addr.clone()).collect::<Vec<_>>();
-
-				for a in &addresses {
-					if self.code(a).map_or(false, |c| c.sha3() == broken_dao) {
-						// Figure out if the balance has been reduced.
-						let maybe_original = SecTrieDB::new(self.db.as_hashdb(), &self.root).expect(SEC_TRIE_DB_UNWRAP_STR).get(&a).map(Account::from_rlp);
-						if maybe_original.map_or(false, |original| *original.balance() > self.balance(a)) {
-							return Err(Error::Transaction(TransactionError::DAORescue));
-						}
-					}
-				}
-			}
-		}
-
 		// TODO uncomment once to_pod() works correctly.
 //		trace!("Applied transaction. Diff:\n{}\n", state_diff::diff_pod(&old, &self.to_pod()));
 		self.commit();
@@ -413,7 +389,8 @@ use spec::*;
 use transaction::*;
 use util::log::init_log;
 use trace::trace;
-use trace::trace::{Trace};
+use trace::FlatTrace;
+use types::executed::CallType;
 
 #[test]
 fn should_apply_create_transaction() {
@@ -438,8 +415,9 @@ fn should_apply_create_transaction() {
 	state.add_balance(t.sender().as_ref().unwrap(), &(100.into()));
 	let vm_factory = Default::default();
 	let result = state.apply(&info, &engine, &vm_factory, &t, true).unwrap();
-	let expected_trace = Some(Trace {
-		depth: 0,
+	let expected_trace = vec![FlatTrace {
+		trace_address: Default::default(),
+		subtraces: 0,
 		action: trace::Action::Create(trace::Create {
 			from: "9cce34f7ab185c7aba1b7c8140d620b4bda941d6".into(),
 			value: 100.into(),
@@ -451,8 +429,7 @@ fn should_apply_create_transaction() {
 			address: Address::from_str("8988167e088c87cd314df6d3c2b83da5acb93ace").unwrap(),
 			code: vec![96, 0, 53, 84, 21, 96, 9, 87, 0, 91, 96, 32, 53, 96, 0, 53]
 		}),
-		subs: vec![]
-	});
+	}];
 
 	assert_eq!(result.trace, expected_trace);
 }
@@ -499,8 +476,8 @@ fn should_trace_failed_create_transaction() {
 	state.add_balance(t.sender().as_ref().unwrap(), &(100.into()));
 	let vm_factory = Default::default();
 	let result = state.apply(&info, &engine, &vm_factory, &t, true).unwrap();
-	let expected_trace = Some(Trace {
-		depth: 0,
+	let expected_trace = vec![FlatTrace {
+		trace_address: Default::default(),
 		action: trace::Action::Create(trace::Create {
 			from: "9cce34f7ab185c7aba1b7c8140d620b4bda941d6".into(),
 			value: 100.into(),
@@ -508,8 +485,8 @@ fn should_trace_failed_create_transaction() {
 			init: vec![91, 96, 0, 86],
 		}),
 		result: trace::Res::FailedCreate,
-		subs: vec![]
-	});
+		subtraces: 0
+	}];
 
 	assert_eq!(result.trace, expected_trace);
 }
@@ -538,21 +515,22 @@ fn should_trace_call_transaction() {
 	state.add_balance(t.sender().as_ref().unwrap(), &(100.into()));
 	let vm_factory = Default::default();
 	let result = state.apply(&info, &engine, &vm_factory, &t, true).unwrap();
-	let expected_trace = Some(Trace {
-		depth: 0,
+	let expected_trace = vec![FlatTrace {
+		trace_address: Default::default(),
 		action: trace::Action::Call(trace::Call {
 			from: "9cce34f7ab185c7aba1b7c8140d620b4bda941d6".into(),
 			to: 0xa.into(),
 			value: 100.into(),
 			gas: 79000.into(),
 			input: vec![],
+			call_type: CallType::Call,
 		}),
 		result: trace::Res::Call(trace::CallResult {
 			gas_used: U256::from(3),
 			output: vec![]
 		}),
-		subs: vec![]
-	});
+		subtraces: 0,
+	}];
 
 	assert_eq!(result.trace, expected_trace);
 }
@@ -580,21 +558,22 @@ fn should_trace_basic_call_transaction() {
 	state.add_balance(t.sender().as_ref().unwrap(), &(100.into()));
 	let vm_factory = Default::default();
 	let result = state.apply(&info, &engine, &vm_factory, &t, true).unwrap();
-	let expected_trace = Some(Trace {
-		depth: 0,
+	let expected_trace = vec![FlatTrace {
+		trace_address: Default::default(),
 		action: trace::Action::Call(trace::Call {
 			from: "9cce34f7ab185c7aba1b7c8140d620b4bda941d6".into(),
 			to: 0xa.into(),
 			value: 100.into(),
 			gas: 79000.into(),
 			input: vec![],
+			call_type: CallType::Call,
 		}),
 		result: trace::Res::Call(trace::CallResult {
 			gas_used: U256::from(0),
 			output: vec![]
 		}),
-		subs: vec![]
-	});
+		subtraces: 0,
+	}];
 
 	assert_eq!(result.trace, expected_trace);
 }
@@ -622,21 +601,24 @@ fn should_trace_call_transaction_to_builtin() {
 	let vm_factory = Default::default();
 	let result = state.apply(&info, engine.deref(), &vm_factory, &t, true).unwrap();
 
-	assert_eq!(result.trace, Some(Trace {
-		depth: 0,
+	let expected_trace = vec![FlatTrace {
+		trace_address: Default::default(),
 		action: trace::Action::Call(trace::Call {
 			from: "9cce34f7ab185c7aba1b7c8140d620b4bda941d6".into(),
 			to: "0000000000000000000000000000000000000001".into(),
 			value: 0.into(),
 			gas: 79_000.into(),
 			input: vec![],
+			call_type: CallType::Call,
 		}),
 		result: trace::Res::Call(trace::CallResult {
 			gas_used: U256::from(3000),
 			output: vec![]
 		}),
-		subs: vec![]
-	}));
+		subtraces: 0,
+	}];
+
+	assert_eq!(result.trace, expected_trace);
 }
 
 #[test]
@@ -663,21 +645,23 @@ fn should_not_trace_subcall_transaction_to_builtin() {
 	let vm_factory = Default::default();
 	let result = state.apply(&info, engine.deref(), &vm_factory, &t, true).unwrap();
 
-	let expected_trace = Some(Trace {
-		depth: 0,
+	let expected_trace = vec![FlatTrace {
+		trace_address: Default::default(),
 		action: trace::Action::Call(trace::Call {
 			from: "9cce34f7ab185c7aba1b7c8140d620b4bda941d6".into(),
 			to: 0xa.into(),
 			value: 0.into(),
 			gas: 79000.into(),
 			input: vec![],
+			call_type: CallType::Call,
 		}),
 		result: trace::Res::Call(trace::CallResult {
 			gas_used: U256::from(28_061),
 			output: vec![]
 		}),
-		subs: vec![]
-	});
+		subtraces: 0,
+	}];
+
 	assert_eq!(result.trace, expected_trace);
 }
 
@@ -706,21 +690,38 @@ fn should_not_trace_callcode() {
 	let vm_factory = Default::default();
 	let result = state.apply(&info, engine.deref(), &vm_factory, &t, true).unwrap();
 
-	let expected_trace = Some(Trace {
-		depth: 0,
+	let expected_trace = vec![FlatTrace {
+		trace_address: Default::default(),
+		subtraces: 1,
 		action: trace::Action::Call(trace::Call {
 			from: "9cce34f7ab185c7aba1b7c8140d620b4bda941d6".into(),
 			to: 0xa.into(),
 			value: 0.into(),
 			gas: 79000.into(),
 			input: vec![],
+			call_type: CallType::Call,
 		}),
 		result: trace::Res::Call(trace::CallResult {
-			gas_used: U256::from(64),
+			gas_used: 64.into(),
 			output: vec![]
 		}),
-		subs: vec![]
-	});
+	}, FlatTrace {
+		trace_address: vec![0].into_iter().collect(),
+		subtraces: 0,
+		action: trace::Action::Call(trace::Call {
+			from: 0xa.into(),
+			to: 0xa.into(),
+			value: 0.into(),
+			gas: 4096.into(),
+			input: vec![],
+			call_type: CallType::CallCode,
+		}),
+		result: trace::Res::Call(trace::CallResult {
+			gas_used: 3.into(),
+			output: vec![],
+		}),
+	}];
+
 	assert_eq!(result.trace, expected_trace);
 }
 
@@ -752,21 +753,38 @@ fn should_not_trace_delegatecall() {
 	let vm_factory = Default::default();
 	let result = state.apply(&info, engine.deref(), &vm_factory, &t, true).unwrap();
 
-	let expected_trace = Some(Trace {
-		depth: 0,
+	let expected_trace = vec![FlatTrace {
+		trace_address: Default::default(),
+		subtraces: 1,
 		action: trace::Action::Call(trace::Call {
 			from: "9cce34f7ab185c7aba1b7c8140d620b4bda941d6".into(),
 			to: 0xa.into(),
 			value: 0.into(),
 			gas: 79000.into(),
 			input: vec![],
+			call_type: CallType::Call,
 		}),
 		result: trace::Res::Call(trace::CallResult {
 			gas_used: U256::from(61),
 			output: vec![]
 		}),
-		subs: vec![]
-	});
+	}, FlatTrace {
+		trace_address: vec![0].into_iter().collect(),
+		subtraces: 0,
+		action: trace::Action::Call(trace::Call {
+			from: "9cce34f7ab185c7aba1b7c8140d620b4bda941d6".into(),
+			to: 0xa.into(),
+			value: 0.into(),
+			gas: 32768.into(),
+			input: vec![],
+			call_type: CallType::DelegateCall,
+		}),
+		result: trace::Res::Call(trace::CallResult {
+			gas_used: 3.into(),
+			output: vec![],
+		}),
+	}];
+
 	assert_eq!(result.trace, expected_trace);
 }
 
@@ -794,20 +812,19 @@ fn should_trace_failed_call_transaction() {
 	state.add_balance(t.sender().as_ref().unwrap(), &(100.into()));
 	let vm_factory = Default::default();
 	let result = state.apply(&info, &engine, &vm_factory, &t, true).unwrap();
-	let expected_trace = Some(Trace {
-		depth: 0,
+	let expected_trace = vec![FlatTrace {
+		trace_address: Default::default(),
 		action: trace::Action::Call(trace::Call {
 			from: "9cce34f7ab185c7aba1b7c8140d620b4bda941d6".into(),
 			to: 0xa.into(),
 			value: 100.into(),
 			gas: 79000.into(),
 			input: vec![],
+			call_type: CallType::Call,
 		}),
 		result: trace::Res::FailedCall,
-		subs: vec![]
-	});
-
-	println!("trace: {:?}", result.trace);
+		subtraces: 0,
+	}];
 
 	assert_eq!(result.trace, expected_trace);
 }
@@ -837,35 +854,38 @@ fn should_trace_call_with_subcall_transaction() {
 	state.add_balance(t.sender().as_ref().unwrap(), &(100.into()));
 	let vm_factory = Default::default();
 	let result = state.apply(&info, &engine, &vm_factory, &t, true).unwrap();
-	let expected_trace = Some(Trace {
-		depth: 0,
+
+	let expected_trace = vec![FlatTrace {
+		trace_address: Default::default(),
+		subtraces: 1,
 		action: trace::Action::Call(trace::Call {
 			from: "9cce34f7ab185c7aba1b7c8140d620b4bda941d6".into(),
 			to: 0xa.into(),
 			value: 100.into(),
 			gas: 79000.into(),
 			input: vec![],
+			call_type: CallType::Call,
 		}),
 		result: trace::Res::Call(trace::CallResult {
 			gas_used: U256::from(69),
 			output: vec![]
 		}),
-		subs: vec![Trace {
-			depth: 1,
-			action: trace::Action::Call(trace::Call {
-				from: 0xa.into(),
-				to: 0xb.into(),
-				value: 0.into(),
-				gas: 78934.into(),
-				input: vec![],
-			}),
-			result: trace::Res::Call(trace::CallResult {
-				gas_used: U256::from(3),
-				output: vec![]
-			}),
-			subs: vec![]
-		}]
-	});
+	}, FlatTrace {
+		trace_address: vec![0].into_iter().collect(),
+		subtraces: 0,
+		action: trace::Action::Call(trace::Call {
+			from: 0xa.into(),
+			to: 0xb.into(),
+			value: 0.into(),
+			gas: 78934.into(),
+			input: vec![],
+			call_type: CallType::Call,
+		}),
+		result: trace::Res::Call(trace::CallResult {
+			gas_used: U256::from(3),
+			output: vec![]
+		}),
+	}];
 
 	assert_eq!(result.trace, expected_trace);
 }
@@ -894,32 +914,34 @@ fn should_trace_call_with_basic_subcall_transaction() {
 	state.add_balance(t.sender().as_ref().unwrap(), &(100.into()));
 	let vm_factory = Default::default();
 	let result = state.apply(&info, &engine, &vm_factory, &t, true).unwrap();
-	let expected_trace = Some(Trace {
-		depth: 0,
+	let expected_trace = vec![FlatTrace {
+		trace_address: Default::default(),
+		subtraces: 1,
 		action: trace::Action::Call(trace::Call {
 			from: "9cce34f7ab185c7aba1b7c8140d620b4bda941d6".into(),
 			to: 0xa.into(),
 			value: 100.into(),
 			gas: 79000.into(),
 			input: vec![],
+			call_type: CallType::Call,
 		}),
 		result: trace::Res::Call(trace::CallResult {
 			gas_used: U256::from(31761),
 			output: vec![]
 		}),
-		subs: vec![Trace {
-			depth: 1,
-			action: trace::Action::Call(trace::Call {
-				from: 0xa.into(),
-				to: 0xb.into(),
-				value: 69.into(),
-				gas: 2300.into(),
-				input: vec![],
-			}),
-			result: trace::Res::Call(trace::CallResult::default()),
-			subs: vec![]
-		}]
-	});
+	}, FlatTrace {
+		trace_address: vec![0].into_iter().collect(),
+		subtraces: 0,
+		action: trace::Action::Call(trace::Call {
+			from: 0xa.into(),
+			to: 0xb.into(),
+			value: 69.into(),
+			gas: 2300.into(),
+			input: vec![],
+			call_type: CallType::Call,
+		}),
+		result: trace::Res::Call(trace::CallResult::default()),
+	}];
 
 	assert_eq!(result.trace, expected_trace);
 }
@@ -948,21 +970,22 @@ fn should_not_trace_call_with_invalid_basic_subcall_transaction() {
 	state.add_balance(t.sender().as_ref().unwrap(), &(100.into()));
 	let vm_factory = Default::default();
 	let result = state.apply(&info, &engine, &vm_factory, &t, true).unwrap();
-	let expected_trace = Some(Trace {
-		depth: 0,
+	let expected_trace = vec![FlatTrace {
+		trace_address: Default::default(),
+		subtraces: 0,
 		action: trace::Action::Call(trace::Call {
 			from: "9cce34f7ab185c7aba1b7c8140d620b4bda941d6".into(),
 			to: 0xa.into(),
 			value: 100.into(),
 			gas: 79000.into(),
 			input: vec![],
+			call_type: CallType::Call,
 		}),
 		result: trace::Res::Call(trace::CallResult {
 			gas_used: U256::from(31761),
 			output: vec![]
 		}),
-		subs: vec![]
-	});
+	}];
 
 	assert_eq!(result.trace, expected_trace);
 }
@@ -992,32 +1015,34 @@ fn should_trace_failed_subcall_transaction() {
 	state.add_balance(t.sender().as_ref().unwrap(), &(100.into()));
 	let vm_factory = Default::default();
 	let result = state.apply(&info, &engine, &vm_factory, &t, true).unwrap();
-	let expected_trace = Some(Trace {
-		depth: 0,
+	let expected_trace = vec![FlatTrace {
+		trace_address: Default::default(),
+		subtraces: 1,
 		action: trace::Action::Call(trace::Call {
 			from: "9cce34f7ab185c7aba1b7c8140d620b4bda941d6".into(),
 			to: 0xa.into(),
 			value: 100.into(),
 			gas: 79000.into(),
 			input: vec![],
+			call_type: CallType::Call,
 		}),
 		result: trace::Res::Call(trace::CallResult {
 			gas_used: U256::from(79_000),
 			output: vec![]
 		}),
-		subs: vec![Trace {
-			depth: 1,
-			action: trace::Action::Call(trace::Call {
-				from: 0xa.into(),
-				to: 0xb.into(),
-				value: 0.into(),
-				gas: 78934.into(),
-				input: vec![],
-			}),
-			result: trace::Res::FailedCall,
-			subs: vec![]
-		}]
-	});
+	}, FlatTrace {
+		trace_address: vec![0].into_iter().collect(),
+		subtraces: 0,
+		action: trace::Action::Call(trace::Call {
+			from: 0xa.into(),
+			to: 0xb.into(),
+			value: 0.into(),
+			gas: 78934.into(),
+			input: vec![],
+			call_type: CallType::Call,
+		}),
+		result: trace::Res::FailedCall,
+	}];
 
 	assert_eq!(result.trace, expected_trace);
 }
@@ -1048,49 +1073,52 @@ fn should_trace_call_with_subcall_with_subcall_transaction() {
 	state.add_balance(t.sender().as_ref().unwrap(), &(100.into()));
 	let vm_factory = Default::default();
 	let result = state.apply(&info, &engine, &vm_factory, &t, true).unwrap();
-	let expected_trace = Some(Trace {
-		depth: 0,
+	let expected_trace = vec![FlatTrace {
+		trace_address: Default::default(),
+		subtraces: 1,
 		action: trace::Action::Call(trace::Call {
 			from: "9cce34f7ab185c7aba1b7c8140d620b4bda941d6".into(),
 			to: 0xa.into(),
 			value: 100.into(),
 			gas: 79000.into(),
 			input: vec![],
+			call_type: CallType::Call,
 		}),
 		result: trace::Res::Call(trace::CallResult {
 			gas_used: U256::from(135),
 			output: vec![]
 		}),
-		subs: vec![Trace {
-			depth: 1,
-			action: trace::Action::Call(trace::Call {
-				from: 0xa.into(),
-				to: 0xb.into(),
-				value: 0.into(),
-				gas: 78934.into(),
-				input: vec![],
-			}),
-			result: trace::Res::Call(trace::CallResult {
-				gas_used: U256::from(69),
-				output: vec![]
-			}),
-			subs: vec![Trace {
-				depth: 2,
-				action: trace::Action::Call(trace::Call {
-					from: 0xb.into(),
-					to: 0xc.into(),
-					value: 0.into(),
-					gas: 78868.into(),
-					input: vec![],
-				}),
-				result: trace::Res::Call(trace::CallResult {
-					gas_used: U256::from(3),
-					output: vec![]
-				}),
-				subs: vec![]
-			}]
-		}]
-	});
+	}, FlatTrace {
+		trace_address: vec![0].into_iter().collect(),
+		subtraces: 1,
+		action: trace::Action::Call(trace::Call {
+			from: 0xa.into(),
+			to: 0xb.into(),
+			value: 0.into(),
+			gas: 78934.into(),
+			input: vec![],
+			call_type: CallType::Call,
+		}),
+		result: trace::Res::Call(trace::CallResult {
+			gas_used: U256::from(69),
+			output: vec![]
+		}),
+	}, FlatTrace {
+		trace_address: vec![0, 0].into_iter().collect(),
+		subtraces: 0,
+		action: trace::Action::Call(trace::Call {
+			from: 0xb.into(),
+			to: 0xc.into(),
+			value: 0.into(),
+			gas: 78868.into(),
+			input: vec![],
+			call_type: CallType::Call,
+		}),
+		result: trace::Res::Call(trace::CallResult {
+			gas_used: U256::from(3),
+			output: vec![]
+		}),
+	}];
 
 	assert_eq!(result.trace, expected_trace);
 }
@@ -1121,46 +1149,104 @@ fn should_trace_failed_subcall_with_subcall_transaction() {
 	state.add_balance(t.sender().as_ref().unwrap(), &(100.into()));
 	let vm_factory = Default::default();
 	let result = state.apply(&info, &engine, &vm_factory, &t, true).unwrap();
-	let expected_trace = Some(Trace {
-		depth: 0,
+
+	let expected_trace = vec![FlatTrace {
+		trace_address: Default::default(),
+		subtraces: 1,
 		action: trace::Action::Call(trace::Call {
 			from: "9cce34f7ab185c7aba1b7c8140d620b4bda941d6".into(),
 			to: 0xa.into(),
 			value: 100.into(),
 			gas: 79000.into(),
 			input: vec![],
+			call_type: CallType::Call,
 		}),
 		result: trace::Res::Call(trace::CallResult {
 			gas_used: U256::from(79_000),
 			output: vec![]
-		}),
-		subs: vec![Trace {
-			depth: 1,
+		})
+	}, FlatTrace {
+		trace_address: vec![0].into_iter().collect(),
+		subtraces: 1,
 			action: trace::Action::Call(trace::Call {
-				from: 0xa.into(),
-				to: 0xb.into(),
-				value: 0.into(),
-				gas: 78934.into(),
-				input: vec![],
-			}),
-			result: trace::Res::FailedCall,
-			subs: vec![Trace {
-				depth: 2,
-				action: trace::Action::Call(trace::Call {
-				from: 0xb.into(),
-				to: 0xc.into(),
-				value: 0.into(),
-				gas: 78868.into(),
-				input: vec![],
-				}),
-				result: trace::Res::Call(trace::CallResult {
-					gas_used: U256::from(3),
-					output: vec![]
-				}),
-				subs: vec![]
-			}]
-		}]
-	});
+			from: 0xa.into(),
+			to: 0xb.into(),
+			value: 0.into(),
+			gas: 78934.into(),
+			input: vec![],
+			call_type: CallType::Call,
+		}),
+		result: trace::Res::FailedCall,
+	}, FlatTrace {
+		trace_address: vec![0, 0].into_iter().collect(),
+		subtraces: 0,
+		action: trace::Action::Call(trace::Call {
+			from: 0xb.into(),
+			to: 0xc.into(),
+			value: 0.into(),
+			gas: 78868.into(),
+			call_type: CallType::Call,
+			input: vec![],
+		}),
+		result: trace::Res::Call(trace::CallResult {
+			gas_used: U256::from(3),
+			output: vec![]
+		}),
+	}];
+
+	assert_eq!(result.trace, expected_trace);
+}
+
+#[test]
+fn should_trace_suicide() {
+	init_log();
+
+	let temp = RandomTempPath::new();
+	let mut state = get_temp_state_in(temp.as_path());
+
+	let mut info = EnvInfo::default();
+	info.gas_limit = 1_000_000.into();
+	let engine = TestEngine::new(5);
+
+	let t = Transaction {
+		nonce: 0.into(),
+		gas_price: 0.into(),
+		gas: 100_000.into(),
+		action: Action::Call(0xa.into()),
+		value: 100.into(),
+		data: vec![],
+	}.sign(&"".sha3());
+
+	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());
+	let vm_factory = Default::default();
+	let result = state.apply(&info, &engine, &vm_factory, &t, true).unwrap();
+	let expected_trace = vec![FlatTrace {
+		trace_address: Default::default(),
+		subtraces: 1,
+		action: trace::Action::Call(trace::Call {
+			from: "9cce34f7ab185c7aba1b7c8140d620b4bda941d6".into(),
+			to: 0xa.into(),
+			value: 100.into(),
+			gas: 79000.into(),
+			input: vec![],
+			call_type: CallType::Call,
+		}),
+		result: trace::Res::Call(trace::CallResult {
+			gas_used: 3.into(),
+			output: vec![]
+		}),
+	}, FlatTrace {
+		trace_address: vec![0].into_iter().collect(),
+		subtraces: 0,
+		action: trace::Action::Suicide(trace::Suicide {
+			address: 0xa.into(),
+			refund_address: 0xb.into(),
+			balance: 150.into(),
+		}),
+		result: trace::Res::None,
+	}];
 
 	assert_eq!(result.trace, expected_trace);
 }

ethcore/src/tests/helpers.rs

@@ -30,6 +30,7 @@ use miner::Miner;
 pub enum ChainEra {
 	Frontier,
 	Homestead,
+	DaoHardfork,
 }
 
 #[cfg(test)]
@@ -179,7 +180,6 @@ pub fn generate_dummy_client_with_spec_and_data<F>(get_test_spec: F, block_numbe
 			db,
 			&last_header,
 			last_hashes.clone(),
-			None,
 			author.clone(),
 			(3141562.into(), 31415620.into()),
 			vec![]

ethcore/src/trace/block.rs

@@ -1,58 +0,0 @@
-// Copyright 2015, 2016 Ethcore (UK) Ltd.
-// This file is part of Parity.
-
-// Parity is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-
-// Parity is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-
-// You should have received a copy of the GNU General Public License
-// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
-
-use util::rlp::*;
-use basic_types::LogBloom;
-use super::Trace;
-
-/// Traces created by transactions from the same block.
-#[derive(Clone)]
-pub struct BlockTraces(Vec<Trace>);
-
-impl From<Vec<Trace>> for BlockTraces {
-	fn from(traces: Vec<Trace>) -> Self {
-		BlockTraces(traces)
-	}
-}
-
-impl Into<Vec<Trace>> for BlockTraces {
-	fn into(self) -> Vec<Trace> {
-		self.0
-	}
-}
-
-impl Decodable for BlockTraces {
-	fn decode<D>(decoder: &D) -> Result<Self, DecoderError> where D: Decoder {
-		let traces = try!(Decodable::decode(decoder));
-		let block_traces = BlockTraces(traces);
-		Ok(block_traces)
-	}
-}
-
-impl Encodable for BlockTraces {
-	fn rlp_append(&self, s: &mut RlpStream) {
-		Encodable::rlp_append(&self.0, s)
-	}
-}
-
-impl BlockTraces {
-	/// Returns bloom of all traces in given block.
-	pub fn bloom(&self) -> LogBloom {
-		self.0.iter()
-			.fold(LogBloom::default(), |acc, trace| acc | trace.bloom())
-	}
-}
-

ethcore/src/trace/db.rs

@@ -15,7 +15,6 @@
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
 //! Trace database.
-use std::ptr;
 use std::ops::{Deref, DerefMut};
 use std::collections::HashMap;
 use std::sync::{RwLock, Arc};
@@ -24,7 +23,7 @@ use bloomchain::{Number, Config as BloomConfig};
 use bloomchain::group::{BloomGroupDatabase, BloomGroupChain, GroupPosition, BloomGroup};
 use util::{H256, H264, Database, DatabaseConfig, DBTransaction};
 use header::BlockNumber;
-use trace::{BlockTraces, LocalizedTrace, Config, Switch, Filter, Database as TraceDatabase, ImportRequest,
+use trace::{LocalizedTrace, Config, Switch, Filter, Database as TraceDatabase, ImportRequest,
 DatabaseExtras, Error};
 use db::{Key, Writable, Readable, CacheUpdatePolicy};
 use blooms;
@@ -41,15 +40,13 @@ enum TraceDBIndex {
 	BloomGroups = 1,
 }
 
-impl Key<BlockTraces> for H256 {
+impl Key<FlatBlockTraces> for H256 {
 	type Target = H264;
 
 	fn key(&self) -> H264 {
 		let mut result = H264::default();
 		result[0] = TraceDBIndex::BlockTraces as u8;
-		unsafe {
-			ptr::copy(self.as_ptr(), result.as_mut_ptr().offset(1), 32);
-		}
+		result[1..33].copy_from_slice(self);
 		result
 	}
 }
@@ -84,9 +81,9 @@ impl Key<blooms::BloomGroup> for TraceGroupPosition {
 		result[0] = TraceDBIndex::BloomGroups as u8;
 		result[1] = self.0.level;
 		result[2] = self.0.index as u8;
-		result[3] = (self.0.index << 8) as u8;
-		result[4] = (self.0.index << 16) as u8;
-		result[5] = (self.0.index << 24) as u8;
+		result[3] = (self.0.index >> 8) as u8;
+		result[4] = (self.0.index >> 16) as u8;
+		result[5] = (self.0.index >> 24) as u8;
 		TraceGroupKey(result)
 	}
 }
@@ -94,7 +91,7 @@ impl Key<blooms::BloomGroup> for TraceGroupPosition {
 /// Trace database.
 pub struct TraceDB<T> where T: DatabaseExtras {
 	// cache
-	traces: RwLock<HashMap<H256, BlockTraces>>,
+	traces: RwLock<HashMap<H256, FlatBlockTraces>>,
 	blooms: RwLock<HashMap<TraceGroupPosition, blooms::BloomGroup>>,
 	// db
 	tracesdb: Database,
@@ -156,15 +153,13 @@ impl<T> TraceDB<T> where T: DatabaseExtras {
 	}
 
 	/// Returns traces for block with hash.
-	fn traces(&self, block_hash: &H256) -> Option<BlockTraces> {
+	fn traces(&self, block_hash: &H256) -> Option<FlatBlockTraces> {
 		self.tracesdb.read_with_cache(&self.traces, block_hash)
 	}
 
 	/// Returns vector of transaction traces for given block.
 	fn transactions_traces(&self, block_hash: &H256) -> Option<Vec<FlatTransactionTraces>> {
-		self.traces(block_hash)
-			.map(FlatBlockTraces::from)
-			.map(Into::into)
+		self.traces(block_hash).map(Into::into)
 	}
 
 	fn matching_block_traces(
@@ -202,7 +197,7 @@ impl<T> TraceDB<T> where T: DatabaseExtras {
 						action: trace.action,
 						result: trace.result,
 						subtraces: trace.subtraces,
-						trace_address: trace.trace_address,
+						trace_address: trace.trace_address.into_iter().collect(),
 						transaction_number: tx_number,
 						transaction_hash: tx_hash.clone(),
 						block_number: block_number,
@@ -268,12 +263,13 @@ impl<T> TraceDatabase for TraceDB<T> where T: DatabaseExtras {
 	}
 
 	fn trace(&self, block_number: BlockNumber, tx_position: usize, trace_position: Vec<usize>) -> Option<LocalizedTrace> {
+		let trace_position_deq = trace_position.into_iter().collect();
 		self.extras.block_hash(block_number)
 			.and_then(|block_hash| self.transactions_traces(&block_hash)
 				.and_then(|traces| traces.into_iter().nth(tx_position))
 				.map(Into::<Vec<FlatTrace>>::into)
 				// this may and should be optimized
-				.and_then(|traces| traces.into_iter().find(|trace| trace.trace_address == trace_position))
+				.and_then(|traces| traces.into_iter().find(|trace| trace.trace_address == trace_position_deq))
 				.map(|trace| {
 					let tx_hash = self.extras.transaction_hash(block_number, tx_position)
 						.expect("Expected to find transaction hash. Database is probably corrupted");
@@ -282,7 +278,7 @@ impl<T> TraceDatabase for TraceDB<T> where T: DatabaseExtras {
 						action: trace.action,
 						result: trace.result,
 						subtraces: trace.subtraces,
-						trace_address: trace.trace_address,
+						trace_address: trace.trace_address.into_iter().collect(),
 						transaction_number: tx_position,
 						transaction_hash: tx_hash,
 						block_number: block_number,
@@ -306,7 +302,7 @@ impl<T> TraceDatabase for TraceDB<T> where T: DatabaseExtras {
 						action: trace.action,
 						result: trace.result,
 						subtraces: trace.subtraces,
-						trace_address: trace.trace_address,
+						trace_address: trace.trace_address.into_iter().collect(),
 						transaction_number: tx_position,
 						transaction_hash: tx_hash.clone(),
 						block_number: block_number,
@@ -333,7 +329,7 @@ impl<T> TraceDatabase for TraceDB<T> where T: DatabaseExtras {
 									action: trace.action,
 									result: trace.result,
 									subtraces: trace.subtraces,
-									trace_address: trace.trace_address,
+									trace_address: trace.trace_address.into_iter().collect(),
 									transaction_number: tx_position,
 									transaction_hash: tx_hash.clone(),
 									block_number: block_number,
@@ -356,8 +352,7 @@ impl<T> TraceDatabase for TraceDB<T> where T: DatabaseExtras {
 					.expect("Expected to find block hash. Extras db is probably corrupted");
 				let traces = self.traces(&hash)
 					.expect("Expected to find a trace. Db is probably corrupted.");
-				let flat_block = FlatBlockTraces::from(traces);
-				self.matching_block_traces(filter, flat_block, hash, number)
+				self.matching_block_traces(filter, traces, hash, number)
 			})
 			.collect()
 	}
@@ -371,8 +366,10 @@ mod tests {
 	use devtools::RandomTempPath;
 	use header::BlockNumber;
 	use trace::{Config, Switch, TraceDB, Database, DatabaseExtras, ImportRequest};
-	use trace::{BlockTraces, Trace, Filter, LocalizedTrace, AddressesFilter};
+	use trace::{Filter, LocalizedTrace, AddressesFilter};
 	use trace::trace::{Call, Action, Res};
+	use trace::flat::{FlatTrace, FlatBlockTraces, FlatTransactionTraces};
+	use types::executed::CallType;
 
 	struct NoopExtras;
 
@@ -386,6 +383,7 @@ mod tests {
 		}
 	}
 
+	#[derive(Clone)]
 	struct Extras {
 		block_hashes: HashMap<BlockNumber, H256>,
 		transaction_hashes: HashMap<BlockNumber, Vec<H256>>,
@@ -490,18 +488,19 @@ mod tests {
 
 	fn create_simple_import_request(block_number: BlockNumber, block_hash: H256) -> ImportRequest {
 		ImportRequest {
-			traces: BlockTraces::from(vec![Trace {
-				depth: 0,
+			traces: FlatBlockTraces::from(vec![FlatTransactionTraces::from(vec![FlatTrace {
+				trace_address: Default::default(),
+				subtraces: 0,
 				action: Action::Call(Call {
-					from: Address::from(1),
-					to: Address::from(2),
-					value: U256::from(3),
-					gas: U256::from(4),
+					from: 1.into(),
+					to: 2.into(),
+					value: 3.into(),
+					gas: 4.into(),
 					input: vec![],
+					call_type: CallType::Call,
 				}),
 				result: Res::FailedCall,
-				subs: vec![],
-			}]),
+			}])]),
 			block_hash: block_hash.clone(),
 			block_number: block_number,
 			enacted: vec![block_hash],
@@ -517,6 +516,7 @@ mod tests {
 				value: U256::from(3),
 				gas: U256::from(4),
 				input: vec![],
+				call_type: CallType::Call,
 			}),
 			result: Res::FailedCall,
 			trace_address: vec![],

ethcore/src/trace/executive_tracer.rs

@@ -18,13 +18,53 @@
 
 use util::{Bytes, Address, U256};
 use action_params::ActionParams;
-use trace::trace::{Trace, Call, Create, Action, Res, CreateResult, CallResult, VMTrace, VMOperation, VMExecutedOperation, MemoryDiff, StorageDiff};
-use trace::{Tracer, VMTracer};
+use trace::trace::{Call, Create, Action, Res, CreateResult, CallResult, VMTrace, VMOperation, VMExecutedOperation, MemoryDiff, StorageDiff, Suicide};
+use trace::{Tracer, VMTracer, FlatTrace};
 
 /// Simple executive tracer. Traces all calls and creates. Ignores delegatecalls.
 #[derive(Default)]
 pub struct ExecutiveTracer {
-	traces: Vec<Trace>,
+	traces: Vec<FlatTrace>,
+}
+
+fn top_level_subtraces(traces: &[FlatTrace]) -> usize {
+	traces.iter().filter(|t| t.trace_address.is_empty()).count()
+}
+
+fn update_trace_address(traces: Vec<FlatTrace>) -> Vec<FlatTrace> {
+	// input traces are expected to be ordered like
+	// []
+	// [0]
+	// [0, 0]
+	// [0, 1]
+	// []
+	// [0]
+	//
+	// so they can be transformed to
+	//
+	// [0]
+	// [0, 0]
+	// [0, 0, 0]
+	// [0, 0, 1]
+	// [1]
+	// [1, 0]
+	let mut top_subtrace_index = 0;
+	let mut subtrace_subtraces_left = 0;
+	traces.into_iter().map(|mut trace| {
+		let is_top_subtrace = trace.trace_address.is_empty();
+		trace.trace_address.push_front(top_subtrace_index);
+
+		if is_top_subtrace {
+			subtrace_subtraces_left = trace.subtraces;
+		} else {
+			subtrace_subtraces_left -= 1;
+		}
+
+		if subtrace_subtraces_left == 0 {
+			top_subtrace_index += 1;
+		}
+		trace
+	}).collect()
 }
 
 impl Tracer for ExecutiveTracer {
@@ -40,59 +80,67 @@ impl Tracer for ExecutiveTracer {
 		Some(vec![])
 	}
 
-	fn trace_call(&mut self, call: Option<Call>, gas_used: U256, output: Option<Bytes>, depth: usize, subs: Vec<Trace>, delegate_call: bool) {
-		// don't trace if it's DELEGATECALL or CALLCODE.
-		if delegate_call {
-			return;
-		}
-
-		let trace = Trace {
-			depth: depth,
-			subs: subs,
+	fn trace_call(&mut self, call: Option<Call>, gas_used: U256, output: Option<Bytes>, subs: Vec<FlatTrace>) {
+		let trace = FlatTrace {
+			trace_address: Default::default(),
+			subtraces: top_level_subtraces(&subs),
 			action: Action::Call(call.expect("self.prepare_trace_call().is_some(): so we must be tracing: qed")),
 			result: Res::Call(CallResult {
 				gas_used: gas_used,
 				output: output.expect("self.prepare_trace_output().is_some(): so we must be tracing: qed")
-			})
+			}),
 		};
 		self.traces.push(trace);
+		self.traces.extend(update_trace_address(subs));
 	}
 
-	fn trace_create(&mut self, create: Option<Create>, gas_used: U256, code: Option<Bytes>, address: Address, depth: usize, subs: Vec<Trace>) {
-		let trace = Trace {
-			depth: depth,
-			subs: subs,
+	fn trace_create(&mut self, create: Option<Create>, gas_used: U256, code: Option<Bytes>, address: Address, subs: Vec<FlatTrace>) {
+		let trace = FlatTrace {
+			subtraces: top_level_subtraces(&subs),
 			action: Action::Create(create.expect("self.prepare_trace_create().is_some(): so we must be tracing: qed")),
 			result: Res::Create(CreateResult {
 				gas_used: gas_used,
 				code: code.expect("self.prepare_trace_output.is_some(): so we must be tracing: qed"),
 				address: address
-			})
+			}),
+			trace_address: Default::default(),
 		};
 		self.traces.push(trace);
+		self.traces.extend(update_trace_address(subs));
 	}
 
-	fn trace_failed_call(&mut self, call: Option<Call>, depth: usize, subs: Vec<Trace>, delegate_call: bool) {
-		// don't trace if it's DELEGATECALL or CALLCODE.
-		if delegate_call {
-			return;
-		}
-
-		let trace = Trace {
-			depth: depth,
-			subs: subs,
+	fn trace_failed_call(&mut self, call: Option<Call>, subs: Vec<FlatTrace>) {
+		let trace = FlatTrace {
+			trace_address: Default::default(),
+			subtraces: top_level_subtraces(&subs),
 			action: Action::Call(call.expect("self.prepare_trace_call().is_some(): so we must be tracing: qed")),
 			result: Res::FailedCall,
 		};
 		self.traces.push(trace);
+		self.traces.extend(update_trace_address(subs));
 	}
 
-	fn trace_failed_create(&mut self, create: Option<Create>, depth: usize, subs: Vec<Trace>) {
-		let trace = Trace {
-			depth: depth,
-			subs: subs,
+	fn trace_failed_create(&mut self, create: Option<Create>, subs: Vec<FlatTrace>) {
+		let trace = FlatTrace {
+			subtraces: top_level_subtraces(&subs),
 			action: Action::Create(create.expect("self.prepare_trace_create().is_some(): so we must be tracing: qed")),
 			result: Res::FailedCreate,
+			trace_address: Default::default(),
+		};
+		self.traces.push(trace);
+		self.traces.extend(update_trace_address(subs));
+	}
+
+	fn trace_suicide(&mut self, address: Address, balance: U256, refund_address: Address) {
+		let trace = FlatTrace {
+			subtraces: 0,
+			action: Action::Suicide(Suicide {
+				address: address,
+				refund_address: refund_address,
+				balance: balance,
+			}),
+			result: Res::None,
+			trace_address: Default::default(),
 		};
 		self.traces.push(trace);
 	}
@@ -101,7 +149,7 @@ impl Tracer for ExecutiveTracer {
 		ExecutiveTracer::default()
 	}
 
-	fn traces(self) -> Vec<Trace> {
+	fn traces(self) -> Vec<FlatTrace> {
 		self.traces
 	}
 }

ethcore/src/trace/flat.rs

@@ -1,183 +0,0 @@
-// 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/>.
-
-//! Flat trace module
-
-use trace::BlockTraces;
-use super::trace::{Trace, Action, Res};
-
-/// Trace localized in vector of traces produced by a single transaction.
-///
-/// Parent and children indexes refer to positions in this vector.
-pub struct FlatTrace {
-	/// Type of action performed by a transaction.
-	pub action: Action,
-	/// Result of this action.
-	pub result: Res,
-	/// Number of subtraces.
-	pub subtraces: usize,
-	/// Exact location of trace.
-	///
-	/// [index in root, index in first CALL, index in second CALL, ...]
-	pub trace_address: Vec<usize>,
-}
-
-/// Represents all traces produced by a single transaction.
-pub struct FlatTransactionTraces(Vec<FlatTrace>);
-
-impl Into<Vec<FlatTrace>> for FlatTransactionTraces {
-	fn into(self) -> Vec<FlatTrace> {
-		self.0
-	}
-}
-
-/// Represents all traces produced by transactions in a single block.
-pub struct FlatBlockTraces(Vec<FlatTransactionTraces>);
-
-impl From<BlockTraces> for FlatBlockTraces {
-	fn from(block_traces: BlockTraces) -> Self {
-		let traces: Vec<Trace> = block_traces.into();
-		let ordered = traces.into_iter()
-			.map(|trace| FlatBlockTraces::flatten(vec![], trace))
-			.map(FlatTransactionTraces)
-			.collect();
-		FlatBlockTraces(ordered)
-	}
-}
-
-impl Into<Vec<FlatTransactionTraces>> for FlatBlockTraces {
-	fn into(self) -> Vec<FlatTransactionTraces> {
-		self.0
-	}
-}
-
-impl FlatBlockTraces {
-	/// Helper function flattening nested tree structure to vector of ordered traces.
-	fn flatten(address: Vec<usize>, trace: Trace) -> Vec<FlatTrace> {
-		let subtraces = trace.subs.len();
-		let all_subs = trace.subs
-			.into_iter()
-			.enumerate()
-			.flat_map(|(index, subtrace)| {
-				let mut subtrace_address = address.clone();
-				subtrace_address.push(index);
-				FlatBlockTraces::flatten(subtrace_address, subtrace)
-			})
-			.collect::<Vec<_>>();
-
-		let ordered = FlatTrace {
-			action: trace.action,
-			result: trace.result,
-			subtraces: subtraces,
-			trace_address: address,
-		};
-
-		let mut result = vec![ordered];
-		result.extend(all_subs);
-		result
-	}
-}
-
-#[cfg(test)]
-mod tests {
-	use super::{FlatBlockTraces, FlatTransactionTraces, FlatTrace};
-	use util::{U256, Address};
-	use trace::trace::{Action, Res, CallResult, Call, Create, Trace};
-	use trace::BlockTraces;
-
-	#[test]
-	fn test_block_from() {
-		let trace = Trace {
-			depth: 2,
-			action: Action::Call(Call {
-				from: Address::from(1),
-				to: Address::from(2),
-				value: U256::from(3),
-				gas: U256::from(4),
-				input: vec![0x5]
-			}),
-			subs: vec![
-				Trace {
-					depth: 3,
-					action: Action::Create(Create {
-						from: Address::from(6),
-						value: U256::from(7),
-						gas: U256::from(8),
-						init: vec![0x9]
-					}),
-					subs: vec![
-						Trace {
-							depth: 3,
-							action: Action::Create(Create {
-								from: Address::from(6),
-								value: U256::from(7),
-								gas: U256::from(8),
-								init: vec![0x9]
-							}),
-							subs: vec![
-							],
-							result: Res::FailedCreate
-						},
-						Trace {
-							depth: 3,
-							action: Action::Create(Create {
-								from: Address::from(6),
-								value: U256::from(7),
-								gas: U256::from(8),
-								init: vec![0x9]
-							}),
-							subs: vec![
-							],
-							result: Res::FailedCreate
-						}
-					],
-					result: Res::FailedCreate
-				},
-				Trace {
-					depth: 3,
-					action: Action::Create(Create {
-						from: Address::from(6),
-						value: U256::from(7),
-						gas: U256::from(8),
-						init: vec![0x9]
-					}),
-					subs: vec![],
-					result: Res::FailedCreate,
-				}
-			],
-			result: Res::Call(CallResult {
-				gas_used: U256::from(10),
-				output: vec![0x11, 0x12]
-			})
-		};
-
-		let block_traces = FlatBlockTraces::from(BlockTraces::from(vec![trace]));
-		let transaction_traces: Vec<FlatTransactionTraces> = block_traces.into();
-		assert_eq!(transaction_traces.len(), 1);
-		let ordered_traces: Vec<FlatTrace> = transaction_traces.into_iter().nth(0).unwrap().into();
-		assert_eq!(ordered_traces.len(), 5);
-		assert_eq!(ordered_traces[0].trace_address, vec![]);
-		assert_eq!(ordered_traces[0].subtraces, 2);
-		assert_eq!(ordered_traces[1].trace_address, vec![0]);
-		assert_eq!(ordered_traces[1].subtraces, 2);
-		assert_eq!(ordered_traces[2].trace_address, vec![0, 0]);
-		assert_eq!(ordered_traces[2].subtraces, 0);
-		assert_eq!(ordered_traces[3].trace_address, vec![0, 1]);
-		assert_eq!(ordered_traces[3].subtraces, 0);
-		assert_eq!(ordered_traces[4].trace_address, vec![1]);
-		assert_eq!(ordered_traces[4].subtraces, 0);
-	}
-}

ethcore/src/trace/import.rs

@@ -17,12 +17,12 @@
 //! Traces import request.
 use util::H256;
 use header::BlockNumber;
-use trace::BlockTraces;
+use trace::FlatBlockTraces;
 
 /// Traces import request.
 pub struct ImportRequest {
 	/// Traces to import.
-	pub traces: BlockTraces,
+	pub traces: FlatBlockTraces,
 	/// Hash of traces block.
 	pub block_hash: H256,
 	/// Number of traces block.

ethcore/src/trace/mod.rs

@@ -16,22 +16,20 @@
 
 //! Tracing
 
-mod block;
 mod bloom;
 mod config;
 mod db;
 mod error;
 mod executive_tracer;
-pub mod flat;
 mod import;
 mod noop_tracer;
 
 pub use types::trace_types::*;
-pub use self::block::BlockTraces;
 pub use self::config::{Config, Switch};
 pub use self::db::TraceDB;
 pub use self::error::Error;
-pub use types::trace_types::trace::{Trace, VMTrace, VMOperation, VMExecutedOperation, MemoryDiff, StorageDiff};
+pub use types::trace_types::trace::{VMTrace, VMOperation, VMExecutedOperation, MemoryDiff, StorageDiff};
+pub use types::trace_types::flat::{FlatTrace, FlatTransactionTraces, FlatBlockTraces};
 pub use self::noop_tracer::{NoopTracer, NoopVMTracer};
 pub use self::executive_tracer::{ExecutiveTracer, ExecutiveVMTracer};
 pub use types::trace_types::filter::{Filter, AddressesFilter};
@@ -59,9 +57,7 @@ pub trait Tracer: Send {
 		call: Option<Call>,
 		gas_used: U256,
 		output: Option<Bytes>,
-		depth: usize,
-		subs: Vec<Trace>,
-		delegate_call: bool
+		subs: Vec<FlatTrace>,
 	);
 
 	/// Stores trace create info.
@@ -71,21 +67,23 @@ pub trait Tracer: Send {
 		gas_used: U256,
 		code: Option<Bytes>,
 		address: Address,
-		depth: usize,
-		subs: Vec<Trace>
+		subs: Vec<FlatTrace>
 	);
 
 	/// Stores failed call trace.
-	fn trace_failed_call(&mut self, call: Option<Call>, depth: usize, subs: Vec<Trace>, delegate_call: bool);
+	fn trace_failed_call(&mut self, call: Option<Call>, subs: Vec<FlatTrace>);
 
 	/// Stores failed create trace.
-	fn trace_failed_create(&mut self, create: Option<Create>, depth: usize, subs: Vec<Trace>);
+	fn trace_failed_create(&mut self, create: Option<Create>, subs: Vec<FlatTrace>);
+
+	/// Stores suicide info.
+	fn trace_suicide(&mut self, address: Address, balance: U256, refund_address: Address);
 
 	/// Spawn subtracer which will be used to trace deeper levels of execution.
 	fn subtracer(&self) -> Self where Self: Sized;
 
 	/// Consumes self and returns all traces.
-	fn traces(self) -> Vec<Trace>;
+	fn traces(self) -> Vec<FlatTrace>;
 }
 
 /// Used by executive to build VM traces.

ethcore/src/trace/noop_tracer.rs

@@ -18,8 +18,8 @@
 
 use util::{Bytes, Address, U256};
 use action_params::ActionParams;
-use trace::{Tracer, VMTracer};
-use trace::trace::{Trace, Call, Create, VMTrace};
+use trace::{Tracer, VMTracer, FlatTrace};
+use trace::trace::{Call, Create, VMTrace};
 
 /// Nonoperative tracer. Does not trace anything.
 pub struct NoopTracer;
@@ -37,29 +37,32 @@ impl Tracer for NoopTracer {
 		None
 	}
 
-	fn trace_call(&mut self, call: Option<Call>, _: U256, output: Option<Bytes>, _: usize, _: Vec<Trace>, _: bool) {
+	fn trace_call(&mut self, call: Option<Call>, _: U256, output: Option<Bytes>, _: Vec<FlatTrace>) {
 		assert!(call.is_none(), "self.prepare_trace_call().is_none(): so we can't be tracing: qed");
 		assert!(output.is_none(), "self.prepare_trace_output().is_none(): so we can't be tracing: qed");
 	}
 
-	fn trace_create(&mut self, create: Option<Create>, _: U256, code: Option<Bytes>, _: Address, _: usize, _: Vec<Trace>) {
+	fn trace_create(&mut self, create: Option<Create>, _: U256, code: Option<Bytes>, _: Address, _: Vec<FlatTrace>) {
 		assert!(create.is_none(), "self.prepare_trace_create().is_none(): so we can't be tracing: qed");
 		assert!(code.is_none(), "self.prepare_trace_output().is_none(): so we can't be tracing: qed");
 	}
 
-	fn trace_failed_call(&mut self, call: Option<Call>, _: usize, _: Vec<Trace>, _: bool) {
+	fn trace_failed_call(&mut self, call: Option<Call>, _: Vec<FlatTrace>) {
 		assert!(call.is_none(), "self.prepare_trace_call().is_none(): so we can't be tracing: qed");
 	}
 
-	fn trace_failed_create(&mut self, create: Option<Create>, _: usize, _: Vec<Trace>) {
+	fn trace_failed_create(&mut self, create: Option<Create>, _: Vec<FlatTrace>) {
 		assert!(create.is_none(), "self.prepare_trace_create().is_none(): so we can't be tracing: qed");
 	}
 
+	fn trace_suicide(&mut self, _address: Address, _balance: U256, _refund_address: Address) {
+	}
+
 	fn subtracer(&self) -> Self {
 		NoopTracer
 	}
 
-	fn traces(self) -> Vec<Trace> {
+	fn traces(self) -> Vec<FlatTrace> {
 		vec![]
 	}
 }

ethcore/src/types/executed.rs

@@ -18,7 +18,8 @@
 
 use util::numbers::*;
 use util::Bytes;
-use trace::{Trace, VMTrace};
+use util::rlp::*;
+use trace::{VMTrace, FlatTrace};
 use types::log_entry::LogEntry;
 use types::state_diff::StateDiff;
 use ipc::binary::BinaryConvertError;
@@ -26,6 +27,43 @@ use std::fmt;
 use std::mem;
 use std::collections::VecDeque;
 
+/// The type of the call-like instruction.
+#[derive(Debug, PartialEq, Clone, Binary)]
+pub enum CallType {
+	/// Not a CALL.
+	None,
+	/// CALL.
+	Call,
+	/// CALLCODE.
+	CallCode,
+	/// DELEGATECALL.
+	DelegateCall,
+}
+
+impl Encodable for CallType {
+	fn rlp_append(&self, s: &mut RlpStream) {
+		let v = match *self {
+			CallType::None => 0u32,
+			CallType::Call => 1,
+			CallType::CallCode => 2,
+			CallType::DelegateCall => 3,
+		};
+		s.append(&v);
+	}
+}
+
+impl Decodable for CallType {
+	fn decode<D>(decoder: &D) -> Result<Self, DecoderError> where D: Decoder {
+		decoder.as_rlp().as_val().and_then(|v| Ok(match v {
+			0u32 => CallType::None,
+			1 => CallType::Call,
+			2 => CallType::CallCode,
+			3 => CallType::DelegateCall,
+			_ => return Err(DecoderError::Custom("Invalid value of CallType item")),
+		}))
+	}
+}
+
 /// Transaction execution receipt.
 #[derive(Debug, PartialEq, Clone)]
 pub struct Executed {
@@ -59,7 +97,7 @@ pub struct Executed {
 	/// Transaction output.
 	pub output: Bytes,
 	/// The trace of this transaction.
-	pub trace: Option<Trace>,
+	pub trace: Vec<FlatTrace>,
 	/// The VM trace of this transaction.
 	pub vm_trace: Option<VMTrace>,
 	/// The state diff, if we traced it.
@@ -135,3 +173,12 @@ impl fmt::Display for ExecutionError {
 
 /// Transaction execution result.
 pub type ExecutionResult = Result<Executed, ExecutionError>;
+
+#[test]
+fn should_encode_and_decode_call_type() {
+	use util::rlp;
+	let original = CallType::Call;
+	let encoded = rlp::encode(&original);
+	let decoded = rlp::decode(&encoded);
+	assert_eq!(original, decoded);
+}

ethcore/src/types/ids.rs

@@ -33,7 +33,9 @@ pub enum BlockID {
 	/// Earliest block (genesis).
 	Earliest,
 	/// Latest mined block.
-	Latest
+	Latest,
+	/// Pending block.
+	Pending,
 }
 
 /// Uniquely identifies transaction.

ethcore/src/types/trace_types/filter.rs

@@ -22,7 +22,7 @@ use util::{Address, FixedHash};
 use util::sha3::Hashable;
 use basic_types::LogBloom;
 use trace::flat::FlatTrace;
-use types::trace_types::trace::Action;
+use types::trace_types::trace::{Action, Res};
 use ipc::binary::BinaryConvertError;
 use std::mem;
 use std::collections::VecDeque;
@@ -30,7 +30,7 @@ use std::collections::VecDeque;
 /// Addresses filter.
 ///
 /// Used to create bloom possibilities and match filters.
-#[derive(Binary)]
+#[derive(Debug, Binary)]
 pub struct AddressesFilter {
 	list: Vec<Address>
 }
@@ -58,7 +58,7 @@ impl AddressesFilter {
 			true => vec![LogBloom::new()],
 			false => self.list.iter()
 				.map(|address| LogBloom::from_bloomed(&address.sha3()))
-				.collect()
+				.collect(),
 		}
 	}
 
@@ -71,12 +71,12 @@ impl AddressesFilter {
 				.flat_map(|bloom| self.list.iter()
 					.map(|address| bloom.with_bloomed(&address.sha3()))
 					.collect::<Vec<_>>())
-				.collect()
+				.collect(),
 		}
 	}
 }
 
-#[derive(Binary)]
+#[derive(Debug, Binary)]
 /// Traces filter.
 pub struct Filter {
 	/// Block range.
@@ -110,29 +110,40 @@ impl Filter {
 
 	/// Returns true if given trace matches the filter.
 	pub fn matches(&self, trace: &FlatTrace) -> bool {
-		match trace.action {
+		let action = match trace.action {
 			Action::Call(ref call) => {
 				let from_matches = self.from_address.matches(&call.from);
 				let to_matches = self.to_address.matches(&call.to);
 				from_matches && to_matches
-			},
+			}
 			Action::Create(ref create) => {
 				let from_matches = self.from_address.matches(&create.from);
 				let to_matches = self.to_address.matches_all();
 				from_matches && to_matches
+			},
+			Action::Suicide(ref suicide) => {
+				let from_matches = self.from_address.matches(&suicide.address);
+				let to_matches = self.to_address.matches(&suicide.refund_address);
+				from_matches && to_matches
 			}
+		};
+
+		action || match trace.result {
+			Res::Create(ref create) => self.to_address.matches(&create.address),
+			_ => false
 		}
 	}
 }
 
 #[cfg(test)]
 mod tests {
-	use util::{FixedHash, Address, U256};
+	use util::{FixedHash, Address};
 	use util::sha3::Hashable;
-	use trace::trace::{Action, Call, Res};
+	use trace::trace::{Action, Call, Res, Create, CreateResult, Suicide};
 	use trace::flat::FlatTrace;
 	use trace::{Filter, AddressesFilter};
 	use basic_types::LogBloom;
+	use types::executed::CallType;
 
 	#[test]
 	fn empty_trace_filter_bloom_possibilities() {
@@ -270,14 +281,15 @@ mod tests {
 
 		let trace = FlatTrace {
 			action: Action::Call(Call {
-				from: Address::from(1),
-				to: Address::from(2),
-				value: U256::from(3),
-				gas: U256::from(4),
+				from: 1.into(),
+				to: 2.into(),
+				value: 3.into(),
+				gas: 4.into(),
 				input: vec![0x5],
+				call_type: CallType::Call,
 			}),
 			result: Res::FailedCall,
-			trace_address: vec![0],
+			trace_address: vec![0].into_iter().collect(),
 			subtraces: 0,
 		};
 
@@ -288,5 +300,48 @@ mod tests {
 		assert!(f4.matches(&trace));
 		assert!(f5.matches(&trace));
 		assert!(!f6.matches(&trace));
+
+		let trace = FlatTrace {
+			action: Action::Create(Create {
+				from: 1.into(),
+				value: 3.into(),
+				gas: 4.into(),
+				init: vec![0x5],
+			}),
+			result: Res::Create(CreateResult {
+				gas_used: 10.into(),
+				code: vec![],
+				address: 2.into(),
+			}),
+			trace_address: vec![0].into_iter().collect(),
+			subtraces: 0,
+		};
+
+		assert!(f0.matches(&trace));
+		assert!(f1.matches(&trace));
+		assert!(f2.matches(&trace));
+		assert!(f3.matches(&trace));
+		assert!(f4.matches(&trace));
+		assert!(f5.matches(&trace));
+		assert!(!f6.matches(&trace));
+
+		let trace = FlatTrace {
+			action: Action::Suicide(Suicide {
+				address: 1.into(),
+				refund_address: 2.into(),
+				balance: 3.into(),
+			}),
+			result: Res::None,
+			trace_address: vec![].into_iter().collect(),
+			subtraces: 0
+		};
+
+		assert!(f0.matches(&trace));
+		assert!(f1.matches(&trace));
+		assert!(f2.matches(&trace));
+		assert!(f3.matches(&trace));
+		assert!(f4.matches(&trace));
+		assert!(f5.matches(&trace));
+		assert!(!f6.matches(&trace));
 	}
 }

ethcore/src/types/trace_types/flat.rs

@@ -0,0 +1,210 @@
+// 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/>.
+
+//! Flat trace module
+
+use std::collections::VecDeque;
+use std::mem;
+use ipc::binary::BinaryConvertError;
+use util::rlp::*;
+use basic_types::LogBloom;
+use super::trace::{Action, Res};
+
+/// Trace localized in vector of traces produced by a single transaction.
+///
+/// Parent and children indexes refer to positions in this vector.
+#[derive(Debug, PartialEq, Clone, Binary)]
+pub struct FlatTrace {
+	/// Type of action performed by a transaction.
+	pub action: Action,
+	/// Result of this action.
+	pub result: Res,
+	/// Number of subtraces.
+	pub subtraces: usize,
+	/// Exact location of trace.
+	///
+	/// [index in root, index in first CALL, index in second CALL, ...]
+	pub trace_address: VecDeque<usize>,
+}
+
+impl FlatTrace {
+	/// Returns bloom of the trace.
+	pub fn bloom(&self) -> LogBloom {
+		self.action.bloom() | self.result.bloom()
+	}
+}
+
+impl Encodable for FlatTrace {
+	fn rlp_append(&self, s: &mut RlpStream) {
+		s.begin_list(4);
+		s.append(&self.action);
+		s.append(&self.result);
+		s.append(&self.subtraces);
+		s.append(&self.trace_address.clone().into_iter().collect::<Vec<_>>());
+	}
+}
+
+impl Decodable for FlatTrace {
+	fn decode<D>(decoder: &D) -> Result<Self, DecoderError> where D: Decoder {
+		let d = decoder.as_rlp();
+		let v: Vec<usize> = try!(d.val_at(3));
+		let res = FlatTrace {
+			action: try!(d.val_at(0)),
+			result: try!(d.val_at(1)),
+			subtraces: try!(d.val_at(2)),
+			trace_address: v.into_iter().collect(),
+		};
+
+		Ok(res)
+	}
+}
+
+/// Represents all traces produced by a single transaction.
+#[derive(Debug, PartialEq, Clone)]
+pub struct FlatTransactionTraces(Vec<FlatTrace>);
+
+impl From<Vec<FlatTrace>> for FlatTransactionTraces {
+	fn from(v: Vec<FlatTrace>) -> Self {
+		FlatTransactionTraces(v)
+	}
+}
+
+impl FlatTransactionTraces {
+	/// Returns bloom of the trace.
+	pub fn bloom(&self) -> LogBloom {
+		self.0.iter().fold(Default::default(), | bloom, trace | bloom | trace.bloom())
+	}
+}
+
+impl Encodable for FlatTransactionTraces {
+	fn rlp_append(&self, s: &mut RlpStream) {
+		s.append(&self.0);
+	}
+}
+
+impl Decodable for FlatTransactionTraces {
+	fn decode<D>(decoder: &D) -> Result<Self, DecoderError> where D: Decoder {
+		Ok(FlatTransactionTraces(try!(Decodable::decode(decoder))))
+	}
+}
+
+impl Into<Vec<FlatTrace>> for FlatTransactionTraces {
+	fn into(self) -> Vec<FlatTrace> {
+		self.0
+	}
+}
+
+/// Represents all traces produced by transactions in a single block.
+#[derive(Debug, PartialEq, Clone)]
+pub struct FlatBlockTraces(Vec<FlatTransactionTraces>);
+
+impl From<Vec<FlatTransactionTraces>> for FlatBlockTraces {
+	fn from(v: Vec<FlatTransactionTraces>) -> Self {
+		FlatBlockTraces(v)
+	}
+}
+
+impl FlatBlockTraces {
+	/// Returns bloom of the trace.
+	pub fn bloom(&self) -> LogBloom {
+		self.0.iter().fold(Default::default(), | bloom, tx_traces | bloom | tx_traces.bloom())
+	}
+}
+
+impl Encodable for FlatBlockTraces {
+	fn rlp_append(&self, s: &mut RlpStream) {
+		s.append(&self.0);
+	}
+}
+
+impl Decodable for FlatBlockTraces {
+	fn decode<D>(decoder: &D) -> Result<Self, DecoderError> where D: Decoder {
+		Ok(FlatBlockTraces(try!(Decodable::decode(decoder))))
+	}
+}
+
+impl Into<Vec<FlatTransactionTraces>> for FlatBlockTraces {
+	fn into(self) -> Vec<FlatTransactionTraces> {
+		self.0
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::{FlatBlockTraces, FlatTransactionTraces, FlatTrace};
+	use trace::trace::{Action, Res, CallResult, Call, Suicide};
+	use types::executed::CallType;
+
+	#[test]
+	fn test_trace_serialization() {
+		use util::rlp;
+		// block #51921
+
+		let flat_trace = FlatTrace {
+			action: Action::Call(Call {
+				from: "8dda5e016e674683241bf671cced51e7239ea2bc".parse().unwrap(),
+				to: "37a5e19cc2d49f244805d5c268c0e6f321965ab9".parse().unwrap(),
+				value: "3627e8f712373c0000".parse().unwrap(),
+				gas: 0x03e8.into(),
+				input: vec![],
+				call_type: CallType::Call,
+			}),
+			result: Res::Call(CallResult {
+				gas_used: 0.into(),
+				output: vec![],
+			}),
+			trace_address: Default::default(),
+			subtraces: 0,
+		};
+
+		let flat_trace1 = FlatTrace {
+			action: Action::Call(Call {
+				from: "3d0768da09ce77d25e2d998e6a7b6ed4b9116c2d".parse().unwrap(),
+				to: "412fda7643b37d436cb40628f6dbbb80a07267ed".parse().unwrap(),
+				value: 0.into(),
+				gas: 0x010c78.into(),
+				input: vec![0x41, 0xc0, 0xe1, 0xb5],
+				call_type: CallType::Call,
+			}),
+			result: Res::Call(CallResult {
+				gas_used: 0x0127.into(),
+				output: vec![],
+			}),
+			trace_address: Default::default(),
+			subtraces: 1,
+		};
+
+		let flat_trace2 = FlatTrace {
+			action: Action::Suicide(Suicide {
+				address: "412fda7643b37d436cb40628f6dbbb80a07267ed".parse().unwrap(),
+				balance: 0.into(),
+				refund_address: "3d0768da09ce77d25e2d998e6a7b6ed4b9116c2d".parse().unwrap(),
+			}),
+			result: Res::None,
+			trace_address: vec![0].into_iter().collect(),
+			subtraces: 0,
+		};
+
+		let block_traces = FlatBlockTraces(vec![
+			FlatTransactionTraces(vec![flat_trace]),
+			FlatTransactionTraces(vec![flat_trace1, flat_trace2])
+		]);
+
+		let encoded = rlp::encode(&block_traces);
+		let decoded = rlp::decode(&encoded);
+		assert_eq!(block_traces, decoded);
+	}
+}

ethcore/src/types/trace_types/mod.rs

@@ -17,5 +17,6 @@
 //! Types used in the public api
 
 pub mod filter;
+pub mod flat;
 pub mod trace;
 pub mod localized;

ethcore/src/types/trace_types/trace.rs

@@ -21,6 +21,7 @@ use util::rlp::*;
 use util::sha3::Hashable;
 use action_params::ActionParams;
 use basic_types::LogBloom;
+use types::executed::CallType;
 use ipc::binary::BinaryConvertError;
 use std::mem;
 use std::collections::VecDeque;
@@ -87,6 +88,13 @@ impl Decodable for CreateResult {
 	}
 }
 
+impl CreateResult {
+	/// Returns bloom.
+	pub fn bloom(&self) -> LogBloom {
+		LogBloom::from_bloomed(&self.address.sha3())
+	}
+}
+
 /// Description of a _call_ action, either a `CALL` operation or a message transction.
 #[derive(Debug, Clone, PartialEq, Binary)]
 pub struct Call {
@@ -100,6 +108,8 @@ pub struct Call {
 	pub gas: U256,
 	/// The input data provided to the call.
 	pub input: Bytes,
+	/// The type of the call.
+	pub call_type: CallType,
 }
 
 impl From<ActionParams> for Call {
@@ -110,18 +120,20 @@ impl From<ActionParams> for Call {
 			value: p.value.value(),
 			gas: p.gas,
 			input: p.data.unwrap_or_else(Vec::new),
+			call_type: p.call_type,
 		}
 	}
 }
 
 impl Encodable for Call {
 	fn rlp_append(&self, s: &mut RlpStream) {
-		s.begin_list(5);
+		s.begin_list(6);
 		s.append(&self.from);
 		s.append(&self.to);
 		s.append(&self.value);
 		s.append(&self.gas);
 		s.append(&self.input);
+		s.append(&self.call_type);
 	}
 }
 
@@ -134,6 +146,7 @@ impl Decodable for Call {
 			value: try!(d.val_at(2)),
 			gas: try!(d.val_at(3)),
 			input: try!(d.val_at(4)),
+			call_type: try!(d.val_at(5)),
 		};
 
 		Ok(res)
@@ -205,6 +218,48 @@ impl Create {
 	}
 }
 
+/// Suicide action.
+#[derive(Debug, Clone, PartialEq, Binary)]
+pub struct Suicide {
+	/// Suicided address.
+	pub address: Address,
+	/// Suicided contract heir.
+	pub refund_address: Address,
+	/// Balance of the contract just before suicide.
+	pub balance: U256,
+}
+
+impl Suicide {
+	/// Return suicide action bloom.
+	pub fn bloom(&self) -> LogBloom {
+		LogBloom::from_bloomed(&self.address.sha3())
+			.with_bloomed(&self.refund_address.sha3())
+	}
+}
+
+impl Encodable for Suicide {
+	fn rlp_append(&self, s: &mut RlpStream) {
+		s.begin_list(3);
+		s.append(&self.address);
+		s.append(&self.refund_address);
+		s.append(&self.balance);
+	}
+}
+
+impl Decodable for Suicide {
+	fn decode<D>(decoder: &D) -> Result<Self, DecoderError> where D: Decoder {
+		let d = decoder.as_rlp();
+		let res = Suicide {
+			address: try!(d.val_at(0)),
+			refund_address: try!(d.val_at(1)),
+			balance: try!(d.val_at(2)),
+		};
+
+		Ok(res)
+	}
+}
+
+
 /// Description of an action that we trace; will be either a call or a create.
 #[derive(Debug, Clone, PartialEq, Binary)]
 pub enum Action {
@@ -212,6 +267,8 @@ pub enum Action {
 	Call(Call),
 	/// It's a create action.
 	Create(Create),
+	/// Suicide.
+	Suicide(Suicide),
 }
 
 impl Encodable for Action {
@@ -225,6 +282,10 @@ impl Encodable for Action {
 			Action::Create(ref create) => {
 				s.append(&1u8);
 				s.append(create);
+			},
+			Action::Suicide(ref suicide) => {
+				s.append(&2u8);
+				s.append(suicide);
 			}
 		}
 	}
@@ -237,6 +298,7 @@ impl Decodable for Action {
 		match action_type {
 			0 => d.val_at(1).map(Action::Call),
 			1 => d.val_at(1).map(Action::Create),
+			2 => d.val_at(1).map(Action::Suicide),
 			_ => Err(DecoderError::Custom("Invalid action type.")),
 		}
 	}
@@ -248,6 +310,7 @@ impl Action {
 		match *self {
 			Action::Call(ref call) => call.bloom(),
 			Action::Create(ref create) => create.bloom(),
+			Action::Suicide(ref suicide) => suicide.bloom(),
 		}
 	}
 }
@@ -263,6 +326,8 @@ pub enum Res {
 	FailedCall,
 	/// Failed create.
 	FailedCreate,
+	/// None
+	None,
 }
 
 impl Encodable for Res {
@@ -285,6 +350,10 @@ impl Encodable for Res {
 			Res::FailedCreate => {
 				s.begin_list(1);
 				s.append(&3u8);
+			},
+			Res::None => {
+				s.begin_list(1);
+				s.append(&4u8);
 			}
 		}
 	}
@@ -299,53 +368,19 @@ impl Decodable for Res {
 			1 => d.val_at(1).map(Res::Create),
 			2 => Ok(Res::FailedCall),
 			3 => Ok(Res::FailedCreate),
+			4 => Ok(Res::None),
 			_ => Err(DecoderError::Custom("Invalid result type.")),
 		}
 	}
 }
 
-#[derive(Debug, Clone, PartialEq, Binary)]
-/// A trace; includes a description of the action being traced and sub traces of each interior action.
-pub struct Trace {
-	/// The number of EVM execution environments active when this action happened; 0 if it's
-	/// the outer action of the transaction.
-	pub depth: usize,
-	/// The action being performed.
-	pub action: Action,
-	/// The sub traces for each interior action performed as part of this call.
-	pub subs: Vec<Trace>,
-	/// The result of the performed action.
-	pub result: Res,
-}
-
-impl Encodable for Trace {
-	fn rlp_append(&self, s: &mut RlpStream) {
-		s.begin_list(4);
-		s.append(&self.depth);
-		s.append(&self.action);
-		s.append(&self.subs);
-		s.append(&self.result);
-	}
-}
-
-impl Decodable for Trace {
-	fn decode<D>(decoder: &D) -> Result<Self, DecoderError> where D: Decoder {
-		let d = decoder.as_rlp();
-		let res = Trace {
-			depth: try!(d.val_at(0)),
-			action: try!(d.val_at(1)),
-			subs: try!(d.val_at(2)),
-			result: try!(d.val_at(3)),
-		};
-
-		Ok(res)
-	}
-}
-
-impl Trace {
-	/// Returns trace bloom.
+impl Res {
+	/// Returns result bloom.
 	pub fn bloom(&self) -> LogBloom {
-		self.subs.iter().fold(self.action.bloom(), |b, s| b | s.bloom())
+		match *self {
+			Res::Create(ref create) => create.bloom(),
+			Res::Call(_) | Res::FailedCall | Res::FailedCreate | Res::None => Default::default(),
+		}
 	}
 }
 
@@ -513,84 +548,3 @@ impl Decodable for VMTrace {
 	}
 }
 
-#[cfg(test)]
-mod tests {
-	use util::{Address, U256, FixedHash};
-	use util::rlp::{encode, decode};
-	use util::sha3::Hashable;
-	use trace::trace::{Call, CallResult, Create, Res, Action, Trace};
-
-	#[test]
-	fn traces_rlp() {
-		let trace = Trace {
-			depth: 2,
-			action: Action::Call(Call {
-				from: Address::from(1),
-				to: Address::from(2),
-				value: U256::from(3),
-				gas: U256::from(4),
-				input: vec![0x5]
-			}),
-			subs: vec![
-				Trace {
-					depth: 3,
-					action: Action::Create(Create {
-						from: Address::from(6),
-						value: U256::from(7),
-						gas: U256::from(8),
-						init: vec![0x9]
-					}),
-					subs: vec![],
-					result: Res::FailedCreate
-				}
-			],
-			result: Res::Call(CallResult {
-				gas_used: U256::from(10),
-				output: vec![0x11, 0x12]
-			})
-		};
-
-		let encoded = encode(&trace);
-		let decoded: Trace = decode(&encoded);
-		assert_eq!(trace, decoded);
-	}
-
-	#[test]
-	fn traces_bloom() {
-		let trace = Trace {
-			depth: 2,
-			action: Action::Call(Call {
-				from: Address::from(1),
-				to: Address::from(2),
-				value: U256::from(3),
-				gas: U256::from(4),
-				input: vec![0x5]
-			}),
-			subs: vec![
-				Trace {
-					depth: 3,
-					action: Action::Create(Create {
-						from: Address::from(6),
-						value: U256::from(7),
-						gas: U256::from(8),
-						init: vec![0x9]
-					}),
-					subs: vec![],
-					result: Res::FailedCreate
-				}
-			],
-			result: Res::Call(CallResult {
-				gas_used: U256::from(10),
-				output: vec![0x11, 0x12]
-			})
-		};
-
-		let bloom = trace.bloom();
-
-		// right now only addresses are bloomed
-		assert!(bloom.contains_bloomed(&Address::from(1).sha3()));
-		assert!(bloom.contains_bloomed(&Address::from(2).sha3()));
-		assert!(!bloom.contains_bloomed(&Address::from(20).sha3()));
-		assert!(bloom.contains_bloomed(&Address::from(6).sha3()));
-	}
-}

ethcore/src/types/transaction.rs

@@ -91,7 +91,7 @@ impl Transaction {
 
 impl From<ethjson::state::Transaction> for SignedTransaction {
 	fn from(t: ethjson::state::Transaction) -> Self {
-		let to: Option<_> = t.to.into();
+		let to: Option<ethjson::hash::Address> = t.to.into();
 		Transaction {
 			nonce: t.nonce.into(),
 			gas_price: t.gas_price.into(),
@@ -108,7 +108,7 @@ impl From<ethjson::state::Transaction> for SignedTransaction {
 
 impl From<ethjson::transaction::Transaction> for SignedTransaction {
 	fn from(t: ethjson::transaction::Transaction) -> Self {
-		let to: Option<_> = t.to.into();
+		let to: Option<ethjson::hash::Address> = t.to.into();
 		SignedTransaction {
 			unsigned: Transaction {
 				nonce: t.nonce.into(),

evmjit/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "evmjit"
-version = "1.3.0"
+version = "1.2.0"
 authors = ["debris <marek.kotewicz@gmail.com>"]
 
 [lib]

ipc/codegen/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ethcore-ipc-codegen"
-version = "1.3.0"
+version = "1.2.0"
 authors = ["Nikolay Volf"]
 license = "GPL-3.0"
 description = "Macros to auto-generate implementations for ipc call"

ipc/nano/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ethcore-ipc-nano"
-version = "1.3.0"
+version = "1.2.0"
 authors = ["Nikolay Volf <nikolay@ethcore.io>"]
 license = "GPL-3.0"
 

ipc/rpc/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ethcore-ipc"
-version = "1.3.0"
+version = "1.2.0"
 authors = ["Nikolay Volf <nikvolf@gmail.com>"]
 license = "GPL-3.0"
 

ipc/rpc/src/binary.rs

@@ -139,6 +139,74 @@ impl<R: BinaryConvertable, E: BinaryConvertable> BinaryConvertable for Result<R,
 	}
 }
 
+impl<T> BinaryConvertable for VecDeque<T> where T: BinaryConvertable {
+	fn size(&self) -> usize {
+		match T::len_params() {
+			0 => mem::size_of::<T>() * self.len(),
+			_ => self.iter().fold(0usize, |acc, t| acc + t.size()),
+		}
+	}
+
+	fn to_bytes(&self, buffer: &mut [u8], length_stack: &mut VecDeque<usize>) -> Result<(), BinaryConvertError> {
+		let mut offset = 0usize;
+		for item in self.iter() {
+			let next_size = match T::len_params() {
+				0 => mem::size_of::<T>(),
+				_ => { let size = item.size(); length_stack.push_back(size); size },
+			};
+			if next_size > 0 {
+				let item_end = offset + next_size;
+				try!(item.to_bytes(&mut buffer[offset..item_end], length_stack));
+				offset = item_end;
+			}
+		}
+		Ok(())
+	}
+
+	fn from_bytes(buffer: &[u8], length_stack: &mut VecDeque<usize>) -> Result<Self, BinaryConvertError> {
+		let mut index = 0;
+		let mut result = Self::with_capacity(
+			match T::len_params() {
+				0 => buffer.len() /  mem::size_of::<T>(),
+				_ => 128,
+			});
+
+		if buffer.len() == 0 { return Ok(result); }
+
+		loop {
+			let next_size = match T::len_params() {
+				0 => mem::size_of::<T>(),
+				_ => try!(length_stack.pop_front().ok_or(BinaryConvertError)),
+			};
+			let item = if next_size == 0 {
+				try!(T::from_empty_bytes())
+			}
+			else {
+				try!(T::from_bytes(&buffer[index..index+next_size], length_stack))
+			};
+			result.push_back(item);
+
+			index = index + next_size;
+			if index == buffer.len() { break; }
+			if index + next_size > buffer.len() {
+				return Err(BinaryConvertError)
+			}
+		}
+
+		Ok(result)
+	}
+
+	fn from_empty_bytes() -> Result<Self, BinaryConvertError> {
+		Ok(Self::new())
+	}
+
+	fn len_params() -> usize {
+		1
+	}
+}
+
+//
+
 impl<T> BinaryConvertable for Vec<T> where T: BinaryConvertable {
 	fn size(&self) -> usize {
 		match T::len_params() {

json/src/spec/engine.rs

@@ -54,7 +54,9 @@ mod tests {
 					"blockReward": "0x4563918244F40000",
 					"registrar" : "0xc6d9d2cd449a754c494264e1809c50e34d64562b",
 					"frontierCompatibilityModeLimit" : "0x",
-					"daoRescueSoftFork": true
+					"daoHardforkTransition": "0xffffffffffffffff",
+					"daoHardforkBeneficiary": "0x0000000000000000000000000000000000000000",
+					"daoHardforkAccounts": []
 				}
 			}
 		}"#;

json/src/spec/ethash.rs

@@ -19,32 +19,38 @@
 use uint::Uint;
 use hash::Address;
 
-/// Ethash params deserialization.
+/// Deserializable doppelganger of EthashParams.
 #[derive(Debug, PartialEq, Deserialize)]
 pub struct EthashParams {
-	/// Gas limit divisor.
+	/// See main EthashParams docs.
 	#[serde(rename="gasLimitBoundDivisor")]
 	pub gas_limit_bound_divisor: Uint,
-	/// Minimum difficulty.
+	/// See main EthashParams docs.
 	#[serde(rename="minimumDifficulty")]
 	pub minimum_difficulty: Uint,
-	/// Difficulty bound divisor.
+	/// See main EthashParams docs.
 	#[serde(rename="difficultyBoundDivisor")]
 	pub difficulty_bound_divisor: Uint,
-	/// Block duration.
+	/// See main EthashParams docs.
 	#[serde(rename="durationLimit")]
 	pub duration_limit: Uint,
-	/// Block reward.
+	/// See main EthashParams docs.
 	#[serde(rename="blockReward")]
 	pub block_reward: Uint,
-	/// Namereg contract address.
-	pub registrar: Address,
-	/// Homestead transition block number.
+	/// See main EthashParams docs.
+	pub registrar: Option<Address>,
+	/// See main EthashParams docs.
 	#[serde(rename="frontierCompatibilityModeLimit")]
-	pub frontier_compatibility_mode_limit: Uint,
-	/// DAO rescue soft-fork?
-	#[serde(rename="daoRescueSoftFork")]
-	pub dao_rescue_soft_fork: bool,
+	pub frontier_compatibility_mode_limit: Option<Uint>,
+	/// See main EthashParams docs.
+	#[serde(rename="daoHardforkTransition")]
+	pub dao_hardfork_transition: Option<Uint>,
+	/// See main EthashParams docs.
+	#[serde(rename="daoHardforkBeneficiary")]
+	pub dao_hardfork_beneficiary: Option<Address>,
+	/// See main EthashParams docs.
+	#[serde(rename="daoHardforkAccounts")]
+	pub dao_hardfork_accounts: Option<Vec<Address>>,
 }
 
 /// Ethash engine deserialization.
@@ -70,7 +76,45 @@ mod tests {
 				"blockReward": "0x4563918244F40000",
 				"registrar": "0xc6d9d2cd449a754c494264e1809c50e34d64562b",
 				"frontierCompatibilityModeLimit": "0x42",
-				"daoRescueSoftFork": true
+				"daoHardforkTransition": "0x08",
+				"daoHardforkBeneficiary": "0xabcabcabcabcabcabcabcabcabcabcabcabcabca",
+				"daoHardforkAccounts": [
+					"0x304a554a310c7e546dfe434669c62820b7d83490",
+					"0x914d1b8b43e92723e64fd0a06f5bdb8dd9b10c79",
+					"0xfe24cdd8648121a43a7c86d289be4dd2951ed49f",
+					"0x17802f43a0137c506ba92291391a8a8f207f487d",
+					"0xb136707642a4ea12fb4bae820f03d2562ebff487",
+					"0xdbe9b615a3ae8709af8b93336ce9b477e4ac0940",
+					"0xf14c14075d6c4ed84b86798af0956deef67365b5",
+					"0xca544e5c4687d109611d0f8f928b53a25af72448",
+					"0xaeeb8ff27288bdabc0fa5ebb731b6f409507516c",
+					"0xcbb9d3703e651b0d496cdefb8b92c25aeb2171f7",
+					"0xaccc230e8a6e5be9160b8cdf2864dd2a001c28b6",
+					"0x2b3455ec7fedf16e646268bf88846bd7a2319bb2",
+					"0x4613f3bca5c44ea06337a9e439fbc6d42e501d0a",
+					"0xd343b217de44030afaa275f54d31a9317c7f441e",
+					"0x84ef4b2357079cd7a7c69fd7a37cd0609a679106",
+					"0xda2fef9e4a3230988ff17df2165440f37e8b1708",
+					"0xf4c64518ea10f995918a454158c6b61407ea345c",
+					"0x7602b46df5390e432ef1c307d4f2c9ff6d65cc97",
+					"0xbb9bc244d798123fde783fcc1c72d3bb8c189413",
+					"0x807640a13483f8ac783c557fcdf27be11ea4ac7a"
+				]
+			}
+		}"#;
+
+		let _deserialized: Ethash = serde_json::from_str(s).unwrap();
+	}
+
+	#[test]
+	fn ethash_deserialization_missing_optionals() {
+		let s = r#"{
+			"params": {
+				"gasLimitBoundDivisor": "0x0400",
+				"minimumDifficulty": "0x020000",
+				"difficultyBoundDivisor": "0x0800",
+				"durationLimit": "0x0d",
+				"blockReward": "0x4563918244F40000"
 			}
 		}"#;
 

json/src/spec/params.rs

@@ -17,6 +17,7 @@
 //! Spec params deserialization.
 
 use uint::Uint;
+use hash::H256;
 
 /// Spec params.
 #[derive(Debug, PartialEq, Deserialize)]
@@ -33,6 +34,12 @@ pub struct Params {
 	/// Minimum gas limit.
 	#[serde(rename="minGasLimit")]
 	pub min_gas_limit: Uint,
+	/// Option fork block number to check.
+	#[serde(rename="forkBlock")]
+	pub fork_block: Option<Uint>,
+	/// Expected fork block hash.
+	#[serde(rename="forkCanonHash")]
+	pub fork_hash: Option<H256>,
 }
 
 #[cfg(test)]

json/src/spec/spec.rs

@@ -64,7 +64,9 @@ mod tests {
 				"blockReward": "0x4563918244F40000",
 				"registrar" : "0xc6d9d2cd449a754c494264e1809c50e34d64562b",
 				"frontierCompatibilityModeLimit" : "0x",
-				"daoRescueSoftFork": false
+				"daoHardforkTransition": "0xffffffffffffffff",
+				"daoHardforkBeneficiary": "0x0000000000000000000000000000000000000000",
+				"daoHardforkAccounts": []
 			}
 		}
 	},
@@ -73,7 +75,9 @@ mod tests {
 		"frontierCompatibilityModeLimit": "0x789b0",
 		"maximumExtraDataSize": "0x20",
 		"minGasLimit": "0x1388",
-		"networkID" : "0x2"
+		"networkID" : "0x2",
+		"forkBlock": "0xffffffffffffffff",
+		"forkCanonHash": "0x0000000000000000000000000000000000000000000000000000000000000000"
 	},
 	"genesis": {
 		"seal": {

nsis/installer.nsi

@@ -3,8 +3,8 @@
 !define COMPANYNAME "Ethcore"
 !define DESCRIPTION "Fast, light, robust Ethereum implementation"
 !define VERSIONMAJOR 1
-!define VERSIONMINOR 3
-!define VERSIONBUILD 0
+!define VERSIONMINOR 2
+!define VERSIONBUILD 3
 
 !addplugindir .\
 

parity/cli.rs

@@ -35,19 +35,13 @@ Usage:
 Protocol Options:
   --chain CHAIN            Specify the blockchain type. CHAIN may be either a
                            JSON chain specification file or olympic, frontier,
-                           homestead, mainnet, morden, or testnet
-                           [default: homestead].
+                           homestead, mainnet, morden, homestead-dogmatic, or
+                           testnet [default: homestead].
   -d --db-path PATH        Specify the database & configuration directory path
                            [default: $HOME/.parity].
   --keys-path PATH         Specify the path for JSON key files to be found
                            [default: $HOME/.parity/keys].
   --identity NAME          Specify your node's name.
-  --fork POLICY            Specifies the client's fork policy. POLICY must be
-                           one of:
-                           dogmatic - sticks rigidly to the standard chain.
-                           dao-soft - votes for the DAO-rescue soft-fork.
-                           normal - goes with whatever fork is decided but
-                           votes for none. [default: normal].
 
 Account Options:
   --unlock ACCOUNTS        Unlock ACCOUNTS for the duration of the execution.
@@ -136,7 +130,7 @@ Sealing/Mining Options:
                            none - never reseal on new transactions;
                            own - reseal only on a new local transaction;
                            ext - reseal only on a new external transaction;
-                           all - reseal on all new transactions [default: all].
+                           all - reseal on all new transactions [default: own].
   --reseal-min-period MS   Specify the minimum time between reseals from 
                            incoming transactions. MS is time measured in
                            milliseconds [default: 2000].
@@ -273,7 +267,6 @@ pub struct Args {
 	pub flag_chain: String,
 	pub flag_db_path: String,
 	pub flag_identity: String,
-	pub flag_fork: String,
 	pub flag_unlock: Option<String>,
 	pub flag_password: Vec<String>,
 	pub flag_cache: Option<usize>,

parity/configuration.rs

@@ -47,13 +47,6 @@ pub struct Directories {
 	pub signer: String,
 }
 
-#[derive(Eq, PartialEq, Debug)]
-pub enum Policy {
-	DaoSoft,
-	Normal,
-	Dogmatic,
-}
-
 impl Configuration {
 	pub fn parse() -> Self {
 		Configuration {
@@ -124,35 +117,18 @@ impl Configuration {
 			}))
 	}
 
-	pub fn policy(&self) -> Policy {
-		match self.args.flag_fork.as_str() {
-			"dao-soft" => Policy::DaoSoft,
-			"normal" => Policy::Normal,
-			"dogmatic" => Policy::Dogmatic,
-			x => die!("{}: Invalid value given for --policy option. Use --help for more info.", x)
-		}
-	}
-
 	pub fn gas_floor_target(&self) -> U256 {
-		if self.policy() == Policy::DaoSoft {
-			3_141_592.into()
-		} else {
-			let d = &self.args.flag_gas_floor_target;
-			U256::from_dec_str(d).unwrap_or_else(|_| {
-				die!("{}: Invalid target gas floor given. Must be a decimal unsigned 256-bit number.", d)
-			})
-		}
+		let d = &self.args.flag_gas_floor_target;
+		U256::from_dec_str(d).unwrap_or_else(|_| {
+			die!("{}: Invalid target gas floor given. Must be a decimal unsigned 256-bit number.", d)
+		})
 	}
 
 	pub fn gas_ceil_target(&self) -> U256 {
-		if self.policy() == Policy::DaoSoft {
-			3_141_592.into()
-		} else {
-			let d = &self.args.flag_gas_cap;
-			U256::from_dec_str(d).unwrap_or_else(|_| {
-				die!("{}: Invalid target gas ceiling given. Must be a decimal unsigned 256-bit number.", d)
-			})
-		}
+		let d = &self.args.flag_gas_cap;
+		U256::from_dec_str(d).unwrap_or_else(|_| {
+			die!("{}: Invalid target gas ceiling given. Must be a decimal unsigned 256-bit number.", d)
+		})
 	}
 
 	pub fn gas_price(&self) -> U256 {
@@ -198,7 +174,8 @@ impl Configuration {
 
 	pub fn spec(&self) -> Spec {
 		match self.chain().as_str() {
-			"frontier" | "homestead" | "mainnet" => ethereum::new_frontier(self.policy() != Policy::Dogmatic),
+			"frontier" | "homestead" | "mainnet" => ethereum::new_frontier(),
+			"homestead-dogmatic" => ethereum::new_frontier_dogmatic(),
 			"morden" | "testnet" => ethereum::new_morden(),
 			"olympic" => ethereum::new_olympic(),
 			f => Spec::load(contents(f).unwrap_or_else(|_| {
@@ -358,6 +335,7 @@ impl Configuration {
 		sync_config.network_id = self.args.flag_network_id.as_ref().or(self.args.flag_networkid.as_ref()).map_or(spec.network_id(), |id| {
 			U256::from_str(id).unwrap_or_else(|_| die!("{}: Invalid index given with --network-id/--networkid", id))
 		});
+		sync_config.fork_block = spec.fork_block().clone();
 		sync_config
 	}
 

parity/main.rs

@@ -97,7 +97,7 @@ use rpc::RpcServer;
 use signer::{SignerServer, new_token};
 use dapps::WebappServer;
 use io_handler::ClientIoHandler;
-use configuration::Configuration;
+use configuration::{Configuration};
 
 fn main() {
 	let conf = Configuration::parse();

rpc/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 description = "Ethcore jsonrpc"
 name = "ethcore-rpc"
-version = "1.3.0"
+version = "1.2.0"
 license = "GPL-3.0"
 authors = ["Ethcore <admin@ethcore.io"]
 build = "build.rs"

rpc/rpctest/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 description = "Rpc test client."
 name = "rpctest"
-version = "1.3.0"
+version = "1.2.0"
 license = "GPL-3.0"
 authors = ["Ethcore <admin@ethcore.io>"]
 

rpc/src/v1/impls/mod.rs

@@ -55,7 +55,7 @@ pub use self::rpc::RpcClient;
 
 use v1::types::TransactionRequest;
 use ethcore::error::Error as EthcoreError;
-use ethcore::miner::{AccountDetails, MinerService};
+use ethcore::miner::MinerService;
 use ethcore::client::MiningBlockChainClient;
 use ethcore::transaction::{Action, SignedTransaction, Transaction};
 use ethcore::account_provider::{AccountProvider, Error as AccountError};
@@ -79,12 +79,7 @@ fn dispatch_transaction<C, M>(client: &C, miner: &M, signed_transaction: SignedT
 	where C: MiningBlockChainClient, M: MinerService {
 	let hash = signed_transaction.hash();
 
-	let import = miner.import_own_transaction(client, signed_transaction, |a: &Address| {
-		AccountDetails {
-			nonce: client.latest_nonce(&a),
-			balance: client.latest_balance(&a),
-		}
-	});
+	let import = miner.import_own_transaction(client, signed_transaction);
 
 	import
 		.map_err(transaction_error)
@@ -174,7 +169,6 @@ fn transaction_error(error: EthcoreError) -> Error {
 				format!("Transaction cost exceeds current gas limit. Limit: {}, got: {}. Try decreasing supplied gas.", limit, got)
 			},
 			InvalidGasLimit(_) => "Supplied gas is beyond limit.".into(),
-			DAORescue => "Transaction removes funds from a DAO.".into(),
 		};
 		Error {
 			code: ErrorCode::ServerError(error_codes::TRANSACTION_ERROR),

rpc/src/v1/impls/traces.rs

@@ -18,13 +18,13 @@
 
 use std::sync::{Weak, Arc};
 use jsonrpc_core::*;
-use std::collections::BTreeMap;
 use util::H256;
+use util::rlp::{UntrustedRlp, View};
 use ethcore::client::{BlockChainClient, CallAnalytics, TransactionID, TraceId};
 use ethcore::miner::MinerService;
 use ethcore::transaction::{Transaction as EthTransaction, SignedTransaction, Action};
 use v1::traits::Traces;
-use v1::types::{TraceFilter, LocalizedTrace, Trace, BlockNumber, Index, CallRequest, Bytes, StateDiff, VMTrace};
+use v1::types::{TraceFilter, LocalizedTrace, BlockNumber, Index, CallRequest, Bytes, TraceResults};
 
 /// Traces api implementation.
 pub struct TracesClient<C, M> where C: BlockChainClient, M: MinerService {
@@ -113,22 +113,30 @@ impl<C, M> Traces for TracesClient<C, M> where C: BlockChainClient + 'static, M:
 					state_diffing: flags.contains(&("stateDiff".to_owned())),
 				};
 				let signed = try!(self.sign_call(request));
-				let r = take_weak!(self.client).call(&signed, analytics);
-				if let Ok(executed) = r {
-					// TODO maybe add other stuff to this?
-					let mut ret = map!["output".to_owned() => to_value(&Bytes(executed.output)).unwrap()];
-					if let Some(trace) = executed.trace {
-						ret.insert("trace".to_owned(), to_value(&Trace::from(trace)).unwrap());
-					}
-					if let Some(vm_trace) = executed.vm_trace {
-						ret.insert("vmTrace".to_owned(), to_value(&VMTrace::from(vm_trace)).unwrap());
-					}
-					if let Some(state_diff) = executed.state_diff {
-						ret.insert("stateDiff".to_owned(), to_value(&StateDiff::from(state_diff)).unwrap());
-					}
-					return Ok(Value::Object(ret))
+				match take_weak!(self.client).call(&signed, analytics) {
+					Ok(e) => to_value(&TraceResults::from(e)),
+					_ => Ok(Value::Null),
+				}
+			})
+	}
+
+	fn raw_transaction(&self, params: Params) -> Result<Value, Error> {
+		trace!(target: "jsonrpc", "call: {:?}", params);
+		from_params::<(Bytes, Vec<String>)>(params)
+			.and_then(|(raw_transaction, flags)| {
+				let raw_transaction = raw_transaction.to_vec();
+				let analytics = CallAnalytics {
+					transaction_tracing: flags.contains(&("trace".to_owned())),
+					vm_tracing: flags.contains(&("vmTrace".to_owned())),
+					state_diffing: flags.contains(&("stateDiff".to_owned())),
+				};
+				match UntrustedRlp::new(&raw_transaction).as_val() {
+					Ok(signed) => match take_weak!(self.client).call(&signed, analytics) {
+						Ok(e) => to_value(&TraceResults::from(e)),
+						_ => Ok(Value::Null),
+					},
+					Err(_) => Err(Error::invalid_params()),
 				}
-				Ok(Value::Null)
 			})
 	}
 }

rpc/src/v1/tests/eth.rs

@@ -200,7 +200,9 @@ const TRANSACTION_COUNT_SPEC: &'static [u8] = br#"{
 				"blockReward": "0x4563918244F40000",
 				"registrar" : "0xc6d9d2cd449a754c494264e1809c50e34d64562b",
 				"frontierCompatibilityModeLimit": "0xffffffffffffffff",
-				"daoRescueSoftFork": false
+				"daoHardforkTransition": "0xffffffffffffffff",
+				"daoHardforkBeneficiary": "0x0000000000000000000000000000000000000000",
+				"daoHardforkAccounts": []
 			}
 		}
 	},

rpc/src/v1/tests/helpers/miner_service.rs

@@ -23,7 +23,7 @@ use ethcore::client::{MiningBlockChainClient, Executed, CallAnalytics};
 use ethcore::block::{ClosedBlock, IsBlock};
 use ethcore::transaction::SignedTransaction;
 use ethcore::receipt::Receipt;
-use ethcore::miner::{MinerService, MinerStatus, AccountDetails, TransactionImportResult};
+use ethcore::miner::{MinerService, MinerStatus, TransactionImportResult};
 
 /// Test miner service.
 pub struct TestMinerService {
@@ -130,14 +130,13 @@ impl MinerService for TestMinerService {
 	}
 
 	/// Imports transactions to transaction queue.
-	fn import_transactions<T>(&self, _chain: &MiningBlockChainClient, transactions: Vec<SignedTransaction>, fetch_account: T) ->
-		Vec<Result<TransactionImportResult, Error>>
-		where T: Fn(&Address) -> AccountDetails {
+	fn import_external_transactions(&self, _chain: &MiningBlockChainClient, transactions: Vec<SignedTransaction>) ->
+		Vec<Result<TransactionImportResult, Error>> {
 		// lets assume that all txs are valid
 		self.imported_transactions.lock().unwrap().extend_from_slice(&transactions);
 
 		for sender in transactions.iter().filter_map(|t| t.sender().ok()) {
-			let nonce = self.last_nonce(&sender).unwrap_or(fetch_account(&sender).nonce);
+			let nonce = self.last_nonce(&sender).expect("last_nonce must be populated in tests");
 			self.last_nonces.write().unwrap().insert(sender, nonce + U256::from(1));
 		}
 		transactions
@@ -147,9 +146,8 @@ impl MinerService for TestMinerService {
 	}
 
 	/// Imports transactions to transaction queue.
-	fn import_own_transaction<T>(&self, chain: &MiningBlockChainClient, transaction: SignedTransaction, _fetch_account: T) ->
-		Result<TransactionImportResult, Error>
-		where T: Fn(&Address) -> AccountDetails {
+	fn import_own_transaction(&self, chain: &MiningBlockChainClient, transaction: SignedTransaction) ->
+		Result<TransactionImportResult, Error> {
 
 		// keep the pending nonces up to date
 		if let Ok(ref sender) = transaction.sender() {

rpc/src/v1/tests/mocked/eth.rs

@@ -366,7 +366,7 @@ fn rpc_eth_pending_transaction_by_hash() {
 		tester.miner.pending_transactions.lock().unwrap().insert(H256::zero(), tx);
 	}
 
-	let response = r#"{"jsonrpc":"2.0","result":{"blockHash":null,"blockNumber":null,"creates":null,"from":"0x0f65fe9276bc9a24ae7083ae28e2660ef72df99e","gas":"0x5208","gasPrice":"0x01","hash":"0x41df922fd0d4766fcc02e161f8295ec28522f329ae487f14d811e4b64c8d6e31","input":"0x","nonce":"0x00","to":"0x095e7baea6a6c7c4c2dfeb977efac326af552d87","transactionIndex":null,"value":"0x0a"},"id":1}"#;
+	let response = r#"{"jsonrpc":"2.0","result":{"blockHash":null,"blockNumber":null,"creates":null,"from":"0x0f65fe9276bc9a24ae7083ae28e2660ef72df99e","gas":"0x5208","gasPrice":"0x01","hash":"0x41df922fd0d4766fcc02e161f8295ec28522f329ae487f14d811e4b64c8d6e31","input":"0x","nonce":"0x00","raw":"0xf85f800182520894095e7baea6a6c7c4c2dfeb977efac326af552d870a801ba048b55bfa915ac795c431978d8a6a992b628d557da5ff759b307d495a36649353a0efffd310ac743f371de3b9f7f9cb56c0b28ad43601b4ab949f53faa07bd2c804","to":"0x095e7baea6a6c7c4c2dfeb977efac326af552d87","transactionIndex":null,"value":"0x0a"},"id":1}"#;
 	let request = r#"{
 		"jsonrpc": "2.0",
 		"method": "eth_getTransactionByHash",
@@ -430,7 +430,7 @@ fn rpc_eth_call() {
 		logs: vec![],
 		contracts_created: vec![],
 		output: vec![0x12, 0x34, 0xff],
-		trace: None,
+		trace: vec![],
 		vm_trace: None,
 		state_diff: None,
 	});
@@ -465,7 +465,7 @@ fn rpc_eth_call_default_block() {
 		logs: vec![],
 		contracts_created: vec![],
 		output: vec![0x12, 0x34, 0xff],
-		trace: None,
+		trace: vec![],
 		vm_trace: None,
 		state_diff: None,
 	});
@@ -499,7 +499,7 @@ fn rpc_eth_estimate_gas() {
 		logs: vec![],
 		contracts_created: vec![],
 		output: vec![0x12, 0x34, 0xff],
-		trace: None,
+		trace: vec![],
 		vm_trace: None,
 		state_diff: None,
 	});
@@ -534,7 +534,7 @@ fn rpc_eth_estimate_gas_default_block() {
 		logs: vec![],
 		contracts_created: vec![],
 		output: vec![0x12, 0x34, 0xff],
-		trace: None,
+		trace: vec![],
 		vm_trace: None,
 		state_diff: None,
 	});

rpc/src/v1/traits/traces.rs

@@ -35,6 +35,9 @@ pub trait Traces: Sized + Send + Sync + 'static {
 	/// Executes the given call and returns a number of possible traces for it.
 	fn call(&self, _: Params) -> Result<Value, Error>;
 
+	/// Executes the given raw transaction and returns a number of possible traces for it.
+	fn raw_transaction(&self, _: Params) -> Result<Value, Error>;
+
 	/// Should be used to convert object to io delegate.
 	fn to_delegate(self) -> IoDelegate<Self> {
 		let mut delegate = IoDelegate::new(Arc::new(self));
@@ -43,6 +46,7 @@ pub trait Traces: Sized + Send + Sync + 'static {
 		delegate.add_method("trace_transaction", Traces::transaction_traces);
 		delegate.add_method("trace_block", Traces::block_traces);
 		delegate.add_method("trace_call", Traces::call);
+		delegate.add_method("trace_rawTransaction", Traces::raw_transaction);
 
 		delegate
 	}

rpc/src/v1/types/block.rs

@@ -103,7 +103,7 @@ mod tests {
 	fn test_serialize_block_transactions() {
 		let t = BlockTransactions::Full(vec![Transaction::default()]);
 		let serialized = serde_json::to_string(&t).unwrap();
-		assert_eq!(serialized, r#"[{"hash":"0x0000000000000000000000000000000000000000000000000000000000000000","nonce":"0x00","blockHash":null,"blockNumber":null,"transactionIndex":null,"from":"0x0000000000000000000000000000000000000000","to":null,"value":"0x00","gasPrice":"0x00","gas":"0x00","input":"0x","creates":null}]"#);
+		assert_eq!(serialized, r#"[{"hash":"0x0000000000000000000000000000000000000000000000000000000000000000","nonce":"0x00","blockHash":null,"blockNumber":null,"transactionIndex":null,"from":"0x0000000000000000000000000000000000000000","to":null,"value":"0x00","gasPrice":"0x00","gas":"0x00","input":"0x","creates":null,"raw":"0x"}]"#);
 
 		let t = BlockTransactions::Hashes(vec![H256::default()]);
 		let serialized = serde_json::to_string(&t).unwrap();

rpc/src/v1/types/block_number.rs

@@ -28,7 +28,7 @@ pub enum BlockNumber {
 	/// Earliest block (genesis)
 	Earliest,
 	/// Pending block (being mined)
-	Pending
+	Pending,
 }
 
 impl Deserialize for BlockNumber {
@@ -63,8 +63,8 @@ impl Into<BlockID> for BlockNumber {
 		match self {
 			BlockNumber::Num(n) => BlockID::Number(n),
 			BlockNumber::Earliest => BlockID::Earliest,
-			// TODO: change this once blockid support pendingst,
-			BlockNumber::Pending | BlockNumber::Latest => BlockID::Latest,
+			BlockNumber::Latest => BlockID::Latest,
+			BlockNumber::Pending => BlockID::Pending,
 		}
 	}
 }
@@ -87,7 +87,7 @@ mod tests {
 		assert_eq!(BlockID::Number(100), BlockNumber::Num(100).into());
 		assert_eq!(BlockID::Earliest, BlockNumber::Earliest.into());
 		assert_eq!(BlockID::Latest, BlockNumber::Latest.into());
-		assert_eq!(BlockID::Latest, BlockNumber::Pending.into());
+		assert_eq!(BlockID::Pending, BlockNumber::Pending.into());
 	}
 }
 

rpc/src/v1/types/mod.rs.in

@@ -41,5 +41,5 @@ pub use self::transaction::Transaction;
 pub use self::transaction_request::{TransactionRequest, TransactionConfirmation, TransactionModification};
 pub use self::call_request::CallRequest;
 pub use self::receipt::Receipt;
-pub use self::trace::{Trace, LocalizedTrace, StateDiff, VMTrace};
+pub use self::trace::{LocalizedTrace, TraceResults};
 pub use self::trace_filter::TraceFilter;

rpc/src/v1/types/trace.rs

@@ -18,11 +18,13 @@ use std::collections::BTreeMap;
 use util::{Address, U256, H256, Uint};
 use serde::{Serialize, Serializer};
 use ethcore::trace::trace;
-use ethcore::trace::{Trace as EthTrace, LocalizedTrace as EthLocalizedTrace};
+use ethcore::trace::{FlatTrace, LocalizedTrace as EthLocalizedTrace};
 use ethcore::trace as et;
 use ethcore::state_diff;
 use ethcore::account_diff;
-use v1::types::Bytes;
+use v1::types::{Bytes};
+use ethcore::client::Executed;
+use ethcore::executed;
 
 #[derive(Debug, Serialize)]
 /// A diff of some chunk of memory.
@@ -193,6 +195,7 @@ impl From<account_diff::AccountDiff> for AccountDiff {
 	}
 }
 
+#[derive(Debug)]
 /// Serde-friendly `StateDiff` shadow.
 pub struct StateDiff(BTreeMap<Address, AccountDiff>);
 
@@ -233,6 +236,34 @@ impl From<trace::Create> for Create {
 	}
 }
 
+/// Call type.
+#[derive(Debug, Serialize)]
+pub enum CallType {
+	/// None
+	#[serde(rename="none")]
+	None,
+	/// Call
+	#[serde(rename="call")]
+	Call,
+	/// Call code
+	#[serde(rename="callcode")]
+	CallCode,
+	/// Delegate call
+	#[serde(rename="delegatecall")]
+	DelegateCall,
+}
+
+impl From<executed::CallType> for CallType {
+	fn from(c: executed::CallType) -> Self {
+		match c {
+			executed::CallType::None => CallType::None,
+			executed::CallType::Call => CallType::Call,
+			executed::CallType::CallCode => CallType::CallCode,
+			executed::CallType::DelegateCall => CallType::DelegateCall,
+		}
+	}
+}
+
 /// Call response
 #[derive(Debug, Serialize)]
 pub struct Call {
@@ -246,6 +277,9 @@ pub struct Call {
 	gas: U256,
 	/// Input data
 	input: Bytes,
+	/// The type of the call.
+	#[serde(rename="callType")]
+	call_type: CallType,
 }
 
 impl From<trace::Call> for Call {
@@ -256,6 +290,29 @@ impl From<trace::Call> for Call {
 			value: c.value,
 			gas: c.gas,
 			input: Bytes::new(c.input),
+			call_type: c.call_type.into(),
+		}
+	}
+}
+
+/// Suicide
+#[derive(Debug, Serialize)]
+pub struct Suicide {
+	/// Address.
+	pub address: Address,
+	/// Refund address.
+	#[serde(rename="refundAddress")]
+	pub refund_address: Address,
+	/// Balance.
+	pub balance: U256,
+}
+
+impl From<trace::Suicide> for Suicide {
+	fn from(s: trace::Suicide) -> Self {
+		Suicide {
+			address: s.address.into(),
+			refund_address: s.refund_address.into(),
+			balance: s.balance.into(),
 		}
 	}
 }
@@ -269,13 +326,17 @@ pub enum Action {
 	/// Create
 	#[serde(rename="create")]
 	Create(Create),
+	/// Suicide
+	#[serde(rename="suicide")]
+	Suicide(Suicide),
 }
 
 impl From<trace::Action> for Action {
 	fn from(c: trace::Action) -> Self {
 		match c {
-			trace::Action::Call(call) => Action::Call(Call::from(call)),
-			trace::Action::Create(create) => Action::Create(Create::from(create)),
+			trace::Action::Call(call) => Action::Call(call.into()),
+			trace::Action::Create(create) => Action::Create(create.into()),
+			trace::Action::Suicide(suicide) => Action::Suicide(suicide.into()),
 		}
 	}
 }
@@ -336,6 +397,9 @@ pub enum Res {
 	/// Creation failure
 	#[serde(rename="failedCreate")]
 	FailedCreate,
+	/// None
+	#[serde(rename="none")]
+	None,
 }
 
 impl From<trace::Res> for Res {
@@ -345,6 +409,7 @@ impl From<trace::Res> for Res {
 			trace::Res::Create(create) => Res::Create(CreateResult::from(create)),
 			trace::Res::FailedCall => Res::FailedCall,
 			trace::Res::FailedCreate => Res::FailedCreate,
+			trace::Res::None => Res::None,
 		}
 	}
 }
@@ -393,23 +458,50 @@ impl From<EthLocalizedTrace> for LocalizedTrace {
 /// Trace
 #[derive(Debug, Serialize)]
 pub struct Trace {
-	/// Depth within the call trace tree.
-	depth: usize,
+	/// Trace address
+	#[serde(rename="traceAddress")]
+	trace_address: Vec<U256>,
+	/// Subtraces
+	subtraces: U256,
 	/// Action
 	action: Action,
 	/// Result
 	result: Res,
-	/// Subtraces
-	subtraces: Vec<Trace>,
 }
 
-impl From<EthTrace> for Trace {
-	fn from(t: EthTrace) -> Self {
+impl From<FlatTrace> for Trace {
+	fn from(t: FlatTrace) -> Self {
 		Trace {
-			depth: t.depth.into(),
+			trace_address: t.trace_address.into_iter().map(Into::into).collect(),
+			subtraces: t.subtraces.into(),
 			action: t.action.into(),
 			result: t.result.into(),
-			subtraces: t.subs.into_iter().map(From::from).collect(),
+		}
+	}
+}
+
+#[derive(Debug, Serialize)]
+/// A diff of some chunk of memory.
+pub struct TraceResults {
+	/// The output of the call/create
+	pub output: Vec<u8>,
+	/// The transaction trace.
+	pub trace: Vec<Trace>,
+	/// The transaction trace.
+	#[serde(rename="vmTrace")]
+	pub vm_trace: Option<VMTrace>,
+	/// The transaction trace.
+	#[serde(rename="stateDiff")]
+	pub state_diff: Option<StateDiff>,
+}
+
+impl From<Executed> for TraceResults {
+	fn from(t: Executed) -> Self {
+		TraceResults {
+			output: t.output.into(),
+			trace: t.trace.into_iter().map(Into::into).collect(),
+			vm_trace: t.vm_trace.map(Into::into),
+			state_diff: t.state_diff.map(Into::into),
 		}
 	}
 }
@@ -422,6 +514,18 @@ mod tests {
 	use v1::types::Bytes;
 	use super::*;
 
+	#[test]
+	fn should_serialize_trace_results() {
+		let r = TraceResults {
+			output: vec![0x60],
+			trace: vec![],
+			vm_trace: None,
+			state_diff: None,
+		};
+		let serialized = serde_json::to_string(&r).unwrap();
+		assert_eq!(serialized, r#"{"output":[96],"trace":[],"vmTrace":null,"stateDiff":null}"#);
+	}
+
 	#[test]
 	fn test_trace_serialize() {
 		let t = LocalizedTrace {
@@ -431,6 +535,7 @@ mod tests {
 				value: U256::from(6),
 				gas: U256::from(7),
 				input: Bytes::new(vec![0x12, 0x34]),
+				call_type: CallType::Call,
 			}),
 			result: Res::Call(CallResult {
 				gas_used: U256::from(8),
@@ -444,7 +549,7 @@ mod tests {
 			block_hash: H256::from(14),
 		};
 		let serialized = serde_json::to_string(&t).unwrap();
-		assert_eq!(serialized, r#"{"action":{"call":{"from":"0x0000000000000000000000000000000000000004","to":"0x0000000000000000000000000000000000000005","value":"0x06","gas":"0x07","input":"0x1234"}},"result":{"call":{"gasUsed":"0x08","output":"0x5678"}},"traceAddress":["0x0a"],"subtraces":"0x01","transactionPosition":"0x0b","transactionHash":"0x000000000000000000000000000000000000000000000000000000000000000c","blockNumber":"0x0d","blockHash":"0x000000000000000000000000000000000000000000000000000000000000000e"}"#);
+		assert_eq!(serialized, r#"{"action":{"call":{"from":"0x0000000000000000000000000000000000000004","to":"0x0000000000000000000000000000000000000005","value":"0x06","gas":"0x07","input":"0x1234","callType":{"call":[]}}},"result":{"call":{"gasUsed":"0x08","output":"0x5678"}},"traceAddress":["0x0a"],"subtraces":"0x01","transactionPosition":"0x0b","transactionHash":"0x000000000000000000000000000000000000000000000000000000000000000c","blockNumber":"0x0d","blockHash":"0x000000000000000000000000000000000000000000000000000000000000000e"}"#);
 	}
 
 	#[test]
@@ -520,6 +625,7 @@ mod tests {
 			value: U256::from(3),
 			gas: U256::from(4),
 			input: Bytes::new(vec![0x12, 0x34]),
+			call_type: CallType::Call,
 		}), Action::Create(Create {
 			from: Address::from(5),
 			value: U256::from(6),
@@ -528,7 +634,7 @@ mod tests {
 		})];
 
 		let serialized = serde_json::to_string(&actions).unwrap();
-		assert_eq!(serialized, r#"[{"call":{"from":"0x0000000000000000000000000000000000000001","to":"0x0000000000000000000000000000000000000002","value":"0x03","gas":"0x04","input":"0x1234"}},{"create":{"from":"0x0000000000000000000000000000000000000005","value":"0x06","gas":"0x07","init":"0x5678"}}]"#);
+		assert_eq!(serialized, r#"[{"call":{"from":"0x0000000000000000000000000000000000000001","to":"0x0000000000000000000000000000000000000002","value":"0x03","gas":"0x04","input":"0x1234","callType":{"call":[]}}},{"create":{"from":"0x0000000000000000000000000000000000000005","value":"0x06","gas":"0x07","init":"0x5678"}}]"#);
 	}
 
 	#[test]

rpc/src/v1/types/transaction.rs

@@ -15,6 +15,7 @@
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
 use util::numbers::*;
+use util::rlp::encode;
 use ethcore::contract_address;
 use ethcore::transaction::{LocalizedTransaction, Action, SignedTransaction};
 use v1::types::{Bytes, OptionalValue};
@@ -50,6 +51,8 @@ pub struct Transaction {
 	pub input: Bytes,
 	/// Creates contract
 	pub creates: OptionalValue<Address>,
+	/// Raw transaction data
+	pub raw: Bytes,
 }
 
 impl From<LocalizedTransaction> for Transaction {
@@ -73,6 +76,7 @@ impl From<LocalizedTransaction> for Transaction {
 				Action::Create => OptionalValue::Value(contract_address(&t.sender().unwrap(), &t.nonce)),
 				Action::Call(_) => OptionalValue::Null,
 			},
+			raw: encode(&t.signed).to_vec().into(),
 		}
 	}
 }
@@ -98,6 +102,7 @@ impl From<SignedTransaction> for Transaction {
 				Action::Create => OptionalValue::Value(contract_address(&t.sender().unwrap(), &t.nonce)),
 				Action::Call(_) => OptionalValue::Null,
 			},
+			raw: encode(&t).to_vec().into(),
 		}
 	}
 }
@@ -111,7 +116,7 @@ mod tests {
 	fn test_transaction_serialize() {
 		let t = Transaction::default();
 		let serialized = serde_json::to_string(&t).unwrap();
-		assert_eq!(serialized, r#"{"hash":"0x0000000000000000000000000000000000000000000000000000000000000000","nonce":"0x00","blockHash":null,"blockNumber":null,"transactionIndex":null,"from":"0x0000000000000000000000000000000000000000","to":null,"value":"0x00","gasPrice":"0x00","gas":"0x00","input":"0x","creates":null}"#);
+		assert_eq!(serialized, r#"{"hash":"0x0000000000000000000000000000000000000000000000000000000000000000","nonce":"0x00","blockHash":null,"blockNumber":null,"transactionIndex":null,"from":"0x0000000000000000000000000000000000000000","to":null,"value":"0x00","gasPrice":"0x00","gas":"0x00","input":"0x","creates":null,"raw":"0x"}"#);
 	}
 }
 

signer/Cargo.toml

@@ -3,7 +3,7 @@ description = "Ethcore Trusted Signer"
 homepage = "http://ethcore.io"
 license = "GPL-3.0"
 name = "ethcore-signer"
-version = "1.3.0"
+version = "1.2.0"
 authors = ["Ethcore <admin@ethcore.io>"]
 build = "build.rs"
 
@@ -18,9 +18,11 @@ env_logger = "0.3"
 ws = { git = "https://github.com/ethcore/ws-rs.git", branch = "stable" }
 ethcore-util = { path = "../util" }
 ethcore-rpc = { path = "../rpc" }
-parity-minimal-sysui = { git = "https://github.com/ethcore/parity-dapps-minimal-sysui-rs.git", version = "0.2.0" }
+parity-dapps-signer = { git = "https://github.com/ethcore/parity-ui.git", version = "0.6", optional = true}
 
 clippy = { version = "0.0.77", optional = true}
 
 [features]
 dev = ["clippy"]
+ui = ["parity-dapps-signer"]
+use-precompiled-js = ["parity-dapps-signer/use-precompiled-js"]

signer/src/lib.rs

@@ -51,7 +51,8 @@ extern crate ethcore_util as util;
 extern crate ethcore_rpc as rpc;
 extern crate jsonrpc_core;
 extern crate ws;
-extern crate parity_minimal_sysui as sysui;
+#[cfg(feature = "ui")]
+extern crate parity_dapps_signer as signer;
 
 mod authcode_store;
 mod ws_server;

signer/src/ws_server/session.rs

@@ -17,7 +17,6 @@
 //! Session handlers factory.
 
 use ws;
-use sysui;
 use authcode_store::AuthCodes;
 use std::path::{PathBuf, Path};
 use std::sync::Arc;
@@ -25,6 +24,26 @@ use std::str::FromStr;
 use jsonrpc_core::IoHandler;
 use util::H256;
 
+#[cfg(feature = "ui")]
+mod signer {
+	use signer;
+
+	pub fn handle(req: &str) -> Option<signer::File> {
+		signer::handle(req)
+	}
+}
+#[cfg(not(feature = "ui"))]
+mod signer {
+	pub struct File {
+		pub content: String,
+		pub mime: String,
+	}
+
+	pub fn handle(_req: &str) -> Option<File> {
+		None
+	}
+}
+
 fn origin_is_allowed(self_origin: &str, header: Option<&Vec<u8>>) -> bool {
 	match header {
 		None => false,
@@ -111,7 +130,7 @@ impl ws::Handler for Session {
 		}
 
 		// Otherwise try to serve a page.
-		Ok(sysui::handle(req.resource())
+		Ok(signer::handle(req.resource())
 			.map_or_else(
 				// return 404 not found
 				|| add_headers(ws::Response::not_found("Not found".into()), "text/plain"),

sync/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 description = "Ethcore blockchain sync"
 name = "ethsync"
-version = "1.3.0"
+version = "1.2.0"
 license = "GPL-3.0"
 authors = ["Ethcore <admin@ethcore.io"]
 

sync/src/blocks.rs

@@ -120,13 +120,22 @@ impl BlockCollection {
 			if let Some(head) = head {
 				match self.blocks.get(&head) {
 					Some(block) if block.body.is_none() && !self.downloading_bodies.contains(&head) => {
+						self.downloading_bodies.insert(head.clone());
 						needed_bodies.push(head.clone());
 					}
 					_ => (),
 				}
 			}
 		}
-		self.downloading_bodies.extend(needed_bodies.iter());
+		for h in self.header_ids.values() {
+			if needed_bodies.len() >= count {
+				break;
+			}
+			if !self.downloading_bodies.contains(h) {
+				needed_bodies.push(h.clone());
+				self.downloading_bodies.insert(h.clone());
+			}
+		}
 		needed_bodies
 	}
 
@@ -286,6 +295,7 @@ impl BlockCollection {
 
 		self.parents.insert(info.parent_hash.clone(), hash.clone());
 		self.blocks.insert(hash.clone(), block);
+		trace!(target: "sync", "New header: {}", hash.hex());
 		Ok(hash)
 	}
 

sync/src/chain.rs

@@ -113,14 +113,15 @@ const MAX_NODE_DATA_TO_SEND: usize = 1024;
 const MAX_RECEIPTS_TO_SEND: usize = 1024;
 const MAX_RECEIPTS_HEADERS_TO_SEND: usize = 256;
 const MAX_HEADERS_TO_REQUEST: usize = 128;
-const MAX_BODIES_TO_REQUEST: usize = 64;
+const MAX_BODIES_TO_REQUEST: usize = 128;
 const MIN_PEERS_PROPAGATION: usize = 4;
 const MAX_PEERS_PROPAGATION: usize = 128;
 const MAX_PEER_LAG_PROPAGATION: BlockNumber = 20;
-const SUBCHAIN_SIZE: usize = 64;
+const SUBCHAIN_SIZE: usize = 256;
 const MAX_ROUND_PARENTS: usize = 32;
 const MAX_NEW_HASHES: usize = 64;
 const MAX_TX_TO_IMPORT: usize = 512;
+const MAX_NEW_BLOCK_AGE: BlockNumber = 20;
 
 const STATUS_PACKET: u8 = 0x00;
 const NEW_BLOCK_HASHES_PACKET: u8 = 0x01;
@@ -136,7 +137,9 @@ const NODE_DATA_PACKET: u8 = 0x0e;
 const GET_RECEIPTS_PACKET: u8 = 0x0f;
 const RECEIPTS_PACKET: u8 = 0x10;
 
-const CONNECTION_TIMEOUT_SEC: f64 = 15f64;
+const HEADERS_TIMEOUT_SEC: f64 = 15f64;
+const BODIES_TIMEOUT_SEC: f64 = 5f64;
+const FORK_HEADER_TIMEOUT_SEC: f64 = 3f64;
 
 #[derive(Copy, Clone, Eq, PartialEq, Debug)]
 /// Sync state
@@ -184,6 +187,7 @@ pub struct SyncStatus {
 /// Peer data type requested
 enum PeerAsking {
 	Nothing,
+	ForkHeader,
 	BlockHeaders,
 	BlockBodies,
 	Heads,
@@ -212,6 +216,16 @@ struct PeerInfo {
 	asking_hash: Option<H256>,
 	/// Request timestamp
 	ask_time: f64,
+	/// Pending request is expird and result should be ignored
+	expired: bool,
+	/// Peer fork confirmed
+	confirmed: bool,
+}
+
+impl PeerInfo {
+	fn is_available(&self) -> bool {
+		self.confirmed && !self.expired
+	}
 }
 
 /// Blockchain sync handler.
@@ -245,6 +259,8 @@ pub struct ChainSync {
 	round_parents: VecDeque<(H256, H256)>,
 	/// Network ID
 	network_id: U256,
+	/// Optional fork block to check
+	fork_block: Option<(BlockNumber, H256)>,
 }
 
 type RlpResponseResult = Result<Option<(PacketId, RlpStream)>, PacketDecodeError>;
@@ -268,6 +284,7 @@ impl ChainSync {
 			round_parents: VecDeque::new(),
 			_max_download_ahead_blocks: max(MAX_HEADERS_TO_REQUEST, config.max_download_ahead_blocks),
 			network_id: config.network_id,
+			fork_block: config.fork_block,
 		};
 		sync.reset();
 		sync
@@ -284,8 +301,8 @@ impl ChainSync {
 			highest_block_number: self.highest_block.map(|n| max(n, self.last_imported_block)),
 			blocks_received: if self.last_imported_block > self.starting_block { self.last_imported_block - self.starting_block } else { 0 },
 			blocks_total: match self.highest_block { Some(x) if x > self.starting_block => x - self.starting_block, _ => 0 },
-			num_peers: self.peers.len(),
-			num_active_peers: self.peers.values().filter(|p| p.asking != PeerAsking::Nothing).count(),
+			num_peers: self.peers.values().filter(|p| p.confirmed).count(),
+			num_active_peers: self.peers.values().filter(|p| p.confirmed && p.asking != PeerAsking::Nothing).count(),
 			mem_used:
 				self.blocks.heap_size()
 				+ self.peers.heap_size_of_children()
@@ -306,6 +323,10 @@ impl ChainSync {
 		for (_, ref mut p) in &mut self.peers {
 			p.asking_blocks.clear();
 			p.asking_hash = None;
+			// mark any pending requests as expired
+			if p.asking != PeerAsking::Nothing && p.confirmed {
+				p.expired = true;
+			}
 		}
 		self.syncing_difficulty = From::from(0u64);
 		self.state = SyncState::Idle;
@@ -356,6 +377,8 @@ impl ChainSync {
 			asking_blocks: Vec::new(),
 			asking_hash: None,
 			ask_time: 0f64,
+			expired: false,
+			confirmed: self.fork_block.is_none(),
 		};
 
 		trace!(target: "sync", "New peer {} (protocol: {}, network: {:?}, difficulty: {:?}, latest:{}, genesis:{})", peer_id, peer.protocol_version, peer.network_id, peer.difficulty, peer.latest_hash, peer.genesis);
@@ -383,18 +406,43 @@ impl ChainSync {
 		self.peers.insert(peer_id.clone(), peer);
 		self.active_peers.insert(peer_id.clone());
 		debug!(target: "sync", "Connected {}:{}", peer_id, io.peer_info(peer_id));
-		self.sync_peer(io, peer_id, false);
+		if let Some((fork_block, _)) = self.fork_block {
+			self.request_headers_by_number(io, peer_id, fork_block, 1, 0, false, PeerAsking::ForkHeader);
+		} else {
+			self.sync_peer(io, peer_id, false);
+		}
 		Ok(())
 	}
 
 	#[cfg_attr(feature="dev", allow(cyclomatic_complexity))]
 	/// Called by peer once it has new block headers during sync
 	fn on_peer_block_headers(&mut self, io: &mut SyncIo, peer_id: PeerId, r: &UntrustedRlp) -> Result<(), PacketDecodeError> {
+		let confirmed = match self.peers.get_mut(&peer_id) {
+			Some(ref mut peer) if peer.asking == PeerAsking::ForkHeader => {
+				let item_count = r.item_count();
+				if item_count == 0 || (item_count == 1 && try!(r.at(0)).as_raw().sha3() == self.fork_block.unwrap().1) {
+					trace!(target: "sync", "{}: Confirmed peer", peer_id);
+					peer.asking = PeerAsking::Nothing;
+					peer.confirmed = true;
+					true
+				} else {
+					trace!(target: "sync", "{}: Fork mismatch", peer_id);
+					io.disconnect_peer(peer_id);
+					false
+				}
+			},
+			_ => false,
+		};
+		if confirmed {
+			self.sync_peer(io, peer_id, false);
+			return Ok(());
+		}
+
 		self.clear_peer_download(peer_id);
-		let expected_hash = self.peers.get(&peer_id).and_then(|p| p.asking_hash);
 		let expected_asking = if self.state == SyncState::ChainHead { PeerAsking::Heads } else { PeerAsking::BlockHeaders };
+		let expected_hash = self.peers.get(&peer_id).and_then(|p| p.asking_hash);
 		if !self.reset_peer_asking(peer_id, expected_asking) || expected_hash.is_none() {
-			trace!(target: "sync", "Ignored unexpected headers");
+			trace!(target: "sync", "{}: Ignored unexpected headers", peer_id);
 			self.continue_sync(io);
 			return Ok(());
 		}
@@ -460,14 +508,14 @@ impl ChainSync {
 
 		// Disable the peer for this syncing round if it gives invalid chain
 		if !valid_response {
-			trace!(target: "sync", "{} Deactivated for invalid headers response", peer_id);
-			self.deactivate_peer(io, peer_id);
+			trace!(target: "sync", "{} Disabled for invalid headers response", peer_id);
+			io.disable_peer(peer_id);
 		}
 
 		if headers.is_empty() {
 			// Peer does not have any new subchain heads, deactivate it nd try with another
-			trace!(target: "sync", "{} Deactivated for no data", peer_id);
-			self.deactivate_peer(io, peer_id);
+			trace!(target: "sync", "{} Disabled for no data", peer_id);
+			io.disable_peer(peer_id);
 		}
 		match self.state {
 			SyncState::ChainHead => {
@@ -491,6 +539,9 @@ impl ChainSync {
 		}
 
 		self.collect_blocks(io);
+		// give a task to the same peer first if received valuable headers.
+		self.sync_peer(io, peer_id, false);
+		// give tasks to other peers
 		self.continue_sync(io);
 		Ok(())
 	}
@@ -543,6 +594,11 @@ impl ChainSync {
 			peer.latest_hash = header.hash();
 			peer.latest_number = Some(header.number());
 		}
+		if self.last_imported_block > header.number() && self.last_imported_block - header.number() > MAX_NEW_BLOCK_AGE {
+			trace!(target: "sync", "Ignored ancient new block {:?}", h);
+			io.disable_peer(peer_id);
+			return Ok(());
+		}
 		match io.chain().import_block(block_rlp.as_raw().to_vec()) {
 			Err(Error::Import(ImportError::AlreadyInChain)) => {
 				trace!(target: "sync", "New block already in chain {:?}", h);
@@ -600,34 +656,39 @@ impl ChainSync {
 		let hashes = r.iter().take(MAX_NEW_HASHES).map(|item| (item.val_at::<H256>(0), item.val_at::<BlockNumber>(1)));
 		let mut max_height: BlockNumber = 0;
 		let mut new_hashes = Vec::new();
-		for (rh, rd) in hashes {
-			let h = try!(rh);
-			let d = try!(rd);
-			if d > self.highest_block.unwrap_or(0) {
-				self.highest_block = Some(d);
+		for (rh, rn) in hashes {
+			let hash = try!(rh);
+			let number = try!(rn);
+			if number > self.highest_block.unwrap_or(0) {
+				self.highest_block = Some(number);
 			}
-			if self.blocks.is_downloading(&h) {
+			if self.blocks.is_downloading(&hash) {
 				continue;
 			}
-			match io.chain().block_status(BlockID::Hash(h.clone())) {
+			if self.last_imported_block > number && self.last_imported_block - number > MAX_NEW_BLOCK_AGE {
+				trace!(target: "sync", "Ignored ancient new block hash {:?}", hash);
+				io.disable_peer(peer_id);
+				continue;
+			}
+			match io.chain().block_status(BlockID::Hash(hash.clone())) {
 				BlockStatus::InChain  => {
-					trace!(target: "sync", "New block hash already in chain {:?}", h);
+					trace!(target: "sync", "New block hash already in chain {:?}", hash);
 				},
 				BlockStatus::Queued => {
-					trace!(target: "sync", "New hash block already queued {:?}", h);
+					trace!(target: "sync", "New hash block already queued {:?}", hash);
 				},
 				BlockStatus::Unknown => {
-					new_hashes.push(h.clone());
-					if d > max_height {
-						trace!(target: "sync", "New unknown block hash {:?}", h);
+					new_hashes.push(hash.clone());
+					if number > max_height {
+						trace!(target: "sync", "New unknown block hash {:?}", hash);
 						let peer = self.peers.get_mut(&peer_id).unwrap();
-						peer.latest_hash = h.clone();
-						peer.latest_number = Some(d);
-						max_height = d;
+						peer.latest_hash = hash.clone();
+						peer.latest_number = Some(number);
+						max_height = number;
 					}
 				},
 				BlockStatus::Bad => {
-					debug!(target: "sync", "Bad new block hash {:?}", h);
+					debug!(target: "sync", "Bad new block hash {:?}", hash);
 					io.disable_peer(peer_id);
 					return Ok(());
 				}
@@ -665,7 +726,8 @@ impl ChainSync {
 
 	/// Resume downloading
 	fn continue_sync(&mut self, io: &mut SyncIo) {
-		let mut peers: Vec<(PeerId, U256)> = self.peers.iter().map(|(k, p)| (*k, p.difficulty.unwrap_or_else(U256::zero))).collect();
+		let mut peers: Vec<(PeerId, U256)> = self.peers.iter().filter_map(|(k, p)|
+			if p.is_available() { Some((*k, p.difficulty.unwrap_or_else(U256::zero))) } else { None }).collect();
 		thread_rng().shuffle(&mut peers); //TODO: sort by rating
 		trace!(target: "sync", "Syncing with {}/{} peers", self.active_peers.len(), peers.len());
 		for (p, _) in peers {
@@ -673,7 +735,7 @@ impl ChainSync {
 				self.sync_peer(io, p, false);
 			}
 		}
-		if self.state != SyncState::Waiting && !self.peers.values().any(|p| p.asking != PeerAsking::Nothing) {
+		if self.state != SyncState::Waiting && !self.peers.values().any(|p| p.asking != PeerAsking::Nothing && p.is_available()) {
 			self.complete_sync();
 		}
 	}
@@ -699,7 +761,7 @@ impl ChainSync {
 		}
 		let (peer_latest, peer_difficulty) = {
 			let peer = self.peers.get_mut(&peer_id).unwrap();
-			if peer.asking != PeerAsking::Nothing {
+			if peer.asking != PeerAsking::Nothing || !peer.is_available() {
 				return;
 			}
 			if self.state == SyncState::Waiting {
@@ -727,7 +789,9 @@ impl ChainSync {
 					// Request subchain headers
 					trace!(target: "sync", "Starting sync with better chain");
 					let last = self.last_imported_hash.clone();
-					self.request_headers_by_hash(io, peer_id, &last, SUBCHAIN_SIZE, MAX_HEADERS_TO_REQUEST - 1, false, PeerAsking::Heads);
+					// Request MAX_HEADERS_TO_REQUEST - 2 headers apart so that
+					// MAX_HEADERS_TO_REQUEST would include headers for neighbouring subchains
+					self.request_headers_by_hash(io, peer_id, &last, SUBCHAIN_SIZE, MAX_HEADERS_TO_REQUEST - 2, false, PeerAsking::Heads);
 				},
 				SyncState::Blocks | SyncState::NewBlocks => {
 					if io.chain().block_status(BlockID::Hash(peer_latest)) == BlockStatus::Unknown {
@@ -895,6 +959,17 @@ impl ChainSync {
 			.asking_hash = Some(h.clone());
 	}
 
+	/// Request headers from a peer by block number
+	#[cfg_attr(feature="dev", allow(too_many_arguments))]
+	fn request_headers_by_number(&mut self, sync: &mut SyncIo, peer_id: PeerId, n: BlockNumber, count: usize, skip: usize, reverse: bool, asking: PeerAsking) {
+		trace!(target: "sync", "{} <- GetBlockHeaders: {} entries starting from {}", peer_id, count, n);
+		let mut rlp = RlpStream::new_list(4);
+		rlp.append(&n);
+		rlp.append(&count);
+		rlp.append(&skip);
+		rlp.append(&if reverse {1u32} else {0u32});
+		self.send_request(sync, peer_id, asking, GET_BLOCK_HEADERS_PACKET, rlp.out());
+	}
 	/// Request block bodies from a peer
 	fn request_bodies(&mut self, sync: &mut SyncIo, peer_id: PeerId, hashes: Vec<H256>) {
 		let mut rlp = RlpStream::new_list(hashes.len());
@@ -908,6 +983,7 @@ impl ChainSync {
 	/// Reset peer status after request is complete.
 	fn reset_peer_asking(&mut self, peer_id: PeerId, asking: PeerAsking) -> bool {
 		let peer = self.peers.get_mut(&peer_id).unwrap();
+		peer.expired = false;
 		if peer.asking != asking {
 			trace!(target:"sync", "Asking {:?} while expected {:?}", peer.asking, asking);
 			peer.asking = PeerAsking::Nothing;
@@ -947,6 +1023,9 @@ impl ChainSync {
 		if !io.is_chain_queue_empty() {
 			return Ok(());
 		}
+		if self.peers.get(&peer_id).map_or(false, |p| p.confirmed) {
+			trace!(target: "sync", "{} Ignoring transactions from unconfirmed/unknown peer", peer_id);
+		}
 
 		let mut item_count = r.item_count();
 		trace!(target: "sync", "{} -> Transactions ({} entries)", peer_id, item_count);
@@ -1178,7 +1257,13 @@ impl ChainSync {
 		let tick = time::precise_time_s();
 		let mut aborting = Vec::new();
 		for (peer_id, peer) in &self.peers {
-			if peer.asking != PeerAsking::Nothing && (tick - peer.ask_time) > CONNECTION_TIMEOUT_SEC {
+			let timeout = match peer.asking {
+				PeerAsking::BlockHeaders | PeerAsking::Heads => (tick - peer.ask_time) > HEADERS_TIMEOUT_SEC,
+				PeerAsking::BlockBodies => (tick - peer.ask_time) > BODIES_TIMEOUT_SEC,
+				PeerAsking::Nothing => false,
+				PeerAsking::ForkHeader => (tick - peer.ask_time) > FORK_HEADER_TIMEOUT_SEC,
+			};
+			if timeout {
 				trace!(target:"sync", "Timeout {}", peer_id);
 				io.disconnect_peer(*peer_id);
 				aborting.push(*peer_id);
@@ -1593,6 +1678,8 @@ mod tests {
 				asking_blocks: Vec::new(),
 				asking_hash: None,
 				ask_time: 0f64,
+				expired: false,
+				confirmed: false,
 			});
 		sync
 	}

sync/src/lib.rs

@@ -44,10 +44,10 @@
 //! 	let mut service = NetworkService::new(NetworkConfiguration::new()).unwrap();
 //! 	service.start().unwrap();
 //! 	let dir = env::temp_dir();
-//! 	let miner = Miner::new(Default::default(), ethereum::new_frontier(true), None);
+//! 	let miner = Miner::new(Default::default(), ethereum::new_frontier(), None);
 //! 	let client = Client::new(
 //!			ClientConfig::default(),
-//!			ethereum::new_frontier(true),
+//!			ethereum::new_frontier(),
 //!			&dir,
 //!			miner,
 //!			service.io().channel()
@@ -72,8 +72,9 @@ use std::ops::*;
 use std::sync::*;
 use util::network::{NetworkProtocolHandler, NetworkService, NetworkContext, PeerId};
 use util::TimerToken;
-use util::{U256, ONE_U256};
+use util::{U256, ONE_U256, H256};
 use ethcore::client::Client;
+use ethcore::header::BlockNumber;
 use ethcore::service::{SyncMessage, NetSyncMessage};
 use io::NetSyncIo;
 use util::io::IoChannel;
@@ -93,6 +94,8 @@ pub struct SyncConfig {
 	pub max_download_ahead_blocks: usize,
 	/// Network ID
 	pub network_id: U256,
+	/// Optional fork block id
+	pub fork_block: Option<(BlockNumber, H256)>,
 }
 
 impl Default for SyncConfig {
@@ -100,6 +103,7 @@ impl Default for SyncConfig {
 		SyncConfig {
 			max_download_ahead_blocks: 20000,
 			network_id: ONE_U256,
+			fork_block: None,
 		}
 	}
 }

sync/src/tests/chain.rs

@@ -15,7 +15,7 @@
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
 use util::*;
-use ethcore::client::{BlockChainClient, BlockID, EachBlockWith};
+use ethcore::client::{TestBlockChainClient, BlockChainClient, BlockID, EachBlockWith};
 use chain::{SyncState};
 use super::helpers::*;
 
@@ -95,6 +95,25 @@ fn forked() {
 	assert_eq!(net.peer(2).chain.numbers.read().unwrap().deref(), &peer1_chain);
 }
 
+#[test]
+fn net_hard_fork() {
+	::env_logger::init().ok();
+	let ref_client = TestBlockChainClient::new();
+	ref_client.add_blocks(50, EachBlockWith::Uncle);
+	{
+		let mut net = TestNet::new_with_fork(2, Some((50, ref_client.block_hash(BlockID::Number(50)).unwrap())));
+		net.peer_mut(0).chain.add_blocks(100, EachBlockWith::Uncle);
+		net.sync();
+		assert_eq!(net.peer(1).chain.chain_info().best_block_number, 100);
+	}
+	{
+		let mut net = TestNet::new_with_fork(2, Some((50, ref_client.block_hash(BlockID::Number(50)).unwrap())));
+		net.peer_mut(0).chain.add_blocks(100, EachBlockWith::Nothing);
+		net.sync();
+		assert_eq!(net.peer(1).chain.chain_info().best_block_number, 0);
+	}
+}
+
 #[test]
 fn restart() {
 	let mut net = TestNet::new(3);
@@ -108,7 +127,7 @@ fn restart() {
 	net.restart_peer(0);
 
 	let status = net.peer(0).sync.read().unwrap().status();
-	assert_eq!(status.state, SyncState::ChainHead);
+	assert_eq!(status.state, SyncState::Idle);
 }
 
 #[test]

sync/src/tests/helpers.rs

@@ -16,6 +16,7 @@
 
 use util::*;
 use ethcore::client::{TestBlockChainClient, BlockChainClient};
+use ethcore::header::BlockNumber;
 use io::SyncIo;
 use chain::ChainSync;
 use ::SyncConfig;
@@ -89,13 +90,19 @@ pub struct TestNet {
 
 impl TestNet {
 	pub fn new(n: usize) -> TestNet {
+		Self::new_with_fork(n, None)
+	}
+
+	pub fn new_with_fork(n: usize, fork: Option<(BlockNumber, H256)>) -> TestNet {
 		let mut net = TestNet {
 			peers: Vec::new(),
 			started: false,
 		};
 		for _ in 0..n {
 			let chain = TestBlockChainClient::new();
-			let sync = ChainSync::new(SyncConfig::default(), &chain);
+			let mut config = SyncConfig::default();
+			config.fork_block = fork;
+			let sync = ChainSync::new(config, &chain);
 			net.peers.push(TestPeer {
 				sync: RwLock::new(sync),
 				chain: chain,

util/Cargo.toml

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