Bumping status page

* Bumping clippy

* Fixing warnings found by clippy

.travis.yml

@@ -8,20 +8,44 @@ branches:
   - /^stable-.*$/
   - /^beta$/
   - /^stable$/
+git:
+  depth: 3
 matrix:
-  fast_finish: false
+  fast_finish: true
   allow_failures:
   - rust: nightly
   include:
   - rust: stable
-    env: FEATURES="--features travis-beta" KCOV_FEATURES="" TARGETS="-p ethash -p ethcore-util -p ethcore -p ethsync -p ethcore-rpc -p parity -p ethminer" ARCHIVE_SUFFIX="-${TRAVIS_OS_NAME}-${TRAVIS_TAG}"
+    env: FEATURES="--features travis-beta" RUN_TESTS="true"
+  # - rust: beta
+    # env: FEATURES="--features travis-beta" RUN_TESTS="true"
+  - rust: stable
+    env: FEATURES="--features travis-beta" RUN_BUILD="true"
+  - rust: beta
+    env: FEATURES="--features travis-beta" RUN_BUILD="true"
+  - rust: stable
+    env: FEATURES="--features travis-beta" RUN_COVERAGE="true"
+  # - rust: nightly
+    # env: FEATURES="--features travis-nightly" RUN_BENCHES="true"
+  - rust: nightly
+    env: FEATURES="--features travis-nightly" RUN_TESTS="true"
+env:
+  global:
+  # GH_TOKEN
+  - secure: bumJASbZSU8bxJ0EyPUJmu16AiV9EXOpyOj86Jlq/Ty9CfwGqsSXt96uDyE+OUJf34RUFQMsw0nk37/zC4lcn6kqk2wpuH3N/o85Zo/cVZY/NusBWLQqtT5VbYWsV+u2Ua4Tmmsw8yVYQhYwU2ZOejNpflL+Cs9XGgORp1L+/gMRMC2y5Se6ZhwnKPQlRJ8LGsG1dzjQULxzADIt3/zuspNBS8a2urJwlHfGMkvHDoUWCviP/GXoSqw3TZR7FmKyxE19I8n9+iSvm9+oZZquvcgfUxMHn8Gq/b44UbPvjtFOg2yam4xdWXF/RyWCHdc/R9EHorSABeCbefIsm+zcUF3/YQxwpSxM4IZEeH2rTiC7dcrsKw3XsO16xFQz5YI5Bay+CT/wTdMmJd7DdYz7Dyf+pOvcM9WOf/zorxYWSBOMYy0uzbusU2iyIghQ82s7E/Ahg+WARtPgkuTLSB5aL1oCTBKHqQscMr7lo5Ti6RpWLxEdTQMBznc+bMr+6dEtkEcG9zqc6cE9XX+ox3wTU6+HVMfQ1ltCntJ4UKcw3A6INEbw9wgocQa812CIASQ2fE+SCAbz6JxBjIAlFUnD1lUB7S8PdMPwn9plfQgKQ2A5YZqg6FnBdf0rQXIJYxQWKHXj/rBHSUCT0tHACDlzTA+EwWggvkP5AGIxRxm8jhw=
+  - TARGETS="-p ethash -p ethcore-util -p ethcore -p ethsync -p ethcore-rpc -p parity -p ethminer -p ethjson"
+  - ARCHIVE_SUFFIX="-${TRAVIS_OS_NAME}-${TRAVIS_TAG}"
+  - KCOV_FEATURES=""
+  - KCOV_CMD="./kcov-master/tmp/usr/local/bin/kcov --exclude-pattern /usr/,/.cargo,/root/.multirust,src/tests,util/json-tests,util/src/network/tests,sync/src/tests,ethcore/src/tests,ethcore/src/evm/tests target/kcov"
+  - RUN_TESTS="false"
+  - RUN_COVERAGE="false"
+  - RUN_BUILD="false"
+  - RUN_BENCHES="false"
+  - RUST_BACKTRACE="1"
 cache:
   apt: true
   directories:
-  - target/debug/deps
-  - target/debug/build
-  - target/release/deps
-  - target/release/build
+  - $TRAVIS_BUILD_DIR/target
   - $HOME/.cargo
 addons:
   apt:
@@ -29,22 +53,26 @@ addons:
     - libcurl4-openssl-dev
     - libelf-dev
     - libdw-dev
+
 script:
-- cargo build --release --verbose ${FEATURES}
-- cargo test --release --verbose ${FEATURES} ${TARGETS}
-#- cargo bench --no-run ${FEATURES} ${TARGETS}
-- tar cvzf parity${ARCHIVE_SUFFIX}.tar.gz -C target/release parity
+  - if [ "$RUN_TESTS" = "true" ]; then cargo test --release --verbose ${FEATURES} ${TARGETS}; fi
+  - if [ "$RUN_BENCHES" = "true" ]; then cargo bench --no-run ${FEATURES} ${TARGETS}; fi
+  - if [ "$RUN_BUILD" = "true" ]; then cargo build --release --verbose ${FEATURES}; fi
+  - if [ "$RUN_BUILD" = "true" ]; then tar cvzf parity${ARCHIVE_SUFFIX}.tar.gz -C target/release parity; fi
+
 after_success: |
+  [ "$RUN_COVERAGE" = "true" ] &&
   wget https://github.com/SimonKagstrom/kcov/archive/master.tar.gz &&
   tar xzf master.tar.gz && mkdir kcov-master/build && cd kcov-master/build && cmake .. && make && make install DESTDIR=../tmp && cd ../.. &&
   cargo test --no-run ${KCOV_FEATURES} ${TARGETS} &&
-  ./kcov-master/tmp/usr/local/bin/kcov --exclude-pattern /usr/,/.cargo,/root/.multirust,src/tests,util/json-tests,util/src/network/tests,sync/src/tests,ethcore/src/tests,ethcore/src/evm/tests target/kcov target/debug/deps/ethcore_util-* &&
-  ./kcov-master/tmp/usr/local/bin/kcov --exclude-pattern /usr/,/.cargo,/root/.multirust,src/tests,util/json-tests,util/src/network/tests,sync/src/tests,ethcore/src/tests,ethcore/src/evm/tests target/kcov target/debug/deps/ethash-* &&
-  ./kcov-master/tmp/usr/local/bin/kcov --exclude-pattern /usr/,/.cargo,/root/.multirust,src/tests,util/json-tests,util/src/network/tests,sync/src/tests,ethcore/src/tests,ethcore/src/evm/tests target/kcov target/debug/deps/ethcore-* &&
-  ./kcov-master/tmp/usr/local/bin/kcov --exclude-pattern /usr/,/.cargo,/root/.multirust,src/tests,util/json-tests,util/src/network/tests,sync/src/tests,ethcore/src/tests,ethcore/src/evm/tests target/kcov target/debug/deps/ethsync-* &&
-  ./kcov-master/tmp/usr/local/bin/kcov --exclude-pattern /usr/,/.cargo,/root/.multirust,src/tests,util/json-tests,util/src/network/tests,sync/src/tests,ethcore/src/tests,ethcore/src/evm/tests target/kcov target/debug/deps/ethcore_rpc-* &&
-  ./kcov-master/tmp/usr/local/bin/kcov --exclude-pattern /usr/,/.cargo,/root/.multirust,src/tests,util/json-tests,util/src/network/tests,sync/src/tests,ethcore/src/tests,ethcore/src/evm/tests target/kcov target/debug/deps/ethminer-* &&
-  ./kcov-master/tmp/usr/local/bin/kcov --coveralls-id=${TRAVIS_JOB_ID} --exclude-pattern /usr/,/.cargo,/root/.multirust target/kcov target/debug/parity-* &&
+  $KCOV_CMD target/debug/deps/ethcore_util-* &&
+  $KCOV_CMD target/debug/deps/ethash-* &&
+  $KCOV_CMD target/debug/deps/ethcore-* &&
+  $KCOV_CMD target/debug/deps/ethsync-* &&
+  $KCOV_CMD target/debug/deps/ethcore_rpc-* &&
+  $KCOV_CMD target/debug/deps/ethminer-* &&
+  $KCOV_CMD target/debug/deps/ethjson-* &&
+  $KCOV_CMD target/debug/parity-* &&
   [ $TRAVIS_BRANCH = master ] &&
   [ $TRAVIS_PULL_REQUEST = false ] &&
   [ $TRAVIS_RUST_VERSION = stable ] &&
@@ -53,10 +81,6 @@ after_success: |
   pip install --user ghp-import &&
   /home/travis/.local/bin/ghp-import -n target/doc &&
   git push -fq https://${GH_TOKEN}@github.com/${TRAVIS_REPO_SLUG}.git gh-pages
-env:
-  global:
-  # GH_TOKEN
-  - secure: bumJASbZSU8bxJ0EyPUJmu16AiV9EXOpyOj86Jlq/Ty9CfwGqsSXt96uDyE+OUJf34RUFQMsw0nk37/zC4lcn6kqk2wpuH3N/o85Zo/cVZY/NusBWLQqtT5VbYWsV+u2Ua4Tmmsw8yVYQhYwU2ZOejNpflL+Cs9XGgORp1L+/gMRMC2y5Se6ZhwnKPQlRJ8LGsG1dzjQULxzADIt3/zuspNBS8a2urJwlHfGMkvHDoUWCviP/GXoSqw3TZR7FmKyxE19I8n9+iSvm9+oZZquvcgfUxMHn8Gq/b44UbPvjtFOg2yam4xdWXF/RyWCHdc/R9EHorSABeCbefIsm+zcUF3/YQxwpSxM4IZEeH2rTiC7dcrsKw3XsO16xFQz5YI5Bay+CT/wTdMmJd7DdYz7Dyf+pOvcM9WOf/zorxYWSBOMYy0uzbusU2iyIghQ82s7E/Ahg+WARtPgkuTLSB5aL1oCTBKHqQscMr7lo5Ti6RpWLxEdTQMBznc+bMr+6dEtkEcG9zqc6cE9XX+ox3wTU6+HVMfQ1ltCntJ4UKcw3A6INEbw9wgocQa812CIASQ2fE+SCAbz6JxBjIAlFUnD1lUB7S8PdMPwn9plfQgKQ2A5YZqg6FnBdf0rQXIJYxQWKHXj/rBHSUCT0tHACDlzTA+EwWggvkP5AGIxRxm8jhw=
 
 deploy:
   provider: releases
@@ -68,9 +92,14 @@ deploy:
     tags: true
 
 notifications:
- webhooks:
-   urls:
-     - https://hooks.slack.com/services/${SLACK_WEBHOOK}
-   on_success: always
-   on_failure: always
-   on_start: never
+  webhooks:
+    urls:
+      - https://hooks.slack.com/services/${SLACK_WEBHOOK}
+    on_success: always
+    on_failure: always
+    on_start: never
+
+notifications:
+  slack:
+    rooms:
+      - ethcore:4EGxt9WP6AS7uX4JKXSfR9vi#chatops

Cargo.toml

@@ -8,6 +8,8 @@ build = "build.rs"
 
 [build-dependencies]
 rustc_version = "0.1"
+syntex = "*"
+"ethcore-ipc-codegen" = { path = "ipc/codegen" }
 
 [dependencies]
 log = "0.3"
@@ -18,20 +20,33 @@ time = "0.1"
 ctrlc = { git = "https://github.com/tomusdrw/rust-ctrlc.git" }
 fdlimit = { path = "util/fdlimit" }
 daemonize = "0.2"
+num_cpus = "0.2"
 number_prefix = "0.2"
-rpassword = "0.1"
-clippy = { version = "0.0.50", optional = true }
+rpassword = "0.2.1"
+clippy = { version = "0.0.64", optional = true}
 ethcore = { path = "ethcore" }
 ethcore-util = { path = "util" }
 ethsync = { path = "sync" }
 ethminer = { path = "miner" }
 ethcore-devtools = { path = "devtools" }
 ethcore-rpc = { path = "rpc", optional = true }
+ethcore-webapp = { path = "webapp", optional = true }
+semver = "0.2"
+ethcore-ipc-nano = { path = "ipc/nano" }
+"ethcore-ipc" = { path = "ipc/rpc" }
+bincode = "*"
+serde = "0.7.0"
+
+[dependencies.hyper]
+version = "0.8"
+default-features = false
 
 [features]
-default = ["rpc"]
+default = ["rpc", "webapp"]
 rpc = ["ethcore-rpc"]
-dev = ["clippy", "ethcore/dev", "ethcore-util/dev", "ethsync/dev", "ethcore-rpc/dev", "ethminer/dev"]
+webapp = ["ethcore-webapp"]
+dev = ["clippy", "ethcore/dev", "ethcore-util/dev", "ethsync/dev", "ethcore-rpc/dev", "ethminer/dev",
+"ethcore-webapp/dev"]
 travis-beta = ["ethcore/json-tests"]
 travis-nightly = ["ethcore/json-tests", "dev"]
 
@@ -40,5 +55,5 @@ path = "parity/main.rs"
 name = "parity"
 
 [profile.release]
-debug = false
+debug = true
 lto = false

README.md

@@ -19,12 +19,13 @@ First (if you don't already have it) get multirust:
 
 - Linux:
 ```bash
-curl -sf https://raw.githubusercontent.com/brson/multirust/master/quick-install.sh | sudo sh -s -- --yes
+curl -sf https://raw.githubusercontent.com/brson/multirust/master/quick-install.sh | sh
 ```
 
 - OSX with Homebrew:
 ```bash
 brew update && brew install multirust
+multirust default stable
 ```
 
 Then, download and build Parity:

build.rs

@@ -15,11 +15,35 @@
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
 extern crate rustc_version;
+extern crate syntex;
+extern crate ethcore_ipc_codegen as codegen;
 
+use std::env;
+use std::path::Path;
 use rustc_version::{version_meta, Channel};
 
 fn main() {
 	if let Channel::Nightly = version_meta().channel {
 		println!("cargo:rustc-cfg=nightly");
 	}
+
+	let out_dir = env::var_os("OUT_DIR").unwrap();
+
+	// ipc pass
+	{
+		let src = Path::new("parity/hypervisor/service.rs.in");
+		let dst = Path::new(&out_dir).join("hypervisor_service_ipc.rs");
+		let mut registry = syntex::Registry::new();
+		codegen::register(&mut registry);
+		registry.expand("", &src, &dst).unwrap();
+	}
+
+	// serialization pass
+	{
+		let src = Path::new(&out_dir).join("hypervisor_service_ipc.rs");
+		let dst = Path::new(&out_dir).join("hypervisor_service_cg.rs");
+		let mut registry = syntex::Registry::new();
+		codegen::register(&mut registry);
+		registry.expand("", &src, &dst).unwrap();
+	}
 }

cov.sh

@@ -23,6 +23,7 @@ cargo test \
 	-p ethcore-rpc \
 	-p parity \
 	-p ethminer \
+	-p ethcore-webapp \
 	--no-run || exit $?
 rm -rf target/coverage
 mkdir -p target/coverage
@@ -33,5 +34,6 @@ kcov --exclude-pattern $EXCLUDE --include-pattern src --verify target/coverage t
 kcov --exclude-pattern $EXCLUDE --include-pattern src --verify target/coverage target/debug/deps/ethcore_util-*
 kcov --exclude-pattern $EXCLUDE --include-pattern src --verify target/coverage target/debug/deps/ethsync-*
 kcov --exclude-pattern $EXCLUDE --include-pattern src --verify target/coverage target/debug/deps/ethcore_rpc-*
+kcov --exclude-pattern $EXCLUDE --include-pattern src --verify target/coverage target/debug/deps/ethcore_webapp-*
 kcov --exclude-pattern $EXCLUDE --include-pattern src --verify target/coverage target/debug/deps/ethminer-*
 xdg-open target/coverage/index.html

devtools/README.md

@@ -1 +0,0 @@
-# ethcore dev tools

devtools/src/lib.rs

@@ -20,5 +20,7 @@
 extern crate rand;
 
 pub mod random_path;
+pub mod test_socket;
 
 pub use random_path::*;
+pub use test_socket::*;

devtools/src/test_socket.rs

@@ -0,0 +1,94 @@
+// 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 std::io::*;
+use std::cmp;
+
+pub struct TestSocket {
+	pub read_buffer: Vec<u8>,
+	pub write_buffer: Vec<u8>,
+	pub cursor: usize,
+	pub buf_size: usize,
+}
+
+impl Default for TestSocket {
+	fn default() -> Self {
+		TestSocket::new()
+	}
+}
+
+impl TestSocket {
+	pub fn new() -> Self {
+		TestSocket {
+			read_buffer: vec![],
+			write_buffer: vec![],
+			cursor: 0,
+			buf_size: 0,
+		}
+	}
+
+	pub fn new_buf(buf_size: usize) -> TestSocket {
+		TestSocket {
+			read_buffer: vec![],
+			write_buffer: vec![],
+			cursor: 0,
+			buf_size: buf_size,
+		}
+	}
+
+	pub fn new_ready(data: Vec<u8>) -> TestSocket {
+		TestSocket {
+			read_buffer: data,
+			write_buffer: vec![],
+			cursor: 0,
+			buf_size: 0,
+		}
+	}
+}
+
+impl Read for TestSocket {
+	fn read(&mut self, buf: &mut [u8]) -> Result<usize> {
+		let end_position = cmp::min(self.read_buffer.len(), self.cursor+buf.len());
+		let len = cmp::max(end_position - self.cursor, 0);
+		match len {
+			0 => Ok(0),
+			_ => {
+				for i in self.cursor..end_position {
+					buf[i-self.cursor] = self.read_buffer[i];
+				}
+				self.cursor = self.cursor + buf.len();
+				Ok(len)
+			}
+		}
+	}
+}
+
+impl Write for TestSocket {
+	fn write(&mut self, buf: &[u8]) -> Result<usize> {
+		if self.buf_size == 0 || buf.len() < self.buf_size {
+			self.write_buffer.extend(buf.iter().cloned());
+			Ok(buf.len())
+		}
+		else {
+			self.write_buffer.extend(buf.iter().take(self.buf_size).cloned());
+			Ok(self.buf_size)
+		}
+	}
+
+	fn flush(&mut self) -> Result<()> {
+		unimplemented!();
+	}
+}

doc.sh

@@ -7,5 +7,6 @@ cargo doc --no-deps --verbose \
 	-p ethcore \
 	-p ethsync \
 	-p ethcore-rpc \
+	-p ethcore-webapp \
 	-p parity \
 	-p ethminer

docker/ubuntu-arm/Dockerfile

@@ -0,0 +1,46 @@
+FROM ubuntu:14.04
+WORKDIR /build
+# install tools and dependencies
+RUN apt-get -y update && \
+	apt-get install -y --force-yes --no-install-recommends \
+	curl git make g++ gcc-arm-linux-gnueabihf g++-arm-linux-gnueabihf \
+	libc6-dev-armhf-cross wget file ca-certificates \
+	binutils-arm-linux-gnueabihf \
+	&& \
+    apt-get clean
+
+# install multirust
+RUN curl -sf https://raw.githubusercontent.com/brson/multirust/master/blastoff.sh | sh -s -- --yes
+ENV RUST_TARGETS="arm-unknown-linux-gnueabihf"
+
+# multirust add arm--linux-gnuabhf toolchain
+RUN multirust add-target stable arm-unknown-linux-gnueabihf
+
+# show backtraces
+ENV RUST_BACKTRACE 1
+# set compilers
+ENV CXX arm-linux-gnueabihf-g++ 
+ENV CC arm-linux-gnueabihf-gcc 
+# build parity
+RUN git clone https://github.com/ethcore/parity && \
+	cd parity && \
+	git checkout master && \
+	wget https://github.com/nix-rust/nix/archive/v0.5.0.tar.gz && \
+	tar -xf v0.5.0.tar.gz && \
+	rm -rf v0.5.0.tar.gz && \
+	wget https://github.com/thkaw/mio/archive/v0.5.x.tar.gz && \
+	tar -xf v0.5.x.tar.gz && \
+	rm -rf v0.5.x.tar.gz && \
+	mkdir -p .cargo && \
+  	echo 'paths = ["nix-0.5.0","mio-0.5.x"]\n\
+	[target.arm-unknown-linux-gnueabihf]\n\
+	linker = "arm-linux-gnueabihf-gcc"\n'\
+	>>.cargo/config && \
+	cat .cargo/config && \
+	rustc -vV && \
+	cargo -V && \
+	cargo build --target arm-unknown-linux-gnueabihf --release --verbose && \
+	ls /build/parity/target/arm-unknown-linux-gnueabihf/release/parity &&	\
+	file /build/parity/target/arm-unknown-linux-gnueabihf/release/parity && \
+	/usr/bin/arm-linux-gnueabihf-strip /build/parity/target/arm-unknown-linux-gnueabihf/release/parity
+RUN file /build/parity/target/arm-unknown-linux-gnueabihf/release/parity

ethash/src/compute.rs

@@ -20,12 +20,14 @@
 // TODO: fix endianess for big endian
 
 use primal::is_prime;
+use std::cell::Cell;
+use std::sync::Mutex;
 use std::mem;
 use std::ptr;
 use sha3;
 use std::slice;
 use std::path::PathBuf;
-use std::io::{Read, Write, self};
+use std::io::{self, Read, Write};
 use std::fs::{self, File};
 
 pub const ETHASH_EPOCH_LENGTH: u64 = 30000;
@@ -42,14 +44,14 @@ const NODE_WORDS: usize = 64 / 4;
 const NODE_BYTES: usize = 64;
 const MIX_WORDS: usize = ETHASH_MIX_BYTES / 4;
 const MIX_NODES: usize = MIX_WORDS / NODE_WORDS;
-const FNV_PRIME: u32 =  0x01000193;
+const FNV_PRIME: u32 = 0x01000193;
 
 /// Computation result
 pub struct ProofOfWork {
 	/// Difficulty boundary
 	pub value: H256,
 	/// Mix
-	pub mix_hash: H256
+	pub mix_hash: H256,
 }
 
 struct Node {
@@ -85,6 +87,7 @@ pub type H256 = [u8; 32];
 pub struct Light {
 	block_number: u64,
 	cache: Vec<Node>,
+	seed_compute: Mutex<SeedHashCompute>,
 }
 
 /// Light cache structur
@@ -101,17 +104,17 @@ impl Light {
 		light_compute(self, header_hash, nonce)
 	}
 
-	pub fn file_path(block_number: u64) -> PathBuf {
+	pub fn file_path(seed_hash: H256) -> PathBuf {
 		let mut home = ::std::env::home_dir().unwrap();
 		home.push(".ethash");
 		home.push("light");
-		let seed_hash = get_seedhash(block_number);
 		home.push(to_hex(&seed_hash));
 		home
 	}
 
 	pub fn from_file(block_number: u64) -> io::Result<Light> {
-		let path = Light::file_path(block_number);
+		let seed_compute = SeedHashCompute::new();
+		let path = Light::file_path(seed_compute.get_seedhash(block_number));
 		let mut file = try!(File::open(path));
 
 		let cache_size = get_cache_size(block_number);
@@ -126,11 +129,13 @@ impl Light {
 		Ok(Light {
 			cache: nodes,
 			block_number: block_number,
+			seed_compute: Mutex::new(seed_compute),
 		})
 	}
 
 	pub fn to_file(&self) -> io::Result<()> {
-		let path = Light::file_path(self.block_number);
+		let seed_compute = self.seed_compute.lock().unwrap();
+		let path = Light::file_path(seed_compute.get_seedhash(self.block_number));
 		try!(fs::create_dir_all(path.parent().unwrap()));
 		let mut file = try!(File::create(path));
 
@@ -141,6 +146,51 @@ impl Light {
 	}
 }
 
+pub struct SeedHashCompute {
+	prev_epoch: Cell<u64>,
+	prev_seedhash: Cell<H256>,
+}
+
+impl SeedHashCompute {
+	#[inline]
+	pub fn new() -> SeedHashCompute {
+		SeedHashCompute {
+			prev_epoch: Cell::new(0),
+			prev_seedhash: Cell::new([0u8; 32]),
+		}
+	}
+
+	#[inline]
+	fn reset_cache(&self) {
+		self.prev_epoch.set(0);
+		self.prev_seedhash.set([0u8; 32]);
+	}
+
+	#[inline]
+	pub fn get_seedhash(&self, block_number: u64) -> H256 {
+		let epoch = block_number / ETHASH_EPOCH_LENGTH;
+		if epoch < self.prev_epoch.get() {
+			// can't build on previous hash if requesting an older block
+			self.reset_cache();
+		}
+		if epoch > self.prev_epoch.get() {
+			let seed_hash = SeedHashCompute::resume_compute_seedhash(self.prev_seedhash.get(), self.prev_epoch.get(), epoch);
+			self.prev_seedhash.set(seed_hash);
+			self.prev_epoch.set(epoch);
+		}
+		self.prev_seedhash.get()
+	}
+
+	#[inline]
+	pub fn resume_compute_seedhash(mut hash: H256, start_epoch: u64, end_epoch: u64) -> H256 {
+		for _ in start_epoch..end_epoch {
+			unsafe { sha3::sha3_256(hash[..].as_mut_ptr(), 32, hash[..].as_ptr(), 32) };
+		}
+		hash
+	}
+}
+
+
 #[inline]
 fn fnv_hash(x: u32, y: u32) -> u32 {
 	return x.wrapping_mul(FNV_PRIME) ^ y;
@@ -153,34 +203,24 @@ fn sha3_512(input: &[u8], output: &mut [u8]) {
 
 #[inline]
 fn get_cache_size(block_number: u64) -> usize {
-    let mut sz: u64 = CACHE_BYTES_INIT + CACHE_BYTES_GROWTH * (block_number / ETHASH_EPOCH_LENGTH);
-    sz = sz - NODE_BYTES as u64;
-    while !is_prime(sz / NODE_BYTES as u64) {
-        sz = sz - 2 * NODE_BYTES as u64;
-    }
-    sz as usize
+	let mut sz: u64 = CACHE_BYTES_INIT + CACHE_BYTES_GROWTH * (block_number / ETHASH_EPOCH_LENGTH);
+	sz = sz - NODE_BYTES as u64;
+	while !is_prime(sz / NODE_BYTES as u64) {
+		sz = sz - 2 * NODE_BYTES as u64;
+	}
+	sz as usize
 }
 
 #[inline]
 fn get_data_size(block_number: u64) -> usize {
-    let mut sz: u64 = DATASET_BYTES_INIT + DATASET_BYTES_GROWTH * (block_number / ETHASH_EPOCH_LENGTH);
-    sz = sz - ETHASH_MIX_BYTES as u64;
-    while !is_prime(sz / ETHASH_MIX_BYTES as u64) {
-        sz = sz - 2 * ETHASH_MIX_BYTES as u64;
-    }
-    sz as usize
+	let mut sz: u64 = DATASET_BYTES_INIT + DATASET_BYTES_GROWTH * (block_number / ETHASH_EPOCH_LENGTH);
+	sz = sz - ETHASH_MIX_BYTES as u64;
+	while !is_prime(sz / ETHASH_MIX_BYTES as u64) {
+		sz = sz - 2 * ETHASH_MIX_BYTES as u64;
+	}
+	sz as usize
 }
 
-#[inline]
-/// Given the `block_number`, determine the seed hash for Ethash.
-pub fn get_seedhash(block_number: u64) -> H256 {
-	let epochs = block_number / ETHASH_EPOCH_LENGTH;
-	let mut ret: H256 = [0u8; 32];
-	for _ in 0..epochs {
-		unsafe { sha3::sha3_256(ret[..].as_mut_ptr(), 32, ret[..].as_ptr(), 32) };
-	}
-	ret
-}
 
 /// Difficulty quick check for POW preverification
 ///
@@ -211,12 +251,12 @@ pub fn light_compute(light: &Light, header_hash: &H256, nonce: u64) -> ProofOfWo
 	hash_compute(light, full_size, header_hash, nonce)
 }
 
-fn hash_compute(light: &Light, full_size: usize,  header_hash: &H256, nonce: u64) -> ProofOfWork {
+fn hash_compute(light: &Light, full_size: usize, header_hash: &H256, nonce: u64) -> ProofOfWork {
 	if full_size % MIX_WORDS != 0 {
 		panic!("Unaligned full size");
 	}
 	// pack hash and nonce together into first 40 bytes of s_mix
-	let mut s_mix: [Node; MIX_NODES + 1] = [ Node::default(), Node::default(), Node::default() ];
+	let mut s_mix: [Node; MIX_NODES + 1] = [Node::default(), Node::default(), Node::default()];
 	unsafe { ptr::copy_nonoverlapping(header_hash.as_ptr(), s_mix.get_unchecked_mut(0).bytes.as_mut_ptr(), 32) };
 	unsafe { ptr::copy_nonoverlapping(mem::transmute(&nonce), s_mix.get_unchecked_mut(0).bytes[32..].as_mut_ptr(), 8) };
 
@@ -257,7 +297,7 @@ fn hash_compute(light: &Light, full_size: usize,  header_hash: &H256, nonce: u64
 		ptr::copy_nonoverlapping(mix.get_unchecked_mut(0).bytes.as_ptr(), buf[64..].as_mut_ptr(), 32);
 		ptr::copy_nonoverlapping(mix.get_unchecked_mut(0).bytes.as_ptr(), mix_hash.as_mut_ptr(), 32);
 		let mut value: H256 = [0u8; 32];
-		sha3::sha3_256(value.as_mut_ptr(), value.len(),  buf.as_ptr(), buf.len());
+		sha3::sha3_256(value.as_mut_ptr(), value.len(), buf.as_ptr(), buf.len());
 		ProofOfWork {
 			mix_hash: mix_hash,
 			value: value,
@@ -287,7 +327,9 @@ fn calculate_dag_item(node_index: u32, light: &Light) -> Node {
 }
 
 fn light_new(block_number: u64) -> Light {
-	let seedhash = get_seedhash(block_number);
+
+	let seed_compute = SeedHashCompute::new();
+	let seedhash = seed_compute.get_seedhash(block_number);
 	let cache_size = get_cache_size(block_number);
 
 	if cache_size % NODE_BYTES != 0 {
@@ -308,7 +350,7 @@ fn light_new(block_number: u64) -> Light {
 				let idx = *nodes.get_unchecked_mut(i).as_words().get_unchecked(0) as usize % num_nodes;
 				let mut data = nodes.get_unchecked((num_nodes - 1 + i) % num_nodes).clone();
 				for w in 0..NODE_WORDS {
-					*data.as_words_mut().get_unchecked_mut(w) ^= *nodes.get_unchecked(idx).as_words().get_unchecked(w) ;
+					*data.as_words_mut().get_unchecked_mut(w) ^= *nodes.get_unchecked(idx).as_words().get_unchecked(w);
 				}
 				sha3_512(&data.bytes, &mut nodes.get_unchecked_mut(i).bytes);
 			}
@@ -318,10 +360,11 @@ fn light_new(block_number: u64) -> Light {
 	Light {
 		cache: nodes,
 		block_number: block_number,
+		seed_compute: Mutex::new(seed_compute),
 	}
 }
 
-static CHARS: &'static[u8] = b"0123456789abcdef";
+static CHARS: &'static [u8] = b"0123456789abcdef";
 fn to_hex(bytes: &[u8]) -> String {
 	let mut v = Vec::with_capacity(bytes.len() * 2);
 	for &byte in bytes.iter() {
@@ -329,9 +372,7 @@ fn to_hex(bytes: &[u8]) -> String {
 		v.push(CHARS[(byte & 0xf) as usize]);
 	}
 
-	unsafe {
-		String::from_utf8_unchecked(v)
-	}
+	unsafe { String::from_utf8_unchecked(v) }
 }
 
 #[test]
@@ -361,8 +402,8 @@ fn test_get_data_size() {
 
 #[test]
 fn test_difficulty_test() {
-	let hash = [0xf5, 0x7e, 0x6f, 0x3a, 0xcf, 0xc0, 0xdd, 0x4b, 0x5b, 0xf2, 0xbe, 0xe4, 0x0a, 0xb3, 0x35, 0x8a, 0xa6, 0x87, 0x73, 0xa8, 0xd0, 0x9f, 0x5e, 0x59, 0x5e, 0xab, 0x55, 0x94, 0x05,  0x52, 0x7d, 0x72];
-	let mix_hash = [0x1f, 0xff, 0x04, 0xce, 0xc9, 0x41, 0x73, 0xfd, 0x59, 0x1e, 0x3d, 0x89, 0x60, 0xce, 0x6b, 0xdf, 0x8b, 0x19, 0x71, 0x04, 0x8c, 0x71, 0xff, 0x93, 0x7b, 0xb2, 0xd3, 0x2a, 0x64, 0x31, 0xab, 0x6d ];
+	let hash = [0xf5, 0x7e, 0x6f, 0x3a, 0xcf, 0xc0, 0xdd, 0x4b, 0x5b, 0xf2, 0xbe, 0xe4, 0x0a, 0xb3, 0x35, 0x8a, 0xa6, 0x87, 0x73, 0xa8, 0xd0, 0x9f, 0x5e, 0x59, 0x5e, 0xab, 0x55, 0x94, 0x05, 0x52, 0x7d, 0x72];
+	let mix_hash = [0x1f, 0xff, 0x04, 0xce, 0xc9, 0x41, 0x73, 0xfd, 0x59, 0x1e, 0x3d, 0x89, 0x60, 0xce, 0x6b, 0xdf, 0x8b, 0x19, 0x71, 0x04, 0x8c, 0x71, 0xff, 0x93, 0x7b, 0xb2, 0xd3, 0x2a, 0x64, 0x31, 0xab, 0x6d];
 	let nonce = 0xd7b3ac70a301a249;
 	let boundary_good = [0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x3e, 0x9b, 0x6c, 0x69, 0xbc, 0x2c, 0xe2, 0xa2, 0x4a, 0x8e, 0x95, 0x69, 0xef, 0xc7, 0xd7, 0x1b, 0x33, 0x35, 0xdf, 0x36, 0x8c, 0x9a, 0xe9, 0x7e, 0x53, 0x84];
 	assert_eq!(quick_get_difficulty(&hash, nonce, &mix_hash)[..], boundary_good[..]);
@@ -372,8 +413,8 @@ fn test_difficulty_test() {
 
 #[test]
 fn test_light_compute() {
-	let hash = [0xf5, 0x7e, 0x6f, 0x3a, 0xcf, 0xc0, 0xdd, 0x4b, 0x5b, 0xf2, 0xbe, 0xe4, 0x0a, 0xb3, 0x35, 0x8a, 0xa6, 0x87, 0x73, 0xa8, 0xd0, 0x9f, 0x5e, 0x59, 0x5e, 0xab, 0x55, 0x94, 0x05,  0x52, 0x7d, 0x72];
-	let mix_hash = [0x1f, 0xff, 0x04, 0xce, 0xc9, 0x41, 0x73, 0xfd, 0x59, 0x1e, 0x3d, 0x89, 0x60, 0xce, 0x6b, 0xdf, 0x8b, 0x19, 0x71, 0x04, 0x8c, 0x71, 0xff, 0x93, 0x7b, 0xb2, 0xd3, 0x2a, 0x64, 0x31, 0xab, 0x6d ];
+	let hash = [0xf5, 0x7e, 0x6f, 0x3a, 0xcf, 0xc0, 0xdd, 0x4b, 0x5b, 0xf2, 0xbe, 0xe4, 0x0a, 0xb3, 0x35, 0x8a, 0xa6, 0x87, 0x73, 0xa8, 0xd0, 0x9f, 0x5e, 0x59, 0x5e, 0xab, 0x55, 0x94, 0x05, 0x52, 0x7d, 0x72];
+	let mix_hash = [0x1f, 0xff, 0x04, 0xce, 0xc9, 0x41, 0x73, 0xfd, 0x59, 0x1e, 0x3d, 0x89, 0x60, 0xce, 0x6b, 0xdf, 0x8b, 0x19, 0x71, 0x04, 0x8c, 0x71, 0xff, 0x93, 0x7b, 0xb2, 0xd3, 0x2a, 0x64, 0x31, 0xab, 0x6d];
 	let boundary = [0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x3e, 0x9b, 0x6c, 0x69, 0xbc, 0x2c, 0xe2, 0xa2, 0x4a, 0x8e, 0x95, 0x69, 0xef, 0xc7, 0xd7, 0x1b, 0x33, 0x35, 0xdf, 0x36, 0x8c, 0x9a, 0xe9, 0x7e, 0x53, 0x84];
 	let nonce = 0xd7b3ac70a301a249;
 	// difficulty = 0x085657254bd9u64;
@@ -382,3 +423,34 @@ fn test_light_compute() {
 	assert_eq!(result.mix_hash[..], mix_hash[..]);
 	assert_eq!(result.value[..], boundary[..]);
 }
+
+#[test]
+fn test_seed_compute_once() {
+	let seed_compute = SeedHashCompute::new();
+	let hash = [241, 175, 44, 134, 39, 121, 245, 239, 228, 236, 43, 160, 195, 152, 46, 7, 199, 5, 253, 147, 241, 206, 98, 43, 3, 104, 17, 40, 192, 79, 106, 162];
+	assert_eq!(seed_compute.get_seedhash(486382), hash);
+}
+
+#[test]
+fn test_seed_compute_zero() {
+	let seed_compute = SeedHashCompute::new();
+	assert_eq!(seed_compute.get_seedhash(0), [0u8; 32]);
+}
+
+#[test]
+fn test_seed_compute_after_older() {
+	let seed_compute = SeedHashCompute::new();
+	// calculating an older value first shouldn't affect the result
+	let _ = seed_compute.get_seedhash(50000);
+	let hash = [241, 175, 44, 134, 39, 121, 245, 239, 228, 236, 43, 160, 195, 152, 46, 7, 199, 5, 253, 147, 241, 206, 98, 43, 3, 104, 17, 40, 192, 79, 106, 162];
+	assert_eq!(seed_compute.get_seedhash(486382), hash);
+}
+
+#[test]
+fn test_seed_compute_after_newer() {
+	let seed_compute = SeedHashCompute::new();
+	// calculating an newer value first shouldn't affect the result
+	let _ = seed_compute.get_seedhash(972764);
+	let hash = [241, 175, 44, 134, 39, 121, 245, 239, 228, 236, 43, 160, 195, 152, 46, 7, 199, 5, 253, 147, 241, 206, 98, 43, 3, 104, 17, 40, 192, 79, 106, 162];
+	assert_eq!(seed_compute.get_seedhash(486382), hash);
+}

ethash/src/lib.rs

@@ -24,7 +24,7 @@ mod compute;
 
 use std::mem;
 use compute::Light;
-pub use compute::{get_seedhash, quick_get_difficulty, H256, ProofOfWork, ETHASH_EPOCH_LENGTH};
+pub use compute::{ETHASH_EPOCH_LENGTH, H256, ProofOfWork, SeedHashCompute, quick_get_difficulty};
 
 use std::sync::{Arc, Mutex};
 
@@ -76,7 +76,7 @@ impl EthashManager {
 						lights.recent.clone()
 					}
 					_ => None,
-				}
+				},
 			};
 			match light {
 				None => {
@@ -95,7 +95,7 @@ impl EthashManager {
 					lights.prev = mem::replace(&mut lights.recent, Some(light.clone()));
 					light
 				}
-				Some(light) => light
+				Some(light) => light,
 			}
 		};
 		light.compute(header_hash, nonce)

ethcore/Cargo.toml

@@ -17,10 +17,12 @@ ethcore-util = { path = "../util" }
 evmjit = { path = "../evmjit", optional = true }
 ethash = { path = "../ethash" }
 num_cpus = "0.2"
-clippy = { version = "0.0.50", optional = true }
+clippy = { version = "0.0.64", optional = true}
 crossbeam = "0.1.5"
 lazy_static = "0.1"
 ethcore-devtools = { path = "../devtools" }
+ethjson = { path = "../json" }
+bloomchain = "0.1"
 
 [features]
 jit = ["evmjit"]

ethcore/res/ethereum/frontier.json

@@ -1,24 +1,33 @@
 {
 	"name": "Frontier/Homestead",
-	"engineName": "Ethash",
+	"engine": {
+		"Ethash": {
+			"params": {
+				"tieBreakingGas": false,
+				"gasLimitBoundDivisor": "0x0400",
+				"minimumDifficulty": "0x020000",
+				"difficultyBoundDivisor": "0x0800",
+				"durationLimit": "0x0d",
+				"blockReward": "0x4563918244F40000",
+				"registrar" : "0xc6d9d2cd449a754c494264e1809c50e34d64562b"
+			}
+		}
+	},
 	"params": {
 		"accountStartNonce": "0x00",
 		"frontierCompatibilityModeLimit": "0x118c30",
 		"maximumExtraDataSize": "0x20",
-		"tieBreakingGas": false,
 		"minGasLimit": "0x1388",
-		"gasLimitBoundDivisor": "0x0400",
-		"minimumDifficulty": "0x020000",
-		"difficultyBoundDivisor": "0x0800",
-		"durationLimit": "0x0d",
-		"blockReward": "0x4563918244F40000",
-		"registrar" : "0xc6d9d2cd449a754c494264e1809c50e34d64562b",
 		"networkID" : "0x1"
 	},
 	"genesis": {
-		"nonce": "0x0000000000000042",
+		"seal": {
+			"ethereum": {
+				"nonce": "0x0000000000000042",
+				"mixHash": "0x0000000000000000000000000000000000000000000000000000000000000000"
+			}
+		},
 		"difficulty": "0x400000000",
-		"mixHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
 		"author": "0x0000000000000000000000000000000000000000",
 		"timestamp": "0x00",
 		"parentHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
@@ -30,13 +39,13 @@
 		"enode://a979fb575495b8d6db44f750317d0f4622bf4c2aa3365d6af7c284339968eef29b69ad0dce72a4d8db5ebb4968de0e3bec910127f134779fbcb0cb6d3331163c@52.16.188.185:30303",
 		"enode://de471bccee3d042261d52e9bff31458daecc406142b401d4cd848f677479f73104b9fdeb090af9583d3391b7f10cb2ba9e26865dd5fca4fcdc0fb1e3b723c786@54.94.239.50:30303",
 		"enode://1118980bf48b0a3640bdba04e0fe78b1add18e1cd99bf22d53daac1fd9972ad650df52176e7c7d89d1114cfef2bc23a2959aa54998a46afcf7d91809f0855082@52.74.57.123:30303",
-		"enode://248f12bc8b18d5289358085520ac78cd8076485211e6d96ab0bc93d6cd25442db0ce3a937dc404f64f207b0b9aed50e25e98ce32af5ac7cb321ff285b97de485@parity-node-zero.ethcore.io:30303"
+		"enode://248f12bc8b18d5289358085520ac78cd8076485211e6d96ab0bc93d6cd25442db0ce3a937dc404f64f207b0b9aed50e25e98ce32af5ac7cb321ff285b97de485@zero.parity.io:30303"
 	],
 	"accounts": {
-		"0000000000000000000000000000000000000001": { "builtin": { "name": "ecrecover", "linear": { "base": 3000, "word": 0 } } },
-		"0000000000000000000000000000000000000002": { "builtin": { "name": "sha256", "linear": { "base": 60, "word": 12 } } },
-		"0000000000000000000000000000000000000003": { "builtin": { "name": "ripemd160", "linear": { "base": 600, "word": 120 } } },
-		"0000000000000000000000000000000000000004": { "builtin": { "name": "identity", "linear": { "base": 15, "word": 3 } } },
+		"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 } } } },
 		"3282791d6fd713f1e94f4bfd565eaa78b3a0599d": {
 			"balance": "1337000000000000000000"
 		},

ethcore/res/ethereum/frontier_like_test.json

@@ -1,24 +1,33 @@
 {
-	"engineName": "Frontier (Test)",
-	"engineName": "Ethash",
+	"name": "Frontier (Test)",
+	"engine": {
+		"Ethash": {
+			"params": {
+				"tieBreakingGas": false,
+				"gasLimitBoundDivisor": "0x0400",
+				"minimumDifficulty": "0x020000",
+				"difficultyBoundDivisor": "0x0800",
+				"durationLimit": "0x0d",
+				"blockReward": "0x4563918244F40000",
+				"registrar" : "0xc6d9d2cd449a754c494264e1809c50e34d64562b"
+			}
+		}
+	},
 	"params": {
 		"accountStartNonce": "0x00",
 		"frontierCompatibilityModeLimit": "0x118c30",
 		"maximumExtraDataSize": "0x20",
-		"tieBreakingGas": false,
 		"minGasLimit": "0x1388",
-		"gasLimitBoundDivisor": "0x0400",
-		"minimumDifficulty": "0x020000",
-		"difficultyBoundDivisor": "0x0800",
-		"durationLimit": "0x0d",
-		"blockReward": "0x4563918244F40000",
-		"registrar" : "0xc6d9d2cd449a754c494264e1809c50e34d64562b",
 		"networkID" : "0x1"
 	},
 	"genesis": {
-		"nonce": "0x0000000000000042",
+		"seal": {
+			"ethereum": {
+				"nonce": "0x0000000000000042",
+				"mixHash": "0x0000000000000000000000000000000000000000000000000000000000000000"
+			}
+		},
 		"difficulty": "0x400000000",
-		"mixHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
 		"author": "0x0000000000000000000000000000000000000000",
 		"timestamp": "0x00",
 		"parentHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
@@ -26,9 +35,9 @@
 		"gasLimit": "0x1388"
 	},
 	"accounts": {
-		"0000000000000000000000000000000000000001": { "builtin": { "name": "ecrecover", "linear": { "base": 3000, "word": 0 } } },
-		"0000000000000000000000000000000000000002": { "builtin": { "name": "sha256", "linear": { "base": 60, "word": 12 } } },
-		"0000000000000000000000000000000000000003": { "builtin": { "name": "ripemd160", "linear": { "base": 600, "word": 120 } } },
-		"0000000000000000000000000000000000000004": { "builtin": { "name": "identity", "linear": { "base": 15, "word": 3 } } }
+		"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

@@ -1,24 +1,33 @@
 {
-	"engineName": "Frontier (Test)",
-	"engineName": "Ethash",
+	"name": "Frontier (Test)",
+	"engine": {
+		"Ethash": {
+			"params": {
+				"tieBreakingGas": false,
+				"gasLimitBoundDivisor": "0x0400",
+				"minimumDifficulty": "0x020000",
+				"difficultyBoundDivisor": "0x0800",
+				"durationLimit": "0x0d",
+				"blockReward": "0x4563918244F40000",
+				"registrar" : "0xc6d9d2cd449a754c494264e1809c50e34d64562b"
+			}
+		}
+	},
 	"params": {
 		"accountStartNonce": "0x00",
 		"frontierCompatibilityModeLimit": "0xffffffffffffffff",
 		"maximumExtraDataSize": "0x20",
-		"tieBreakingGas": false,
 		"minGasLimit": "0x1388",
-		"gasLimitBoundDivisor": "0x0400",
-		"minimumDifficulty": "0x020000",
-		"difficultyBoundDivisor": "0x0800",
-		"durationLimit": "0x0d",
-		"blockReward": "0x4563918244F40000",
-		"registrar" : "0xc6d9d2cd449a754c494264e1809c50e34d64562b",
 		"networkID" : "0x1"
 	},
 	"genesis": {
-		"nonce": "0x0000000000000042",
+		"seal": {
+			"ethereum": {
+				"nonce": "0x0000000000000042",
+				"mixHash": "0x0000000000000000000000000000000000000000000000000000000000000000"
+			}
+		},
 		"difficulty": "0x400000000",
-		"mixHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
 		"author": "0x0000000000000000000000000000000000000000",
 		"timestamp": "0x00",
 		"parentHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
@@ -26,9 +35,9 @@
 		"gasLimit": "0x1388"
 	},
 	"accounts": {
-		"0000000000000000000000000000000000000001": { "builtin": { "name": "ecrecover", "linear": { "base": 3000, "word": 0 } } },
-		"0000000000000000000000000000000000000002": { "builtin": { "name": "sha256", "linear": { "base": 60, "word": 12 } } },
-		"0000000000000000000000000000000000000003": { "builtin": { "name": "ripemd160", "linear": { "base": 600, "word": 120 } } },
-		"0000000000000000000000000000000000000004": { "builtin": { "name": "identity", "linear": { "base": 15, "word": 3 } } }
+		"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/homestead_test.json

@@ -1,24 +1,33 @@
 {
 	"name": "Homestead (Test)",
-	"engineName": "Ethash",
+	"engine": {
+		"Ethash": {
+			"params": {
+				"tieBreakingGas": false,
+				"gasLimitBoundDivisor": "0x0400",
+				"minimumDifficulty": "0x020000",
+				"difficultyBoundDivisor": "0x0800",
+				"durationLimit": "0x0d",
+				"blockReward": "0x4563918244F40000",
+				"registrar" : "0xc6d9d2cd449a754c494264e1809c50e34d64562b"
+			}
+		}
+	},
 	"params": {
 		"accountStartNonce": "0x00",
 		"frontierCompatibilityModeLimit": 0,
 		"maximumExtraDataSize": "0x20",
 		"minGasLimit": "0x1388",
-		"tieBreakingGas": false,
-		"gasLimitBoundDivisor": "0x0400",
-		"minimumDifficulty": "0x020000",
-		"difficultyBoundDivisor": "0x0800",
-		"durationLimit": "0x0d",
-		"blockReward": "0x4563918244F40000",
-		"registrar" : "0xc6d9d2cd449a754c494264e1809c50e34d64562b",
 		"networkID" : "0x1"
 	},
 	"genesis": {
-		"nonce": "0x0000000000000042",
+		"seal": {
+			"ethereum": {
+				"nonce": "0x0000000000000042",
+				"mixHash": "0x0000000000000000000000000000000000000000000000000000000000000000"
+			}
+		},
 		"difficulty": "0x400000000",
-		"mixHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
 		"author": "0x0000000000000000000000000000000000000000",
 		"timestamp": "0x00",
 		"parentHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
@@ -26,9 +35,9 @@
 		"gasLimit": "0x1388"
 	},
 	"accounts": {
-		"0000000000000000000000000000000000000001": { "balance": "1", "builtin": { "name": "ecrecover", "linear": { "base": 3000, "word": 0 } } },
-		"0000000000000000000000000000000000000002": { "balance": "1", "builtin": { "name": "sha256", "linear": { "base": 60, "word": 12 } } },
-		"0000000000000000000000000000000000000003": { "balance": "1", "builtin": { "name": "ripemd160", "linear": { "base": 600, "word": 120 } } },
-		"0000000000000000000000000000000000000004": { "balance": "1", "builtin": { "name": "identity", "linear": { "base": 15, "word": 3 } } }
+		"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

@@ -1,24 +1,33 @@
 {
 	"name": "Morden",
-	"engineName": "Ethash",
+	"engine": {
+		"Ethash": {
+			"params": {
+				"tieBreakingGas": false,
+				"gasLimitBoundDivisor": "0x0400",
+				"minimumDifficulty": "0x020000",
+				"difficultyBoundDivisor": "0x0800",
+				"durationLimit": "0x0d",
+				"blockReward": "0x4563918244F40000",
+				"registrar": ""
+			}
+		}
+	},
 	"params": {
 		"accountStartNonce": "0x0100000",
 		"frontierCompatibilityModeLimit": "0x789b0",
 		"maximumExtraDataSize": "0x20",
-		"tieBreakingGas": false,
 		"minGasLimit": "0x1388",
-		"gasLimitBoundDivisor": "0x0400",
-		"minimumDifficulty": "0x020000",
-		"difficultyBoundDivisor": "0x0800",
-		"durationLimit": "0x0d",
-		"blockReward": "0x4563918244F40000",
-		"registrar": "",
 		"networkID" : "0x2"
 	},
 	"genesis": {
-		"nonce": "0x00006d6f7264656e",
+		"seal": {
+			"ethereum": {
+				"nonce": "0x00006d6f7264656e",
+				"mixHash": "0x00000000000000000000000000000000000000647572616c65787365646c6578"
+			}
+		},
 		"difficulty": "0x20000",
-		"mixHash": "0x00000000000000000000000000000000000000647572616c65787365646c6578",
 		"author": "0x0000000000000000000000000000000000000000",
 		"timestamp": "0x00",
 		"parentHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
@@ -29,10 +38,10 @@
 		"enode://b1217cbaa440e35ed471157123fe468e19e8b5ad5bedb4b1fdbcbdab6fb2f5ed3e95dd9c24a22a79fdb2352204cea207df27d92bfd21bfd41545e8b16f637499@104.44.138.37:30303"
 	],
 	"accounts": {
-		"0000000000000000000000000000000000000001": { "balance": "1", "nonce": "1048576", "builtin": { "name": "ecrecover", "linear": { "base": 3000, "word": 0 } } },
-		"0000000000000000000000000000000000000002": { "balance": "1", "nonce": "1048576", "builtin": { "name": "sha256", "linear": { "base": 60, "word": 12 } } },
-		"0000000000000000000000000000000000000003": { "balance": "1", "nonce": "1048576", "builtin": { "name": "ripemd160", "linear": { "base": 600, "word": 120 } } },
-		"0000000000000000000000000000000000000004": { "balance": "1", "nonce": "1048576", "builtin": { "name": "identity", "linear": { "base": 15, "word": 3 } } },
+		"0000000000000000000000000000000000000001": { "balance": "1", "nonce": "1048576", "builtin": { "name": "ecrecover", "pricing": { "linear": { "base": 3000, "word": 0 } } } },
+		"0000000000000000000000000000000000000002": { "balance": "1", "nonce": "1048576", "builtin": { "name": "sha256", "pricing": { "linear": { "base": 60, "word": 12 } } } },
+		"0000000000000000000000000000000000000003": { "balance": "1", "nonce": "1048576", "builtin": { "name": "ripemd160", "pricing": { "linear": { "base": 600, "word": 120 } } } },
+		"0000000000000000000000000000000000000004": { "balance": "1", "nonce": "1048576", "builtin": { "name": "identity", "pricing": { "linear": { "base": 15, "word": 3 } } } },
 		"102e61f5d8f9bc71d0ad4a084df4e65e05ce0e1c": { "balance": "1606938044258990275541962092341162602522202993782792835301376", "nonce": "1048576" }
 	}
 }

ethcore/res/ethereum/olympic.json

@@ -1,24 +1,33 @@
 {
 	"name": "Olympic",
-	"engineName": "Ethash",
+	"engine": {
+		"Ethash": {
+			"params": {
+				"tieBreakingGas": false,
+				"gasLimitBoundDivisor": "0x0400",
+				"minimumDifficulty": "0x020000",
+				"difficultyBoundDivisor": "0x0800",
+				"durationLimit": "0x08",
+				"blockReward": "0x14D1120D7B160000",
+				"registrar": "5e70c0bbcd5636e0f9f9316e9f8633feb64d4050"
+			}
+		}
+	},
 	"params": {
 		"accountStartNonce": "0x00",
 		"frontierCompatibilityModeLimit": "0xffffffffffffffff",
 		"maximumExtraDataSize": "0x0400",
-		"tieBreakingGas": false,
 		"minGasLimit": "125000",
-		"gasLimitBoundDivisor": "0x0400",
-		"minimumDifficulty": "0x020000",
-		"difficultyBoundDivisor": "0x0800",
-		"durationLimit": "0x08",
-		"blockReward": "0x14D1120D7B160000",
-		"registrar": "5e70c0bbcd5636e0f9f9316e9f8633feb64d4050",
 		"networkID" : "0x0"
 	},
 	"genesis": {
-		"nonce": "0x000000000000002a",
+		"seal": {
+			"ethereum": {
+				"nonce": "0x000000000000002a",
+				"mixHash": "0x0000000000000000000000000000000000000000000000000000000000000000"
+			}
+		},
 		"difficulty": "0x20000",
-		"mixHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
 		"author": "0x0000000000000000000000000000000000000000",
 		"timestamp": "0x00",
 		"parentHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
@@ -26,10 +35,10 @@
 		"gasLimit": "0x2fefd8"
 	},
 	"accounts": {
-		"0000000000000000000000000000000000000001": { "balance": "1", "builtin": { "name": "ecrecover", "linear": { "base": 3000, "word": 0 } } },
-		"0000000000000000000000000000000000000002": { "balance": "1", "builtin": { "name": "sha256", "linear": { "base": 60, "word": 12 } } },
-		"0000000000000000000000000000000000000003": { "balance": "1", "builtin": { "name": "ripemd160", "linear": { "base": 600, "word": 120 } } },
-		"0000000000000000000000000000000000000004": { "balance": "1", "builtin": { "name": "identity", "linear": { "base": 15, "word": 3 } } },
+		"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 } } } },
 		"dbdbdb2cbd23b783741e8d7fcf51e459b497e4a6": { "balance": "1606938044258990275541962092341162602522202993782792835301376" },
 		"e6716f9544a56c530d868e4bfbacb172315bdead": { "balance": "1606938044258990275541962092341162602522202993782792835301376" },
 		"b9c015918bdaba24b4ff057a92a3873d6eb201be": { "balance": "1606938044258990275541962092341162602522202993782792835301376" },

ethcore/res/null_homestead_morden.json

@@ -0,0 +1,34 @@
+{
+	"name": "Morden",
+	"engine": {
+		"Null": null
+	},
+	"params": {
+		"accountStartNonce": "0x0100000",
+		"frontierCompatibilityModeLimit": "0x0",
+		"maximumExtraDataSize": "0x20",
+		"minGasLimit": "0x1388",
+		"networkID" : "0x2"
+	},
+	"genesis": {
+		"seal": {
+			"ethereum": {
+				"nonce": "0x00006d6f7264656e",
+				"mixHash": "0x00000000000000000000000000000000000000647572616c65787365646c6578"
+			}
+		},
+		"difficulty": "0x20000",
+		"author": "0x0000000000000000000000000000000000000000",
+		"timestamp": "0x00",
+		"parentHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
+		"extraData": "0x",
+		"gasLimit": "0x2fefd8"
+	},
+	"accounts": {
+		"0000000000000000000000000000000000000001": { "balance": "1", "nonce": "1048576", "builtin": { "name": "ecrecover", "pricing": { "linear": { "base": 3000, "word": 0 } } } },
+		"0000000000000000000000000000000000000002": { "balance": "1", "nonce": "1048576", "builtin": { "name": "sha256", "pricing": { "linear": { "base": 60, "word": 12 } } } },
+		"0000000000000000000000000000000000000003": { "balance": "1", "nonce": "1048576", "builtin": { "name": "ripemd160", "pricing": { "linear": { "base": 600, "word": 120 } } } },
+		"0000000000000000000000000000000000000004": { "balance": "1", "nonce": "1048576", "builtin": { "name": "identity", "pricing": { "linear": { "base": 15, "word": 3 } } } },
+		"102e61f5d8f9bc71d0ad4a084df4e65e05ce0e1c": { "balance": "1606938044258990275541962092341162602522202993782792835301376", "nonce": "1048576" }
+	}
+}

ethcore/res/null_morden.json

@@ -1,24 +1,23 @@
 {
 	"name": "Morden",
-	"engineName": "NullEngine",
+	"engine": {
+		"Null": null
+	},
 	"params": {
 		"accountStartNonce": "0x0100000",
-		"frontierCompatibilityModeLimit": "0xfffa2990",
+		"frontierCompatibilityModeLimit": "0x789b0",
 		"maximumExtraDataSize": "0x20",
-		"tieBreakingGas": false,
 		"minGasLimit": "0x1388",
-		"gasLimitBoundDivisor": "0x0400",
-		"minimumDifficulty": "0x020000",
-		"difficultyBoundDivisor": "0x0800",
-		"durationLimit": "0x0d",
-		"blockReward": "0x4563918244F40000",
-		"registrar": "",
 		"networkID" : "0x2"
 	},
 	"genesis": {
-		"nonce": "0x00006d6f7264656e",
+		"seal": {
+			"ethereum": {
+				"nonce": "0x00006d6f7264656e",
+				"mixHash": "0x00000000000000000000000000000000000000647572616c65787365646c6578"
+			}
+		},
 		"difficulty": "0x20000",
-		"mixHash": "0x00000000000000000000000000000000000000647572616c65787365646c6578",
 		"author": "0x0000000000000000000000000000000000000000",
 		"timestamp": "0x00",
 		"parentHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
@@ -26,10 +25,10 @@
 		"gasLimit": "0x2fefd8"
 	},
 	"accounts": {
-		"0000000000000000000000000000000000000001": { "balance": "1", "nonce": "1048576", "builtin": { "name": "ecrecover", "linear": { "base": 3000, "word": 0 } } },
-		"0000000000000000000000000000000000000002": { "balance": "1", "nonce": "1048576", "builtin": { "name": "sha256", "linear": { "base": 60, "word": 12 } } },
-		"0000000000000000000000000000000000000003": { "balance": "1", "nonce": "1048576", "builtin": { "name": "ripemd160", "linear": { "base": 600, "word": 120 } } },
-		"0000000000000000000000000000000000000004": { "balance": "1", "nonce": "1048576", "builtin": { "name": "identity", "linear": { "base": 15, "word": 3 } } },
+		"0000000000000000000000000000000000000001": { "balance": "1", "nonce": "1048576", "builtin": { "name": "ecrecover", "pricing": { "linear": { "base": 3000, "word": 0 } } } },
+		"0000000000000000000000000000000000000002": { "balance": "1", "nonce": "1048576", "builtin": { "name": "sha256", "pricing": { "linear": { "base": 60, "word": 12 } } } },
+		"0000000000000000000000000000000000000003": { "balance": "1", "nonce": "1048576", "builtin": { "name": "ripemd160", "pricing": { "linear": { "base": 600, "word": 120 } } } },
+		"0000000000000000000000000000000000000004": { "balance": "1", "nonce": "1048576", "builtin": { "name": "identity", "pricing": { "linear": { "base": 15, "word": 3 } } } },
 		"102e61f5d8f9bc71d0ad4a084df4e65e05ce0e1c": { "balance": "1606938044258990275541962092341162602522202993782792835301376", "nonce": "1048576" }
 	}
 }

ethcore/src/account.rs

@@ -138,7 +138,7 @@ impl Account {
 	/// get someone who knows to call `note_code`.
 	pub fn code(&self) -> Option<&[u8]> {
 		match self.code_hash {
-			Some(SHA3_EMPTY) | None if self.code_cache.is_empty() => Some(&self.code_cache),
+			Some(c) if c == SHA3_EMPTY && self.code_cache.is_empty() => Some(&self.code_cache),
 			Some(_) if !self.code_cache.is_empty() => Some(&self.code_cache),
 			None => Some(&self.code_cache),
 			_ => None,

ethcore/src/action_params.rs

@@ -16,6 +16,7 @@
 
 //! Evm input params.
 use common::*;
+use ethjson;
 
 /// Transaction value
 #[derive(Clone, Debug)]
@@ -26,6 +27,15 @@ pub enum ActionValue {
 	Apparent(U256)
 }
 
+impl ActionValue {
+	/// Returns action value as U256.
+	pub fn value(&self) -> U256 {
+		match *self {
+			ActionValue::Transfer(x) | ActionValue::Apparent(x) => x
+		}
+	}
+}
+
 // TODO: should be a trait, possible to avoid cloning everything from a Transaction(/View).
 /// Action (call/create) input params. Everything else should be specified in Externalities.
 #[derive(Clone, Debug)]
@@ -67,3 +77,19 @@ impl Default for ActionParams {
 		}
 	}
 }
+
+impl From<ethjson::vm::Transaction> for ActionParams {
+	fn from(t: ethjson::vm::Transaction) -> Self {
+		ActionParams {
+			code_address: Address::new(),
+			address: t.address.into(),
+			sender: t.sender.into(),
+			origin: t.origin.into(),
+			code: Some(t.code.into()),
+			data: Some(t.data.into()),
+			gas: t.gas.into(),
+			gas_price: t.gas_price.into(),
+			value: ActionValue::Transfer(t.value.into()),
+		}
+	}
+}

ethcore/src/block.rs

@@ -22,9 +22,9 @@ use common::*;
 use engine::*;
 use state::*;
 use verification::PreverifiedBlock;
+use trace::Trace;
 
 /// A block, encoded as it is on the block chain.
-// TODO: rename to Block
 #[derive(Default, Debug, Clone)]
 pub struct Block {
 	/// The header of this block.
@@ -76,15 +76,14 @@ impl Decodable for Block {
 }
 
 /// Internal type for a block's common elements.
-// TODO: rename to ExecutedBlock
-// TODO: use BareBlock
-#[derive(Debug)]
+#[derive(Clone)]
 pub struct ExecutedBlock {
 	base: Block,
 
 	receipts: Vec<Receipt>,
 	transactions_set: HashSet<H256>,
 	state: State,
+	traces: Option<Vec<Trace>>,
 }
 
 /// A set of references to `ExecutedBlock` fields that are publicly accessible.
@@ -99,25 +98,64 @@ pub struct BlockRefMut<'a> {
 	pub receipts: &'a Vec<Receipt>,
 	/// State.
 	pub state: &'a mut State,
+	/// Traces.
+	pub traces: &'a Option<Vec<Trace>>,
+}
+
+/// A set of immutable references to `ExecutedBlock` fields that are publicly accessible.
+pub struct BlockRef<'a> {
+	/// Block header.
+	pub header: &'a Header,
+	/// Block transactions.
+	pub transactions: &'a Vec<SignedTransaction>,
+	/// Block uncles.
+	pub uncles: &'a Vec<Header>,
+	/// Transaction receipts.
+	pub receipts: &'a Vec<Receipt>,
+	/// State.
+	pub state: &'a State,
+	/// Traces.
+	pub traces: &'a Option<Vec<Trace>>,
 }
 
 impl ExecutedBlock {
 	/// Create a new block from the given `state`.
-	fn new(state: State) -> ExecutedBlock { ExecutedBlock { base: Default::default(), receipts: Default::default(), transactions_set: Default::default(), state: state } }
+	fn new(state: State, tracing: bool) -> ExecutedBlock {
+		ExecutedBlock {
+			base: Default::default(),
+			receipts: Default::default(),
+			transactions_set: Default::default(),
+			state: state,
+			traces: if tracing {Some(Vec::new())} else {None},
+		}
+	}
 
 	/// Get a structure containing individual references to all public fields.
-	pub fn fields(&mut self) -> BlockRefMut {
+	pub fn fields_mut(&mut self) -> BlockRefMut {
 		BlockRefMut {
 			header: &self.base.header,
 			transactions: &self.base.transactions,
 			uncles: &self.base.uncles,
 			state: &mut self.state,
 			receipts: &self.receipts,
+			traces: &self.traces,
+		}
+	}
+
+	/// Get a structure containing individual references to all public fields.
+	pub fn fields(&self) -> BlockRef {
+		BlockRef {
+			header: &self.base.header,
+			transactions: &self.base.transactions,
+			uncles: &self.base.uncles,
+			state: &self.state,
+			receipts: &self.receipts,
+			traces: &self.traces,
 		}
 	}
 }
 
-/// Trait for a object that is_a `ExecutedBlock`.
+/// Trait for a object that is a `ExecutedBlock`.
 pub trait IsBlock {
 	/// Get the block associated with this object.
 	fn block(&self) -> &ExecutedBlock;
@@ -134,6 +172,9 @@ pub trait IsBlock {
 	/// Get all information on receipts in this block.
 	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 }
+
 	/// Get all uncles in this block.
 	fn uncles(&self) -> &Vec<Header> { &self.block().base.uncles }
 }
@@ -152,28 +193,42 @@ pub struct OpenBlock<'x> {
 	last_hashes: LastHashes,
 }
 
-/// Just like OpenBlock, except that we've applied `Engine::on_close_block`, finished up the non-seal header fields,
+/// Just like `OpenBlock`, except that we've applied `Engine::on_close_block`, finished up the non-seal header fields,
 /// and collected the uncles.
 ///
 /// There is no function available to push a transaction.
+#[derive(Clone)]
 pub struct ClosedBlock {
 	block: ExecutedBlock,
 	uncle_bytes: Bytes,
+	last_hashes: LastHashes,
+	unclosed_state: State,
+}
+
+/// Just like `ClosedBlock` except that we can't reopen it and it's faster.
+///
+/// We actually store the post-`Engine::on_close_block` state, unlike in `ClosedBlock` where it's the pre.
+#[derive(Clone)]
+pub struct LockedBlock {
+	block: ExecutedBlock,
+	uncle_bytes: Bytes,
+	last_hashes: LastHashes,
 }
 
 /// A block that has a valid seal.
 ///
-/// The block's header has valid seal arguments. The block cannot be reversed into a ClosedBlock or OpenBlock.
+/// The block's header has valid seal arguments. The block cannot be reversed into a `ClosedBlock` or `OpenBlock`.
 pub struct SealedBlock {
 	block: ExecutedBlock,
 	uncle_bytes: Bytes,
 }
 
 impl<'x> OpenBlock<'x> {
-	/// Create a new OpenBlock ready for transaction pushing.
-	pub fn new(engine: &'x Engine, db: Box<JournalDB>, parent: &Header, last_hashes: LastHashes, author: Address, gas_floor_target: U256, extra_data: Bytes) -> Self {
+	#[cfg_attr(feature="dev", allow(too_many_arguments))]
+	/// Create a new `OpenBlock` ready for transaction pushing.
+	pub fn new(engine: &'x Engine, tracing: bool, db: Box<JournalDB>, parent: &Header, last_hashes: LastHashes, author: Address, gas_floor_target: U256, extra_data: Bytes) -> Self {
 		let mut r = OpenBlock {
-			block: ExecutedBlock::new(State::from_existing(db, parent.state_root().clone(), engine.account_start_nonce())),
+			block: ExecutedBlock::new(State::from_existing(db, parent.state_root().clone(), engine.account_start_nonce()), tracing),
 			engine: engine,
 			last_hashes: last_hashes,
 		};
@@ -247,22 +302,31 @@ impl<'x> OpenBlock<'x> {
 	///
 	/// If valid, it will be executed, and archived together with the receipt.
 	pub fn push_transaction(&mut self, t: SignedTransaction, h: Option<H256>) -> Result<&Receipt, Error> {
+		if self.block.transactions_set.contains(&t.hash()) {
+			return Err(From::from(TransactionError::AlreadyImported));
+		}
+
 		let env_info = self.env_info();
 //		info!("env_info says gas_used={}", env_info.gas_used);
-		match self.block.state.apply(&env_info, self.engine, &t) {
-			Ok(receipt) => {
+		match self.block.state.apply(&env_info, self.engine, &t, self.block.traces.is_some()) {
+			Ok(outcome) => {
 				self.block.transactions_set.insert(h.unwrap_or_else(||t.hash()));
 				self.block.base.transactions.push(t);
-				self.block.receipts.push(receipt);
+				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.receipts.push(outcome.receipt);
 				Ok(&self.block.receipts.last().unwrap())
 			}
 			Err(x) => Err(From::from(x))
 		}
 	}
 
-	/// Turn this into a `ClosedBlock`. A BlockChain must be provided in order to figure out the uncles.
+	/// Turn this into a `ClosedBlock`. A `BlockChain` must be provided in order to figure out the uncles.
 	pub fn close(self) -> ClosedBlock {
 		let mut s = self;
+
+		let unclosed_state = s.block.state.clone();
+
 		s.engine.on_close_block(&mut s.block);
 		s.block.base.header.transactions_root = ordered_trie_root(s.block.base.transactions.iter().map(|ref e| e.rlp_bytes().to_vec()).collect());
 		let uncle_bytes = s.block.base.uncles.iter().fold(RlpStream::new_list(s.block.base.uncles.len()), |mut s, u| {s.append_raw(&u.rlp(Seal::With), 1); s} ).out();
@@ -276,6 +340,29 @@ impl<'x> OpenBlock<'x> {
 		ClosedBlock {
 			block: s.block,
 			uncle_bytes: uncle_bytes,
+			last_hashes: s.last_hashes,
+			unclosed_state: unclosed_state,
+		}
+	}
+
+	/// Turn this into a `LockedBlock`. A BlockChain must be provided in order to figure out the uncles.
+	pub fn close_and_lock(self) -> LockedBlock {
+		let mut s = self;
+
+		s.engine.on_close_block(&mut s.block);
+		s.block.base.header.transactions_root = ordered_trie_root(s.block.base.transactions.iter().map(|ref e| e.rlp_bytes().to_vec()).collect());
+		let uncle_bytes = s.block.base.uncles.iter().fold(RlpStream::new_list(s.block.base.uncles.len()), |mut s, u| {s.append_raw(&u.rlp(Seal::With), 1); s} ).out();
+		s.block.base.header.uncles_hash = uncle_bytes.sha3();
+		s.block.base.header.state_root = s.block.state.root().clone();
+		s.block.base.header.receipts_root = ordered_trie_root(s.block.receipts.iter().map(|ref r| r.rlp_bytes().to_vec()).collect());
+		s.block.base.header.log_bloom = s.block.receipts.iter().fold(LogBloom::zero(), |mut b, r| {b = &b | &r.log_bloom; b}); //TODO: use |= operator
+		s.block.base.header.gas_used = s.block.receipts.last().map_or(U256::zero(), |r| r.gas_used);
+		s.block.base.header.note_dirty();
+
+		LockedBlock {
+			block: s.block,
+			uncle_bytes: uncle_bytes,
+			last_hashes: s.last_hashes,
 		}
 	}
 }
@@ -288,10 +375,40 @@ impl<'x> IsBlock for ClosedBlock {
 	fn block(&self) -> &ExecutedBlock { &self.block }
 }
 
+impl<'x> IsBlock for LockedBlock {
+	fn block(&self) -> &ExecutedBlock { &self.block }
+}
+
 impl ClosedBlock {
 	/// Get the hash of the header without seal arguments.
 	pub fn hash(&self) -> H256 { self.header().rlp_sha3(Seal::Without) }
 
+	/// Turn this into a `LockedBlock`, unable to be reopened again.
+	pub fn lock(self) -> LockedBlock {
+		LockedBlock {
+			block: self.block,
+			uncle_bytes: self.uncle_bytes,
+			last_hashes: self.last_hashes,
+		}
+	}
+
+	/// Given an engine reference, reopen the `ClosedBlock` into an `OpenBlock`.
+	pub fn reopen(self, engine: &Engine) -> OpenBlock {
+		// revert rewards (i.e. set state back at last transaction's state).
+		let mut block = self.block;
+		block.state = self.unclosed_state;
+		OpenBlock {
+			block: block,
+			engine: engine,
+			last_hashes: self.last_hashes,
+		}
+	}
+}
+
+impl LockedBlock {
+	/// Get the hash of the header without seal arguments.
+	pub fn hash(&self) -> H256 { self.header().rlp_sha3(Seal::Without) }
+
 	/// Provide a valid seal in order to turn this into a `SealedBlock`.
 	///
 	/// NOTE: This does not check the validity of `seal` with the engine.
@@ -307,7 +424,7 @@ impl ClosedBlock {
 	/// Provide a valid seal in order to turn this into a `SealedBlock`.
 	/// This does check the validity of `seal` with the engine.
 	/// Returns the `ClosedBlock` back again if the seal is no good.
-	pub fn try_seal(self, engine: &Engine, seal: Vec<Bytes>) -> Result<SealedBlock, ClosedBlock> {
+	pub fn try_seal(self, engine: &Engine, seal: Vec<Bytes>) -> Result<SealedBlock, LockedBlock> {
 		let mut s = self;
 		s.block.base.header.set_seal(seal);
 		match engine.verify_block_seal(&s.block.base.header) {
@@ -339,40 +456,41 @@ impl IsBlock for SealedBlock {
 }
 
 /// Enact the block given by block header, transactions and uncles
-pub fn enact(header: &Header, transactions: &[SignedTransaction], uncles: &[Header], engine: &Engine, db: Box<JournalDB>, parent: &Header, last_hashes: LastHashes) -> Result<ClosedBlock, Error> {
+#[cfg_attr(feature="dev", allow(too_many_arguments))]
+pub fn enact(header: &Header, transactions: &[SignedTransaction], uncles: &[Header], engine: &Engine, tracing: bool, db: Box<JournalDB>, parent: &Header, last_hashes: LastHashes) -> Result<LockedBlock, Error> {
 	{
 		if ::log::max_log_level() >= ::log::LogLevel::Trace {
-			let s = State::from_existing(db.spawn(), parent.state_root().clone(), engine.account_start_nonce());
+			let s = State::from_existing(db.boxed_clone(), parent.state_root().clone(), engine.account_start_nonce());
 			trace!("enact(): root={}, author={}, author_balance={}\n", s.root(), header.author(), s.balance(&header.author()));
 		}
 	}
 
-	let mut b = OpenBlock::new(engine, db, parent, last_hashes, header.author().clone(), x!(3141562), header.extra_data().clone());
+	let mut b = OpenBlock::new(engine, tracing, db, parent, last_hashes, header.author().clone(), x!(3141562), header.extra_data().clone());
 	b.set_difficulty(*header.difficulty());
 	b.set_gas_limit(*header.gas_limit());
 	b.set_timestamp(header.timestamp());
 	for t in transactions { try!(b.push_transaction(t.clone(), None)); }
 	for u in uncles { try!(b.push_uncle(u.clone())); }
-	Ok(b.close())
+	Ok(b.close_and_lock())
 }
 
 /// Enact the block given by `block_bytes` using `engine` on the database `db` with given `parent` block header
-pub fn enact_bytes(block_bytes: &[u8], engine: &Engine, db: Box<JournalDB>, parent: &Header, last_hashes: LastHashes) -> Result<ClosedBlock, Error> {
+pub fn enact_bytes(block_bytes: &[u8], engine: &Engine, tracing: bool, db: Box<JournalDB>, parent: &Header, last_hashes: LastHashes) -> Result<LockedBlock, Error> {
 	let block = BlockView::new(block_bytes);
 	let header = block.header();
-	enact(&header, &block.transactions(), &block.uncles(), engine, db, parent, last_hashes)
+	enact(&header, &block.transactions(), &block.uncles(), engine, tracing, db, parent, last_hashes)
 }
 
 /// Enact the block given by `block_bytes` using `engine` on the database `db` with given `parent` block header
-pub fn enact_verified(block: &PreverifiedBlock, engine: &Engine, db: Box<JournalDB>, parent: &Header, last_hashes: LastHashes) -> Result<ClosedBlock, Error> {
+pub fn enact_verified(block: &PreverifiedBlock, engine: &Engine, tracing: bool, db: Box<JournalDB>, parent: &Header, last_hashes: LastHashes) -> Result<LockedBlock, Error> {
 	let view = BlockView::new(&block.bytes);
-	enact(&block.header, &block.transactions, &view.uncles(), engine, db, parent, last_hashes)
+	enact(&block.header, &block.transactions, &view.uncles(), engine, tracing, db, parent, last_hashes)
 }
 
 /// Enact the block given by `block_bytes` using `engine` on the database `db` with given `parent` block header. Seal the block aferwards
-pub fn enact_and_seal(block_bytes: &[u8], engine: &Engine, db: Box<JournalDB>, parent: &Header, last_hashes: LastHashes) -> Result<SealedBlock, Error> {
+pub fn enact_and_seal(block_bytes: &[u8], engine: &Engine, tracing: bool, db: Box<JournalDB>, parent: &Header, last_hashes: LastHashes) -> Result<SealedBlock, Error> {
 	let header = BlockView::new(block_bytes).header_view();
-	Ok(try!(try!(enact_bytes(block_bytes, engine, db, parent, last_hashes)).seal(engine, header.seal())))
+	Ok(try!(try!(enact_bytes(block_bytes, engine, tracing, db, parent, last_hashes)).seal(engine, header.seal())))
 }
 
 #[cfg(test)]
@@ -380,39 +498,40 @@ mod tests {
 	use tests::helpers::*;
 	use super::*;
 	use common::*;
-	use engine::*;
 
 	#[test]
 	fn open_block() {
 		use spec::*;
-		let engine = Spec::new_test().to_engine().unwrap();
-		let genesis_header = engine.spec().genesis_header();
+		let spec = Spec::new_test();
+		let engine = &spec.engine;
+		let genesis_header = spec.genesis_header();
 		let mut db_result = get_temp_journal_db();
 		let mut db = db_result.take();
-		engine.spec().ensure_db_good(db.as_hashdb_mut());
+		spec.ensure_db_good(db.as_hashdb_mut());
 		let last_hashes = vec![genesis_header.hash()];
-		let b = OpenBlock::new(engine.deref(), db, &genesis_header, last_hashes, Address::zero(), x!(3141562), vec![]);
-		let b = b.close();
+		let b = OpenBlock::new(engine.deref(), false, db, &genesis_header, last_hashes, Address::zero(), x!(3141562), vec![]);
+		let b = b.close_and_lock();
 		let _ = b.seal(engine.deref(), vec![]);
 	}
 
 	#[test]
 	fn enact_block() {
 		use spec::*;
-		let engine = Spec::new_test().to_engine().unwrap();
-		let genesis_header = engine.spec().genesis_header();
+		let spec = Spec::new_test();
+		let engine = &spec.engine;
+		let genesis_header = spec.genesis_header();
 
 		let mut db_result = get_temp_journal_db();
 		let mut db = db_result.take();
-		engine.spec().ensure_db_good(db.as_hashdb_mut());
-		let b = OpenBlock::new(engine.deref(), db, &genesis_header, vec![genesis_header.hash()], Address::zero(), x!(3141562), vec![]).close().seal(engine.deref(), vec![]).unwrap();
+		spec.ensure_db_good(db.as_hashdb_mut());
+		let b = OpenBlock::new(engine.deref(), false, db, &genesis_header, vec![genesis_header.hash()], Address::zero(), x!(3141562), vec![]).close_and_lock().seal(engine.deref(), vec![]).unwrap();
 		let orig_bytes = b.rlp_bytes();
 		let orig_db = b.drain();
 
 		let mut db_result = get_temp_journal_db();
 		let mut db = db_result.take();
-		engine.spec().ensure_db_good(db.as_hashdb_mut());
-		let e = enact_and_seal(&orig_bytes, engine.deref(), db, &genesis_header, vec![genesis_header.hash()]).unwrap();
+		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()]).unwrap();
 
 		assert_eq!(e.rlp_bytes(), orig_bytes);
 
@@ -424,28 +543,29 @@ mod tests {
 	#[test]
 	fn enact_block_with_uncle() {
 		use spec::*;
-		let engine = Spec::new_test().to_engine().unwrap();
-		let genesis_header = engine.spec().genesis_header();
+		let spec = Spec::new_test();
+		let engine = &spec.engine;
+		let genesis_header = spec.genesis_header();
 
 		let mut db_result = get_temp_journal_db();
 		let mut db = db_result.take();
-		engine.spec().ensure_db_good(db.as_hashdb_mut());
-		let mut open_block = OpenBlock::new(engine.deref(), db, &genesis_header, vec![genesis_header.hash()], Address::zero(), x!(3141562), vec![]);
+		spec.ensure_db_good(db.as_hashdb_mut());
+		let mut open_block = OpenBlock::new(engine.deref(), false, db, &genesis_header, vec![genesis_header.hash()], Address::zero(), x!(3141562), vec![]);
 		let mut uncle1_header = Header::new();
 		uncle1_header.extra_data = b"uncle1".to_vec();
 		let mut uncle2_header = Header::new();
 		uncle2_header.extra_data = b"uncle2".to_vec();
 		open_block.push_uncle(uncle1_header).unwrap();
 		open_block.push_uncle(uncle2_header).unwrap();
-		let b = open_block.close().seal(engine.deref(), vec![]).unwrap();
-		
+		let b = open_block.close_and_lock().seal(engine.deref(), vec![]).unwrap();
+
 		let orig_bytes = b.rlp_bytes();
 		let orig_db = b.drain();
 
 		let mut db_result = get_temp_journal_db();
 		let mut db = db_result.take();
-		engine.spec().ensure_db_good(db.as_hashdb_mut());
-		let e = enact_and_seal(&orig_bytes, engine.deref(), db, &genesis_header, vec![genesis_header.hash()]).unwrap();
+		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()]).unwrap();
 
 		let bytes = e.rlp_bytes();
 		assert_eq!(bytes, orig_bytes);

ethcore/src/block_queue.rs

@@ -14,7 +14,7 @@
 // You should have received a copy of the GNU General Public License
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
-//! A queue of blocks. Sits between network or other I/O and the BlockChain.
+//! A queue of blocks. Sits between network or other I/O and the `BlockChain`.
 //! Sorts them ready for blockchain insertion.
 use std::thread::{JoinHandle, self};
 use std::sync::atomic::{AtomicBool, Ordering as AtomicOrdering};
@@ -89,7 +89,7 @@ impl BlockQueueInfo {
 	}
 }
 
-/// A queue of blocks. Sits between network or other I/O and the BlockChain.
+/// A queue of blocks. Sits between network or other I/O and the `BlockChain`.
 /// Sorts them ready for blockchain insertion.
 pub struct BlockQueue {
 	panic_handler: Arc<PanicHandler>,
@@ -116,6 +116,7 @@ struct VerifyingBlock {
 }
 
 struct QueueSignal {
+	deleting: Arc<AtomicBool>,
 	signalled: AtomicBool,
 	message_channel: IoChannel<NetSyncMessage>,
 }
@@ -123,10 +124,16 @@ struct QueueSignal {
 impl QueueSignal {
 	#[cfg_attr(feature="dev", allow(bool_comparison))]
 	fn set(&self) {
+		// Do not signal when we are about to close
+		if self.deleting.load(AtomicOrdering::Relaxed) {
+			return;
+		}
+
 		if self.signalled.compare_and_swap(false, true, AtomicOrdering::Relaxed) == false {
 			self.message_channel.send(UserMessage(SyncMessage::BlockVerified)).expect("Error sending BlockVerified message");
 		}
 	}
+
 	fn reset(&self) {
 		self.signalled.store(false, AtomicOrdering::Relaxed);
 	}
@@ -150,8 +157,12 @@ impl BlockQueue {
 			bad: Mutex::new(HashSet::new()),
 		});
 		let more_to_verify = Arc::new(Condvar::new());
-		let ready_signal = Arc::new(QueueSignal { signalled: AtomicBool::new(false), message_channel: message_channel });
 		let deleting = Arc::new(AtomicBool::new(false));
+		let ready_signal = Arc::new(QueueSignal {
+			deleting: deleting.clone(),
+			signalled: AtomicBool::new(false),
+			message_channel: message_channel
+		});
 		let empty = Arc::new(Condvar::new());
 		let panic_handler = PanicHandler::new_in_arc();
 
@@ -431,12 +442,14 @@ impl MayPanic for BlockQueue {
 
 impl Drop for BlockQueue {
 	fn drop(&mut self) {
+		trace!(target: "shutdown", "[BlockQueue] Closing...");
 		self.clear();
 		self.deleting.store(true, AtomicOrdering::Release);
 		self.more_to_verify.notify_all();
 		for t in self.verifiers.drain(..) {
 			t.join().unwrap();
 		}
+		trace!(target: "shutdown", "[BlockQueue] Closed.");
 	}
 }
 
@@ -451,7 +464,7 @@ mod tests {
 
 	fn get_test_queue() -> BlockQueue {
 		let spec = get_test_spec();
-		let engine = spec.to_engine().unwrap();
+		let engine = spec.engine;
 		BlockQueue::new(BlockQueueConfig::default(), Arc::new(engine), IoChannel::disconnected())
 	}
 
@@ -459,7 +472,7 @@ mod tests {
 	fn can_be_created() {
 		// TODO better test
 		let spec = Spec::new_test();
-		let engine = spec.to_engine().unwrap();
+		let engine = spec.engine;
 		let _ = BlockQueue::new(BlockQueueConfig::default(), Arc::new(engine), IoChannel::disconnected());
 	}
 
@@ -520,7 +533,7 @@ mod tests {
 	#[test]
 	fn test_mem_limit() {
 		let spec = get_test_spec();
-		let engine = spec.to_engine().unwrap();
+		let engine = spec.engine;
 		let mut config = BlockQueueConfig::default();
 		config.max_mem_use = super::MIN_MEM_LIMIT;  // empty queue uses about 15000
 		let queue = BlockQueue::new(config, Arc::new(engine), IoChannel::disconnected());

ethcore/src/blockchain/block_info.rs

@@ -17,6 +17,8 @@
 use util::numbers::{U256,H256};
 use header::BlockNumber;
 
+use util::bytes::{FromRawBytesVariable, FromBytesError, ToBytesWithMap};
+
 /// Brief info about inserted block.
 #[derive(Clone)]
 pub struct BlockInfo {
@@ -40,12 +42,55 @@ pub enum BlockLocation {
 	/// It's part of the fork which should become canon chain,
 	/// because it's total difficulty is higher than current
 	/// canon chain difficulty.
-	BranchBecomingCanonChain {
-		/// Hash of the newest common ancestor with old canon chain.
-		ancestor: H256,
-		/// Hashes of the blocks between ancestor and this block.
-		enacted: Vec<H256>,
-		/// Hashes of the blocks which were invalidated.
-		retracted: Vec<H256>,
+	BranchBecomingCanonChain(BranchBecomingCanonChainData),
+}
+
+#[derive(Clone)]
+pub struct BranchBecomingCanonChainData {
+	/// Hash of the newest common ancestor with old canon chain.
+	pub ancestor: H256,
+	/// Hashes of the blocks between ancestor and this block.
+	pub enacted: Vec<H256>,
+	/// Hashes of the blocks which were invalidated.
+	pub retracted: Vec<H256>,
+}
+
+impl FromRawBytesVariable for BranchBecomingCanonChainData {
+	fn from_bytes_variable(bytes: &[u8]) -> Result<BranchBecomingCanonChainData, FromBytesError> {
+		type Tuple = (Vec<H256>, Vec<H256>, H256);
+		let (enacted, retracted, ancestor) = try!(Tuple::from_bytes_variable(bytes));
+		Ok(BranchBecomingCanonChainData { ancestor: ancestor, enacted: enacted, retracted: retracted })
+	}
+}
+
+impl FromRawBytesVariable for BlockLocation {
+	fn from_bytes_variable(bytes: &[u8]) -> Result<BlockLocation, FromBytesError> {
+		match bytes[0] {
+			0 => Ok(BlockLocation::CanonChain),
+			1 => Ok(BlockLocation::Branch),
+			2 => Ok(BlockLocation::BranchBecomingCanonChain(
+				try!(BranchBecomingCanonChainData::from_bytes_variable(&bytes[1..bytes.len()])))),
+			_ => Err(FromBytesError::UnknownMarker)
+		}
+	}
+}
+
+impl ToBytesWithMap for BranchBecomingCanonChainData {
+	fn to_bytes_map(&self) -> Vec<u8> {
+		(&self.enacted, &self.retracted, &self.ancestor).to_bytes_map()
+	}
+}
+
+impl ToBytesWithMap for BlockLocation {
+	fn to_bytes_map(&self) -> Vec<u8> {
+		match *self {
+			BlockLocation::CanonChain => vec![0u8],
+			BlockLocation::Branch => vec![1u8],
+			BlockLocation::BranchBecomingCanonChain(ref data) => {
+				let mut bytes = (&data.enacted, &data.retracted, &data.ancestor).to_bytes_map();
+				bytes.insert(0, 2u8);
+				bytes
+			}
+		}
 	}
 }

ethcore/src/blockchain/blockchain.rs

@@ -24,12 +24,13 @@ use transaction::*;
 use views::*;
 use receipt::Receipt;
 use chainfilter::{ChainFilter, BloomIndex, FilterDataSource};
-use blockchain::block_info::{BlockInfo, BlockLocation};
+use blockchain::block_info::{BlockInfo, BlockLocation, BranchBecomingCanonChainData};
 use blockchain::best_block::BestBlock;
 use blockchain::bloom_indexer::BloomIndexer;
 use blockchain::tree_route::TreeRoute;
 use blockchain::update::ExtrasUpdate;
 use blockchain::{CacheSize, ImportRoute};
+use db::{Writable, Readable, Key, CacheUpdatePolicy};
 
 const BLOOM_INDEX_SIZE: usize = 16;
 const BLOOM_LEVELS: u8 = 3;
@@ -100,6 +101,11 @@ pub trait BlockProvider {
 		self.block(&address.block_hash).and_then(|bytes| BlockView::new(&bytes).localized_transaction_at(address.index))
 	}
 
+	/// Get transaction receipt.
+	fn transaction_receipt(&self, address: &TransactionAddress) -> Option<Receipt> {
+		self.block_receipts(&address.block_hash).and_then(|br| br.receipts.into_iter().nth(address.index))
+	}
+
 	/// Get a list of transactions for a given block.
 	/// Returns None if block does not exist.
 	fn transactions(&self, hash: &H256) -> Option<Vec<LocalizedTransaction>> {
@@ -174,7 +180,7 @@ impl BlockProvider for BlockChain {
 	/// Returns true if the given block is known
 	/// (though not necessarily a part of the canon chain).
 	fn is_known(&self, hash: &H256) -> bool {
-		self.query_extras_exist(hash, &self.block_details)
+		self.extras_db.exists_with_cache(&self.block_details, hash)
 	}
 
 	/// Get raw block data
@@ -303,8 +309,8 @@ impl BlockChain {
 				bc.blocks_db.put(&hash, genesis).unwrap();
 
 				let batch = DBTransaction::new();
-				batch.put_extras(&hash, &details);
-				batch.put_extras(&header.number(), &hash);
+				batch.write(&hash, &details);
+				batch.write(&header.number(), &hash);
 				batch.put(b"best", &hash).unwrap();
 				bc.extras_db.write(batch).unwrap();
 
@@ -416,6 +422,7 @@ impl BlockChain {
 		}
 	}
 
+	#[cfg_attr(feature="dev", allow(similar_names))]
 	/// Inserts the block into backing cache database.
 	/// Expects the block to be valid and already verified.
 	/// If the block is already known, does nothing.
@@ -453,28 +460,22 @@ impl BlockChain {
 		batch.put(b"best", &update.info.hash).unwrap();
 
 		{
-			let mut write_details = self.block_details.write().unwrap();
-			for (hash, details) in update.block_details.into_iter() {
-				batch.put_extras(&hash, &details);
-				self.note_used(CacheID::Extras(ExtrasIndex::BlockDetails, hash.clone()));
-				write_details.insert(hash, details);
+			for hash in update.block_details.keys().cloned() {
+				self.note_used(CacheID::Extras(ExtrasIndex::BlockDetails, hash));
 			}
+
+			let mut write_details = self.block_details.write().unwrap();
+			batch.extend_with_cache(&mut write_details, update.block_details, CacheUpdatePolicy::Overwrite);
 		}
 
 		{
 			let mut write_receipts = self.block_receipts.write().unwrap();
-			for (hash, receipt) in &update.block_receipts {
-				batch.put_extras(hash, receipt);
-				write_receipts.remove(hash);
-			}
+			batch.extend_with_cache(&mut write_receipts, update.block_receipts, CacheUpdatePolicy::Remove);
 		}
 
 		{
 			let mut write_blocks_blooms = self.blocks_blooms.write().unwrap();
-			for (bloom_hash, blocks_bloom) in &update.blocks_blooms {
-				batch.put_extras(bloom_hash, blocks_bloom);
-				write_blocks_blooms.remove(bloom_hash);
-			}
+			batch.extend_with_cache(&mut write_blocks_blooms, update.blocks_blooms, CacheUpdatePolicy::Remove);
 		}
 
 		// These cached values must be updated last and togeterh
@@ -495,15 +496,8 @@ impl BlockChain {
 				}
 			}
 
-			for (number, hash) in &update.block_hashes {
-				batch.put_extras(number, hash);
-				write_hashes.remove(number);
-			}
-
-			for (hash, tx_address) in &update.transactions_addresses {
-				batch.put_extras(hash, tx_address);
-				write_txs.remove(hash);
-			}
+			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();
@@ -541,7 +535,7 @@ impl BlockChain {
 		Some(ret)
 	}
 
-	/// Get inserted block info which is critical to preapre extras updates.
+	/// Get inserted block info which is critical to prepare extras updates.
 	fn block_info(&self, block_bytes: &[u8]) -> BlockInfo {
 		let block = BlockView::new(block_bytes);
 		let header = block.header_view();
@@ -570,11 +564,11 @@ impl BlockChain {
 					_ => {
 						let retracted = route.blocks.iter().take(route.index).cloned().collect::<Vec<H256>>();
 
-						BlockLocation::BranchBecomingCanonChain {
+						BlockLocation::BranchBecomingCanonChain(BranchBecomingCanonChainData {
 							ancestor: route.ancestor,
 							enacted: route.blocks.into_iter().skip(route.index).collect(),
 							retracted: retracted.into_iter().rev().collect(),
-						}
+						})
 					}
 				}
 			} else {
@@ -595,11 +589,11 @@ impl BlockChain {
 			BlockLocation::CanonChain => {
 				block_hashes.insert(number, info.hash.clone());
 			},
-			BlockLocation::BranchBecomingCanonChain { ref ancestor, ref enacted, .. } => {
-				let ancestor_number = self.block_number(ancestor).unwrap();
+			BlockLocation::BranchBecomingCanonChain(ref data) => {
+				let ancestor_number = self.block_number(&data.ancestor).unwrap();
 				let start_number = ancestor_number + 1;
 
-				for (index, hash) in enacted.iter().cloned().enumerate() {
+				for (index, hash) in data.enacted.iter().cloned().enumerate() {
 					block_hashes.insert(start_number + index as BlockNumber, hash);
 				}
 
@@ -684,11 +678,11 @@ impl BlockChain {
 				ChainFilter::new(self, self.bloom_indexer.index_size(), self.bloom_indexer.levels())
 					.add_bloom(&header.log_bloom(), header.number() as usize)
 			},
-			BlockLocation::BranchBecomingCanonChain { ref ancestor, ref enacted, .. } => {
-				let ancestor_number = self.block_number(ancestor).unwrap();
+			BlockLocation::BranchBecomingCanonChain(ref data) => {
+				let ancestor_number = self.block_number(&data.ancestor).unwrap();
 				let start_number = ancestor_number + 1;
 
-				let mut blooms: Vec<H2048> = enacted.iter()
+				let mut blooms: Vec<H2048> = data.enacted.iter()
 					.map(|hash| self.block(hash).unwrap())
 					.map(|bytes| BlockView::new(&bytes).header_view().log_bloom())
 					.collect();
@@ -734,38 +728,13 @@ impl BlockChain {
 		self.query_extras(hash, &self.blocks_blooms)
 	}
 
-	fn query_extras<K, T>(&self, hash: &K, cache: &RwLock<HashMap<K, T>>) -> Option<T> where
-		T: Clone + Decodable + ExtrasIndexable,
-		K: ExtrasSliceConvertable + Eq + Hash + Clone {
-		{
-			let read = cache.read().unwrap();
-			if let Some(v) = read.get(hash) {
-				return Some(v.clone());
-			}
-		}
-
-		if let Some(h) = hash.as_h256() {
-			self.note_used(CacheID::Extras(T::extras_index(), h.clone()));
-		}
-
-		self.extras_db.get_extras(hash).map(| t: T | {
-			let mut write = cache.write().unwrap();
-			write.insert(hash.clone(), t.clone());
-			t
-		})
-	}
-
-	fn query_extras_exist<K, T>(&self, hash: &K, cache: &RwLock<HashMap<K, T>>) -> bool where
-		K: ExtrasSliceConvertable + Eq + Hash + Clone,
-		T: ExtrasIndexable {
-		{
-			let read = cache.read().unwrap();
-			if let Some(_) = read.get(hash) {
-				return true;
-			}
-		}
-
-		self.extras_db.extras_exists::<_, T>(hash)
+	fn query_extras<K, T, R>(&self, hash: &K, cache: &RwLock<HashMap<K, T>>) -> Option<T> where
+		T: ExtrasIndexable + Clone + Decodable,
+		K: Key<T, Target = R> + Eq + Hash + Clone,
+		R: Deref<Target = [u8]>,
+		H256: From<K> {
+		self.note_used(CacheID::Extras(T::index(), H256::from(hash.clone())));
+		self.extras_db.read_with_cache(cache, hash)
 	}
 
 	/// Get current cache size.
@@ -819,7 +788,8 @@ impl BlockChain {
 						CacheID::Extras(ExtrasIndex::BlockLogBlooms, h) => { block_logs.remove(&h); },
 						CacheID::Extras(ExtrasIndex::BlocksBlooms, h) => { blocks_blooms.remove(&h); },
 						CacheID::Extras(ExtrasIndex::BlockReceipts, h) => { block_receipts.remove(&h); },
-						_ => panic!(),
+						// TODO: debris, temporary fix
+						CacheID::Extras(ExtrasIndex::BlockHash, _) => { },
 					}
 				}
 				cache_man.cache_usage.push_front(HashSet::new());
@@ -844,6 +814,7 @@ impl BlockChain {
 
 #[cfg(test)]
 mod tests {
+	#![cfg_attr(feature="dev", allow(similar_names))]
 	use std::str::FromStr;
 	use rustc_serialize::hex::FromHex;
 	use util::hash::*;
@@ -974,21 +945,25 @@ mod tests {
 		assert_eq!(ir1, ImportRoute {
 			enacted: vec![b1_hash],
 			retracted: vec![],
+			omitted: vec![],
 		});
 
 		assert_eq!(ir2, ImportRoute {
 			enacted: vec![b2_hash],
 			retracted: vec![],
+			omitted: vec![],
 		});
 
 		assert_eq!(ir3b, ImportRoute {
 			enacted: vec![b3b_hash],
 			retracted: vec![],
+			omitted: vec![],
 		});
 
 		assert_eq!(ir3a, ImportRoute {
 			enacted: vec![b3a_hash],
 			retracted: vec![b3b_hash],
+			omitted: vec![],
 		});
 
 		assert_eq!(bc.best_block_hash(), best_block_hash);

ethcore/src/blockchain/import_route.rs

@@ -26,6 +26,8 @@ pub struct ImportRoute {
 	pub retracted: Vec<H256>,
 	/// Blocks that were validated by new block.
 	pub enacted: Vec<H256>,
+	/// Blocks which are neither retracted nor enacted.
+	pub omitted: Vec<H256>,
 }
 
 impl ImportRoute {
@@ -33,6 +35,7 @@ impl ImportRoute {
 		ImportRoute {
 			retracted: vec![],
 			enacted: vec![],
+			omitted: vec![],
 		}
 	}
 }
@@ -43,13 +46,19 @@ impl From<BlockInfo> for ImportRoute {
 			BlockLocation::CanonChain => ImportRoute {
 				retracted: vec![],
 				enacted: vec![info.hash],
+				omitted: vec![],
 			},
-			BlockLocation::Branch => ImportRoute::none(),
-			BlockLocation::BranchBecomingCanonChain { mut enacted, retracted, .. } => {
-				enacted.push(info.hash);
+			BlockLocation::Branch => ImportRoute {
+				retracted: vec![],
+				enacted: vec![],
+				omitted: vec![info.hash],
+			},
+			BlockLocation::BranchBecomingCanonChain(mut data) => {
+				data.enacted.push(info.hash);
 				ImportRoute {
-					retracted: retracted,
-					enacted: enacted,
+					retracted: data.retracted,
+					enacted: data.enacted,
+					omitted: vec![],
 				}
 			}
 		}
@@ -60,7 +69,7 @@ impl From<BlockInfo> for ImportRoute {
 mod tests {
 	use util::hash::H256;
 	use util::numbers::U256;
-	use blockchain::block_info::{BlockInfo, BlockLocation};
+	use blockchain::block_info::{BlockInfo, BlockLocation, BranchBecomingCanonChainData};
 	use blockchain::ImportRoute;
 
 	#[test]
@@ -68,6 +77,7 @@ mod tests {
 		assert_eq!(ImportRoute::none(), ImportRoute {
 			enacted: vec![],
 			retracted: vec![],
+			omitted: vec![],
 		});
 	}
 
@@ -80,7 +90,11 @@ mod tests {
 			location: BlockLocation::Branch,
 		};
 
-		assert_eq!(ImportRoute::from(info), ImportRoute::none());
+		assert_eq!(ImportRoute::from(info), ImportRoute {
+			retracted: vec![],
+			enacted: vec![],
+			omitted: vec![H256::from(U256::from(1))],
+		});
 	}
 
 	#[test]
@@ -95,6 +109,7 @@ mod tests {
 		assert_eq!(ImportRoute::from(info), ImportRoute {
 			retracted: vec![],
 			enacted: vec![H256::from(U256::from(1))],
+			omitted: vec![],
 		});
 	}
 
@@ -104,16 +119,17 @@ mod tests {
 			hash: H256::from(U256::from(2)),
 			number: 0,
 			total_difficulty: U256::from(0),
-			location: BlockLocation::BranchBecomingCanonChain {
-			ancestor: H256::from(U256::from(0)),
+			location: BlockLocation::BranchBecomingCanonChain(BranchBecomingCanonChainData {
+				ancestor: H256::from(U256::from(0)),
 				enacted: vec![H256::from(U256::from(1))],
 				retracted: vec![H256::from(U256::from(3)), H256::from(U256::from(4))],
-			}
+			})
 		};
 
 		assert_eq!(ImportRoute::from(info), ImportRoute {
 			retracted: vec![H256::from(U256::from(3)), H256::from(U256::from(4))],
 			enacted: vec![H256::from(U256::from(1)), H256::from(U256::from(2))],
+			omitted: vec![],
 		});
 	}
 }

ethcore/src/builtin.rs

@@ -18,8 +18,9 @@ use util::*;
 use crypto::sha2::Sha256;
 use crypto::ripemd160::Ripemd160;
 use crypto::digest::Digest;
+use ethjson;
 
-/// Definition of a contract whose implementation is built-in. 
+/// Definition of a contract whose implementation is built-in.
 pub struct Builtin {
 	/// The gas cost of running this built-in for the given size of input data.
 	pub cost: Box<Fn(usize) -> U256>,	// TODO: U256 should be bignum.
@@ -46,13 +47,12 @@ impl Builtin {
 	}
 
 	/// Create a new object from a builtin-function name with a linear cost associated with input size.
-	pub fn from_named_linear(name: &str, base_cost: usize, word_cost: usize) -> Option<Builtin> {
-		new_builtin_exec(name).map(|b| {
-			let cost = Box::new(move|s: usize| -> U256 {
-				U256::from(base_cost) + U256::from(word_cost) * U256::from((s + 31) / 32)
-			});
-			Self::new(cost, b)
-		})
+	pub fn from_named_linear(name: &str, base_cost: usize, word_cost: usize) -> Builtin {
+		let cost = Box::new(move|s: usize| -> U256 {
+			U256::from(base_cost) + U256::from(word_cost) * U256::from((s + 31) / 32)
+		});
+
+		Self::new(cost, new_builtin_exec(name))
 	}
 
 	/// Simple forwarder for cost.
@@ -60,22 +60,15 @@ impl Builtin {
 
 	/// Simple forwarder for execute.
 	pub fn execute(&self, input: &[u8], output: &mut[u8]) { (*self.execute)(input, output); }
+}
 
-	/// Create a builtin from JSON.
-	///
-	/// JSON must be of the form `{ "name": "identity", "linear": {"base": 10, "word": 20} }`.
-	pub fn from_json(json: &Json) -> Option<Builtin> {
-		// NICE: figure out a more convenient means of handing errors here.
-		if let Json::String(ref name) = json["name"] {
-			if let Json::Object(ref o) = json["linear"] {
-				if let Json::U64(ref word) = o["word"] {
-					if let Json::U64(ref base) = o["base"] {
-						return Self::from_named_linear(&name[..], *base as usize, *word as usize);
-					}
-				}
+impl From<ethjson::spec::Builtin> for Builtin {
+	fn from(b: ethjson::spec::Builtin) -> Self {
+		match b.pricing {
+			ethjson::spec::Pricing::Linear(linear) => {
+				Self::from_named_linear(b.name.as_ref(), linear.base, linear.word)
 			}
 		}
-		None
 	}
 }
 
@@ -90,14 +83,14 @@ pub fn copy_to(src: &[u8], dest: &mut[u8]) {
 
 /// Create a new builtin executor according to `name`.
 /// TODO: turn in to a factory with dynamic registration.
-pub fn new_builtin_exec(name: &str) -> Option<Box<Fn(&[u8], &mut [u8])>> {
+pub fn new_builtin_exec(name: &str) -> Box<Fn(&[u8], &mut [u8])> {
 	match name {
-		"identity" => Some(Box::new(move|input: &[u8], output: &mut[u8]| {
+		"identity" => Box::new(move|input: &[u8], output: &mut[u8]| {
 			for i in 0..min(input.len(), output.len()) {
 				output[i] = input[i];
 			}
-		})),
-		"ecrecover" => Some(Box::new(move|input: &[u8], output: &mut[u8]| {
+		}),
+		"ecrecover" => Box::new(move|input: &[u8], output: &mut[u8]| {
 			#[repr(packed)]
 			#[derive(Debug)]
 			struct InType {
@@ -120,8 +113,8 @@ pub fn new_builtin_exec(name: &str) -> Option<Box<Fn(&[u8], &mut [u8])>> {
 					}
 				}
 			}
-		})),
-		"sha256" => Some(Box::new(move|input: &[u8], output: &mut[u8]| {
+		}),
+		"sha256" => Box::new(move|input: &[u8], output: &mut[u8]| {
 			let mut sha = Sha256::new();
 			sha.input(input);
 			if output.len() >= 32 {
@@ -131,21 +124,23 @@ pub fn new_builtin_exec(name: &str) -> Option<Box<Fn(&[u8], &mut [u8])>> {
 				sha.result(ret.as_slice_mut());
 				copy_to(&ret, output);
 			}
-		})),
-		"ripemd160" => Some(Box::new(move|input: &[u8], output: &mut[u8]| {
+		}),
+		"ripemd160" => Box::new(move|input: &[u8], output: &mut[u8]| {
 			let mut sha = Ripemd160::new();
 			sha.input(input);
 			let mut ret = H256::new();
 			sha.result(&mut ret.as_slice_mut()[12..32]);
 			copy_to(&ret, output);
-		})),
-		_ => None
+		}),
+		_ => {
+			panic!("invalid builtin name {}", name);
+		}
 	}
 }
 
 #[test]
 fn identity() {
-	let f = new_builtin_exec("identity").unwrap();
+	let f = new_builtin_exec("identity");
 	let i = [0u8, 1, 2, 3];
 
 	let mut o2 = [255u8; 2];
@@ -165,7 +160,7 @@ fn identity() {
 #[test]
 fn sha256() {
 	use rustc_serialize::hex::FromHex;
-	let f = new_builtin_exec("sha256").unwrap();
+	let f = new_builtin_exec("sha256");
 	let i = [0u8; 0];
 
 	let mut o = [255u8; 32];
@@ -184,7 +179,7 @@ fn sha256() {
 #[test]
 fn ripemd160() {
 	use rustc_serialize::hex::FromHex;
-	let f = new_builtin_exec("ripemd160").unwrap();
+	let f = new_builtin_exec("ripemd160");
 	let i = [0u8; 0];
 
 	let mut o = [255u8; 32];
@@ -211,7 +206,7 @@ fn ecrecover() {
 	let s = k.sign(&m).unwrap();
 	println!("Signed: {}", s);*/
 
-	let f = new_builtin_exec("ecrecover").unwrap();
+	let f = new_builtin_exec("ecrecover");
 	let i = FromHex::from_hex("47173285a8d7341e5e972fc677286384f802f8ef42a5ec5f03bbfa254cb01fad000000000000000000000000000000000000000000000000000000000000001b650acf9d3f5f0a2c799776a1254355d5f4061762a237396a99a0e0e3fc2bcd6729514a0dacb2e623ac4abd157cb18163ff942280db4d5caad66ddf941ba12e03").unwrap();
 
 	let mut o = [255u8; 32];
@@ -258,9 +253,15 @@ fn ecrecover() {
 	assert_eq!(&o[..], &(FromHex::from_hex("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff").unwrap())[..]);*/
 }
 
+#[test]
+#[should_panic]
+fn from_unknown_linear() {
+	let _ = Builtin::from_named_linear("dw", 10, 20);
+}
+
 #[test]
 fn from_named_linear() {
-	let b = Builtin::from_named_linear("identity", 10, 20).unwrap();
+	let b = Builtin::from_named_linear("identity", 10, 20);
 	assert_eq!((*b.cost)(0), U256::from(10));
 	assert_eq!((*b.cost)(1), U256::from(30));
 	assert_eq!((*b.cost)(32), U256::from(30));
@@ -274,9 +275,14 @@ fn from_named_linear() {
 
 #[test]
 fn from_json() {
-	let text = "{ \"name\": \"identity\", \"linear\": {\"base\": 10, \"word\": 20} }";
-	let json = Json::from_str(text).unwrap();
-	let b = Builtin::from_json(&json).unwrap();
+	let b = Builtin::from(ethjson::spec::Builtin {
+		name: "identity".to_owned(),
+		pricing: ethjson::spec::Pricing::Linear(ethjson::spec::Linear {
+			base: 10,
+			word: 20,
+		})
+	});
+
 	assert_eq!((*b.cost)(0), U256::from(10));
 	assert_eq!((*b.cost)(1), U256::from(30));
 	assert_eq!((*b.cost)(32), U256::from(30));

ethcore/src/chainfilter/indexer.rs

@@ -60,7 +60,7 @@ impl Indexer {
 	}
 
 	/// Return bloom which are dependencies for given index.
-	/// 
+	///
 	/// Bloom indexes are ordered from lowest to highest.
 	pub fn lower_level_bloom_indexes(&self, index: &BloomIndex) -> Vec<BloomIndex> {
 		// this is the lowest level
@@ -87,6 +87,7 @@ impl Indexer {
 
 #[cfg(test)]
 mod tests {
+	#![cfg_attr(feature="dev", allow(similar_names))]
 	use chainfilter::BloomIndex;
 	use chainfilter::indexer::Indexer;
 

ethcore/src/chainfilter/tests.rs

@@ -23,7 +23,7 @@ use chainfilter::{BloomIndex, FilterDataSource, ChainFilter};
 
 /// In memory cache for blooms.
 ///
-/// Stores all blooms in HashMap, which indexes them by `BloomIndex`.
+/// Stores all blooms in `HashMap`, which indexes them by `BloomIndex`.
 pub struct MemoryCache {
 	blooms: HashMap<BloomIndex, H2048>,
 }

ethcore/src/client/client.rs

@@ -17,11 +17,12 @@
 //! Blockchain database client.
 
 use std::marker::PhantomData;
+use std::path::PathBuf;
 use util::*;
 use util::panics::*;
 use views::BlockView;
 use error::*;
-use header::{BlockNumber};
+use header::{BlockNumber, Header};
 use state::State;
 use spec::Spec;
 use engine::Engine;
@@ -30,14 +31,20 @@ use service::{NetSyncMessage, SyncMessage};
 use env_info::LastHashes;
 use verification::*;
 use block::*;
-use transaction::{LocalizedTransaction, SignedTransaction};
+use transaction::{LocalizedTransaction, SignedTransaction, Action};
 use extras::TransactionAddress;
 use filter::Filter;
 use log_entry::LocalizedLogEntry;
 use block_queue::{BlockQueue, BlockQueueInfo};
 use blockchain::{BlockChain, BlockProvider, TreeRoute, ImportRoute};
-use client::{BlockId, TransactionId, ClientConfig, BlockChainClient};
+use client::{BlockId, TransactionId, UncleId, TraceId, ClientConfig, BlockChainClient, TraceFilter};
+use env_info::EnvInfo;
+use executive::{Executive, Executed, TransactOptions, contract_address};
+use receipt::LocalizedReceipt;
 pub use blockchain::CacheSize as BlockChainCacheSize;
+use trace::{TraceDB, ImportRequest as TraceImportRequest, LocalizedTrace, Database as TraceDatabase, Filter as
+	TracedbFilter};
+use trace;
 
 /// General block status
 #[derive(Debug, Eq, PartialEq)]
@@ -99,6 +106,7 @@ impl ClientReport {
 /// Call `import_block()` to import a block asynchronously; `flush_queue()` flushes the queue.
 pub struct Client<V = CanonVerifier> where V: Verifier {
 	chain: Arc<BlockChain>,
+	tracedb: Arc<TraceDB<BlockChain>>,
 	engine: Arc<Box<Engine>>,
 	state_db: Mutex<Box<JournalDB>>,
 	block_queue: BlockQueue,
@@ -118,39 +126,51 @@ const CLIENT_DB_VER_STR: &'static str = "5.3";
 
 impl Client<CanonVerifier> {
 	/// Create a new client with given spec and DB path.
-	pub fn new(config: ClientConfig, spec: Spec, path: &Path, message_channel: IoChannel<NetSyncMessage> ) -> Result<Arc<Client>, Error> {
+	pub fn new(config: ClientConfig, spec: Spec, path: &Path, message_channel: IoChannel<NetSyncMessage> ) -> Arc<Client> {
 		Client::<CanonVerifier>::new_with_verifier(config, spec, path, message_channel)
 	}
 }
 
+/// Get the path for the databases given the root path and information on the databases.
+pub fn get_db_path(path: &Path, pruning: journaldb::Algorithm, genesis_hash: H256) -> PathBuf {
+	let mut dir = path.to_path_buf();
+	dir.push(H64::from(genesis_hash).hex());
+	//TODO: sec/fat: pruned/full versioning
+	// version here is a bit useless now, since it's controlled only be the pruning algo.
+	dir.push(format!("v{}-sec-{}", CLIENT_DB_VER_STR, pruning));
+	dir
+}
+
+/// Append a path element to the given path and return the string.
+pub fn append_path(path: &Path, item: &str) -> String {
+	let mut p = path.to_path_buf();
+	p.push(item);
+	p.to_str().unwrap().to_owned()
+}
+
 impl<V> Client<V> where V: Verifier {
 	///  Create a new client with given spec and DB path and custom verifier.
-	pub fn new_with_verifier(config: ClientConfig, spec: Spec, path: &Path, message_channel: IoChannel<NetSyncMessage> ) -> Result<Arc<Client<V>>, Error> {
-		let mut dir = path.to_path_buf();
-		dir.push(H64::from(spec.genesis_header().hash()).hex());
-		//TODO: sec/fat: pruned/full versioning
-		// version here is a bit useless now, since it's controlled only be the pruning algo.
-		dir.push(format!("v{}-sec-{}", CLIENT_DB_VER_STR, config.pruning));
-		let path = dir.as_path();
+	pub fn new_with_verifier(config: ClientConfig, spec: Spec, path: &Path, message_channel: IoChannel<NetSyncMessage> ) -> Arc<Client<V>> {
+		let path = get_db_path(path, config.pruning, spec.genesis_header().hash());
 		let gb = spec.genesis_block();
-		let chain = Arc::new(BlockChain::new(config.blockchain, &gb, path));
-		let mut state_path = path.to_path_buf();
-		state_path.push("state");
+		let chain = Arc::new(BlockChain::new(config.blockchain, &gb, &path));
+		let tracedb = Arc::new(TraceDB::new(config.tracing, &path, chain.clone()));
 
-		let engine = Arc::new(try!(spec.to_engine()));
-		let state_path_str = state_path.to_str().unwrap();
-		let mut state_db = journaldb::new(state_path_str, config.pruning);
+		let mut state_db = journaldb::new(&append_path(&path, "state"), config.pruning);
 
-		if state_db.is_empty() && engine.spec().ensure_db_good(state_db.as_hashdb_mut()) {
-			state_db.commit(0, &engine.spec().genesis_header().hash(), None).expect("Error commiting genesis state to state DB");
+		if state_db.is_empty() && spec.ensure_db_good(state_db.as_hashdb_mut()) {
+			state_db.commit(0, &spec.genesis_header().hash(), None).expect("Error commiting genesis state to state DB");
 		}
 
+		let engine = Arc::new(spec.engine);
+
 		let block_queue = BlockQueue::new(config.queue, engine.clone(), message_channel);
 		let panic_handler = PanicHandler::new_in_arc();
 		panic_handler.forward_from(&block_queue);
 
-		Ok(Arc::new(Client {
+		Arc::new(Client {
 			chain: chain,
+			tracedb: tracedb,
 			engine: engine,
 			state_db: Mutex::new(state_db),
 			block_queue: block_queue,
@@ -158,7 +178,7 @@ impl<V> Client<V> where V: Verifier {
 			import_lock: Mutex::new(()),
 			panic_handler: panic_handler,
 			verifier: PhantomData,
-		}))
+		})
 	}
 
 	/// Flush the block import queue.
@@ -181,7 +201,7 @@ impl<V> Client<V> where V: Verifier {
 		last_hashes
 	}
 
-	fn check_and_close_block(&self, block: &PreverifiedBlock) -> Result<ClosedBlock, ()> {
+	fn check_and_close_block(&self, block: &PreverifiedBlock) -> Result<LockedBlock, ()> {
 		let engine = self.engine.deref().deref();
 		let header = &block.header;
 
@@ -209,22 +229,22 @@ impl<V> Client<V> where V: Verifier {
 		// Enact Verified Block
 		let parent = chain_has_parent.unwrap();
 		let last_hashes = self.build_last_hashes(header.parent_hash.clone());
-		let db = self.state_db.lock().unwrap().spawn();
+		let db = self.state_db.lock().unwrap().boxed_clone();
 
-		let enact_result = enact_verified(&block, engine, db, &parent, last_hashes);
+		let enact_result = enact_verified(&block, engine, self.tracedb.tracing_enabled(), db, &parent, last_hashes);
 		if let Err(e) = enact_result {
 			warn!(target: "client", "Block import failed for #{} ({})\nError: {:?}", header.number(), header.hash(), e);
 			return Err(());
 		};
 
 		// Final Verification
-		let closed_block = enact_result.unwrap();
-		if let Err(e) = V::verify_block_final(&header, closed_block.block().header()) {
+		let locked_block = enact_result.unwrap();
+		if let Err(e) = V::verify_block_final(&header, locked_block.block().header()) {
 			warn!(target: "client", "Stage 4 block verification failed for #{} ({})\nError: {:?}", header.number(), header.hash(), e);
 			return Err(());
 		}
 
-		Ok(closed_block)
+		Ok(locked_block)
 	}
 
 	fn calculate_enacted_retracted(&self, import_results: Vec<ImportRoute>) -> (Vec<H256>, Vec<H256>) {
@@ -291,6 +311,8 @@ impl<V> Client<V> where V: Verifier {
 			// Commit results
 			let closed_block = closed_block.unwrap();
 			let receipts = closed_block.block().receipts().clone();
+			let traces = From::from(closed_block.block().traces().clone().unwrap_or_else(Vec::new));
+
 			closed_block.drain()
 				.commit(header.number(), &header.hash(), ancient)
 				.expect("State DB commit failed.");
@@ -298,6 +320,14 @@ impl<V> Client<V> where V: Verifier {
 			// And update the chain after commit to prevent race conditions
 			// (when something is in chain but you are not able to fetch details)
 			let route = self.chain.insert_block(&block.bytes, receipts);
+			self.tracedb.import(TraceImportRequest {
+				traces: traces,
+				block_hash: header.hash(),
+				block_number: header.number(),
+				enacted: route.enacted.clone(),
+				retracted: route.retracted.len()
+			});
+
 			import_results.push(route);
 
 			self.report.write().unwrap().accrue_block(&block);
@@ -339,7 +369,7 @@ impl<V> Client<V> where V: Verifier {
 
 	/// Get a copy of the best block's state.
 	pub fn state(&self) -> State {
-		State::from_existing(self.state_db.lock().unwrap().spawn(), HeaderView::new(&self.best_block_header()).state_root(), self.engine.account_start_nonce())
+		State::from_existing(self.state_db.lock().unwrap().boxed_clone(), HeaderView::new(&self.best_block_header()).state_root(), self.engine.account_start_nonce())
 	}
 
 	/// Get info on the cache.
@@ -382,23 +412,64 @@ impl<V> Client<V> where V: Verifier {
 			BlockId::Latest => Some(self.chain.best_block_number())
 		}
 	}
+
+	fn transaction_address(&self, id: TransactionId) -> Option<TransactionAddress> {
+		match id {
+			TransactionId::Hash(ref hash) => self.chain.transaction_address(hash),
+			TransactionId::Location(id, index) => Self::block_hash(&self.chain, id).map(|hash| TransactionAddress {
+				block_hash: hash,
+				index: index
+			})
+		}
+	}
 }
 
 impl<V> BlockChainClient for Client<V> where V: Verifier {
-	// TODO [todr] Should be moved to miner crate eventually.
-	fn try_seal(&self, block: ClosedBlock, seal: Vec<Bytes>) -> Result<SealedBlock, ClosedBlock> {
-		block.try_seal(self.engine.deref().deref(), seal)
+	fn call(&self, t: &SignedTransaction) -> Result<Executed, Error> {
+		let header = self.block_header(BlockId::Latest).unwrap();
+		let view = HeaderView::new(&header);
+		let last_hashes = self.build_last_hashes(view.hash());
+		let env_info = EnvInfo {
+			number: view.number(),
+			author: view.author(),
+			timestamp: view.timestamp(),
+			difficulty: view.difficulty(),
+			last_hashes: last_hashes,
+			gas_used: U256::zero(),
+			gas_limit: U256::max_value(),
+		};
+		// that's just a copy of the state.
+		let mut state = self.state();
+		let sender = try!(t.sender());
+		let balance = state.balance(&sender);
+		// give the sender max balance
+		state.sub_balance(&sender, &balance);
+		state.add_balance(&sender, &U256::max_value());
+		let options = TransactOptions { tracing: false, check_nonce: false };
+		Executive::new(&mut state, &env_info, self.engine.deref().deref()).transact(t, options)
 	}
 
 	// TODO [todr] Should be moved to miner crate eventually.
-	fn prepare_sealing(&self, author: Address, gas_floor_target: U256, extra_data: Bytes, transactions: Vec<SignedTransaction>) -> Option<ClosedBlock> {
+	fn try_seal(&self, block: LockedBlock, seal: Vec<Bytes>) -> Result<SealedBlock, LockedBlock> {
+		block.try_seal(self.engine.deref().deref(), seal)
+	}
+
+	fn engine(&self) -> &Engine {
+		self.engine.deref().deref()
+	}
+
+	// TODO [todr] Should be moved to miner crate eventually.
+	fn prepare_sealing(&self, author: Address, gas_floor_target: U256, extra_data: Bytes, transactions: Vec<SignedTransaction>)
+		-> (Option<ClosedBlock>, HashSet<H256>) {
 		let engine = self.engine.deref().deref();
 		let h = self.chain.best_block_hash();
+		let mut invalid_transactions = HashSet::new();
 
 		let mut b = OpenBlock::new(
 			engine,
-			self.state_db.lock().unwrap().spawn(),
-			match self.chain.block_header(&h) { Some(ref x) => x, None => {return None} },
+			false,	// TODO: this will need to be parameterised once we want to do immediate mining insertion.
+			self.state_db.lock().unwrap().boxed_clone(),
+			match self.chain.block_header(&h) { Some(ref x) => x, None => { return (None, invalid_transactions) } },
 			self.build_last_hashes(h.clone()),
 			author,
 			gas_floor_target,
@@ -417,21 +488,39 @@ impl<V> BlockChainClient for Client<V> where V: Verifier {
 
 		// Add transactions
 		let block_number = b.block().header().number();
+		let min_tx_gas = U256::from(self.engine.schedule(&b.env_info()).tx_gas);
+
 		for tx in transactions {
+			// Push transaction to block
+			let hash = tx.hash();
 			let import = b.push_transaction(tx, None);
-			if let Err(e) = import {
-				trace!("Error adding transaction to block: number={}. Error: {:?}", block_number, e);
+
+			match import {
+				Err(Error::Execution(ExecutionError::BlockGasLimitReached { gas_limit, gas_used, .. })) => {
+					trace!(target: "miner", "Skipping adding transaction to block because of gas limit: {:?}", hash);
+					// Exit early if gas left is smaller then min_tx_gas
+					if gas_limit - gas_used < min_tx_gas {
+						break;
+					}
+				},
+				Err(e) => {
+					invalid_transactions.insert(hash);
+					trace!(target: "miner",
+						   "Error adding transaction to block: number={}. transaction_hash={:?}, Error: {:?}",
+						   block_number, hash, e);
+				},
+				_ => {}
 			}
 		}
 
 		// And close
 		let b = b.close();
-		trace!("Sealing: number={}, hash={}, diff={}",
+		trace!(target: "miner", "Sealing: number={}, hash={}, diff={}",
 			   b.block().header().number(),
 			   b.hash(),
 			   b.block().header().difficulty()
 		);
-		Some(b)
+		(Some(b), invalid_transactions)
 	}
 
 	fn block_header(&self, id: BlockId) -> Option<Bytes> {
@@ -489,13 +578,50 @@ impl<V> BlockChainClient for Client<V> where V: Verifier {
 	}
 
 	fn transaction(&self, id: TransactionId) -> Option<LocalizedTransaction> {
-		match id {
-			TransactionId::Hash(ref hash) => self.chain.transaction_address(hash),
-			TransactionId::Location(id, index) => Self::block_hash(&self.chain, id).map(|hash| TransactionAddress {
-				block_hash: hash,
-				index: index
-			})
-		}.and_then(|address| self.chain.transaction(&address))
+		self.transaction_address(id).and_then(|address| self.chain.transaction(&address))
+	}
+
+	fn uncle(&self, id: UncleId) -> Option<Header> {
+		let index = id.1;
+		self.block(id.0).and_then(|block| BlockView::new(&block).uncle_at(index))
+	}
+
+	fn transaction_receipt(&self, id: TransactionId) -> Option<LocalizedReceipt> {
+		self.transaction_address(id).and_then(|address| {
+			let t = self.chain.block(&address.block_hash)
+				.and_then(|block| BlockView::new(&block).localized_transaction_at(address.index));
+
+			match (t, self.chain.transaction_receipt(&address)) {
+				(Some(tx), Some(receipt)) => {
+					let block_hash = tx.block_hash.clone();
+					let block_number = tx.block_number.clone();
+					let transaction_hash = tx.hash();
+					let transaction_index = tx.transaction_index;
+					Some(LocalizedReceipt {
+						transaction_hash: tx.hash(),
+						transaction_index: tx.transaction_index,
+						block_hash: tx.block_hash,
+						block_number: tx.block_number,
+						// TODO: to fix this, query all previous transaction receipts and retrieve their gas usage
+						cumulative_gas_used: receipt.gas_used,
+						gas_used: receipt.gas_used,
+						contract_address: match tx.action {
+							Action::Call(_) => None,
+							Action::Create => Some(contract_address(&tx.sender().unwrap(), &tx.nonce))
+						},
+						logs: receipt.logs.into_iter().enumerate().map(|(i, log)| LocalizedLogEntry {
+							entry: log,
+							block_hash: block_hash.clone(),
+							block_number: block_number,
+							transaction_hash: transaction_hash.clone(),
+							transaction_index: transaction_index,
+							log_index: i
+						}).collect()
+					})
+				},
+				_ => None
+			}
+		})
 	}
 
 	fn tree_route(&self, from: &H256, to: &H256) -> Option<TreeRoute> {
@@ -580,7 +706,7 @@ impl<V> BlockChainClient for Client<V> where V: Verifier {
 						 	.map(|(i, log)| LocalizedLogEntry {
 							 	entry: log,
 								block_hash: hash.clone(),
-								block_number: number as usize,
+								block_number: number,
 								transaction_hash: hashes.get(index).cloned().unwrap_or_else(H256::new),
 								transaction_index: index,
 								log_index: log_index + i
@@ -592,6 +718,50 @@ impl<V> BlockChainClient for Client<V> where V: Verifier {
 			})
 			.collect()
 	}
+
+	fn filter_traces(&self, filter: TraceFilter) -> Option<Vec<LocalizedTrace>> {
+		let start = self.block_number(filter.range.start);
+		let end = self.block_number(filter.range.end);
+
+		if start.is_some() && end.is_some() {
+			let filter = trace::Filter {
+				range: start.unwrap() as usize..end.unwrap() as usize,
+				from_address: From::from(filter.from_address),
+				to_address: From::from(filter.to_address),
+			};
+
+			let traces = self.tracedb.filter(&filter);
+			Some(traces)
+		} else {
+			None
+		}
+	}
+
+	fn trace(&self, trace: TraceId) -> Option<LocalizedTrace> {
+		let trace_address = trace.address;
+		self.transaction_address(trace.transaction)
+			.and_then(|tx_address| {
+				self.block_number(BlockId::Hash(tx_address.block_hash))
+					.and_then(|number| self.tracedb.trace(number, tx_address.index, trace_address))
+			})
+	}
+
+	fn transaction_traces(&self, transaction: TransactionId) -> Option<Vec<LocalizedTrace>> {
+		self.transaction_address(transaction)
+			.and_then(|tx_address| {
+				self.block_number(BlockId::Hash(tx_address.block_hash))
+					.and_then(|number| self.tracedb.transaction_traces(number, tx_address.index))
+			})
+	}
+
+	fn block_traces(&self, block: BlockId) -> Option<Vec<LocalizedTrace>> {
+		self.block_number(block)
+			.and_then(|number| self.tracedb.block_traces(number))
+	}
+
+	fn last_hashes(&self) -> LastHashes {
+		self.build_last_hashes(self.chain.best_block_hash())
+	}
 }
 
 impl MayPanic for Client {

ethcore/src/client/config.rs

@@ -16,6 +16,7 @@
 
 pub use block_queue::BlockQueueConfig;
 pub use blockchain::BlockChainConfig;
+pub use trace::{Config as TraceConfig, Switch};
 use util::journaldb;
 
 /// Client configuration. Includes configs for all sub-systems.
@@ -25,6 +26,8 @@ pub struct ClientConfig {
 	pub queue: BlockQueueConfig,
 	/// Blockchain configuration.
 	pub blockchain: BlockChainConfig,
+	/// Trace configuration.
+	pub tracing: TraceConfig,
 	/// The JournalDB ("pruning") algorithm to use.
 	pub pruning: journaldb::Algorithm,
 	/// The name of the client instance.

ethcore/src/client/ids.rs

@@ -18,9 +18,10 @@
 
 use util::hash::H256;
 use header::BlockNumber;
+use util::bytes::{FromRawBytes, FromBytesError, ToBytesWithMap, Populatable};
 
 /// Uniquely identifies block.
-#[derive(Debug, PartialEq, Clone)]
+#[derive(Debug, PartialEq, Clone, Hash, Eq)]
 pub enum BlockId {
 	/// Block's sha3.
 	/// Querying by hash is always faster.
@@ -34,7 +35,7 @@ pub enum BlockId {
 }
 
 /// Uniquely identifies transaction.
-#[derive(Debug, PartialEq, Clone)]
+#[derive(Debug, PartialEq, Clone, Hash, Eq)]
 pub enum TransactionId {
 	/// Transaction's sha3.
 	Hash(H256),
@@ -42,3 +43,23 @@ pub enum TransactionId {
 	/// Querying by block position is always faster.
 	Location(BlockId, usize)
 }
+
+/// Uniquely identifies Trace.
+pub struct TraceId {
+	/// Transaction
+	pub transaction: TransactionId,
+	/// Trace address within transaction.
+	pub address: Vec<usize>,
+}
+
+/// Uniquely identifies Uncle.
+pub struct UncleId (
+	/// Block id.
+	pub BlockId,
+	/// Position in block.
+	pub usize
+);
+
+sized_binary_map!(TransactionId);
+sized_binary_map!(UncleId);
+sized_binary_map!(BlockId);

ethcore/src/client/mod.rs

@@ -20,23 +20,31 @@ mod client;
 mod config;
 mod ids;
 mod test_client;
+mod trace;
 
 pub use self::client::*;
-pub use self::config::{ClientConfig, BlockQueueConfig, BlockChainConfig};
-pub use self::ids::{BlockId, TransactionId};
+pub use self::config::{ClientConfig, BlockQueueConfig, BlockChainConfig, Switch};
+pub use self::ids::{BlockId, TransactionId, UncleId, TraceId};
 pub use self::test_client::{TestBlockChainClient, EachBlockWith};
+pub use self::trace::Filter as TraceFilter;
+pub use executive::{Executed, Executive, TransactOptions};
+pub use env_info::{LastHashes, EnvInfo};
 
+use std::collections::HashSet;
 use util::bytes::Bytes;
 use util::hash::{Address, H256, H2048};
 use util::numbers::U256;
 use blockchain::TreeRoute;
 use block_queue::BlockQueueInfo;
-use block::{ClosedBlock, SealedBlock};
-use header::BlockNumber;
+use block::{ClosedBlock, LockedBlock, SealedBlock};
+use header::{BlockNumber, Header};
 use transaction::{LocalizedTransaction, SignedTransaction};
 use log_entry::LocalizedLogEntry;
 use filter::Filter;
-use error::{ImportResult};
+use error::{ImportResult, Error};
+use receipt::LocalizedReceipt;
+use engine::{Engine};
+use trace::LocalizedTrace;
 
 /// Blockchain database client. Owns and manages a blockchain and a block queue.
 pub trait BlockChainClient : Sync + Send {
@@ -74,6 +82,12 @@ pub trait BlockChainClient : Sync + Send {
 	/// Get transaction with given hash.
 	fn transaction(&self, id: TransactionId) -> Option<LocalizedTransaction>;
 
+	/// Get uncle with given id.
+	fn uncle(&self, id: UncleId) -> Option<Header>;
+
+	/// Get transaction receipt with given hash.
+	fn transaction_receipt(&self, id: TransactionId) -> Option<LocalizedReceipt>;
+
 	/// Get a tree route between `from` and `to`.
 	/// See `BlockChain::tree_route`.
 	fn tree_route(&self, from: &H256, to: &H256) -> Option<TreeRoute>;
@@ -110,11 +124,32 @@ pub trait BlockChainClient : Sync + Send {
 
 	// TODO [todr] Should be moved to miner crate eventually.
 	/// Returns ClosedBlock prepared for sealing.
-	fn prepare_sealing(&self, author: Address, gas_floor_target: U256, extra_data: Bytes, transactions: Vec<SignedTransaction>) -> Option<ClosedBlock>;
+	fn prepare_sealing(&self, author: Address, gas_floor_target: U256, extra_data: Bytes, transactions: Vec<SignedTransaction>)
+		-> (Option<ClosedBlock>, HashSet<H256>);
 
 	// TODO [todr] Should be moved to miner crate eventually.
 	/// Attempts to seal given block. Returns `SealedBlock` on success and the same block in case of error.
-	fn try_seal(&self, block: ClosedBlock, seal: Vec<Bytes>) -> Result<SealedBlock, ClosedBlock>;
+	fn try_seal(&self, block: LockedBlock, seal: Vec<Bytes>) -> Result<SealedBlock, LockedBlock>;
 
+	/// Makes a non-persistent transaction call.
+	fn call(&self, t: &SignedTransaction) -> Result<Executed, Error>;
+
+	/// Executes a function providing it with a reference to an engine.
+	fn engine(&self) -> &Engine;
+
+	/// Returns traces matching given filter.
+	fn filter_traces(&self, filter: TraceFilter) -> Option<Vec<LocalizedTrace>>;
+
+	/// Returns trace with given id.
+	fn trace(&self, trace: TraceId) -> Option<LocalizedTrace>;
+
+	/// Returns traces created by transaction.
+	fn transaction_traces(&self, trace: TransactionId) -> Option<Vec<LocalizedTrace>>;
+
+	/// Returns traces created by transaction from block.
+	fn block_traces(&self, trace: BlockId) -> Option<Vec<LocalizedTrace>>;
+
+	/// Get last hashes starting from best block.
+	fn last_hashes(&self) -> LastHashes;
 }
 

ethcore/src/client/test_client.rs

@@ -16,19 +16,24 @@
 
 //! Test client.
 
+use std::sync::atomic::{AtomicUsize, Ordering as AtomicOrder};
 use util::*;
 use transaction::{Transaction, LocalizedTransaction, SignedTransaction, Action};
 use blockchain::TreeRoute;
-use client::{BlockChainClient, BlockChainInfo, BlockStatus, BlockId, TransactionId};
+use client::{BlockChainClient, BlockChainInfo, BlockStatus, BlockId, TransactionId, UncleId, TraceId, TraceFilter, LastHashes};
 use header::{Header as BlockHeader, BlockNumber};
 use filter::Filter;
 use log_entry::LocalizedLogEntry;
-use receipt::Receipt;
+use receipt::{Receipt, LocalizedReceipt};
 use extras::BlockReceipts;
 use error::{ImportResult};
 
 use block_queue::BlockQueueInfo;
-use block::{SealedBlock, ClosedBlock};
+use block::{SealedBlock, ClosedBlock, LockedBlock};
+use executive::Executed;
+use error::Error;
+use engine::Engine;
+use trace::LocalizedTrace;
 
 /// Test client.
 pub struct TestBlockChainClient {
@@ -44,10 +49,18 @@ pub struct TestBlockChainClient {
 	pub difficulty: RwLock<U256>,
 	/// Balances.
 	pub balances: RwLock<HashMap<Address, U256>>,
+	/// Nonces.
+	pub nonces: RwLock<HashMap<Address, U256>>,
 	/// Storage.
 	pub storage: RwLock<HashMap<(Address, H256), H256>>,
 	/// Code.
 	pub code: RwLock<HashMap<Address, Bytes>>,
+	/// Execution result.
+	pub execution_result: RwLock<Option<Executed>>,
+	/// Transaction receipts.
+	pub receipts: RwLock<HashMap<TransactionId, LocalizedReceipt>>,
+	/// Block queue size.
+	pub queue_size: AtomicUsize,
 }
 
 #[derive(Clone)]
@@ -80,19 +93,38 @@ impl TestBlockChainClient {
 			last_hash: RwLock::new(H256::new()),
 			difficulty: RwLock::new(From::from(0)),
 			balances: RwLock::new(HashMap::new()),
+			nonces: RwLock::new(HashMap::new()),
 			storage: RwLock::new(HashMap::new()),
 			code: RwLock::new(HashMap::new()),
+			execution_result: RwLock::new(None),
+			receipts: RwLock::new(HashMap::new()),
+			queue_size: AtomicUsize::new(0),
 		};
 		client.add_blocks(1, EachBlockWith::Nothing); // add genesis block
 		client.genesis_hash = client.last_hash.read().unwrap().clone();
 		client
 	}
 
+	/// Set the transaction receipt result
+	pub fn set_transaction_receipt(&self, id: TransactionId, receipt: LocalizedReceipt) {
+		self.receipts.write().unwrap().insert(id, receipt);
+	}
+
+	/// Set the execution result.
+	pub fn set_execution_result(&self, result: Executed) {
+		*self.execution_result.write().unwrap() = Some(result);
+	}
+
 	/// Set the balance of account `address` to `balance`.
 	pub fn set_balance(&self, address: Address, balance: U256) {
 		self.balances.write().unwrap().insert(address, balance);
 	}
 
+	/// Set nonce of account `address` to `nonce`.
+	pub fn set_nonce(&self, address: Address, nonce: U256) {
+		self.nonces.write().unwrap().insert(address, nonce);
+	}
+
 	/// Set `code` at `address`.
 	pub fn set_code(&self, address: Address, code: Bytes) {
 		self.code.write().unwrap().insert(address, code);
@@ -103,6 +135,11 @@ impl TestBlockChainClient {
 		self.storage.write().unwrap().insert((address, position), value);
 	}
 
+	/// Set block queue size for testing
+	pub fn set_queue_size(&self, size: usize) {
+		self.queue_size.store(size, AtomicOrder::Relaxed);
+	}
+
 	/// Add blocks to test client.
 	pub fn add_blocks(&self, count: usize, with: EachBlockWith) {
 		let len = self.numbers.read().unwrap().len();
@@ -111,6 +148,7 @@ impl TestBlockChainClient {
 			header.difficulty = From::from(n);
 			header.parent_hash = self.last_hash.read().unwrap().clone();
 			header.number = n as BlockNumber;
+			header.gas_limit = U256::from(1_000_000);
 			let uncles = match with {
 				EachBlockWith::Uncle | EachBlockWith::UncleAndTransaction => {
 					let mut uncles = RlpStream::new_list(1);
@@ -128,6 +166,8 @@ impl TestBlockChainClient {
 				EachBlockWith::Transaction | EachBlockWith::UncleAndTransaction => {
 					let mut txs = RlpStream::new_list(1);
 					let keypair = KeyPair::create().unwrap();
+					// Update nonces value
+					self.nonces.write().unwrap().insert(keypair.address(), U256::one());
 					let tx = Transaction {
 						action: Action::Create,
 						value: U256::from(100),
@@ -181,6 +221,10 @@ impl TestBlockChainClient {
 }
 
 impl BlockChainClient for TestBlockChainClient {
+	fn call(&self, _t: &SignedTransaction) -> Result<Executed, Error> {
+		Ok(self.execution_result.read().unwrap().clone().unwrap())
+	}
+
 	fn block_total_difficulty(&self, _id: BlockId) -> Option<U256> {
 		Some(U256::zero())
 	}
@@ -189,8 +233,8 @@ impl BlockChainClient for TestBlockChainClient {
 		unimplemented!();
 	}
 
-	fn nonce(&self, _address: &Address) -> U256 {
-		U256::zero()
+	fn nonce(&self, address: &Address) -> U256 {
+		self.nonces.read().unwrap().get(address).cloned().unwrap_or_else(U256::zero)
 	}
 
 	fn code(&self, address: &Address) -> Option<Bytes> {
@@ -209,6 +253,14 @@ impl BlockChainClient for TestBlockChainClient {
 		unimplemented!();
 	}
 
+	fn uncle(&self, _id: UncleId) -> Option<BlockHeader> {
+		unimplemented!();
+	}
+
+	fn transaction_receipt(&self, id: TransactionId) -> Option<LocalizedReceipt> {
+		self.receipts.read().unwrap().get(&id).cloned()
+	}
+
 	fn blocks_with_bloom(&self, _bloom: &H2048, _from_block: BlockId, _to_block: BlockId) -> Option<Vec<BlockNumber>> {
 		unimplemented!();
 	}
@@ -217,12 +269,16 @@ impl BlockChainClient for TestBlockChainClient {
 		unimplemented!();
 	}
 
-	fn prepare_sealing(&self, _author: Address, _gas_floor_target: U256, _extra_data: Bytes, _transactions: Vec<SignedTransaction>) -> Option<ClosedBlock> {
-		unimplemented!()
+	fn last_hashes(&self) -> LastHashes {
+		unimplemented!();
 	}
 
-	fn try_seal(&self, _block: ClosedBlock, _seal: Vec<Bytes>) -> Result<SealedBlock, ClosedBlock> {
-		unimplemented!()
+	fn prepare_sealing(&self, _author: Address, _gas_floor_target: U256, _extra_data: Bytes, _transactions: Vec<SignedTransaction>) -> (Option<ClosedBlock>, HashSet<H256>) {
+		(None, HashSet::new())
+	}
+
+	fn try_seal(&self, block: LockedBlock, _seal: Vec<Bytes>) -> Result<SealedBlock, LockedBlock> {
+		Err(block)
 	}
 
 	fn block_header(&self, id: BlockId) -> Option<Bytes> {
@@ -352,7 +408,7 @@ impl BlockChainClient for TestBlockChainClient {
 
 	fn queue_info(&self) -> BlockQueueInfo {
 		BlockQueueInfo {
-			verified_queue_size: 0,
+			verified_queue_size: self.queue_size.load(AtomicOrder::Relaxed),
 			unverified_queue_size: 0,
 			verifying_queue_size: 0,
 			max_queue_size: 0,
@@ -373,4 +429,24 @@ impl BlockChainClient for TestBlockChainClient {
 			best_block_number: self.blocks.read().unwrap().len() as BlockNumber - 1,
 		}
 	}
+
+	fn engine(&self) -> &Engine {
+		unimplemented!();
+	}
+
+	fn filter_traces(&self, _filter: TraceFilter) -> Option<Vec<LocalizedTrace>> {
+		unimplemented!();
+	}
+
+	fn trace(&self, _trace: TraceId) -> Option<LocalizedTrace> {
+		unimplemented!();
+	}
+
+	fn transaction_traces(&self, _trace: TransactionId) -> Option<Vec<LocalizedTrace>> {
+		unimplemented!();
+	}
+
+	fn block_traces(&self, _trace: BlockId) -> Option<Vec<LocalizedTrace>> {
+		unimplemented!();
+	}
 }

ethcore/src/client/trace.rs

@@ -0,0 +1,38 @@
+
+//! Bridge between Tracedb and Blockchain.
+
+use std::ops::Range;
+use util::{Address, H256};
+use header::BlockNumber;
+use trace::DatabaseExtras as TraceDatabaseExtras;
+use blockchain::{BlockChain, BlockProvider};
+use extras::TransactionAddress;
+use super::BlockId;
+
+impl TraceDatabaseExtras for BlockChain {
+	fn block_hash(&self, block_number: BlockNumber) -> Option<H256> {
+		(self as &BlockProvider).block_hash(block_number)
+	}
+
+	fn transaction_hash(&self, block_number: BlockNumber, tx_position: usize) -> Option<H256> {
+		(self as &BlockProvider).block_hash(block_number)
+			.and_then(|block_hash| {
+				let tx_address = TransactionAddress {
+					block_hash: block_hash,
+					index: tx_position
+				};
+				self.transaction(&tx_address)
+			})
+			.map(|tx| tx.hash())
+	}
+}
+
+/// Easy to use trace filter.
+pub struct Filter {
+	/// Range of filtering.
+	pub range: Range<BlockId>,
+	/// From address.
+	pub from_address: Vec<Address>,
+	/// To address.
+	pub to_address: Vec<Address>,
+}

ethcore/src/common.rs

@@ -25,4 +25,4 @@ pub use account::*;
 pub use transaction::*;
 pub use log_entry::*;
 pub use receipt::*;
-pub use action_params::*;
+pub use action_params::*;

ethcore/src/db.rs

@@ -0,0 +1,157 @@
+// 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/>.
+
+//! Extras db utils.
+
+use std::ops::Deref;
+use std::hash::Hash;
+use std::sync::RwLock;
+use std::collections::HashMap;
+use util::{DBTransaction, Database};
+use util::rlp::{encode, Encodable, decode, Decodable};
+
+#[derive(Clone, Copy)]
+pub enum CacheUpdatePolicy {
+	Overwrite,
+	Remove,
+}
+
+/// Should be used to get database key associated with given value.
+pub trait Key<T> {
+	type Target: Deref<Target = [u8]>;
+
+	/// Returns db key.
+	fn key(&self) -> Self::Target;
+}
+
+/// Should be used to write value into database.
+pub trait Writable {
+	/// Writes the value into the database.
+	fn write<T, R>(&self, key: &Key<T, Target = R>, value: &T) where T: Encodable, R: Deref<Target = [u8]>;
+
+	/// Writes the value into the database and updates the cache.
+	fn write_with_cache<K, T, R>(&self, cache: &mut HashMap<K, T>, key: K, value: T, policy: CacheUpdatePolicy) where
+	K: Key<T, Target = R> + Hash + Eq,
+	T: Encodable,
+	R: Deref<Target = [u8]> {
+		self.write(&key, &value);
+		match policy {
+			CacheUpdatePolicy::Overwrite => {
+				cache.insert(key, value);
+			},
+			CacheUpdatePolicy::Remove => {
+				cache.remove(&key);
+			}
+		}
+	}
+
+	/// Writes the values into the database and updates the cache.
+	fn extend_with_cache<K, T, R>(&self, cache: &mut HashMap<K, T>, values: HashMap<K, T>, policy: CacheUpdatePolicy) where
+	K: Key<T, Target = R> + Hash + Eq,
+	T: Encodable,
+	R: Deref<Target = [u8]> {
+		match policy {
+			CacheUpdatePolicy::Overwrite => {
+				for (key, value) in values.into_iter() {
+					self.write(&key, &value);
+					cache.insert(key, value);
+				}
+			},
+			CacheUpdatePolicy::Remove => {
+				for (key, value) in &values {
+					self.write(key, value);
+					cache.remove(key);
+				}
+			},
+		}
+	}
+}
+
+/// Should be used to read values from database.
+pub trait Readable {
+	/// Returns value for given key.
+	fn read<T, R>(&self, key: &Key<T, Target = R>) -> Option<T> where
+	T: Decodable,
+	R: Deref<Target = [u8]>;
+
+	/// Returns value for given key either in cache or in database.
+	fn read_with_cache<K, T>(&self, cache: &RwLock<HashMap<K, T>>,  key: &K) -> Option<T> where
+		K: Key<T> + Eq + Hash + Clone,
+		T: Clone + Decodable {
+		{
+			let read = cache.read().unwrap();
+			if let Some(v) = read.get(key) {
+				return Some(v.clone());
+			}
+		}
+
+		self.read(key).map(|value: T|{
+			let mut write = cache.write().unwrap();
+			write.insert(key.clone(), value.clone());
+			value
+		})
+	}
+
+	/// Returns true if given value exists.
+	fn exists<T, R>(&self, key: &Key<T, Target = R>) -> bool where R: Deref<Target= [u8]>;
+
+	/// Returns true if given value exists either in cache or in database.
+	fn exists_with_cache<K, T, R>(&self, cache: &RwLock<HashMap<K, T>>, key: &K) -> bool where
+	K: Eq + Hash + Key<T, Target = R>,
+	R: Deref<Target = [u8]> {
+		{
+			let read = cache.read().unwrap();
+			if read.get(key).is_some() {
+				return true;
+			}
+		}
+
+		self.exists::<T, R>(key)
+	}
+}
+
+impl Writable for DBTransaction {
+	fn write<T, R>(&self, key: &Key<T, Target = R>, value: &T) where T: Encodable, R: Deref<Target = [u8]> {
+		let result = self.put(&key.key(), &encode(value));
+		if let Err(err) = result {
+			panic!("db put failed, key: {:?}, err: {:?}", &key.key() as &[u8], err);
+		}
+	}
+}
+
+impl Readable for Database {
+	fn read<T, R>(&self, key: &Key<T, Target = R>) -> Option<T> where T: Decodable, R: Deref<Target = [u8]> {
+		let result = self.get(&key.key());
+
+		match result {
+			Ok(option) => option.map(|v| decode(&v)),
+			Err(err) => {
+				panic!("db get failed, key: {:?}, err: {:?}", &key.key() as &[u8], err);
+			}
+		}
+	}
+
+	fn exists<T, R>(&self, key: &Key<T, Target = R>) -> bool where R: Deref<Target = [u8]> {
+		let result = self.get(&key.key());
+
+		match result {
+			Ok(v) => v.is_some(),
+			Err(err) => {
+				panic!("db get failed, key: {:?}, err: {:?}", &key.key() as &[u8], err);
+			}
+		}
+	}
+}

ethcore/src/engine.rs

@@ -16,7 +16,7 @@
 
 use common::*;
 use block::ExecutedBlock;
-use spec::Spec;
+use spec::CommonParams;
 use evm::Schedule;
 use evm::Factory;
 
@@ -25,7 +25,7 @@ use evm::Factory;
 pub trait Engine : Sync + Send {
 	/// The name of this engine.
 	fn name(&self) -> &str;
-	/// The version of this engine. Should be of the form 
+	/// The version of this engine. Should be of the form
 	fn version(&self) -> SemanticVersion { SemanticVersion::new(0, 0, 0) }
 
 	/// The number of additional header fields required for this engine.
@@ -35,7 +35,7 @@ pub trait Engine : Sync + Send {
 	fn extra_info(&self, _header: &Header) -> HashMap<String, String> { HashMap::new() }
 
 	/// Get the general parameters of the chain.
-	fn spec(&self) -> &Spec;
+	fn params(&self) -> &CommonParams;
 
 	/// Get current EVM factory
 	fn vm_factory(&self) -> &Factory;
@@ -43,29 +43,33 @@ pub trait Engine : Sync + Send {
 	/// Get the EVM schedule for the given `env_info`.
 	fn schedule(&self, env_info: &EnvInfo) -> Schedule;
 
+	/// Builtin-contracts we would like to see in the chain.
+	/// (In principle these are just hints for the engine since that has the last word on them.)
+	fn builtins(&self) -> &BTreeMap<Address, Builtin>;
+
 	/// Some intrinsic operation parameters; by default they take their value from the `spec()`'s `engine_params`.
-	fn maximum_extra_data_size(&self) -> usize { decode(&self.spec().engine_params.get("maximumExtraDataSize").unwrap()) }
+	fn maximum_extra_data_size(&self) -> usize { self.params().maximum_extra_data_size }
 	/// Maximum number of uncles a block is allowed to declare.
 	fn maximum_uncle_count(&self) -> usize { 2 }
 	/// The number of generations back that uncles can be.
 	fn maximum_uncle_age(&self) -> usize { 6 }
 	/// The nonce with which accounts begin.
-	fn account_start_nonce(&self) -> U256 { decode(&self.spec().engine_params.get("accountStartNonce").unwrap()) }
+	fn account_start_nonce(&self) -> U256 { self.params().account_start_nonce }
 
 	/// Block transformation functions, before the transactions.
 	fn on_new_block(&self, _block: &mut ExecutedBlock) {}
 	/// Block transformation functions, after the transactions.
 	fn on_close_block(&self, _block: &mut ExecutedBlock) {}
 
-	/// Phase 1 quick block verification. Only does checks that are cheap. `block` (the header's full block) 
+	/// Phase 1 quick block verification. Only does checks that are cheap. `block` (the header's full block)
 	/// may be provided for additional checks. Returns either a null `Ok` or a general error detailing the problem with import.
 	fn verify_block_basic(&self, _header: &Header,  _block: Option<&[u8]>) -> Result<(), Error> { Ok(()) }
 
-	/// Phase 2 verification. Perform costly checks such as transaction signatures. `block` (the header's full block) 
+	/// Phase 2 verification. Perform costly checks such as transaction signatures. `block` (the header's full block)
 	/// may be provided for additional checks. Returns either a null `Ok` or a general error detailing the problem with import.
 	fn verify_block_unordered(&self, _header: &Header, _block: Option<&[u8]>) -> Result<(), Error> { Ok(()) }
 
-	/// Phase 3 verification. Check block information against parent and uncles. `block` (the header's full block) 
+	/// Phase 3 verification. Check block information against parent and uncles. `block` (the header's full block)
 	/// may be provided for additional checks. Returns either a null `Ok` or a general error detailing the problem with import.
 	fn verify_block_family(&self, _header: &Header, _parent: &Header, _block: Option<&[u8]>) -> Result<(), Error> { Ok(()) }
 
@@ -94,13 +98,13 @@ pub trait Engine : Sync + Send {
 	// TODO: builtin contract routing - to do this properly, it will require removing the built-in configuration-reading logic
 	// from Spec into here and removing the Spec::builtins field.
 	/// Determine whether a particular address is a builtin contract.
-	fn is_builtin(&self, a: &Address) -> bool { self.spec().builtins.contains_key(a) }
+	fn is_builtin(&self, a: &Address) -> bool { self.builtins().contains_key(a) }
 	/// Determine the code execution cost of the builtin contract with address `a`.
 	/// Panics if `is_builtin(a)` is not true.
-	fn cost_of_builtin(&self, a: &Address, input: &[u8]) -> U256 { self.spec().builtins.get(a).unwrap().cost(input.len()) }
+	fn cost_of_builtin(&self, a: &Address, input: &[u8]) -> U256 { self.builtins().get(a).unwrap().cost(input.len()) }
 	/// Execution the builtin contract `a` on `input` and return `output`.
 	/// Panics if `is_builtin(a)` is not true.
-	fn execute_builtin(&self, a: &Address, input: &[u8], output: &mut [u8]) { self.spec().builtins.get(a).unwrap().execute(input, output); }
+	fn execute_builtin(&self, a: &Address, input: &[u8], output: &mut [u8]) { self.builtins().get(a).unwrap().execute(input, output); }
 
 	// TODO: sealing stuff - though might want to leave this for later.
 }

ethcore/src/env_info.rs

@@ -16,6 +16,7 @@
 
 use util::*;
 use header::BlockNumber;
+use ethjson;
 
 /// Simple vector of hashes, should be at most 256 items large, can be smaller if being used
 /// for a block whose number is less than 257.
@@ -54,17 +55,17 @@ impl Default for EnvInfo {
 	}
 }
 
-impl FromJson for EnvInfo {
-	fn from_json(json: &Json) -> EnvInfo {
-		let current_number: u64 = xjson!(&json["currentNumber"]);
+impl From<ethjson::vm::Env> for EnvInfo {
+	fn from(e: ethjson::vm::Env) -> Self {
+		let number = e.number.into();
 		EnvInfo {
-			number: current_number,
-			author: xjson!(&json["currentCoinbase"]),
-			difficulty: xjson!(&json["currentDifficulty"]),
-			gas_limit: xjson!(&json["currentGasLimit"]),
-			timestamp: xjson!(&json["currentTimestamp"]),
-			last_hashes: (1..cmp::min(current_number + 1, 257)).map(|i| format!("{}", current_number - i).as_bytes().sha3()).collect(),
-			gas_used: x!(0),
+			number: number,
+			author: e.author.into(),
+			difficulty: e.difficulty.into(),
+			gas_limit: e.gas_limit.into(),
+			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(),
 		}
 	}
 }
@@ -74,24 +75,20 @@ mod tests {
 	extern crate rustc_serialize;
 
 	use super::*;
-	use rustc_serialize::*;
-	use util::from_json::FromJson;
 	use util::hash::*;
+	use util::numbers::U256;
 	use std::str::FromStr;
+	use ethjson;
 
 	#[test]
 	fn it_serializes_form_json() {
-		let env_info = EnvInfo::from_json(&json::Json::from_str(
-r#"
-	{
-		"currentCoinbase": "0x000000f00000000f000000000000f00000000f00",
-		"currentNumber": 1112339,
-		"currentDifficulty": 50000,
-		"currentGasLimit" : 40000,
-		"currentTimestamp" : 1100
-	}
-"#
-		).unwrap());
+		let env_info = EnvInfo::from(ethjson::vm::Env {
+			author: ethjson::hash::Address(Address::from_str("000000f00000000f000000000000f00000000f00").unwrap()),
+			number: ethjson::uint::Uint(U256::from(1_112_339)),
+			difficulty: ethjson::uint::Uint(U256::from(50_000)),
+			gas_limit: ethjson::uint::Uint(U256::from(40_000)),
+			timestamp: ethjson::uint::Uint(U256::from(1_100))
+		});
 
 		assert_eq!(env_info.number, 1112339);
 		assert_eq!(env_info.author, Address::from_str("000000f00000000f000000000000f00000000f00").unwrap());

ethcore/src/error.rs

@@ -62,15 +62,38 @@ pub enum ExecutionError {
 	Internal
 }
 
-#[derive(Debug)]
+#[derive(Debug, PartialEq)]
 /// Errors concerning transaction processing.
 pub enum TransactionError {
+	/// Transaction is already imported to the queue
+	AlreadyImported,
+	/// Transaction is not valid anymore (state already has higher nonce)
+	Old,
+	/// Transaction has too low fee
+	/// (there is already a transaction with the same sender-nonce but higher gas price)
+	TooCheapToReplace,
+	/// Transaction was not imported to the queue because limit has been reached.
+	LimitReached,
 	/// Transaction's gas price is below threshold.
 	InsufficientGasPrice {
 		/// Minimal expected gas price
 		minimal: U256,
 		/// Transaction gas price
-		got: U256
+		got: U256,
+	},
+	/// Sender doesn't have enough funds to pay for this transaction
+	InsufficientBalance {
+		/// Senders balance
+		balance: U256,
+		/// Transaction cost
+		cost: U256,
+	},
+	/// Transactions gas is higher then current gas limit
+	GasLimitExceeded {
+		/// Current gas limit
+		limit: U256,
+		/// Declared transaction gas
+		got: U256,
 	},
 	/// Transaction's gas limit (aka gas) is invalid.
 	InvalidGasLimit(OutOfBounds<U256>),
@@ -135,7 +158,7 @@ pub enum BlockError {
 	UnknownUncleParent(H256),
 }
 
-#[derive(Debug)]
+#[derive(Debug, PartialEq)]
 /// Import to the block queue result
 pub enum ImportError {
 	/// Already in the block chain.

ethcore/src/ethereum/ethash.rs

@@ -19,54 +19,65 @@ extern crate ethash;
 use self::ethash::{quick_get_difficulty, EthashManager, H256 as EH256};
 use common::*;
 use block::*;
-use spec::*;
+use spec::CommonParams;
 use engine::*;
-use evm::Schedule;
-use evm::Factory;
+use evm::{Schedule, Factory};
+use ethjson;
+
+/// Ethash params.
+#[derive(Debug, PartialEq)]
+pub struct EthashParams {
+	/// Tie breaking gas.
+	pub tie_breaking_gas: bool,
+	/// Gas limit divisor.
+	pub gas_limit_bound_divisor: U256,
+	/// Minimum difficulty.
+	pub minimum_difficulty: U256,
+	/// Difficulty bound divisor.
+	pub difficulty_bound_divisor: U256,
+	/// Block duration.
+	pub duration_limit: u64,
+	/// Block reward.
+	pub block_reward: U256,
+	/// Namereg contract address.
+	pub registrar: Address,
+}
+
+impl From<ethjson::spec::EthashParams> for EthashParams {
+	fn from(p: ethjson::spec::EthashParams) -> Self {
+		EthashParams {
+			tie_breaking_gas: p.tie_breaking_gas,
+			gas_limit_bound_divisor: p.gas_limit_bound_divisor.into(),
+			minimum_difficulty: p.minimum_difficulty.into(),
+			difficulty_bound_divisor: p.difficulty_bound_divisor.into(),
+			duration_limit: p.duration_limit.into(),
+			block_reward: p.block_reward.into(),
+			registrar: p.registrar.into(),
+		}
+	}
+}
 
 /// Engine using Ethash proof-of-work consensus algorithm, suitable for Ethereum
 /// mainnet chains in the Olympic, Frontier and Homestead eras.
 pub struct Ethash {
-	spec: Spec,
+	params: CommonParams,
+	ethash_params: EthashParams,
+	builtins: BTreeMap<Address, Builtin>,
 	pow: EthashManager,
 	factory: Factory,
-	u64_params: RwLock<HashMap<String, u64>>,
-	u256_params: RwLock<HashMap<String, U256>>,
 }
 
 impl Ethash {
-	/// Create a new boxed instance of Ethash engine
-	pub fn new_boxed(spec: Spec) -> Box<Engine> {
-		Box::new(Ethash {
-			spec: spec,
-			pow: EthashManager::new(),
-			// TODO [todr] should this return any specific factory?
-			factory: Factory::default(),
-			u64_params: RwLock::new(HashMap::new()),
-			u256_params: RwLock::new(HashMap::new())
-		})
-	}
-
-	#[cfg(test)]
-	fn new_test(spec: Spec) -> Ethash {
+	/// Create a new instance of Ethash engine
+	pub fn new(params: CommonParams, ethash_params: EthashParams, builtins: BTreeMap<Address, Builtin>) -> Self {
 		Ethash {
-			spec: spec,
+			params: params,
+			ethash_params: ethash_params,
+			builtins: builtins,
 			pow: EthashManager::new(),
 			factory: Factory::default(),
-			u64_params: RwLock::new(HashMap::new()),
-			u256_params: RwLock::new(HashMap::new())
 		}
 	}
-
-	fn u64_param(&self, name: &str) -> u64 {
-		*self.u64_params.write().unwrap().entry(name.to_owned()).or_insert_with(||
-			self.spec().engine_params.get(name).map_or(0u64, |a| decode(&a)))
-	}
-
-	fn u256_param(&self, name: &str) -> U256 {
-		*self.u256_params.write().unwrap().entry(name.to_owned()).or_insert_with(||
-			self.spec().engine_params.get(name).map_or(x!(0), |a| decode(&a)))
-	}
 }
 
 impl Engine for Ethash {
@@ -75,17 +86,23 @@ impl Engine for Ethash {
 	// Two fields - mix
 	fn seal_fields(&self) -> usize { 2 }
 
+	fn params(&self) -> &CommonParams { &self.params }
+
+	fn builtins(&self) -> &BTreeMap<Address, Builtin> {
+		&self.builtins
+	}
+
 	/// Additional engine-specific information for the user/developer concerning `header`.
 	fn extra_info(&self, _header: &Header) -> HashMap<String, String> { HashMap::new() }
-	fn spec(&self) -> &Spec { &self.spec }
 
 	fn vm_factory(&self) -> &Factory {
 		&self.factory
 	}
 
 	fn schedule(&self, env_info: &EnvInfo) -> Schedule {
-		trace!(target: "client", "Creating schedule. param={:?}, fCML={}", self.spec().engine_params.get("frontierCompatibilityModeLimit"), self.u64_param("frontierCompatibilityModeLimit"));
-		if env_info.number < self.u64_param("frontierCompatibilityModeLimit") {
+		trace!(target: "client", "Creating schedule. fCML={}", self.params.frontier_compatibility_mode_limit);
+
+		if env_info.number < self.params.frontier_compatibility_mode_limit {
 			Schedule::new_frontier()
 		} else {
 			Schedule::new_homestead()
@@ -96,7 +113,7 @@ impl Engine for Ethash {
 		header.difficulty = self.calculate_difficuty(header, parent);
 		header.gas_limit = {
 			let gas_limit = parent.gas_limit;
-			let bound_divisor = self.u256_param("gasLimitBoundDivisor");
+			let bound_divisor = self.ethash_params.gas_limit_bound_divisor;
 			if gas_limit < gas_floor_target {
 				min(gas_floor_target, gas_limit + gas_limit / bound_divisor - x!(1))
 			} else {
@@ -110,8 +127,8 @@ impl Engine for Ethash {
 	/// 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) {
-		let reward = self.spec().engine_params.get("blockReward").map_or(U256::from(0u64), |a| decode(&a));
-		let fields = block.fields();
+		let reward = self.ethash_params.block_reward;
+		let fields = block.fields_mut();
 
 		// Bestow block reward
 		fields.state.add_balance(&fields.header.author, &(reward + reward / U256::from(32) * U256::from(fields.uncles.len())));
@@ -135,7 +152,7 @@ impl Engine for Ethash {
 		try!(UntrustedRlp::new(&header.seal[1]).as_val::<H64>());
 
 		// TODO: consider removing these lines.
-		let min_difficulty = decode(self.spec().engine_params.get("minimumDifficulty").unwrap());
+		let min_difficulty = self.ethash_params.minimum_difficulty;
 		if header.difficulty < min_difficulty {
 			return Err(From::from(BlockError::DifficultyOutOfBounds(OutOfBounds { min: Some(min_difficulty), max: None, found: header.difficulty })))
 		}
@@ -180,7 +197,7 @@ impl Engine for Ethash {
 		if header.difficulty != expected_difficulty {
 			return Err(From::from(BlockError::InvalidDifficulty(Mismatch { expected: expected_difficulty, found: header.difficulty })))
 		}
-		let gas_limit_divisor = decode(self.spec().engine_params.get("gasLimitBoundDivisor").unwrap());
+		let gas_limit_divisor = self.ethash_params.gas_limit_bound_divisor;
 		let min_gas = parent.gas_limit - parent.gas_limit / gas_limit_divisor;
 		let max_gas = parent.gas_limit + parent.gas_limit / gas_limit_divisor;
 		if header.gas_limit <= min_gas || header.gas_limit >= max_gas {
@@ -190,7 +207,7 @@ impl Engine for Ethash {
 	}
 
 	fn verify_transaction_basic(&self, t: &SignedTransaction, header: &Header) -> result::Result<(), Error> {
-		if header.number() >= self.u64_param("frontierCompatibilityModeLimit") {
+		if header.number() >= self.params.frontier_compatibility_mode_limit {
 			try!(t.check_low_s());
 		}
 		Ok(())
@@ -209,10 +226,11 @@ impl Ethash {
 			panic!("Can't calculate genesis block difficulty");
 		}
 
-		let min_difficulty = self.u256_param("minimumDifficulty");
-		let difficulty_bound_divisor = self.u256_param("difficultyBoundDivisor");
-		let duration_limit = self.u64_param("durationLimit");
-		let frontier_limit = self.u64_param("frontierCompatibilityModeLimit");
+		let min_difficulty = self.ethash_params.minimum_difficulty;
+		let difficulty_bound_divisor = self.ethash_params.difficulty_bound_divisor;
+		let duration_limit = self.ethash_params.duration_limit;
+		let frontier_limit = self.params.frontier_compatibility_mode_limit;
+
 		let mut target = if header.number < frontier_limit {
 			if header.timestamp >= parent.timestamp + duration_limit {
 				parent.difficulty - (parent.difficulty / difficulty_bound_divisor)
@@ -249,11 +267,6 @@ impl Ethash {
 		x!(U256::from((U512::one() << 256) / x!(difficulty)))
 	}
 
-	/// Given the `block_number`, determine the seed hash for Ethash.
-	pub fn get_seedhash(number: BlockNumber) -> H256 {
-		Self::from_ethash(ethash::get_seedhash(number))
-	}
-
 	fn to_ethash(hash: H256) -> EH256 {
 		unsafe { mem::transmute(hash) }
 	}
@@ -288,31 +301,32 @@ mod tests {
 	use block::*;
 	use engine::*;
 	use tests::helpers::*;
-	use super::{Ethash};
 	use super::super::new_morden;
 
 	#[test]
 	fn on_close_block() {
-		let engine = new_morden().to_engine().unwrap();
-		let genesis_header = engine.spec().genesis_header();
+		let spec = new_morden();
+		let engine = &spec.engine;
+		let genesis_header = spec.genesis_header();
 		let mut db_result = get_temp_journal_db();
 		let mut db = db_result.take();
-		engine.spec().ensure_db_good(db.as_hashdb_mut());
+		spec.ensure_db_good(db.as_hashdb_mut());
 		let last_hashes = vec![genesis_header.hash()];
-		let b = OpenBlock::new(engine.deref(), db, &genesis_header, last_hashes, Address::zero(), x!(3141562), vec![]);
+		let b = OpenBlock::new(engine.deref(), false, db, &genesis_header, last_hashes, Address::zero(), x!(3141562), vec![]);
 		let b = b.close();
 		assert_eq!(b.state().balance(&Address::zero()), U256::from_str("4563918244f40000").unwrap());
 	}
 
 	#[test]
 	fn on_close_block_with_uncle() {
-		let engine = new_morden().to_engine().unwrap();
-		let genesis_header = engine.spec().genesis_header();
+		let spec = new_morden();
+		let engine = &spec.engine;
+		let genesis_header = spec.genesis_header();
 		let mut db_result = get_temp_journal_db();
 		let mut db = db_result.take();
-		engine.spec().ensure_db_good(db.as_hashdb_mut());
+		spec.ensure_db_good(db.as_hashdb_mut());
 		let last_hashes = vec![genesis_header.hash()];
-		let mut b = OpenBlock::new(engine.deref(), db, &genesis_header, last_hashes, Address::zero(), x!(3141562), vec![]);
+		let mut b = OpenBlock::new(engine.deref(), false, db, &genesis_header, last_hashes, Address::zero(), x!(3141562), vec![]);
 		let mut uncle = Header::new();
 		let uncle_author = address_from_hex("ef2d6d194084c2de36e0dabfce45d046b37d1106");
 		uncle.author = uncle_author.clone();
@@ -325,27 +339,20 @@ mod tests {
 
 	#[test]
 	fn has_valid_metadata() {
-		let engine = Ethash::new_boxed(new_morden());
+		let engine = new_morden().engine;
 		assert!(!engine.name().is_empty());
 		assert!(engine.version().major >= 1);
 	}
 
-	#[test]
-	fn can_return_params() {
-		let engine = Ethash::new_test(new_morden());
-		assert!(engine.u64_param("durationLimit") > 0);
-		assert!(engine.u256_param("minimumDifficulty") > U256::zero());
-	}
-
 	#[test]
 	fn can_return_factory() {
-		let engine = Ethash::new_test(new_morden());
+		let engine = new_morden().engine;
 		engine.vm_factory();
 	}
 
 	#[test]
 	fn can_return_schedule() {
-		let engine = Ethash::new_test(new_morden());
+		let engine = new_morden().engine;
 		let schedule = engine.schedule(&EnvInfo {
 			number: 10000000,
 			author: x!(0),
@@ -373,7 +380,8 @@ mod tests {
 
 	#[test]
 	fn can_do_seal_verification_fail() {
-		let engine = Ethash::new_test(new_morden());
+		let engine = new_morden().engine;
+		//let engine = Ethash::new_test(new_morden());
 		let header: Header = Header::default();
 
 		let verify_result = engine.verify_block_basic(&header, None);
@@ -387,7 +395,7 @@ mod tests {
 
 	#[test]
 	fn can_do_difficulty_verification_fail() {
-		let engine = Ethash::new_test(new_morden());
+		let engine = new_morden().engine;
 		let mut header: Header = Header::default();
 		header.set_seal(vec![rlp::encode(&H256::zero()).to_vec(), rlp::encode(&H64::zero()).to_vec()]);
 
@@ -402,7 +410,7 @@ mod tests {
 
 	#[test]
 	fn can_do_proof_of_work_verification_fail() {
-		let engine = Ethash::new_test(new_morden());
+		let engine = new_morden().engine;
 		let mut header: Header = Header::default();
 		header.set_seal(vec![rlp::encode(&H256::zero()).to_vec(), rlp::encode(&H64::zero()).to_vec()]);
 		header.set_difficulty(U256::from_str("ffffffffffffffffffffffffffffffffffffffffffffaaaaaaaaaaaaaaaaaaaa").unwrap());
@@ -418,7 +426,7 @@ mod tests {
 
 	#[test]
 	fn can_do_seal_unordered_verification_fail() {
-		let engine = Ethash::new_test(new_morden());
+		let engine = new_morden().engine;
 		let header: Header = Header::default();
 
 		let verify_result = engine.verify_block_unordered(&header, None);
@@ -432,7 +440,7 @@ mod tests {
 
 	#[test]
 	fn can_do_seal256_verification_fail() {
-		let engine = Ethash::new_test(new_morden());
+		let engine = new_morden().engine;
 		let mut header: Header = Header::default();
 		header.set_seal(vec![rlp::encode(&H256::zero()).to_vec(), rlp::encode(&H64::zero()).to_vec()]);
 		let verify_result = engine.verify_block_unordered(&header, None);
@@ -446,7 +454,7 @@ mod tests {
 
 	#[test]
 	fn can_do_proof_of_work_unordered_verification_fail() {
-		let engine = Ethash::new_test(new_morden());
+		let engine = new_morden().engine;
 		let mut header: Header = Header::default();
 		header.set_seal(vec![rlp::encode(&H256::from("b251bd2e0283d0658f2cadfdc8ca619b5de94eca5742725e2e757dd13ed7503d")).to_vec(), rlp::encode(&H64::zero()).to_vec()]);
 		header.set_difficulty(U256::from_str("ffffffffffffffffffffffffffffffffffffffffffffaaaaaaaaaaaaaaaaaaaa").unwrap());
@@ -462,7 +470,7 @@ mod tests {
 
 	#[test]
 	fn can_verify_block_family_genesis_fail() {
-		let engine = Ethash::new_test(new_morden());
+		let engine = new_morden().engine;
 		let header: Header = Header::default();
 		let parent_header: Header = Header::default();
 
@@ -477,7 +485,7 @@ mod tests {
 
 	#[test]
 	fn can_verify_block_family_difficulty_fail() {
-		let engine = Ethash::new_test(new_morden());
+		let engine = new_morden().engine;
 		let mut header: Header = Header::default();
 		header.set_number(2);
 		let mut parent_header: Header = Header::default();
@@ -494,7 +502,7 @@ mod tests {
 
 	#[test]
 	fn can_verify_block_family_gas_fail() {
-		let engine = Ethash::new_test(new_morden());
+		let engine = new_morden().engine;
 		let mut header: Header = Header::default();
 		header.set_number(2);
 		header.set_difficulty(U256::from_str("0000000000000000000000000000000000000000000000000000000000020000").unwrap());
@@ -512,4 +520,3 @@ mod tests {
 
 	// TODO: difficulty test
 }
-

ethcore/src/ethereum/mod.rs

@@ -30,22 +30,22 @@ pub use self::denominations::*;
 use super::spec::*;
 
 /// Create a new Olympic chain spec.
-pub fn new_olympic() -> Spec { Spec::from_json_utf8(include_bytes!("../../res/ethereum/olympic.json")) }
+pub fn new_olympic() -> Spec { Spec::load(include_bytes!("../../res/ethereum/olympic.json")) }
 
 /// Create a new Frontier mainnet chain spec.
-pub fn new_frontier() -> Spec { Spec::from_json_utf8(include_bytes!("../../res/ethereum/frontier.json")) }
+pub fn new_frontier() -> Spec { Spec::load(include_bytes!("../../res/ethereum/frontier.json")) }
 
 /// Create a new Frontier chain spec as though it never changes to Homestead.
-pub fn new_frontier_test() -> Spec { Spec::from_json_utf8(include_bytes!("../../res/ethereum/frontier_test.json")) }
+pub fn new_frontier_test() -> Spec { Spec::load(include_bytes!("../../res/ethereum/frontier_test.json")) }
 
 /// Create a new Homestead chain spec as though it never changed from Frontier.
-pub fn new_homestead_test() -> Spec { Spec::from_json_utf8(include_bytes!("../../res/ethereum/homestead_test.json")) }
+pub fn new_homestead_test() -> Spec { Spec::load(include_bytes!("../../res/ethereum/homestead_test.json")) }
 
 /// Create a new Frontier main net chain spec without genesis accounts.
-pub fn new_mainnet_like() -> Spec { Spec::from_json_utf8(include_bytes!("../../res/ethereum/frontier_like_test.json")) }
+pub fn new_mainnet_like() -> Spec { Spec::load(include_bytes!("../../res/ethereum/frontier_like_test.json")) }
 
 /// Create a new Morden chain spec.
-pub fn new_morden() -> Spec { Spec::from_json_utf8(include_bytes!("../../res/ethereum/morden.json")) }
+pub fn new_morden() -> Spec { Spec::load(include_bytes!("../../res/ethereum/morden.json")) }
 
 #[cfg(test)]
 mod tests {
@@ -57,11 +57,12 @@ mod tests {
 
 	#[test]
 	fn ensure_db_good() {
-		let engine = new_morden().to_engine().unwrap();
-		let genesis_header = engine.spec().genesis_header();
+		let spec = new_morden();
+		let engine = &spec.engine;
+		let genesis_header = spec.genesis_header();
 		let mut db_result = get_temp_journal_db();
 		let mut db = db_result.take();
-		engine.spec().ensure_db_good(db.as_hashdb_mut());
+		spec.ensure_db_good(db.as_hashdb_mut());
 		let s = State::from_existing(db, genesis_header.state_root.clone(), engine.account_start_nonce());
 		assert_eq!(s.balance(&address_from_hex("0000000000000000000000000000000000000001")), U256::from(1u64));
 		assert_eq!(s.balance(&address_from_hex("0000000000000000000000000000000000000002")), U256::from(1u64));
@@ -79,7 +80,7 @@ mod tests {
 		let genesis = morden.genesis_block();
 		assert_eq!(BlockView::new(&genesis).header_view().sha3(), H256::from_str("0cd786a2425d16f152c658316c423e6ce1181e15c3295826d7c9904cba9ce303").unwrap());
 
-		let _ = morden.to_engine();
+		let _ = morden.engine;
 	}
 
 	#[test]
@@ -90,6 +91,6 @@ mod tests {
 		let genesis = frontier.genesis_block();
 		assert_eq!(BlockView::new(&genesis).header_view().sha3(), H256::from_str("d4e56740f876aef8c010b86a40d5f56745a118d0906a34e69aec8c0db1cb8fa3").unwrap());
 
-		let _ = frontier.to_engine();
+		let _ = frontier.engine;
 	}
 }

ethcore/src/evm/evm.rs

@@ -44,7 +44,7 @@ pub enum Error {
 		/// Invoked instruction
 		instruction: &'static str,
 		/// How many stack elements was requested by instruction
-		wanted: usize, 
+		wanted: usize,
 		/// How many elements were on stack
 		on_stack: usize
 	},
@@ -64,8 +64,8 @@ pub enum Error {
 }
 
 /// Evm result.
-/// 
-/// Returns gas_left if execution is successfull, otherwise error.
+///
+/// Returns `gas_left` if execution is successful, otherwise error.
 pub type Result = result::Result<U256, Error>;
 
 /// Evm interface.

ethcore/src/evm/ext.rs

@@ -67,6 +67,7 @@ pub trait Ext {
 	/// Returns Err, if we run out of gas.
 	/// Otherwise returns call_result which contains gas left
 	/// and true if subcall was successfull.
+	#[cfg_attr(feature="dev", allow(too_many_arguments))]
 	fn call(&mut self,
 			gas: &U256,
 			sender_address: &Address,

ethcore/src/evm/factory.rs

@@ -25,7 +25,7 @@ use evm::Evm;
 /// Type of EVM to use.
 pub enum VMType {
 	/// JIT EVM
-	#[cfg(feature="jit")]
+	#[cfg(feature = "jit")]
 	Jit,
 	/// RUST EVM
 	Interpreter
@@ -52,13 +52,13 @@ impl fmt::Display for VMType {
 #[cfg(feature = "json-tests")]
 impl VMType {
 	/// Return all possible VMs (JIT, Interpreter)
-	#[cfg(feature="jit")]
+	#[cfg(feature = "jit")]
 	pub fn all() -> Vec<VMType> {
 		vec![VMType::Jit, VMType::Interpreter]
 	}
 
 	/// Return all possible VMs (Interpreter)
-	#[cfg(not(feature="jit"))]
+	#[cfg(not(feature = "jit"))]
 	pub fn all() -> Vec<VMType> {
 		vec![VMType::Interpreter]
 	}
@@ -66,12 +66,12 @@ impl VMType {
 
 /// Evm factory. Creates appropriate Evm.
 pub struct Factory {
-	evm : VMType
+	evm: VMType
 }
 
 impl Factory {
 	/// Create fresh instance of VM
-	#[cfg(feature="jit")]
+	#[cfg(feature = "jit")]
 	pub fn create(&self) -> Box<Evm> {
 		match self.evm {
 			VMType::Jit => {
@@ -84,7 +84,7 @@ impl Factory {
 	}
 
 	/// Create fresh instance of VM
-	#[cfg(not(feature="jit"))]
+	#[cfg(not(feature = "jit"))]
 	pub fn create(&self) -> Box<Evm> {
 		match self.evm {
 			VMType::Interpreter => {

ethcore/src/evm/instructions.rs

@@ -137,6 +137,7 @@ impl InstructionInfo {
 	}
 }
 
+#[cfg_attr(rustfmt, rustfmt_skip)]
 /// Return details about specific instruction
 pub fn get_info (instruction: Instruction) -> InstructionInfo {
 	match instruction {
@@ -301,7 +302,7 @@ pub const EXP: Instruction = 0x0a;
 pub const SIGNEXTEND: Instruction = 0x0b;
 
 /// less-than comparision
-pub const LT: Instruction = 0x10;		
+pub const LT: Instruction = 0x10;
 /// greater-than comparision
 pub const GT: Instruction = 0x11;
 /// signed less-than comparision
@@ -324,10 +325,10 @@ pub const NOT: Instruction = 0x19;
 pub const BYTE: Instruction = 0x1a;
 
 /// compute SHA3-256 hash
-pub const SHA3: Instruction = 0x20;	
+pub const SHA3: Instruction = 0x20;
 
 /// get address of currently executing account
-pub const ADDRESS: Instruction = 0x30;	
+pub const ADDRESS: Instruction = 0x30;
 /// get balance of the given account
 pub const BALANCE: Instruction = 0x31;
 /// get execution origination address
@@ -367,7 +368,7 @@ pub const DIFFICULTY: Instruction = 0x44;
 pub const GASLIMIT: Instruction = 0x45;
 
 /// remove item from stack
-pub const POP: Instruction = 0x50;		
+pub const POP: Instruction = 0x50;
 /// load word from memory
 pub const MLOAD: Instruction = 0x51;
 /// save word to memory
@@ -392,7 +393,7 @@ pub const GAS: Instruction = 0x5a;
 pub const JUMPDEST: Instruction = 0x5b;
 
 /// place 1 byte item on stack
-pub const PUSH1: Instruction = 0x60;	
+pub const PUSH1: Instruction = 0x60;
 /// place 2 byte item on stack
 pub const PUSH2: Instruction = 0x61;
 /// place 3 byte item on stack
@@ -457,7 +458,7 @@ pub const PUSH31: Instruction = 0x7e;
 pub const PUSH32: Instruction = 0x7f;
 
 /// copies the highest item in the stack to the top of the stack
-pub const DUP1: Instruction = 0x80;	
+pub const DUP1: Instruction = 0x80;
 /// copies the second highest item in the stack to the top of the stack
 pub const DUP2: Instruction = 0x81;
 /// copies the third highest item in the stack to the top of the stack
@@ -490,7 +491,7 @@ pub const DUP15: Instruction = 0x8e;
 pub const DUP16: Instruction = 0x8f;
 
 /// swaps the highest and second highest value on the stack
-pub const SWAP1: Instruction = 0x90;	
+pub const SWAP1: Instruction = 0x90;
 /// swaps the highest and third highest value on the stack
 pub const SWAP2: Instruction = 0x91;
 /// swaps the highest and 4th highest value on the stack
@@ -523,7 +524,7 @@ pub const SWAP15: Instruction = 0x9e;
 pub const SWAP16: Instruction = 0x9f;
 
 /// Makes a log entry; no topics.
-pub const LOG0: Instruction = 0xa0;	
+pub const LOG0: Instruction = 0xa0;
 /// Makes a log entry; 1 topic.
 pub const LOG1: Instruction = 0xa1;
 /// Makes a log entry; 2 topics.
@@ -536,7 +537,7 @@ pub const LOG4: Instruction = 0xa4;
 pub const MAX_NO_OF_TOPICS : usize = 4;
 
 /// create a new account with associated code
-pub const CREATE: Instruction = 0xf0;	
+pub const CREATE: Instruction = 0xf0;
 /// message-call into an account
 pub const CALL: Instruction = 0xf1;
 /// message-call with another account's code only
@@ -546,5 +547,5 @@ pub const RETURN: Instruction = 0xf3;
 /// like CALLCODE but keeps caller's value and sender
 pub const DELEGATECALL: Instruction = 0xf4;
 /// halt execution and register account for later deletion
-pub const SUICIDE: Instruction = 0xff;	
+pub const SUICIDE: Instruction = 0xff;
 

ethcore/src/evm/interpreter.rs

@@ -348,12 +348,13 @@ impl evm::Evm for Interpreter {
 
 impl Interpreter {
 	#[cfg_attr(feature="dev", allow(cyclomatic_complexity))]
-	fn get_gas_cost_mem(&self,
-						ext: &evm::Ext,
-						instruction: Instruction,
-						mem: &mut Memory,
-						stack: &Stack<U256>
-					   ) -> Result<(U256, usize), evm::Error> {
+	fn get_gas_cost_mem(
+		&self,
+		ext: &evm::Ext,
+		instruction: Instruction,
+		mem: &mut Memory,
+		stack: &Stack<U256>
+	) -> Result<(U256, usize), evm::Error> {
 		let schedule = ext.schedule();
 		let info = instructions::get_info(instruction);
 
@@ -521,15 +522,17 @@ impl Interpreter {
 		Ok(overflowing!(offset.overflowing_add(size.clone())))
 	}
 
-	fn exec_instruction(&self,
-						gas: Gas,
-						params: &ActionParams,
-						ext: &mut evm::Ext,
-						instruction: Instruction,
-						code: &mut CodeReader,
-						mem: &mut Memory,
-						stack: &mut Stack<U256>
-					   ) -> Result<InstructionResult, evm::Error> {
+	#[cfg_attr(feature="dev", allow(too_many_arguments))]
+	fn exec_instruction(
+		&self,
+		gas: Gas,
+		params: &ActionParams,
+		ext: &mut evm::Ext,
+		instruction: Instruction,
+		code: &mut CodeReader,
+		mem: &mut Memory,
+		stack: &mut Stack<U256>
+	) -> Result<InstructionResult, evm::Error> {
 		match instruction {
 			instructions::JUMP => {
 				let jump = stack.pop_back();

ethcore/src/evm/jit.rs

@@ -207,7 +207,7 @@ impl<'a> evmjit::Ext for ExtAdapter<'a> {
 		let receive_address = unsafe { Address::from_jit(&*receive_address) };
 		let code_address = unsafe { Address::from_jit(&*code_address) };
 		let transfer_value = unsafe { U256::from_jit(&*transfer_value) };
-		let mut value = Some(transfer_value);
+		let value = Some(transfer_value);
 
 		// receive address and code address are the same in normal calls
 		let is_callcode = receive_address != code_address;

ethcore/src/executive.rs

@@ -21,11 +21,12 @@ use engine::*;
 use evm::{self, Ext};
 use externalities::*;
 use substate::*;
+use trace::{Trace, Tracer, NoopTracer, ExecutiveTracer};
 use crossbeam;
 
 /// Max depth to avoid stack overflow (when it's reached we start a new thread with VM)
 /// TODO [todr] We probably need some more sophisticated calculations here (limit on my machine 132)
-/// Maybe something like here: https://github.com/ethereum/libethereum/blob/4db169b8504f2b87f7d5a481819cfb959fc65f6c/libethereum/ExtVM.cpp
+/// Maybe something like here: `https://github.com/ethereum/libethereum/blob/4db169b8504f2b87f7d5a481819cfb959fc65f6c/libethereum/ExtVM.cpp`
 const MAX_VM_DEPTH_FOR_THREAD: usize = 64;
 
 /// Returns new address created from address and given nonce.
@@ -36,31 +37,48 @@ pub fn contract_address(address: &Address, nonce: &U256) -> Address {
 	From::from(stream.out().sha3())
 }
 
+/// Transaction execution options.
+pub struct TransactOptions {
+	/// Enable call tracing.
+	pub tracing: bool,
+	/// Check transaction nonce before execution.
+	pub check_nonce: bool,
+}
+
 /// Transaction execution receipt.
-#[derive(Debug)]
+#[derive(Debug, PartialEq, Clone)]
 pub struct Executed {
 	/// Gas paid up front for execution of transaction.
 	pub gas: U256,
+
 	/// Gas used during execution of transaction.
 	pub gas_used: U256,
+
 	/// Gas refunded after the execution of transaction.
 	/// To get gas that was required up front, add `refunded` and `gas_used`.
 	pub refunded: U256,
+
 	/// Cumulative gas used in current block so far.
 	///
 	/// `cumulative_gas_used = gas_used(t0) + gas_used(t1) + ... gas_used(tn)`
 	///
 	/// where `tn` is current transaction.
 	pub cumulative_gas_used: U256,
+
 	/// Vector of logs generated by transaction.
 	pub logs: Vec<LogEntry>,
+
 	/// Addresses of contracts created during execution of transaction.
 	/// Ordered from earliest creation.
 	///
 	/// eg. sender creates contract A and A in constructor creates contract B
 	///
 	/// B creation ends first, and it will be the first element of the vector.
-	pub contracts_created: Vec<Address>
+	pub contracts_created: Vec<Address>,
+	/// Transaction output.
+	pub output: Bytes,
+	/// The trace of this transaction.
+	pub trace: Option<Trace>,
 }
 
 /// Transaction execution result.
@@ -71,38 +89,46 @@ pub struct Executive<'a> {
 	state: &'a mut State,
 	info: &'a EnvInfo,
 	engine: &'a Engine,
-	depth: usize
+	depth: usize,
 }
 
 impl<'a> Executive<'a> {
 	/// Basic constructor.
 	pub fn new(state: &'a mut State, info: &'a EnvInfo, engine: &'a Engine) -> Self {
-		Executive::new_with_depth(state, info, engine, 0)
-	}
-
-	/// Populates executive from parent properties. Increments executive depth.
-	pub fn from_parent(state: &'a mut State, info: &'a EnvInfo, engine: &'a Engine, depth: usize) -> Self {
-		Executive::new_with_depth(state, info, engine, depth + 1)
-	}
-
-	/// Helper constructor. Should be used to create `Executive` with desired depth.
-	/// Private.
-	fn new_with_depth(state: &'a mut State, info: &'a EnvInfo, engine: &'a Engine, depth: usize) -> Self {
 		Executive {
 			state: state,
 			info: info,
 			engine: engine,
-			depth: depth
+			depth: 0,
+		}
+	}
+
+	/// Populates executive from parent properties. Increments executive depth.
+	pub fn from_parent(state: &'a mut State, info: &'a EnvInfo, engine: &'a Engine, parent_depth: usize) -> Self {
+		Executive {
+			state: state,
+			info: info,
+			engine: engine,
+			depth: parent_depth + 1,
 		}
 	}
 
 	/// Creates `Externalities` from `Executive`.
-	pub fn as_externalities<'_>(&'_ mut self, origin_info: OriginInfo, substate: &'_ mut Substate, output: OutputPolicy<'_>) -> Externalities {
-		Externalities::new(self.state, self.info, self.engine, self.depth, origin_info, substate, output)
+	pub fn as_externalities<'_, T>(&'_ mut self, origin_info: OriginInfo, substate: &'_ mut Substate, output: OutputPolicy<'_, '_>, tracer: &'_ mut T) -> Externalities<'_, T> where T: Tracer {
+		Externalities::new(self.state, self.info, self.engine, self.depth, origin_info, substate, output, tracer)
 	}
 
-	/// This funtion should be used to execute transaction.
-	pub fn transact(&'a mut self, t: &SignedTransaction) -> Result<Executed, Error> {
+	/// This function should be used to execute transaction.
+	pub fn transact(&'a mut self, t: &SignedTransaction, options: TransactOptions) -> Result<Executed, Error> {
+		let check = options.check_nonce;
+		match options.tracing {
+			true => self.transact_with_tracer(t, check, ExecutiveTracer::default()),
+			false => self.transact_with_tracer(t, check, NoopTracer),
+		}
+	}
+
+	/// Execute transaction/call with tracing enabled
+	pub fn transact_with_tracer<T>(&'a mut self, t: &SignedTransaction, check_nonce: bool, mut tracer: T) -> Result<Executed, Error> where T: Tracer {
 		let sender = try!(t.sender());
 		let nonce = self.state.nonce(&sender);
 
@@ -116,7 +142,7 @@ impl<'a> Executive<'a> {
 		let init_gas = t.gas - base_gas_required;
 
 		// validate transaction nonce
-		if t.nonce != nonce {
+		if check_nonce && t.nonce != nonce {
 			return Err(From::from(ExecutionError::InvalidNonce { expected: nonce, got: t.nonce }));
 		}
 
@@ -145,7 +171,7 @@ impl<'a> Executive<'a> {
 
 		let mut substate = Substate::new();
 
-		let res = match t.action {
+		let (gas_left, output) = match t.action {
 			Action::Create => {
 				let new_address = contract_address(&sender, &nonce);
 				let params = ActionParams {
@@ -159,7 +185,7 @@ impl<'a> Executive<'a> {
 					code: Some(t.data.clone()),
 					data: None,
 				};
-				self.create(params, &mut substate)
+				(self.create(params, &mut substate, &mut tracer), vec![])
 			},
 			Action::Call(ref address) => {
 				let params = ActionParams {
@@ -175,19 +201,21 @@ impl<'a> Executive<'a> {
 				};
 				// TODO: move output upstream
 				let mut out = vec![];
-				self.call(params, &mut substate, BytesRef::Flexible(&mut out))
+				(self.call(params, &mut substate, BytesRef::Flexible(&mut out), &mut tracer), out)
 			}
 		};
 
 		// finalize here!
-		Ok(try!(self.finalize(t, substate, res)))
+		Ok(try!(self.finalize(t, substate, gas_left, output, tracer.traces().pop())))
 	}
 
-	fn exec_vm(&mut self, params: ActionParams, unconfirmed_substate: &mut Substate, output_policy: OutputPolicy) -> evm::Result {
+	fn exec_vm<T>(&mut self, params: ActionParams, unconfirmed_substate: &mut Substate, output_policy: OutputPolicy, tracer: &mut T)
+		-> evm::Result where T: Tracer {
 		// Ordinary execution - keep VM in same thread
 		if (self.depth + 1) % MAX_VM_DEPTH_FOR_THREAD != 0 {
-			let mut ext = self.as_externalities(OriginInfo::from(&params), unconfirmed_substate, output_policy);
+			let mut ext = self.as_externalities(OriginInfo::from(&params), unconfirmed_substate, output_policy, tracer);
 			let vm_factory = self.engine.vm_factory();
+			trace!(target: "executive", "ext.schedule.have_delegate_call: {}", ext.schedule().have_delegate_call);
 			return vm_factory.create().exec(params, &mut ext);
 		}
 
@@ -195,7 +223,7 @@ impl<'a> Executive<'a> {
 		// TODO [todr] No thread builder yet, so we need to reset once for a while
 		// https://github.com/aturon/crossbeam/issues/16
 		crossbeam::scope(|scope| {
-			let mut ext = self.as_externalities(OriginInfo::from(&params), unconfirmed_substate, output_policy);
+			let mut ext = self.as_externalities(OriginInfo::from(&params), unconfirmed_substate, output_policy, tracer);
 			let vm_factory = self.engine.vm_factory();
 
 			scope.spawn(move || {
@@ -208,7 +236,8 @@ impl<'a> Executive<'a> {
 	/// NOTE. It does not finalize the transaction (doesn't do refunds, nor suicides).
 	/// Modifies the substate and the output.
 	/// Returns either gas_left or `evm::Error`.
-	pub fn call(&mut self, params: ActionParams, substate: &mut Substate, mut output: BytesRef) -> evm::Result {
+	pub fn call<T>(&mut self, params: ActionParams, substate: &mut Substate, mut output: BytesRef, tracer: &mut T)
+		-> evm::Result where T: Tracer {
 		// backup used in case of running out of gas
 		self.state.snapshot();
 
@@ -218,51 +247,99 @@ 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
 
 			let default = [];
 			let data = if let Some(ref d) = params.data { d as &[u8] } else { &default as &[u8] };
 
+			let trace_info = tracer.prepare_trace_call(&params);
+
 			let cost = self.engine.cost_of_builtin(&params.code_address, data);
 			match cost <= params.gas {
 				true => {
 					self.engine.execute_builtin(&params.code_address, data, &mut output);
 					self.state.clear_snapshot();
+
+					// trace only top level calls to builtins to avoid DDoS attacks
+					if self.depth == 0 {
+						let mut trace_output = tracer.prepare_trace_output();
+						if let Some(mut out) = trace_output.as_mut() {
+							*out = output.to_owned();
+						}
+
+						tracer.trace_call(
+							trace_info,
+							cost,
+							trace_output,
+							self.depth,
+							vec![],
+							delegate_call
+						);
+					}
+
 					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);
+
 					Err(evm::Error::OutOfGas)
 				}
 			}
-		} else if params.code.is_some() {
-			// if destination is a contract, do normal message call
-
-			// part of substate that may be reverted
-			let mut unconfirmed_substate = Substate::new();
-
-			let res = {
-				self.exec_vm(params, &mut unconfirmed_substate, OutputPolicy::Return(output))
-			};
-
-			trace!("exec: sstore-clears={}\n", unconfirmed_substate.sstore_clears_count);
-			trace!("exec: substate={:?}; unconfirmed_substate={:?}\n", substate, unconfirmed_substate);
-			self.enact_result(&res, substate, unconfirmed_substate);
-			trace!("exec: new substate={:?}\n", substate);
-			res
 		} else {
-			// otherwise, nothing
-			self.state.clear_snapshot();
-			Ok(params.gas)
+			let trace_info = tracer.prepare_trace_call(&params);
+			let mut trace_output = tracer.prepare_trace_output();
+			let mut subtracer = tracer.subtracer();
+			let gas = params.gas;
+
+			if params.code.is_some() {
+				// part of substate that may be reverted
+				let mut unconfirmed_substate = Substate::new();
+
+				let res = {
+					self.exec_vm(params, &mut unconfirmed_substate, OutputPolicy::Return(output, trace_output.as_mut()), &mut subtracer)
+				};
+
+				trace!(target: "executive", "res={:?}", res);
+
+				let traces = subtracer.traces();
+				match res {
+					Ok(gas_left) => tracer.trace_call(
+						trace_info,
+						gas - gas_left,
+						trace_output,
+						self.depth,
+						traces,
+						delegate_call
+					),
+					_ => tracer.trace_failed_call(trace_info, self.depth, traces, delegate_call),
+				};
+
+				trace!(target: "executive", "substate={:?}; unconfirmed_substate={:?}\n", substate, unconfirmed_substate);
+
+				self.enact_result(&res, substate, unconfirmed_substate);
+				trace!(target: "executive", "enacted: substate={:?}\n", substate);
+				res
+			} else {
+				// 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);
+				Ok(params.gas)
+			}
 		}
 	}
 
 	/// Creates contract with given contract params.
 	/// NOTE. It does not finalize the transaction (doesn't do refunds, nor suicides).
 	/// Modifies the substate.
-	pub fn create(&mut self, params: ActionParams, substate: &mut Substate) -> evm::Result {
+	pub fn create<T>(&mut self, params: ActionParams, substate: &mut Substate, tracer: &mut T) -> evm::Result where T:
+		Tracer {
 		// backup used in case of running out of gas
 		self.state.snapshot();
 
@@ -278,15 +355,34 @@ impl<'a> Executive<'a> {
 			self.state.new_contract(&params.address, prev_bal);
 		}
 
+		let trace_info = tracer.prepare_trace_create(&params);
+		let mut trace_output = tracer.prepare_trace_output();
+		let mut subtracer = tracer.subtracer();
+		let gas = params.gas;
+		let created = params.address.clone();
+
 		let res = {
-			self.exec_vm(params, &mut unconfirmed_substate, OutputPolicy::InitContract)
+			self.exec_vm(params, &mut unconfirmed_substate, OutputPolicy::InitContract(trace_output.as_mut()), &mut subtracer)
 		};
+
+		match res {
+			Ok(gas_left) => tracer.trace_create(
+				trace_info,
+				gas - gas_left,
+				trace_output,
+				created,
+				self.depth,
+				subtracer.traces()
+			),
+			_ => tracer.trace_failed_create(trace_info, self.depth, subtracer.traces())
+		};
+
 		self.enact_result(&res, substate, unconfirmed_substate);
 		res
 	}
 
 	/// Finalizes the transaction (does refunds and suicides).
-	fn finalize(&mut self, t: &SignedTransaction, substate: Substate, result: evm::Result) -> ExecutionResult {
+	fn finalize(&mut self, t: &SignedTransaction, substate: Substate, result: evm::Result, output: Bytes, trace: Option<Trace>) -> ExecutionResult {
 		let schedule = self.engine.schedule(self.info);
 
 		// refunds from SSTORE nonzero -> zero
@@ -326,7 +422,9 @@ impl<'a> Executive<'a> {
 					refunded: U256::zero(),
 					cumulative_gas_used: self.info.gas_used + t.gas,
 					logs: vec![],
-					contracts_created: vec![]
+					contracts_created: vec![],
+					output: output,
+					trace: trace,
 				})
 			},
 			_ => {
@@ -337,6 +435,8 @@ impl<'a> Executive<'a> {
 					cumulative_gas_used: self.info.gas_used + gas_used,
 					logs: substate.logs,
 					contracts_created: substate.contracts_created,
+					output: output,
+					trace: trace,
 				})
 			},
 		}
@@ -349,11 +449,11 @@ impl<'a> Executive<'a> {
 				| Err(evm::Error::BadInstruction {.. })
 				| Err(evm::Error::StackUnderflow {..})
 				| Err(evm::Error::OutOfStack {..}) => {
-				self.state.revert_snapshot();
+					self.state.revert_snapshot();
 			},
 			Ok(_) | Err(evm::Error::Internal) => {
 				self.state.clear_snapshot();
-				substate.accrue(un_substate)
+				substate.accrue(un_substate);
 			}
 		}
 	}
@@ -367,6 +467,8 @@ mod tests {
 	use evm::{Factory, VMType};
 	use substate::*;
 	use tests::helpers::*;
+	use trace::trace;
+	use trace::{Trace, Tracer, NoopTracer, ExecutiveTracer};
 
 	#[test]
 	fn test_contract_address() {
@@ -395,7 +497,7 @@ mod tests {
 
 		let gas_left = {
 			let mut ex = Executive::new(&mut state, &info, &engine);
-			ex.create(params, &mut substate).unwrap()
+			ex.create(params, &mut substate, &mut NoopTracer).unwrap()
 		};
 
 		assert_eq!(gas_left, U256::from(79_975));
@@ -408,8 +510,8 @@ mod tests {
 		// TODO: just test state root.
 	}
 
-	evm_test!{test_create_contract: test_create_contract_jit, test_create_contract_int}
-	fn test_create_contract(factory: Factory) {
+	evm_test!{test_create_contract_out_of_depth: test_create_contract_out_of_depth_jit, test_create_contract_out_of_depth_int}
+	fn test_create_contract_out_of_depth(factory: Factory) {
 		// code:
 		//
 		// 7c 601080600c6000396000f3006000355415600957005b60203560003555 - push 29 bytes?
@@ -454,7 +556,7 @@ mod tests {
 
 		let gas_left = {
 			let mut ex = Executive::new(&mut state, &info, &engine);
-			ex.create(params, &mut substate).unwrap()
+			ex.create(params, &mut substate, &mut NoopTracer).unwrap()
 		};
 
 		assert_eq!(gas_left, U256::from(62_976));
@@ -462,6 +564,149 @@ mod tests {
 		assert_eq!(substate.contracts_created.len(), 0);
 	}
 
+	evm_test!{test_call_to_create: test_call_to_create_jit, test_call_to_create_int}
+	fn test_call_to_create(factory: Factory) {
+		// code:
+		//
+		// 7c 601080600c6000396000f3006000355415600957005b60203560003555 - push 29 bytes?
+		// 60 00 - push 0
+		// 52
+		// 60 1d - push 29
+		// 60 03 - push 3
+		// 60 17 - push 17
+		// f0 - create
+		// 60 00 - push 0
+		// 55 sstore
+		//
+		// other code:
+		//
+		// 60 10 - push 16
+		// 80 - duplicate first stack item
+		// 60 0c - push 12
+		// 60 00 - push 0
+		// 39 - copy current code to memory
+		// 60 00 - push 0
+		// f3 - return
+
+		let code = "7c601080600c6000396000f3006000355415600957005b60203560003555600052601d60036017f0600055".from_hex().unwrap();
+
+		let sender = Address::from_str("cd1722f3947def4cf144679da39c4c32bdc35681").unwrap();
+		let address = contract_address(&sender, &U256::zero());
+		// TODO: add tests for 'callcreate'
+		//let next_address = contract_address(&address, &U256::zero());
+		let mut params = ActionParams::default();
+		params.address = address.clone();
+		params.code_address = address.clone();
+		params.sender = sender.clone();
+		params.origin = sender.clone();
+		params.gas = U256::from(100_000);
+		params.code = Some(code.clone());
+		params.value = ActionValue::Transfer(U256::from(100));
+		let mut state_result = get_temp_state();
+		let mut state = state_result.reference_mut();
+		state.add_balance(&sender, &U256::from(100));
+		let info = EnvInfo::default();
+		let engine = TestEngine::new(5, factory);
+		let mut substate = Substate::new();
+		let mut tracer = ExecutiveTracer::default();
+
+		let gas_left = {
+			let mut ex = Executive::new(&mut state, &info, &engine);
+			let output = BytesRef::Fixed(&mut[0u8;0]);
+			ex.call(params, &mut substate, output, &mut tracer).unwrap()
+		};
+
+		let expected_trace = vec![ Trace {
+			depth: 0,
+			action: trace::Action::Call(trace::Call {
+				from: x!("cd1722f3947def4cf144679da39c4c32bdc35681"),
+				to: x!("b010143a42d5980c7e5ef0e4a4416dc098a4fed3"),
+				value: x!(100),
+				gas: x!(100000),
+				input: vec![],
+			}),
+			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: x!("b010143a42d5980c7e5ef0e4a4416dc098a4fed3"),
+					value: x!(23),
+					gas: x!(67979),
+					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![]
+			}]
+		}];
+		assert_eq!(tracer.traces(), expected_trace);
+		assert_eq!(gas_left, U256::from(44_752));
+	}
+
+	evm_test!{test_create_contract: test_create_contract_jit, test_create_contract_int}
+	fn test_create_contract(factory: Factory) {
+		// code:
+		//
+		// 60 10 - push 16
+		// 80 - duplicate first stack item
+		// 60 0c - push 12
+		// 60 00 - push 0
+		// 39 - copy current code to memory
+		// 60 00 - push 0
+		// f3 - return
+
+		let code = "601080600c6000396000f3006000355415600957005b60203560003555".from_hex().unwrap();
+
+		let sender = Address::from_str("cd1722f3947def4cf144679da39c4c32bdc35681").unwrap();
+		let address = contract_address(&sender, &U256::zero());
+		// TODO: add tests for 'callcreate'
+		//let next_address = contract_address(&address, &U256::zero());
+		let mut params = ActionParams::default();
+		params.address = address.clone();
+		params.sender = sender.clone();
+		params.origin = sender.clone();
+		params.gas = U256::from(100_000);
+		params.code = Some(code.clone());
+		params.value = ActionValue::Transfer(x!(100));
+		let mut state_result = get_temp_state();
+		let mut state = state_result.reference_mut();
+		state.add_balance(&sender, &U256::from(100));
+		let info = EnvInfo::default();
+		let engine = TestEngine::new(5, factory);
+		let mut substate = Substate::new();
+		let mut tracer = ExecutiveTracer::default();
+
+		let gas_left = {
+			let mut ex = Executive::new(&mut state, &info, &engine);
+			ex.create(params.clone(), &mut substate, &mut tracer).unwrap()
+		};
+
+		let expected_trace = vec![Trace {
+			depth: 0,
+			action: trace::Action::Create(trace::Create {
+				from: params.sender,
+				value: x!(100),
+				gas: params.gas,
+				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: 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);
+		assert_eq!(gas_left, U256::from(96_776));
+	}
+
 	evm_test!{test_create_contract_value_too_high: test_create_contract_value_too_high_jit, test_create_contract_value_too_high_int}
 	fn test_create_contract_value_too_high(factory: Factory) {
 		// code:
@@ -508,7 +753,7 @@ mod tests {
 
 		let gas_left = {
 			let mut ex = Executive::new(&mut state, &info, &engine);
-			ex.create(params, &mut substate).unwrap()
+			ex.create(params, &mut substate, &mut NoopTracer).unwrap()
 		};
 
 		assert_eq!(gas_left, U256::from(62_976));
@@ -560,7 +805,7 @@ mod tests {
 
 		{
 			let mut ex = Executive::new(&mut state, &info, &engine);
-			ex.create(params, &mut substate).unwrap();
+			ex.create(params, &mut substate, &mut NoopTracer).unwrap();
 		}
 
 		assert_eq!(substate.contracts_created.len(), 1);
@@ -621,7 +866,7 @@ mod tests {
 
 		let gas_left = {
 			let mut ex = Executive::new(&mut state, &info, &engine);
-			ex.call(params, &mut substate, BytesRef::Fixed(&mut [])).unwrap()
+			ex.call(params, &mut substate, BytesRef::Fixed(&mut []), &mut NoopTracer).unwrap()
 		};
 
 		assert_eq!(gas_left, U256::from(73_237));
@@ -666,7 +911,7 @@ mod tests {
 
 		let gas_left = {
 			let mut ex = Executive::new(&mut state, &info, &engine);
-			ex.call(params, &mut substate, BytesRef::Fixed(&mut [])).unwrap()
+			ex.call(params, &mut substate, BytesRef::Fixed(&mut []), &mut NoopTracer).unwrap()
 		};
 
 		assert_eq!(gas_left, U256::from(59_870));
@@ -699,7 +944,8 @@ mod tests {
 
 		let executed = {
 			let mut ex = Executive::new(&mut state, &info, &engine);
-			ex.transact(&t).unwrap()
+			let opts = TransactOptions { check_nonce: true, tracing: false };
+			ex.transact(&t, opts).unwrap()
 		};
 
 		assert_eq!(executed.gas, U256::from(100_000));
@@ -723,7 +969,7 @@ mod tests {
 			gas: U256::from(100_000),
 			gas_price: U256::zero(),
 			nonce: U256::zero()
-		}.fake_sign();
+		}.invalid_sign();
 		let mut state_result = get_temp_state();
 		let mut state = state_result.reference_mut();
 		let mut info = EnvInfo::default();
@@ -732,7 +978,8 @@ mod tests {
 
 		let res = {
 			let mut ex = Executive::new(&mut state, &info, &engine);
-			ex.transact(&t)
+			let opts = TransactOptions { check_nonce: true, tracing: false };
+			ex.transact(&t, opts)
 		};
 
 		match res {
@@ -763,7 +1010,8 @@ mod tests {
 
 		let res = {
 			let mut ex = Executive::new(&mut state, &info, &engine);
-			ex.transact(&t)
+			let opts = TransactOptions { check_nonce: true, tracing: false };
+			ex.transact(&t, opts)
 		};
 
 		match res {
@@ -796,7 +1044,8 @@ mod tests {
 
 		let res = {
 			let mut ex = Executive::new(&mut state, &info, &engine);
-			ex.transact(&t)
+			let opts = TransactOptions { check_nonce: true, tracing: false };
+			ex.transact(&t, opts)
 		};
 
 		match res {
@@ -829,7 +1078,8 @@ mod tests {
 
 		let res = {
 			let mut ex = Executive::new(&mut state, &info, &engine);
-			ex.transact(&t)
+			let opts = TransactOptions { check_nonce: true, tracing: false };
+			ex.transact(&t, opts)
 		};
 
 		match res {
@@ -863,7 +1113,7 @@ mod tests {
 
 		let result = {
 			let mut ex = Executive::new(&mut state, &info, &engine);
-			ex.create(params, &mut substate)
+			ex.create(params, &mut substate, &mut NoopTracer)
 		};
 
 		match result {

ethcore/src/externalities.rs

@@ -21,14 +21,15 @@ use engine::*;
 use executive::*;
 use evm::{self, Schedule, Ext, ContractCreateResult, MessageCallResult};
 use substate::*;
+use trace::Tracer;
 
 /// Policy for handling output data on `RETURN` opcode.
-pub enum OutputPolicy<'a> {
+pub enum OutputPolicy<'a, 'b> {
 	/// Return reference to fixed sized output.
 	/// Used for message calls.
-	Return(BytesRef<'a>),
+	Return(BytesRef<'a>, Option<&'b mut Bytes>),
 	/// Init new contract as soon as `RETURN` is called.
-	InitContract
+	InitContract(Option<&'b mut Bytes>),
 }
 
 /// Transaction properties that externalities need to know about.
@@ -54,7 +55,7 @@ impl OriginInfo {
 }
 
 /// Implementation of evm Externalities.
-pub struct Externalities<'a> {
+pub struct Externalities<'a, T> where T: 'a + Tracer {
 	state: &'a mut State,
 	env_info: &'a EnvInfo,
 	engine: &'a Engine,
@@ -62,18 +63,23 @@ pub struct Externalities<'a> {
 	origin_info: OriginInfo,
 	substate: &'a mut Substate,
 	schedule: Schedule,
-	output: OutputPolicy<'a>
+	output: OutputPolicy<'a, 'a>,
+	tracer: &'a mut T,
 }
 
-impl<'a> Externalities<'a> {
+impl<'a, T> Externalities<'a, T> where T: 'a + Tracer {
+
+	#[cfg_attr(feature="dev", allow(too_many_arguments))]
 	/// Basic `Externalities` constructor.
 	pub fn new(state: &'a mut State,
-			   env_info: &'a EnvInfo,
-			   engine: &'a Engine,
-			   depth: usize,
-			   origin_info: OriginInfo,
-			   substate: &'a mut Substate,
-			   output: OutputPolicy<'a>) -> Self {
+		env_info: &'a EnvInfo,
+		engine: &'a Engine,
+		depth: usize,
+		origin_info: OriginInfo,
+		substate: &'a mut Substate,
+		output: OutputPolicy<'a, 'a>,
+		tracer: &'a mut T,
+	) -> Self {
 		Externalities {
 			state: state,
 			env_info: env_info,
@@ -82,12 +88,13 @@ impl<'a> Externalities<'a> {
 			origin_info: origin_info,
 			substate: substate,
 			schedule: engine.schedule(env_info),
-			output: output
+			output: output,
+			tracer: tracer,
 		}
 	}
 }
 
-impl<'a> Ext for Externalities<'a> {
+impl<'a, T> Ext for Externalities<'a, T> where T: 'a + Tracer {
 	fn storage_at(&self, key: &H256) -> H256 {
 		self.state.storage_at(&self.origin_info.address, key)
 	}
@@ -142,7 +149,7 @@ impl<'a> Ext for Externalities<'a> {
 		let mut ex = Executive::from_parent(self.state, self.env_info, self.engine, self.depth);
 
 		// TODO: handle internal error separately
-		match ex.create(params, self.substate) {
+		match ex.create(params, self.substate, self.tracer) {
 			Ok(gas_left) => {
 				self.substate.contracts_created.push(address.clone());
 				ContractCreateResult::Created(address, gas_left)
@@ -152,13 +159,15 @@ impl<'a> Ext for Externalities<'a> {
 	}
 
 	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]
+	) -> MessageCallResult {
+		trace!(target: "externalities", "call");
 
 		let mut params = ActionParams {
 			sender: sender_address.clone(),
@@ -178,7 +187,7 @@ impl<'a> Ext for Externalities<'a> {
 
 		let mut ex = Executive::from_parent(self.state, self.env_info, self.engine, self.depth);
 
-		match ex.call(params, self.substate, BytesRef::Fixed(output)) {
+		match ex.call(params, self.substate, BytesRef::Fixed(output), self.tracer) {
 			Ok(gas_left) => MessageCallResult::Success(gas_left),
 			_ => MessageCallResult::Failed
 		}
@@ -190,20 +199,31 @@ impl<'a> Ext for Externalities<'a> {
 
 	#[cfg_attr(feature="dev", allow(match_ref_pats))]
 	fn ret(&mut self, gas: &U256, data: &[u8]) -> Result<U256, evm::Error> {
-		match &mut self.output {
-			&mut OutputPolicy::Return(BytesRef::Fixed(ref mut slice)) => unsafe {
+		let handle_copy = |to: &mut Option<&mut Bytes>| {
+			to.as_mut().map(|b| **b = data.to_owned());
+		};
+		match self.output {
+			OutputPolicy::Return(BytesRef::Fixed(ref mut slice), ref mut copy) => {
+				handle_copy(copy);
+
 				let len = cmp::min(slice.len(), data.len());
-				ptr::copy(data.as_ptr(), slice.as_mut_ptr(), len);
+				unsafe {
+					ptr::copy(data.as_ptr(), slice.as_mut_ptr(), len);
+				}
 				Ok(*gas)
 			},
-			&mut OutputPolicy::Return(BytesRef::Flexible(ref mut vec)) => unsafe {
+			OutputPolicy::Return(BytesRef::Flexible(ref mut vec), ref mut copy) => {
+				handle_copy(copy);
+
 				vec.clear();
 				vec.reserve(data.len());
-				ptr::copy(data.as_ptr(), vec.as_mut_ptr(), data.len());
-				vec.set_len(data.len());
+				unsafe {
+					ptr::copy(data.as_ptr(), vec.as_mut_ptr(), data.len());
+					vec.set_len(data.len());
+				}
 				Ok(*gas)
 			},
-			&mut OutputPolicy::InitContract => {
+			OutputPolicy::InitContract(ref mut copy) => {
 				let return_cost = U256::from(data.len()) * U256::from(self.schedule.create_data_gas);
 				if return_cost > *gas {
 					return match self.schedule.exceptional_failed_code_deposit {
@@ -211,14 +231,16 @@ impl<'a> Ext for Externalities<'a> {
 						false => Ok(*gas)
 					}
 				}
+
+				handle_copy(copy);
+
 				let mut code = vec![];
 				code.reserve(data.len());
 				unsafe {
 					ptr::copy(data.as_ptr(), code.as_mut_ptr(), data.len());
 					code.set_len(data.len());
 				}
-				let address = &self.origin_info.address;
-				self.state.init_code(address, code);
+				self.state.init_code(&self.origin_info.address, code);
 				Ok(*gas - return_cost)
 			}
 		}
@@ -272,6 +294,7 @@ mod tests {
 	use substate::*;
 	use tests::helpers::*;
 	use super::*;
+	use trace::{NoopTracer};
 
 	fn get_test_origin() -> OriginInfo {
 		OriginInfo {
@@ -311,7 +334,7 @@ mod tests {
 		fn new() -> Self {
 			TestSetup {
 				state: get_temp_state(),
-				engine: get_test_spec().to_engine().unwrap(),
+				engine: get_test_spec().engine,
 				sub_state: Substate::new(),
 				env_info: get_test_env_info()
 			}
@@ -322,8 +345,9 @@ mod tests {
 	fn can_be_created() {
 		let mut setup = TestSetup::new();
 		let state = setup.state.reference_mut();
+		let mut tracer = NoopTracer;
 
-		let ext = Externalities::new(state, &setup.env_info, &*setup.engine, 0, get_test_origin(), &mut setup.sub_state, OutputPolicy::InitContract);
+		let ext = Externalities::new(state, &setup.env_info, &*setup.engine, 0, get_test_origin(), &mut setup.sub_state, OutputPolicy::InitContract(None), &mut tracer);
 
 		assert_eq!(ext.env_info().number, 100);
 	}
@@ -332,7 +356,9 @@ mod tests {
 	fn can_return_block_hash_no_env() {
 		let mut setup = TestSetup::new();
 		let state = setup.state.reference_mut();
-		let ext = Externalities::new(state, &setup.env_info, &*setup.engine, 0, get_test_origin(), &mut setup.sub_state, OutputPolicy::InitContract);
+		let mut tracer = NoopTracer;
+
+		let ext = Externalities::new(state, &setup.env_info, &*setup.engine, 0, get_test_origin(), &mut setup.sub_state, OutputPolicy::InitContract(None), &mut tracer);
 
 		let hash = ext.blockhash(&U256::from_str("0000000000000000000000000000000000000000000000000000000000120000").unwrap());
 
@@ -351,7 +377,9 @@ mod tests {
 			env_info.last_hashes.push(test_hash.clone());
 		}
 		let state = setup.state.reference_mut();
-		let ext = Externalities::new(state, &setup.env_info, &*setup.engine, 0, get_test_origin(), &mut setup.sub_state, OutputPolicy::InitContract);
+		let mut tracer = NoopTracer;
+
+		let ext = Externalities::new(state, &setup.env_info, &*setup.engine, 0, get_test_origin(), &mut setup.sub_state, OutputPolicy::InitContract(None), &mut tracer);
 
 		let hash = ext.blockhash(&U256::from_str("0000000000000000000000000000000000000000000000000000000000120000").unwrap());
 
@@ -363,7 +391,9 @@ mod tests {
 	fn can_call_fail_empty() {
 		let mut setup = TestSetup::new();
 		let state = setup.state.reference_mut();
-		let mut ext = Externalities::new(state, &setup.env_info, &*setup.engine, 0, get_test_origin(), &mut setup.sub_state, OutputPolicy::InitContract);
+		let mut tracer = NoopTracer;
+
+		let mut ext = Externalities::new(state, &setup.env_info, &*setup.engine, 0, get_test_origin(), &mut setup.sub_state, OutputPolicy::InitContract(None), &mut tracer);
 
 		let mut output = vec![];
 
@@ -385,9 +415,10 @@ mod tests {
 
 		let mut setup = TestSetup::new();
 		let state = setup.state.reference_mut();
+		let mut tracer = NoopTracer;
 
 		{
-			let mut ext = Externalities::new(state, &setup.env_info, &*setup.engine, 0, get_test_origin(), &mut setup.sub_state, OutputPolicy::InitContract);
+			let mut ext = Externalities::new(state, &setup.env_info, &*setup.engine, 0, get_test_origin(), &mut setup.sub_state, OutputPolicy::InitContract(None), &mut tracer);
 			ext.log(log_topics, &log_data);
 		}
 
@@ -400,9 +431,10 @@ mod tests {
 
 		let mut setup = TestSetup::new();
 		let state = setup.state.reference_mut();
+		let mut tracer = NoopTracer;
 
 		{
-			let mut ext = Externalities::new(state, &setup.env_info, &*setup.engine, 0, get_test_origin(), &mut setup.sub_state, OutputPolicy::InitContract);
+			let mut ext = Externalities::new(state, &setup.env_info, &*setup.engine, 0, get_test_origin(), &mut setup.sub_state, OutputPolicy::InitContract(None), &mut tracer);
 			ext.suicide(&refund_account);
 		}
 

ethcore/src/extras.rs

@@ -19,6 +19,7 @@
 use util::*;
 use header::BlockNumber;
 use receipt::Receipt;
+use db::Key;
 
 /// Represents index of extra data in database
 #[derive(Copy, Debug, Hash, Eq, PartialEq, Clone)]
@@ -37,95 +38,100 @@ pub enum ExtrasIndex {
 	BlockReceipts = 5,
 }
 
-/// trait used to write Extras data to db
-pub trait ExtrasWritable {
-	/// Write extra data to db
-	fn put_extras<K, T>(&self, hash: &K, value: &T) where
-		T: ExtrasIndexable + Encodable,
-		K: ExtrasSliceConvertable;
+fn with_index(hash: &H256, i: ExtrasIndex) -> H264 {
+	let mut slice = H264::from_slice(hash);
+	slice[32] = i as u8;
+	slice
 }
 
-/// trait used to read Extras data from db
-pub trait ExtrasReadable {
-	/// Read extra data from db
-	fn get_extras<K, T>(&self, hash: &K) -> Option<T> where
-		T: ExtrasIndexable + Decodable,
-		K: ExtrasSliceConvertable;
-
-	/// Check if extra data exists in the db
-	fn extras_exists<K, T>(&self, hash: &K) -> bool where
-		T: ExtrasIndexable,
-		K: ExtrasSliceConvertable;
-}
-
-impl ExtrasWritable for DBTransaction {
-	fn put_extras<K, T>(&self, hash: &K, value: &T) where
-		T: ExtrasIndexable + Encodable,
-		K: ExtrasSliceConvertable {
-
-		self.put(&hash.to_extras_slice(T::extras_index()), &encode(value)).unwrap()
-	}
-}
-
-impl ExtrasReadable for Database {
-	fn get_extras<K, T>(&self, hash: &K) -> Option<T> where
-		T: ExtrasIndexable + Decodable,
-		K: ExtrasSliceConvertable {
-
-		self.get(&hash.to_extras_slice(T::extras_index())).unwrap()
-			.map(|v| decode(&v))
-	}
-
-	fn extras_exists<K, T>(&self, hash: &K) -> bool where
-		T: ExtrasIndexable,
-		K: ExtrasSliceConvertable {
-
-		self.get(&hash.to_extras_slice(T::extras_index())).unwrap().is_some()
-	}
-}
-
-/// Implementations should convert arbitrary type to database key slice
-pub trait ExtrasSliceConvertable {
-	/// Convert self, with `i` (the index), to a 264-bit extras DB key.
-	fn to_extras_slice(&self, i: ExtrasIndex) -> H264;
-	/// Interpret self as a 256-bit hash, if natively `H256`.
-	fn as_h256(&self) -> Option<&H256> { None }
-}
-
-impl ExtrasSliceConvertable for H256 {
-	fn to_extras_slice(&self, i: ExtrasIndex) -> H264 {
-		let mut slice = H264::from_slice(self);
-		slice[32] = i as u8;
-		slice
-	}
-	fn as_h256(&self) -> Option<&H256> { Some(self) }
-}
-
-impl ExtrasSliceConvertable for U256 {
-	fn to_extras_slice(&self, i: ExtrasIndex) -> H264 {
-		H256::from(self).to_extras_slice(i)
-	}
-}
-
-// NICE: make less horrible.
-impl ExtrasSliceConvertable for BlockNumber {
-	fn to_extras_slice(&self, i: ExtrasIndex) -> H264 {
-		U256::from(*self).to_extras_slice(i)
-	}
-}
-
-/// Types implementing this trait can be indexed in extras database
 pub trait ExtrasIndexable {
-	/// Returns this data index
-	fn extras_index() -> ExtrasIndex;
+	fn index() -> ExtrasIndex;
 }
 
 impl ExtrasIndexable for H256 {
-	fn extras_index() -> ExtrasIndex {
+	fn index() -> ExtrasIndex {
 		ExtrasIndex::BlockHash
 	}
 }
 
+impl ExtrasIndexable for BlockDetails {
+	fn index() -> ExtrasIndex {
+		ExtrasIndex::BlockDetails
+	}
+}
+
+impl ExtrasIndexable for TransactionAddress {
+	fn index() -> ExtrasIndex {
+		ExtrasIndex::TransactionAddress
+	}
+}
+
+impl ExtrasIndexable for BlockLogBlooms {
+	fn index() -> ExtrasIndex {
+		ExtrasIndex::BlockLogBlooms
+	}
+}
+
+impl ExtrasIndexable for BlocksBlooms {
+	fn index() -> ExtrasIndex {
+		ExtrasIndex::BlocksBlooms
+	}
+}
+
+impl ExtrasIndexable for BlockReceipts {
+	fn index() -> ExtrasIndex {
+		ExtrasIndex::BlockReceipts
+	}
+}
+
+impl Key<H256> for BlockNumber {
+	type Target = H264;
+
+	fn key(&self) -> H264 {
+		with_index(&H256::from(*self), ExtrasIndex::BlockHash)
+	}
+}
+
+impl Key<BlockDetails> for H256 {
+	type Target = H264;
+
+	fn key(&self) -> H264 {
+		with_index(self, ExtrasIndex::BlockDetails)
+	}
+}
+
+impl Key<TransactionAddress> for H256 {
+	type Target = H264;
+
+	fn key(&self) -> H264 {
+		with_index(self, ExtrasIndex::TransactionAddress)
+	}
+}
+
+impl Key<BlockLogBlooms> for H256 {
+	type Target = H264;
+
+	fn key(&self) -> H264 {
+		with_index(self, ExtrasIndex::BlockLogBlooms)
+	}
+}
+
+impl Key<BlocksBlooms> for H256 {
+	type Target = H264;
+
+	fn key(&self) -> H264 {
+		with_index(self, ExtrasIndex::BlocksBlooms)
+	}
+}
+
+impl Key<BlockReceipts> for H256 {
+	type Target = H264;
+
+	fn key(&self) -> H264 {
+		with_index(self, ExtrasIndex::BlockReceipts)
+	}
+}
+
 /// Familial details concerning a block
 #[derive(Debug, Clone)]
 pub struct BlockDetails {
@@ -139,12 +145,6 @@ pub struct BlockDetails {
 	pub children: Vec<H256>
 }
 
-impl ExtrasIndexable for BlockDetails {
-	fn extras_index() -> ExtrasIndex {
-		ExtrasIndex::BlockDetails
-	}
-}
-
 impl HeapSizeOf for BlockDetails {
 	fn heap_size_of_children(&self) -> usize {
 		self.children.heap_size_of_children()
@@ -181,12 +181,6 @@ pub struct BlockLogBlooms {
 	pub blooms: Vec<H2048>
 }
 
-impl ExtrasIndexable for BlockLogBlooms {
-	fn extras_index() -> ExtrasIndex {
-		ExtrasIndex::BlockLogBlooms
-	}
-}
-
 impl HeapSizeOf for BlockLogBlooms {
 	fn heap_size_of_children(&self) -> usize {
 		self.blooms.heap_size_of_children()
@@ -227,12 +221,6 @@ impl BlocksBlooms {
 	}
 }
 
-impl ExtrasIndexable for BlocksBlooms {
-	fn extras_index() -> ExtrasIndex {
-		ExtrasIndex::BlocksBlooms
-	}
-}
-
 impl HeapSizeOf for BlocksBlooms {
 	fn heap_size_of_children(&self) -> usize { 0 }
 }
@@ -277,12 +265,6 @@ pub struct TransactionAddress {
 	pub index: usize
 }
 
-impl ExtrasIndexable for TransactionAddress {
-	fn extras_index() -> ExtrasIndex {
-		ExtrasIndex::TransactionAddress
-	}
-}
-
 impl HeapSizeOf for TransactionAddress {
 	fn heap_size_of_children(&self) -> usize { 0 }
 }
@@ -340,9 +322,3 @@ impl HeapSizeOf for BlockReceipts {
 		self.receipts.heap_size_of_children()
 	}
 }
-
-impl ExtrasIndexable for BlockReceipts {
-	fn extras_index() -> ExtrasIndex {
-		ExtrasIndex::BlockReceipts
-	}
-}

ethcore/src/json_tests/chain.rs

@@ -16,18 +16,19 @@
 
 use super::test_common::*;
 use client::{BlockChainClient, Client, ClientConfig};
-use pod_state::*;
 use block::Block;
 use ethereum;
 use tests::helpers::*;
 use devtools::*;
+use spec::Genesis;
+use ethjson;
 
 pub fn json_chain_test(json_data: &[u8], era: ChainEra) -> Vec<String> {
 	init_log();
-	let json = Json::from_str(::std::str::from_utf8(json_data).unwrap()).expect("Json is invalid");
+	let tests = ethjson::blockchain::Test::load(json_data).unwrap();
 	let mut failed = Vec::new();
 
-	for (name, test) in json.as_object().unwrap() {
+	for (name, blockchain) in tests.into_iter() {
 		let mut fail = false;
 		{
 			let mut fail_unless = |cond: bool| if !cond && !fail {
@@ -39,37 +40,36 @@ pub fn json_chain_test(json_data: &[u8], era: ChainEra) -> Vec<String> {
 
 			flush!("   - {}...", name);
 
-			let blocks: Vec<(Bytes, bool)> = test["blocks"].as_array().unwrap().iter().map(|e| (xjson!(&e["rlp"]), e.find("blockHeader").is_some())).collect();
 			let mut spec = match era {
 				ChainEra::Frontier => ethereum::new_frontier_test(),
 				ChainEra::Homestead => ethereum::new_homestead_test(),
 			};
-			let s = PodState::from_json(test.find("pre").unwrap());
-			spec.set_genesis_state(s);
-			spec.overwrite_genesis(test.find("genesisBlockHeader").unwrap());
+
+			let genesis = Genesis::from(blockchain.genesis());
+			let state = From::from(blockchain.pre_state.clone());
+			spec.set_genesis_state(state);
+			spec.overwrite_genesis_params(genesis);
 			assert!(spec.is_state_root_valid());
-			let genesis_hash = spec.genesis_header().hash();
-			assert_eq!(genesis_hash, H256::from_json(&test.find("genesisBlockHeader").unwrap()["hash"]));
 
 			let temp = RandomTempPath::new();
 			{
-				let client = Client::new(ClientConfig::default(), spec, temp.as_path(), IoChannel::disconnected()).unwrap();
-				assert_eq!(client.chain_info().best_block_hash, genesis_hash);
-				for (b, is_valid) in blocks.into_iter() {
+				let client = Client::new(ClientConfig::default(), spec, temp.as_path(), IoChannel::disconnected());
+				for b in &blockchain.blocks_rlp() {
 					if Block::is_good(&b) {
 						let _ = client.import_block(b.clone());
+						client.flush_queue();
+						client.import_verified_blocks(&IoChannel::disconnected());
 					}
-					client.flush_queue();
-					let imported_ok = client.import_verified_blocks(&IoChannel::disconnected()) > 0;
-					assert_eq!(imported_ok, is_valid);
 				}
-				fail_unless(client.chain_info().best_block_hash == H256::from_json(&test["lastblockhash"]));
+				fail_unless(client.chain_info().best_block_hash == blockchain.best_block.into());
 			}
 		}
+
 		if !fail {
 			flushln!("ok");
 		}
 	}
+
 	println!("!!! {:?} tests from failed.", failed.len());
 	failed
 }

ethcore/src/json_tests/executive.rs

@@ -17,42 +17,16 @@
 use super::test_common::*;
 use state::*;
 use executive::*;
-use spec::*;
 use engine::*;
 use evm;
 use evm::{Schedule, Ext, Factory, VMType, ContractCreateResult, MessageCallResult};
-use ethereum;
 use externalities::*;
 use substate::*;
 use tests::helpers::*;
+use ethjson;
+use trace::{Tracer, NoopTracer};
 
-struct TestEngineFrontier {
-	vm_factory: Factory,
-	spec: Spec,
-	max_depth: usize
-}
-
-impl TestEngineFrontier {
-	fn new(max_depth: usize, vm_type: VMType) -> TestEngineFrontier {
-		TestEngineFrontier {
-			vm_factory: Factory::new(vm_type),
-			spec: ethereum::new_frontier_test(),
-			max_depth: max_depth
-		}
-	}
-}
-
-impl Engine for TestEngineFrontier {
-	fn name(&self) -> &str { "TestEngine" }
-	fn spec(&self) -> &Spec { &self.spec }
-	fn vm_factory(&self) -> &Factory { &self.vm_factory }
-	fn schedule(&self, _env_info: &EnvInfo) -> Schedule {
-		let mut schedule = Schedule::new_frontier();
-		schedule.max_depth = self.max_depth;
-		schedule
-	}
-}
-
+#[derive(Debug, PartialEq)]
 struct CallCreate {
 	data: Bytes,
 	destination: Option<Address>,
@@ -60,32 +34,45 @@ struct CallCreate {
 	value: U256
 }
 
+impl From<ethjson::vm::Call> for CallCreate {
+	fn from(c: ethjson::vm::Call) -> Self {
+		let dst: Option<_> = c.destination.into();
+		CallCreate {
+			data: c.data.into(),
+			destination: dst.map(Into::into),
+			gas_limit: c.gas_limit.into(),
+			value: c.value.into()
+		}
+	}
+}
+
 /// Tiny wrapper around executive externalities.
 /// Stores callcreates.
-struct TestExt<'a> {
-	ext: Externalities<'a>,
+struct TestExt<'a, T> where T: 'a + Tracer {
+	ext: Externalities<'a, T>,
 	callcreates: Vec<CallCreate>,
 	contract_address: Address
 }
 
-impl<'a> TestExt<'a> {
+impl<'a, T> TestExt<'a, T> where T: 'a + Tracer {
 	fn new(state: &'a mut State,
 			   info: &'a EnvInfo,
 			   engine: &'a Engine,
 			   depth: usize,
 			   origin_info: OriginInfo,
 			   substate: &'a mut Substate,
-			   output: OutputPolicy<'a>,
-			   address: Address) -> Self {
+			   output: OutputPolicy<'a, 'a>,
+			   address: Address,
+			   tracer: &'a mut T) -> Self {
 		TestExt {
 			contract_address: contract_address(&address, &state.nonce(&address)),
-			ext: Externalities::new(state, info, engine, depth, origin_info, substate, output),
+			ext: Externalities::new(state, info, engine, depth, origin_info, substate, output, tracer),
 			callcreates: vec![]
 		}
 	}
 }
 
-impl<'a> Ext for TestExt<'a> {
+impl<'a, T> Ext for TestExt<'a, T> where T: Tracer {
 	fn storage_at(&self, key: &H256) -> H256 {
 		self.ext.storage_at(key)
 	}
@@ -174,115 +161,80 @@ fn do_json_test(json_data: &[u8]) -> Vec<String> {
 		.collect()
 }
 
-fn do_json_test_for(vm: &VMType, json_data: &[u8]) -> Vec<String> {
-	let json = Json::from_str(::std::str::from_utf8(json_data).unwrap()).expect("Json is invalid");
+fn do_json_test_for(vm_type: &VMType, json_data: &[u8]) -> Vec<String> {
+	let tests = ethjson::vm::Test::load(json_data).unwrap();
 	let mut failed = Vec::new();
-	for (name, test) in json.as_object().unwrap() {
+
+	for (name, vm) in tests.into_iter() {
 		println!("name: {:?}", name);
-		// sync io is usefull when something crashes in jit
-		// ::std::io::stdout().write(&name.as_bytes());
-		// ::std::io::stdout().write(b"\n");
-		// ::std::io::stdout().flush();
 		let mut fail = false;
-		//let mut fail_unless = |cond: bool| if !cond && !fail { failed.push(name.to_string()); fail = true };
+
 		let mut fail_unless = |cond: bool, s: &str | if !cond && !fail {
-			failed.push(format!("[{}] {}: {}", vm, name, s));
+			failed.push(format!("[{}] {}: {}", vm_type, name, s));
 			fail = true
 		};
 
-		// test env
+		let out_of_gas = vm.out_of_gas();
 		let mut state_result = get_temp_state();
 		let mut state = state_result.reference_mut();
-
-		test.find("pre").map(|pre| for (addr, s) in pre.as_object().unwrap() {
-			let address = Address::from(addr.as_ref());
-			let balance = xjson!(&s["balance"]);
-			let code = xjson!(&s["code"]);
-			let _nonce: U256 = xjson!(&s["nonce"]);
-
-			state.new_contract(&address, balance);
-			state.init_code(&address, code);
-			BTreeMap::from_json(&s["storage"]).into_iter().foreach(|(k, v)| state.set_storage(&address, k, v));
-		});
-
-		let info = test.find("env").map(|env| {
-			EnvInfo::from_json(env)
-		}).unwrap_or_default();
-
-		let engine = TestEngineFrontier::new(1, vm.clone());
-
-		// params
-		let mut params = ActionParams::default();
-		test.find("exec").map(|exec| {
-			params.address = xjson!(&exec["address"]);
-			params.sender = xjson!(&exec["caller"]);
-			params.origin = xjson!(&exec["origin"]);
-			params.code = xjson!(&exec["code"]);
-			params.data = xjson!(&exec["data"]);
-			params.gas = xjson!(&exec["gas"]);
-			params.gas_price = xjson!(&exec["gasPrice"]);
-			params.value = ActionValue::Transfer(xjson!(&exec["value"]));
-		});
-
-		let out_of_gas = test.find("callcreates").map(|_calls| {
-		}).is_none();
+		state.populate_from(From::from(vm.pre_state.clone()));
+		let info = From::from(vm.env);
+		let engine = TestEngine::new(1, Factory::new(vm_type.clone()));
+		let params = ActionParams::from(vm.transaction);
 
 		let mut substate = Substate::new();
+		let mut tracer = NoopTracer;
 		let mut output = vec![];
 
 		// execute
 		let (res, callcreates) = {
-			let mut ex = TestExt::new(&mut state,
-									  &info,
-									  &engine,
-									  0,
-									  OriginInfo::from(&params),
-									  &mut substate,
-									  OutputPolicy::Return(BytesRef::Flexible(&mut output)),
-									  params.address.clone());
+			let mut ex = TestExt::new(
+				&mut state,
+				&info,
+				&engine,
+				0,
+				OriginInfo::from(&params),
+				&mut substate,
+				OutputPolicy::Return(BytesRef::Flexible(&mut output), None),
+				params.address.clone(),
+				&mut tracer,
+			);
 			let evm = engine.vm_factory().create();
 			let res = evm.exec(params, &mut ex);
 			(res, ex.callcreates)
 		};
 
-		// then validate
 		match res {
 			Err(_) => fail_unless(out_of_gas, "didn't expect to run out of gas."),
 			Ok(gas_left) => {
-				// println!("name: {}, gas_left : {:?}", name, gas_left);
 				fail_unless(!out_of_gas, "expected to run out of gas.");
-				fail_unless(gas_left == xjson!(&test["gas"]), "gas_left is incorrect");
-				fail_unless(output == Bytes::from_json(&test["out"]), "output is incorrect");
+				fail_unless(Some(gas_left) == vm.gas_left.map(Into::into), "gas_left is incorrect");
+				let vm_output: Option<Vec<u8>> = vm.output.map(Into::into);
+				fail_unless(Some(output) == vm_output, "output is incorrect");
 
-				test.find("post").map(|pre| for (addr, s) in pre.as_object().unwrap() {
-					let address = Address::from(addr.as_ref());
-
-					fail_unless(state.code(&address).unwrap_or_else(|| vec![]) == Bytes::from_json(&s["code"]), "code is incorrect");
-					fail_unless(state.balance(&address) == xjson!(&s["balance"]), "balance is incorrect");
-					fail_unless(state.nonce(&address) == xjson!(&s["nonce"]), "nonce is incorrect");
-					BTreeMap::from_json(&s["storage"]).iter().foreach(|(k, v)| fail_unless(&state.storage_at(&address, &k) == v, "storage is incorrect"));
-				});
-
-				let cc = test["callcreates"].as_array().unwrap();
-				fail_unless(callcreates.len() == cc.len(), "callcreates does not match");
-				for i in 0..cc.len() {
-					let callcreate = &callcreates[i];
-					let expected = &cc[i];
-					fail_unless(callcreate.data == Bytes::from_json(&expected["data"]), "callcreates data is incorrect");
-					fail_unless(callcreate.destination == xjson!(&expected["destination"]), "callcreates destination is incorrect");
-					fail_unless(callcreate.value == xjson!(&expected["value"]), "callcreates value is incorrect");
-					fail_unless(callcreate.gas_limit == xjson!(&expected["gasLimit"]), "callcreates gas_limit is incorrect");
+				for (address, account) in vm.post_state.unwrap().into_iter() {
+					let address = address.into();
+					let code: Vec<u8> = account.code.into();
+					fail_unless(state.code(&address).unwrap_or_else(Vec::new) == code, "code is incorrect");
+					fail_unless(state.balance(&address) == account.balance.into(), "balance is incorrect");
+					fail_unless(state.nonce(&address) == account.nonce.into(), "nonce is incorrect");
+					account.storage.into_iter().foreach(|(k, v)| {
+						let key: U256 = k.into();
+						let value: U256 = v.into();
+						fail_unless(state.storage_at(&address, &From::from(key)) == From::from(value), "storage is incorrect");
+					});
 				}
-			}
-		}
-	}
 
+				let calls: Option<Vec<CallCreate>> = vm.calls.map(|c| c.into_iter().map(From::from).collect());
+				fail_unless(Some(callcreates) == calls, "callcreates does not match");
+			}
+		};
+	}
 
 	for f in &failed {
 		println!("FAILED: {:?}", f);
 	}
 
-	//assert!(false);
 	failed
 }
 

ethcore/src/json_tests/state.rs

@@ -19,6 +19,7 @@ use tests::helpers::*;
 use pod_state::*;
 use state_diff::*;
 use ethereum;
+use ethjson;
 
 fn do_json_test(json_data: &[u8]) -> Vec<String> {
 	json_chain_test(json_data, ChainEra::Frontier)
@@ -26,18 +27,14 @@ fn do_json_test(json_data: &[u8]) -> Vec<String> {
 
 pub fn json_chain_test(json_data: &[u8], era: ChainEra) -> Vec<String> {
 	init_log();
-
-	let json = Json::from_str(::std::str::from_utf8(json_data).unwrap()).expect("Json is invalid");
+	let tests = ethjson::state::Test::load(json_data).unwrap();
 	let mut failed = Vec::new();
-
 	let engine = match era {
-		ChainEra::Frontier => ethereum::new_mainnet_like(),
-		ChainEra::Homestead => ethereum::new_homestead_test(),
-	}.to_engine().unwrap();
+		ChainEra::Frontier => ethereum::new_mainnet_like().engine,
+		ChainEra::Homestead => ethereum::new_homestead_test().engine
+	};
 
-	flushln!("");
-
-	for (name, test) in json.as_object().unwrap() {
+	for (name, test) in tests.into_iter() {
 		let mut fail = false;
 		{
 			let mut fail_unless = |cond: bool| if !cond && !fail {
@@ -49,16 +46,13 @@ pub fn json_chain_test(json_data: &[u8], era: ChainEra) -> Vec<String> {
 
 			flush!("   - {}...", name);
 
-			let t = SignedTransaction::from_json(&test["transaction"]);
-			let env = EnvInfo::from_json(&test["env"]);
-			let _out = Bytes::from_json(&test["out"]);
-			let post_state_root = xjson!(&test["postStateRoot"]);
-			let pre = PodState::from_json(&test["pre"]);
-			let post = PodState::from_json(&test["post"]);
-			let logs: Vec<_> = test["logs"].as_array().unwrap().iter().map(&LogEntry::from_json).collect();
+			let transaction = test.transaction.into();
+			let post_state_root = test.post_state_root.into();
+			let env = test.env.into();
+			let pre: PodState = test.pre_state.into();
+			let post: PodState = test.post_state.into();
+			let logs: Vec<LogEntry> = test.logs.into_iter().map(Into::into).collect();
 
-			//println!("Transaction: {:?}", t);
-			//println!("Env: {:?}", env);
 			let calc_post = sec_trie_root(post.get().iter().map(|(k, v)| (k.to_vec(), v.rlp())).collect());
 
 			if fail_unless(post_state_root == calc_post) {
@@ -69,7 +63,7 @@ pub fn json_chain_test(json_data: &[u8], era: ChainEra) -> Vec<String> {
 				let mut state = state_result.reference_mut();
 				state.populate_from(pre);
 				state.commit();
-				let res = state.apply(&env, engine.deref(), &t);
+				let res = state.apply(&env, engine.deref(), &transaction, false);
 
 				if fail_unless(state.root() == &post_state_root) {
 					println!("!!! {}: State mismatch (got: {}, expect: {}):", name, state.root(), post_state_root);
@@ -80,20 +74,20 @@ pub fn json_chain_test(json_data: &[u8], era: ChainEra) -> Vec<String> {
 				}
 
 				if let Ok(r) = res {
-					if fail_unless(logs == r.logs) {
+					if fail_unless(logs == r.receipt.logs) {
 						println!("!!! {}: Logs mismatch:", name);
-						println!("Got:\n{:?}", r.logs);
+						println!("Got:\n{:?}", r.receipt.logs);
 						println!("Expect:\n{:?}", logs);
 					}
 				}
 			}
 		}
+
 		if !fail {
 			flushln!("ok");
 		}
-		// TODO: Add extra APIs for output
-		//if fail_unless(out == r.)
 	}
+
 	println!("!!! {:?} tests from failed.", failed.len());
 	failed
 }

ethcore/src/json_tests/transaction.rs

@@ -16,75 +16,54 @@
 
 use super::test_common::*;
 use evm;
+use ethjson;
 
 fn do_json_test(json_data: &[u8]) -> Vec<String> {
-	let json = Json::from_str(::std::str::from_utf8(json_data).unwrap()).expect("Json is invalid");
+	let tests = ethjson::transaction::Test::load(json_data).unwrap();
 	let mut failed = Vec::new();
 	let old_schedule = evm::Schedule::new_frontier();
 	let new_schedule = evm::Schedule::new_homestead();
-	let ot = RefCell::new(None);
-	for (name, test) in json.as_object().unwrap() {
+	for (name, test) in tests.into_iter() {
 		let mut fail = false;
-		let mut fail_unless = |cond: bool| if !cond && !fail { failed.push(name.clone()); println!("Transaction: {:?}", ot.borrow()); fail = true };
-		let schedule = match test.find("blocknumber")
-			.and_then(|j| j.as_string())
-			.and_then(|s| BlockNumber::from_str(s).ok())
-			.unwrap_or(0) { x if x < 1_000_000 => &old_schedule, _ => &new_schedule };
-		let rlp = Bytes::from_json(&test["rlp"]);
-		let res = UntrustedRlp::new(&rlp).as_val().map_err(From::from).and_then(|t: SignedTransaction| t.validate(schedule, schedule.have_delegate_call));
-		fail_unless(test.find("transaction").is_none() == res.is_err());
-		if let (Some(&Json::Object(ref tx)), Some(&Json::String(ref expect_sender))) = (test.find("transaction"), test.find("sender")) {
+		let mut fail_unless = |cond: bool| if !cond && !fail { failed.push(name.clone()); println!("Transaction failed: {:?}", name); fail = true };
+
+		let number: Option<u64> = test.block_number.map(Into::into);
+		let schedule = match number {
+			None => &old_schedule,
+			Some(x) if x < 1_150_000 => &old_schedule,
+			Some(_) => &new_schedule
+		};
+
+		let rlp: Vec<u8> = test.rlp.into();
+		let res = UntrustedRlp::new(&rlp)
+			.as_val()
+			.map_err(From::from)
+			.and_then(|t: SignedTransaction| t.validate(schedule, schedule.have_delegate_call));
+
+		fail_unless(test.transaction.is_none() == res.is_err());
+		if let (Some(tx), Some(sender)) = (test.transaction, test.sender) {
 			let t = res.unwrap();
-			fail_unless(t.sender().unwrap() == address_from_hex(clean(expect_sender)));
-			fail_unless(t.data == Bytes::from_json(&tx["data"]));
-			fail_unless(t.gas == xjson!(&tx["gasLimit"]));
-			fail_unless(t.gas_price == xjson!(&tx["gasPrice"]));
-			fail_unless(t.nonce == xjson!(&tx["nonce"]));
-			fail_unless(t.value == xjson!(&tx["value"]));
-			if let Action::Call(ref to) = t.action {
-				*ot.borrow_mut() = Some(t.clone());
-				fail_unless(to == &xjson!(&tx["to"]));
-			} else {
-				*ot.borrow_mut() = Some(t.clone());
-				fail_unless(Bytes::from_json(&tx["to"]).is_empty());
+			fail_unless(t.sender().unwrap() == sender.into());
+			let data: Vec<u8> = tx.data.into();
+			fail_unless(t.data == data);
+			fail_unless(t.gas_price == tx.gas_price.into());
+			fail_unless(t.nonce == tx.nonce.into());
+			fail_unless(t.value == tx.value.into());
+			let to: Option<_> = tx.to.into();
+			let to: Option<Address> = to.map(Into::into);
+			match t.action {
+				Action::Call(dest) => fail_unless(Some(dest) == to),
+				Action::Create => fail_unless(None == to),
 			}
 		}
 	}
+
 	for f in &failed {
 		println!("FAILED: {:?}", f);
 	}
 	failed
 }
 
-// Once we have interpolate idents.
-/*macro_rules! declare_test {
-	($test_set_name: ident / $name: ident) => {
-		#[test]
-		#[allow(non_snake_case)]
-		fn $name() {
-			assert!(do_json_test(include_bytes!(concat!("../res/ethereum/tests/", stringify!($test_set_name), "/", stringify!($name), ".json"))).len() == 0);
-		}
-	};
-	($test_set_name: ident / $prename: ident / $name: ident) => {
-		#[test]
-		#[allow(non_snake_case)]
-		interpolate_idents! { fn [$prename _ $name]()
-			{
-				let json = include_bytes!(concat!("../res/ethereum/tests/", stringify!($test_set_name), "/", stringify!($prename), "/", stringify!($name), ".json"));
-				assert!(do_json_test(json).len() == 0);
-			}
-		}
-	};
-}
-
-declare_test!{TransactionTests/ttTransactionTest}
-declare_test!{TransactionTests/tt10mbDataField}
-declare_test!{TransactionTests/ttWrongRLPTransaction}
-declare_test!{TransactionTests/Homestead/ttTransactionTest}
-declare_test!{heavy => TransactionTests/Homestead/tt10mbDataField}
-declare_test!{TransactionTests/Homestead/ttWrongRLPTransaction}
-declare_test!{TransactionTests/RandomTests/tr201506052141PYTHON}*/
-
 declare_test!{TransactionTests_ttTransactionTest, "TransactionTests/ttTransactionTest"}
 declare_test!{heavy => TransactionTests_tt10mbDataField, "TransactionTests/tt10mbDataField"}
 declare_test!{TransactionTests_ttWrongRLPTransaction, "TransactionTests/ttWrongRLPTransaction"}

ethcore/src/lib.rs

@@ -83,6 +83,8 @@ extern crate time;
 extern crate env_logger;
 extern crate num_cpus;
 extern crate crossbeam;
+extern crate ethjson;
+extern crate bloomchain;
 
 #[cfg(test)] extern crate ethcore_devtools as devtools;
 #[cfg(feature = "jit" )] extern crate evmjit;
@@ -96,17 +98,19 @@ pub mod filter;
 pub mod header;
 pub mod service;
 pub mod log_entry;
+pub mod trace;
 pub mod spec;
 pub mod transaction;
 pub mod views;
 pub mod receipt;
+pub mod pod_state;
 
+mod db;
 mod common;
 mod basic_types;
 #[macro_use] mod evm;
 mod env_info;
 mod pod_account;
-mod pod_state;
 mod account_diff;
 mod state_diff;
 mod engine;

ethcore/src/log_entry.rs

@@ -18,6 +18,8 @@
 
 use util::*;
 use basic_types::LogBloom;
+use header::BlockNumber;
+use ethjson;
 
 /// A record of execution for a `LOG` operation.
 #[derive(Default, Debug, Clone, PartialEq, Eq)]
@@ -64,27 +66,25 @@ impl LogEntry {
 	}
 }
 
-impl FromJson for LogEntry {
-	/// Convert given JSON object to a LogEntry.
-	fn from_json(json: &Json) -> LogEntry {
-		// TODO: check bloom.
+impl From<ethjson::state::Log> for LogEntry {
+	fn from(l: ethjson::state::Log) -> Self {
 		LogEntry {
-			address: xjson!(&json["address"]),
-			topics: xjson!(&json["topics"]),
-			data: xjson!(&json["data"]),
+			address: l.address.into(),
+			topics: l.topics.into_iter().map(Into::into).collect(),
+			data: l.data.into(),
 		}
 	}
 }
 
 /// Log localized in a blockchain.
-#[derive(Default, Debug, PartialEq)]
+#[derive(Default, Debug, PartialEq, Clone)]
 pub struct LocalizedLogEntry {
 	/// Plain log entry.
 	pub entry: LogEntry,
 	/// Block in which this log was created.
 	pub block_hash: H256,
 	/// Block number.
-	pub block_number: usize,
+	pub block_number: BlockNumber,
 	/// Hash of transaction in which this log was created.
 	pub transaction_hash: H256,
 	/// Index of transaction within block.

ethcore/src/null_engine.rs

@@ -14,26 +14,29 @@
 // You should have received a copy of the GNU General Public License
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
+use std::collections::BTreeMap;
+use util::hash::Address;
+use builtin::Builtin;
 use engine::Engine;
-use spec::Spec;
-use evm::Schedule;
-use evm::Factory;
+use spec::CommonParams;
+use evm::{Schedule, Factory};
 use env_info::EnvInfo;
 
 /// An engine which does not provide any consensus mechanism.
 pub struct NullEngine {
-	spec: Spec,
-	factory: Factory
+	params: CommonParams,
+	builtins: BTreeMap<Address, Builtin>,
+	factory: Factory,
 }
 
 impl NullEngine {
 	/// Returns new instance of NullEngine with default VM Factory
-	pub fn new_boxed(spec: Spec) -> Box<Engine> {
-		Box::new(NullEngine{
-			spec: spec,
-			// TODO [todr] should this return any specific factory?
+	pub fn new(params: CommonParams, builtins: BTreeMap<Address, Builtin>) -> Self {
+		NullEngine{
+			params: params,
+			builtins: builtins,
 			factory: Factory::default()
-		})
+		}
 	}
 }
 
@@ -41,7 +44,24 @@ impl Engine for NullEngine {
 	fn vm_factory(&self) -> &Factory {
 		&self.factory
 	}
-	fn name(&self) -> &str { "NullEngine" }
-	fn spec(&self) -> &Spec { &self.spec }
-	fn schedule(&self, _env_info: &EnvInfo) -> Schedule { Schedule::new_frontier() }
+
+	fn name(&self) -> &str {
+		"NullEngine"
+	}
+
+	fn params(&self) -> &CommonParams {
+		&self.params
+	}
+
+	fn builtins(&self) -> &BTreeMap<Address, Builtin> {
+		&self.builtins
+	}
+
+	fn schedule(&self, env_info: &EnvInfo) -> Schedule {
+		if env_info.number < self.params.frontier_compatibility_mode_limit {
+			Schedule::new_frontier()
+		} else {
+			Schedule::new_homestead()
+		}
+	}
 }

ethcore/src/pod_account.rs

@@ -17,8 +17,9 @@
 use util::*;
 use account::*;
 use account_db::*;
+use ethjson;
 
-#[derive(Debug,Clone,PartialEq,Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 /// An account, expressed as Plain-Old-Data (hence the name).
 /// Does not have a DB overlay cache, code hash or anything like that.
 pub struct PodAccount {
@@ -73,6 +74,32 @@ impl PodAccount {
 	}
 }
 
+impl From<ethjson::blockchain::Account> for PodAccount {
+	fn from(a: ethjson::blockchain::Account) -> Self {
+		PodAccount {
+			balance: a.balance.into(),
+			nonce: a.nonce.into(),
+			code: a.code.into(),
+			storage: a.storage.into_iter().map(|(key, value)| {
+				let key: U256 = key.into();
+				let value: U256 = value.into();
+				(H256::from(key), H256::from(value))
+			}).collect()
+		}
+	}
+}
+
+impl From<ethjson::spec::Account> for PodAccount {
+	fn from(a: ethjson::spec::Account) -> Self {
+		PodAccount {
+			balance: a.balance.map_or_else(U256::zero, Into::into),
+			nonce: a.nonce.map_or_else(U256::zero, Into::into),
+			code: vec![],
+			storage: BTreeMap::new()
+		}
+	}
+}
+
 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())

ethcore/src/pod_state.rs

@@ -14,11 +14,14 @@
 // You should have received a copy of the GNU General Public License
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
+//! State of all accounts in the system expressed in Plain Old Data.
+
 use util::*;
 use pod_account::*;
+use ethjson;
 
-#[derive(Debug,Clone,PartialEq,Eq,Default)]
 /// State of all accounts in the system expressed in Plain Old Data.
+#[derive(Debug, Clone, PartialEq, Eq, Default)]
 pub struct PodState (BTreeMap<Address, PodAccount>);
 
 impl PodState {
@@ -43,24 +46,20 @@ impl PodState {
 	pub fn drain(self) -> BTreeMap<Address, PodAccount> { self.0 }
 }
 
-impl FromJson for PodState {
-	/// Translate the JSON object into a hash map of account information ready for insertion into State.
-	fn from_json(json: &Json) -> PodState {
-		PodState(json.as_object().unwrap().iter().fold(BTreeMap::new(), |mut state, (address, acc)| {
-			let balance = acc.find("balance").map(&U256::from_json);
-			let nonce = acc.find("nonce").map(&U256::from_json);
-			let storage = acc.find("storage").map(&BTreeMap::from_json);
-			let code = acc.find("code").map(&Bytes::from_json);
-			if balance.is_some() || nonce.is_some() || storage.is_some() || code.is_some() {
-				state.insert(address_from_hex(address), PodAccount{
-					balance: balance.unwrap_or_else(U256::zero),
-					nonce: nonce.unwrap_or_else(U256::zero),
-					storage: storage.unwrap_or_else(BTreeMap::new),
-					code: code.unwrap_or_else(Vec::new)
-				});
-			}
-			state
-		}))
+impl From<ethjson::blockchain::State> for PodState {
+	fn from(s: ethjson::blockchain::State) -> PodState {
+		let state = s.into_iter().map(|(addr, acc)| (addr.into(), PodAccount::from(acc))).collect();
+		PodState(state)
+	}
+}
+
+impl From<ethjson::spec::State> for PodState {
+	fn from(s: ethjson::spec::State) -> PodState {
+		let state: BTreeMap<_,_> = s.into_iter()
+			.filter(|pair| !pair.1.is_empty())
+			.map(|(addr, acc)| (addr.into(), PodAccount::from(acc)))
+			.collect();
+		PodState(state)
 	}
 }
 
@@ -73,30 +72,3 @@ impl fmt::Display for PodState {
 	}
 }
 
-#[cfg(test)]
-mod tests {
-	extern crate rustc_serialize;
-
-	use super::*;
-	use rustc_serialize::*;
-	use util::from_json::FromJson;
-	use util::hash::*;
-
-	#[test]
-	fn it_serializes_form_json() {
-		let pod_state = PodState::from_json(&json::Json::from_str(
-r#"
-	{
-		"0000000000000000000000000000000000000000": {
-			"balance": "1000",
-			"nonce": "100",
-			"storage": {},
-			"code" : []
-		}
-	}
-"#
-		).unwrap());
-
-		assert!(pod_state.get().get(&ZERO_ADDRESS).is_some());
-	}
-}

ethcore/src/receipt.rs

@@ -18,7 +18,8 @@
 
 use util::*;
 use basic_types::LogBloom;
-use log_entry::LogEntry;
+use header::BlockNumber;
+use log_entry::{LogEntry, LocalizedLogEntry};
 
 /// Information describing execution of a transaction.
 #[derive(Default, Debug, Clone)]
@@ -74,6 +75,27 @@ impl HeapSizeOf for Receipt {
 	}
 }
 
+/// Receipt with additional info.
+#[derive(Debug, Clone, PartialEq)]
+pub struct LocalizedReceipt {
+	/// Transaction hash.
+	pub transaction_hash: H256,
+	/// Transaction index.
+	pub transaction_index: usize,
+	/// Block hash.
+	pub block_hash: H256,
+	/// Block number.
+	pub block_number: BlockNumber,
+	/// Cumulative gas used.
+	pub cumulative_gas_used: U256,
+	/// Gas used.
+	pub gas_used: U256,
+	/// Contract address.
+	pub contract_address: Option<Address>,
+	/// Logs
+	pub logs: Vec<LocalizedLogEntry>,
+}
+
 #[test]
 fn test_basic() {
 	let expected = FromHex::from_hex("f90162a02f697d671e9ae4ee24a43c4b0d7e15f1cb4ba6de1561120d43b9a4e8c4a8a6ee83040caeb9010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000000f838f794dcf421d093428b096ca501a7cd1a740855a7976fc0a00000000000000000000000000000000000000000000000000000000000000000").unwrap();

ethcore/src/service.rs

@@ -60,8 +60,8 @@ impl ClientService {
 		panic_handler.forward_from(&net_service);
 
 		info!("Starting {}", net_service.host_info());
-		info!("Configured for {} using {} engine", spec.name, spec.engine_name);
-		let client = try!(Client::new(config, spec, db_path, net_service.io().channel()));
+		info!("Configured for {} using {:?} engine", spec.name, spec.engine.name());
+		let client = Client::new(config, spec, db_path, net_service.io().channel());
 		panic_handler.forward_from(client.deref());
 		let client_io = Arc::new(ClientIoHandler {
 			client: client.clone()
@@ -146,7 +146,7 @@ mod tests {
 	fn it_can_be_started() {
 		let spec = get_test_spec();
 		let temp_path = RandomTempPath::new();
-		let service = ClientService::start(ClientConfig::default(), spec, NetworkConfiguration::new_with_port(40456), &temp_path.as_path());
+		let service = ClientService::start(ClientConfig::default(), spec, NetworkConfiguration::new_local(), &temp_path.as_path());
 		assert!(service.is_ok());
 	}
 }

ethcore/src/spec.rs

@@ -1,328 +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/>.
-
-//! Parameters for a block chain.
-
-use common::*;
-use engine::*;
-use pod_state::*;
-use null_engine::*;
-use account_db::*;
-
-/// Convert JSON value to equivalent RLP representation.
-// TODO: handle container types.
-fn json_to_rlp(json: &Json) -> Bytes {
-	match *json {
-		Json::Boolean(o) => encode(&(if o {1u64} else {0})).to_vec(),
-		Json::I64(o) => encode(&(o as u64)).to_vec(),
-		Json::U64(o) => encode(&o).to_vec(),
-		Json::String(ref s) if s.len() >= 2 && &s[0..2] == "0x" && U256::from_str(&s[2..]).is_ok() => {
-			encode(&U256::from_str(&s[2..]).unwrap()).to_vec()
-		},
-		Json::String(ref s) => {
-			encode(s).to_vec()
-		},
-		_ => panic!()
-	}
-}
-
-/// Convert JSON to a string->RLP map.
-fn json_to_rlp_map(json: &Json) -> HashMap<String, Bytes> {
-	json.as_object().unwrap().iter().map(|(k, v)| (k, json_to_rlp(v))).fold(HashMap::new(), |mut acc, kv| {
-		acc.insert(kv.0.clone(), kv.1);
-		acc
-	})
-}
-
-/// Parameters for a block chain; includes both those intrinsic to the design of the
-/// chain and those to be interpreted by the active chain engine.
-#[derive(Debug)]
-pub struct Spec {
-	/// User friendly spec name
-	pub name: String,
-	/// What engine are we using for this?
-	pub engine_name: String,
-
-	/// Known nodes on the network in enode format.
-	pub nodes: Vec<String>,
-	/// Network ID
-	pub network_id: U256,
-
-	/// Parameters concerning operation of the specific engine we're using.
-	/// Maps the parameter name to an RLP-encoded value.
-	pub engine_params: HashMap<String, Bytes>,
-
-	/// Builtin-contracts we would like to see in the chain.
-	/// (In principle these are just hints for the engine since that has the last word on them.)
-	pub builtins: BTreeMap<Address, Builtin>,
-
-	/// The genesis block's parent hash field.
-	pub parent_hash: H256,
-	/// The genesis block's author field.
-	pub author: Address,
-	/// The genesis block's difficulty field.
-	pub difficulty: U256,
-	/// The genesis block's gas limit field.
-	pub gas_limit: U256,
-	/// The genesis block's gas used field.
-	pub gas_used: U256,
-	/// The genesis block's timestamp field.
-	pub timestamp: u64,
-	/// Transactions root of the genesis block. Should be SHA3_NULL_RLP.
-	pub transactions_root: H256,
-	/// Receipts root of the genesis block. Should be SHA3_NULL_RLP.
-	pub receipts_root: H256,
-	/// The genesis block's extra data field.
-	pub extra_data: Bytes,
-	/// The number of seal fields in the genesis block.
-	pub seal_fields: usize,
-	/// Each seal field, expressed as RLP, concatenated.
-	pub seal_rlp: Bytes,
-
-	// May be prepopulated if we know this in advance.
-	state_root_memo: RwLock<Option<H256>>,
-
-	// Genesis state as plain old data.
-	genesis_state: PodState,
-}
-
-#[cfg_attr(feature="dev", allow(wrong_self_convention))] // because to_engine(self) should be to_engine(&self)
-impl Spec {
-	/// Convert this object into a boxed Engine of the right underlying type.
-	// TODO avoid this hard-coded nastiness - use dynamic-linked plugin framework instead.
-	pub fn to_engine(self) -> Result<Box<Engine>, Error> {
-		match self.engine_name.as_ref() {
-			"NullEngine" => Ok(NullEngine::new_boxed(self)),
-			"Ethash" => Ok(super::ethereum::Ethash::new_boxed(self)),
-			_ => Err(Error::UnknownEngineName(self.engine_name.clone()))
-		}
-	}
-
-	/// Return the state root for the genesis state, memoising accordingly.
-	pub fn state_root(&self) -> H256 {
-		if self.state_root_memo.read().unwrap().is_none() {
-			*self.state_root_memo.write().unwrap() = Some(self.genesis_state.root());
-		}
-		self.state_root_memo.read().unwrap().as_ref().unwrap().clone()
-	}
-
-	/// Get the known knodes of the network in enode format.
-	pub fn nodes(&self) -> &Vec<String> { &self.nodes }
-
-	/// Get the configured Network ID.
-	pub fn network_id(&self) -> U256 { self.network_id }
-
-	/// Get the header of the genesis block.
-	pub fn genesis_header(&self) -> Header {
-		Header {
-			parent_hash: self.parent_hash.clone(),
-			timestamp: self.timestamp,
-			number: 0,
-			author: self.author.clone(),
-			transactions_root: self.transactions_root.clone(),
-			uncles_hash: RlpStream::new_list(0).out().sha3(),
-			extra_data: self.extra_data.clone(),
-			state_root: self.state_root().clone(),
-			receipts_root: self.receipts_root.clone(),
-			log_bloom: H2048::new().clone(),
-			gas_used: self.gas_used.clone(),
-			gas_limit: self.gas_limit.clone(),
-			difficulty: self.difficulty.clone(),
-			seal: {
-				let seal = {
-					let mut s = RlpStream::new_list(self.seal_fields);
-					s.append_raw(&self.seal_rlp, self.seal_fields);
-					s.out()
-				};
-				let r = Rlp::new(&seal);
-				(0..self.seal_fields).map(|i| r.at(i).as_raw().to_vec()).collect()
-			},
-			hash: RefCell::new(None),
-			bare_hash: RefCell::new(None),
-		}
-	}
-
-	/// Compose the genesis block for this chain.
-	pub fn genesis_block(&self) -> Bytes {
-		let empty_list = RlpStream::new_list(0).out();
-		let header = self.genesis_header();
-		let mut ret = RlpStream::new_list(3);
-		ret.append(&header);
-		ret.append_raw(&empty_list, 1);
-		ret.append_raw(&empty_list, 1);
-		ret.out()
-	}
-
-	/// Overwrite the genesis components with the given JSON, assuming standard Ethereum test format.
-	pub fn overwrite_genesis(&mut self, genesis: &Json) {
-		let (seal_fields, seal_rlp) = {
-			if genesis.find("mixHash").is_some() && genesis.find("nonce").is_some() {
-				let mut s = RlpStream::new();
-				s.append(&H256::from_json(&genesis["mixHash"]));
-				s.append(&H64::from_json(&genesis["nonce"]));
-				(2, s.out())
-			} else {
-				// backup algo that will work with sealFields/sealRlp (and without).
-				(
-					u64::from_json(&genesis["sealFields"]) as usize,
-					Bytes::from_json(&genesis["sealRlp"])
-				)
-			}
-		};
-
-		self.parent_hash = H256::from_json(&genesis["parentHash"]);
-		self.transactions_root = genesis.find("transactionsTrie").and_then(|_| Some(H256::from_json(&genesis["transactionsTrie"]))).unwrap_or(SHA3_NULL_RLP.clone());
-		self.receipts_root = genesis.find("receiptTrie").and_then(|_| Some(H256::from_json(&genesis["receiptTrie"]))).unwrap_or(SHA3_NULL_RLP.clone());
-		self.author = Address::from_json(&genesis["coinbase"]);
-		self.difficulty = U256::from_json(&genesis["difficulty"]);
-		self.gas_limit = U256::from_json(&genesis["gasLimit"]);
-		self.gas_used = U256::from_json(&genesis["gasUsed"]);
-		self.timestamp = u64::from_json(&genesis["timestamp"]);
-		self.extra_data = Bytes::from_json(&genesis["extraData"]);
-		self.seal_fields = seal_fields;
-		self.seal_rlp = seal_rlp;
-		self.state_root_memo = RwLock::new(genesis.find("stateRoot").and_then(|_| Some(H256::from_json(&genesis["stateRoot"]))));
-	}
-
-	/// Alter the value of the genesis state.
-	pub fn set_genesis_state(&mut self, s: PodState) {
-		self.genesis_state = s;
-		*self.state_root_memo.write().unwrap() = None;
-	}
-
-	/// Returns `false` if the memoized state root is invalid. `true` otherwise.
-	pub fn is_state_root_valid(&self) -> bool {
-		self.state_root_memo.read().unwrap().clone().map_or(true, |sr| sr == self.genesis_state.root())
-	}
-}
-
-impl FromJson for Spec {
-	/// Loads a chain-specification from a json data structure
-	fn from_json(json: &Json) -> Spec {
-		// once we commit ourselves to some json parsing library (serde?)
-		// move it to proper data structure
-		let mut builtins = BTreeMap::new();
-		let mut state = PodState::new();
-
-		if let Some(&Json::Object(ref accounts)) = json.find("accounts") {
-			for (address, acc) in accounts.iter() {
-				let addr = Address::from_str(address).unwrap();
-				if let Some(ref builtin_json) = acc.find("builtin") {
-					if let Some(builtin) = Builtin::from_json(builtin_json) {
-						builtins.insert(addr.clone(), builtin);
-					}
-				}
-			}
-			state = xjson!(&json["accounts"]);
-		}
-
-		let nodes = if let Some(&Json::Array(ref ns)) = json.find("nodes") {
-			ns.iter().filter_map(|n| if let Json::String(ref s) = *n { Some(s.clone()) } else {None}).collect()
-		} else { Vec::new() };
-
-		let genesis = &json["genesis"];//.as_object().expect("No genesis object in JSON");
-
-		let (seal_fields, seal_rlp) = {
-			if genesis.find("mixHash").is_some() && genesis.find("nonce").is_some() {
-				let mut s = RlpStream::new();
-				s.append(&H256::from_str(&genesis["mixHash"].as_string().expect("mixHash not a string.")[2..]).expect("Invalid mixHash string value"));
-				s.append(&H64::from_str(&genesis["nonce"].as_string().expect("nonce not a string.")[2..]).expect("Invalid nonce string value"));
-				(2, s.out())
-			} else {
-				// backup algo that will work with sealFields/sealRlp (and without).
-				(
-					usize::from_str(&genesis["sealFields"].as_string().unwrap_or("0x")[2..]).expect("Invalid sealFields integer data"),
-					genesis["sealRlp"].as_string().unwrap_or("0x")[2..].from_hex().expect("Invalid sealRlp hex data")
-				)
-			}
-		};
-
-		Spec {
-			name: json.find("name").map_or("unknown", |j| j.as_string().unwrap()).to_owned(),
-			engine_name: json["engineName"].as_string().unwrap().to_owned(),
-			engine_params: json_to_rlp_map(&json["params"]),
-			nodes: nodes,
-			network_id: U256::from_str(&json["params"]["networkID"].as_string().unwrap()[2..]).unwrap(),
-			builtins: builtins,
-			parent_hash: H256::from_str(&genesis["parentHash"].as_string().unwrap()[2..]).unwrap(),
-			author: Address::from_str(&genesis["author"].as_string().unwrap()[2..]).unwrap(),
-			difficulty: U256::from_str(&genesis["difficulty"].as_string().unwrap()[2..]).unwrap(),
-			gas_limit: U256::from_str(&genesis["gasLimit"].as_string().unwrap()[2..]).unwrap(),
-			gas_used: U256::from(0u8),
-			timestamp: u64::from_str(&genesis["timestamp"].as_string().unwrap()[2..]).unwrap(),
-			transactions_root: SHA3_NULL_RLP.clone(),
-			receipts_root: SHA3_NULL_RLP.clone(),
-			extra_data: genesis["extraData"].as_string().unwrap()[2..].from_hex().unwrap(),
-			genesis_state: state,
-			seal_fields: seal_fields,
-			seal_rlp: seal_rlp,
-			state_root_memo: RwLock::new(genesis.find("stateRoot").and_then(|_| genesis["stateRoot"].as_string()).map(|s| H256::from_str(&s[2..]).unwrap())),
-		}
-	}
-}
-
-impl Spec {
-	/// Ensure that the given state DB has the trie nodes in for the genesis state.
-	pub fn ensure_db_good(&self, db: &mut HashDB) -> bool {
-		if !db.contains(&self.state_root()) {
-			let mut root = H256::new();
-			{
-				let mut t = SecTrieDBMut::new(db, &mut root);
-				for (address, account) in self.genesis_state.get().iter() {
-					t.insert(address.as_slice(), &account.rlp());
-				}
-			}
-			for (address, account) in self.genesis_state.get().iter() {
-				account.insert_additional(&mut AccountDBMut::new(db, address));
-			}
-			assert!(db.contains(&self.state_root()));
-			true
-		} else { false }
-	}
-
-	/// Create a new Spec from a JSON UTF-8 data resource `data`.
-	pub fn from_json_utf8(data: &[u8]) -> Spec {
-		Self::from_json_str(::std::str::from_utf8(data).unwrap())
-	}
-
-	/// Create a new Spec from a JSON string.
-	pub fn from_json_str(s: &str) -> Spec {
-		Self::from_json(&Json::from_str(s).expect("Json is invalid"))
-	}
-
-	/// Create a new Spec which conforms to the Morden chain except that it's a NullEngine consensus.
-	pub fn new_test() -> Spec { Self::from_json_utf8(include_bytes!("../res/null_morden.json")) }
-}
-
-#[cfg(test)]
-mod tests {
-	use std::str::FromStr;
-	use util::hash::*;
-	use util::sha3::*;
-	use views::*;
-	use super::*;
-
-	#[test]
-	fn test_chain() {
-		let test_spec = Spec::new_test();
-
-		assert_eq!(test_spec.state_root(), H256::from_str("f3f4696bbf3b3b07775128eb7a3763279a394e382130f27c21e70233e04946a9").unwrap());
-		let genesis = test_spec.genesis_block();
-		assert_eq!(BlockView::new(&genesis).header_view().sha3(), H256::from_str("0cd786a2425d16f152c658316c423e6ce1181e15c3295826d7c9904cba9ce303").unwrap());
-
-		let _ = test_spec.to_engine();
-	}
-}

ethcore/src/spec/genesis.rs

@@ -0,0 +1,65 @@
+// 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 util::numbers::{Uint, U256};
+use util::hash::{Address, H256};
+use ethjson;
+use super::seal::Seal;
+
+/// Genesis components.
+pub struct Genesis {
+	/// Seal.
+	pub seal: Seal,
+	/// Difficulty.
+	pub difficulty: U256,
+	/// Author.
+	pub author: Address,
+	/// Timestamp.
+	pub timestamp: u64,
+	/// Parent hash.
+	pub parent_hash: H256,
+	/// Gas limit.
+	pub gas_limit: U256,
+	/// Transactions root.
+	pub transactions_root: H256,
+	/// Receipts root.
+	pub receipts_root: H256,
+	/// State root.
+	pub state_root: Option<H256>,
+	/// Gas used.
+	pub gas_used: U256,
+	/// Extra data.
+	pub extra_data: Vec<u8>,
+}
+
+impl From<ethjson::spec::Genesis> for Genesis {
+	fn from(g: ethjson::spec::Genesis) -> Self {
+		Genesis {
+			seal: From::from(g.seal),
+			difficulty: g.difficulty.into(),
+			author: g.author.into(),
+			timestamp: g.timestamp.into(),
+			parent_hash: g.parent_hash.into(),
+			gas_limit: g.gas_limit.into(),
+			transactions_root: g.transactions_root.map_or_else(|| SHA3_NULL_RLP.clone(), Into::into),
+			receipts_root: g.receipts_root.map_or_else(|| SHA3_NULL_RLP.clone(), Into::into),
+			state_root: g.state_root.map(Into::into),
+			gas_used: g.gas_used.map_or_else(U256::zero, Into::into),
+			extra_data: g.extra_data.map_or_else(Vec::new, Into::into),
+		}
+	}
+}

ethcore/src/spec/mod.rs

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

ethcore/src/spec/seal.rs

@@ -0,0 +1,81 @@
+// 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/>.
+
+//! Spec seal.
+
+use util::rlp::*;
+use util::hash::{H64, H256};
+use ethjson;
+
+/// Classic ethereum seal.
+pub struct Ethereum {
+	/// Seal nonce.
+	pub nonce: H64,
+	/// Seal mix hash.
+	pub mix_hash: H256,
+}
+
+impl Into<Generic> for Ethereum {
+	fn into(self) -> Generic {
+		let mut s = RlpStream::new();
+		s.append(&self.mix_hash);
+		s.append(&self.nonce);
+		Generic {
+			fields: 2,
+			rlp: s.out()
+		}
+	}
+}
+
+/// Generic seal.
+pub struct Generic {
+	/// Number of seal fields.
+	pub fields: usize,
+	/// Seal rlp.
+	pub rlp: Vec<u8>,
+}
+
+/// Genesis seal type.
+pub enum Seal {
+	/// Classic ethereum seal.
+	Ethereum(Ethereum),
+	/// Generic seal.
+	Generic(Generic),
+}
+
+impl From<ethjson::spec::Seal> for Seal {
+	fn from(s: ethjson::spec::Seal) -> Self {
+		match s {
+			ethjson::spec::Seal::Ethereum(eth) => Seal::Ethereum(Ethereum {
+				nonce: eth.nonce.into(),
+				mix_hash: eth.mix_hash.into()
+			}),
+			ethjson::spec::Seal::Generic(g) => Seal::Generic(Generic {
+				fields: g.fields,
+				rlp: g.rlp.into()
+			})
+		}
+	}
+}
+
+impl Into<Generic> for Seal {
+	fn into(self) -> Generic {
+		match self {
+			Seal::Generic(generic) => generic,
+			Seal::Ethereum(eth) => eth.into()
+		}
+	}
+}

ethcore/src/spec/spec.rs

@@ -0,0 +1,271 @@
+// 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/>.
+
+//! Parameters for a block chain.
+
+use common::*;
+use engine::*;
+use pod_state::*;
+use null_engine::*;
+use account_db::*;
+use super::genesis::Genesis;
+use super::seal::Generic as GenericSeal;
+use ethereum;
+use ethjson;
+
+/// Parameters common to all engines.
+#[derive(Debug, PartialEq, Clone)]
+pub struct CommonParams {
+	/// Account start nonce.
+	pub account_start_nonce: U256,
+	/// Frontier compatibility mode limit.
+	pub frontier_compatibility_mode_limit: u64,
+	/// Maximum size of extra data.
+	pub maximum_extra_data_size: usize,
+	/// Network id.
+	pub network_id: U256,
+	/// Minimum gas limit.
+	pub min_gas_limit: U256,
+}
+
+impl From<ethjson::spec::Params> for CommonParams {
+	fn from(p: ethjson::spec::Params) -> Self {
+		CommonParams {
+			account_start_nonce: p.account_start_nonce.into(),
+			frontier_compatibility_mode_limit: p.frontier_compatibility_mode_limit.into(),
+			maximum_extra_data_size: p.maximum_extra_data_size.into(),
+			network_id: p.network_id.into(),
+			min_gas_limit: p.min_gas_limit.into(),
+		}
+	}
+}
+
+/// Parameters for a block chain; includes both those intrinsic to the design of the
+/// chain and those to be interpreted by the active chain engine.
+pub struct Spec {
+	/// User friendly spec name
+	pub name: String,
+	/// What engine are we using for this?
+	pub engine: Box<Engine>,
+
+	/// Known nodes on the network in enode format.
+	pub nodes: Vec<String>,
+
+	/// Parameters common to all engines.
+	pub params: CommonParams,
+
+	/// The genesis block's parent hash field.
+	pub parent_hash: H256,
+	/// The genesis block's author field.
+	pub author: Address,
+	/// The genesis block's difficulty field.
+	pub difficulty: U256,
+	/// The genesis block's gas limit field.
+	pub gas_limit: U256,
+	/// The genesis block's gas used field.
+	pub gas_used: U256,
+	/// The genesis block's timestamp field.
+	pub timestamp: u64,
+	/// Transactions root of the genesis block. Should be SHA3_NULL_RLP.
+	pub transactions_root: H256,
+	/// Receipts root of the genesis block. Should be SHA3_NULL_RLP.
+	pub receipts_root: H256,
+	/// The genesis block's extra data field.
+	pub extra_data: Bytes,
+	/// The number of seal fields in the genesis block.
+	pub seal_fields: usize,
+	/// Each seal field, expressed as RLP, concatenated.
+	pub seal_rlp: Bytes,
+
+	// May be prepopulated if we know this in advance.
+	state_root_memo: RwLock<Option<H256>>,
+
+	// Genesis state as plain old data.
+	genesis_state: PodState,
+}
+
+impl From<ethjson::spec::Spec> for Spec {
+	fn from(s: ethjson::spec::Spec) -> Self {
+		let builtins = s.accounts.builtins().into_iter().map(|p| (p.0.into(), From::from(p.1))).collect();
+		let g = Genesis::from(s.genesis);
+		let seal: GenericSeal = g.seal.into();
+		let params = CommonParams::from(s.params);
+		Spec {
+			name: s.name.into(),
+			params: params.clone(),
+			engine: Spec::engine(s.engine, params, builtins),
+			nodes: s.nodes.unwrap_or_else(Vec::new),
+			parent_hash: g.parent_hash,
+			transactions_root: g.transactions_root,
+			receipts_root: g.receipts_root,
+			author: g.author,
+			difficulty: g.difficulty,
+			gas_limit: g.gas_limit,
+			gas_used: g.gas_used,
+			timestamp: g.timestamp,
+			extra_data: g.extra_data,
+			seal_fields: seal.fields,
+			seal_rlp: seal.rlp,
+			state_root_memo: RwLock::new(g.state_root),
+			genesis_state: From::from(s.accounts)
+		}
+	}
+}
+
+impl Spec {
+	/// Convert engine spec into a boxed Engine of the right underlying type.
+	/// TODO avoid this hard-coded nastiness - use dynamic-linked plugin framework instead.
+	fn engine(engine_spec: ethjson::spec::Engine, params: CommonParams, builtins: BTreeMap<Address, Builtin>) -> Box<Engine> {
+		match engine_spec {
+			ethjson::spec::Engine::Null => Box::new(NullEngine::new(params, builtins)),
+			ethjson::spec::Engine::Ethash(ethash) => Box::new(ethereum::Ethash::new(params, From::from(ethash.params), builtins))
+		}
+	}
+
+	/// Return the state root for the genesis state, memoising accordingly.
+	pub fn state_root(&self) -> H256 {
+		if self.state_root_memo.read().unwrap().is_none() {
+			*self.state_root_memo.write().unwrap() = Some(self.genesis_state.root());
+		}
+		self.state_root_memo.read().unwrap().as_ref().unwrap().clone()
+	}
+
+	/// Get the known knodes of the network in enode format.
+	pub fn nodes(&self) -> &Vec<String> { &self.nodes }
+
+	/// Get the configured Network ID.
+	pub fn network_id(&self) -> U256 { self.params.network_id }
+
+	/// Get the header of the genesis block.
+	pub fn genesis_header(&self) -> Header {
+		Header {
+			parent_hash: self.parent_hash.clone(),
+			timestamp: self.timestamp,
+			number: 0,
+			author: self.author.clone(),
+			transactions_root: self.transactions_root.clone(),
+			uncles_hash: RlpStream::new_list(0).out().sha3(),
+			extra_data: self.extra_data.clone(),
+			state_root: self.state_root().clone(),
+			receipts_root: self.receipts_root.clone(),
+			log_bloom: H2048::new().clone(),
+			gas_used: self.gas_used.clone(),
+			gas_limit: self.gas_limit.clone(),
+			difficulty: self.difficulty.clone(),
+			seal: {
+				let seal = {
+					let mut s = RlpStream::new_list(self.seal_fields);
+					s.append_raw(&self.seal_rlp, self.seal_fields);
+					s.out()
+				};
+				let r = Rlp::new(&seal);
+				(0..self.seal_fields).map(|i| r.at(i).as_raw().to_vec()).collect()
+			},
+			hash: RefCell::new(None),
+			bare_hash: RefCell::new(None),
+		}
+	}
+
+	/// Compose the genesis block for this chain.
+	pub fn genesis_block(&self) -> Bytes {
+		let empty_list = RlpStream::new_list(0).out();
+		let header = self.genesis_header();
+		let mut ret = RlpStream::new_list(3);
+		ret.append(&header);
+		ret.append_raw(&empty_list, 1);
+		ret.append_raw(&empty_list, 1);
+		ret.out()
+	}
+
+	/// Overwrite the genesis components.
+	pub fn overwrite_genesis_params(&mut self, g: Genesis) {
+		let seal: GenericSeal = g.seal.into();
+		self.parent_hash = g.parent_hash;
+		self.transactions_root = g.transactions_root;
+		self.receipts_root = g.receipts_root;
+		self.author = g.author;
+		self.difficulty = g.difficulty;
+		self.gas_limit = g.gas_limit;
+		self.gas_used = g.gas_used;
+		self.timestamp = g.timestamp;
+		self.extra_data = g.extra_data;
+		self.seal_fields = seal.fields;
+		self.seal_rlp = seal.rlp;
+		self.state_root_memo = RwLock::new(g.state_root);
+	}
+
+	/// Alter the value of the genesis state.
+	pub fn set_genesis_state(&mut self, s: PodState) {
+		self.genesis_state = s;
+		*self.state_root_memo.write().unwrap() = None;
+	}
+
+	/// Returns `false` if the memoized state root is invalid. `true` otherwise.
+	pub fn is_state_root_valid(&self) -> bool {
+		self.state_root_memo.read().unwrap().clone().map_or(true, |sr| sr == self.genesis_state.root())
+	}
+
+	/// Ensure that the given state DB has the trie nodes in for the genesis state.
+	pub fn ensure_db_good(&self, db: &mut HashDB) -> bool {
+		if !db.contains(&self.state_root()) {
+			let mut root = H256::new();
+			{
+				let mut t = SecTrieDBMut::new(db, &mut root);
+				for (address, account) in self.genesis_state.get().iter() {
+					t.insert(address.as_slice(), &account.rlp());
+				}
+			}
+			for (address, account) in self.genesis_state.get().iter() {
+				account.insert_additional(&mut AccountDBMut::new(db, address));
+			}
+			assert!(db.contains(&self.state_root()));
+			true
+		} else { false }
+	}
+
+	/// Loads spec from json file.
+	pub fn load(reader: &[u8]) -> Self {
+		From::from(ethjson::spec::Spec::load(reader).expect("invalid json file"))
+	}
+
+	/// Create a new Spec which conforms to the Morden chain except that it's a NullEngine consensus.
+	pub fn new_test() -> Spec {
+		Spec::load(include_bytes!("../../res/null_morden.json"))
+	}
+
+	/// Create a new Spec which conforms to the Morden chain except that it's a NullEngine consensus.
+	pub fn new_homestead_test() -> Spec {
+		Spec::load(include_bytes!("../../res/null_homestead_morden.json"))
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use std::str::FromStr;
+	use util::hash::*;
+	use util::sha3::*;
+	use views::*;
+	use super::*;
+
+	#[test]
+	fn test_chain() {
+		let test_spec = Spec::new_test();
+
+		assert_eq!(test_spec.state_root(), H256::from_str("f3f4696bbf3b3b07775128eb7a3763279a394e382130f27c21e70233e04946a9").unwrap());
+		let genesis = test_spec.genesis_block();
+		assert_eq!(BlockView::new(&genesis).header_view().sha3(), H256::from_str("0cd786a2425d16f152c658316c423e6ce1181e15c3295826d7c9904cba9ce303").unwrap());
+	}
+}

ethcore/src/state.rs

@@ -16,8 +16,9 @@
 
 use common::*;
 use engine::Engine;
-use executive::Executive;
+use executive::{Executive, TransactOptions};
 use account_db::*;
+use trace::Trace;
 #[cfg(test)]
 #[cfg(feature = "json-tests")]
 use pod_account::*;
@@ -26,8 +27,16 @@ use pod_account::*;
 use pod_state::PodState;
 //use state_diff::*;	// TODO: uncomment once to_pod() works correctly.
 
+/// Used to return information about an `State::apply` operation.
+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>,
+}
+
 /// Result type for the execution ("application") of a transaction.
-pub type ApplyResult = Result<Receipt, Error>;
+pub type ApplyResult = Result<ApplyOutcome, Error>;
 
 /// Representation of the entire state of all accounts in the system.
 pub struct State {
@@ -209,17 +218,18 @@ impl State {
 
 	/// Execute a given transaction.
 	/// This will change the state accordingly.
-	pub fn apply(&mut self, env_info: &EnvInfo, engine: &Engine, t: &SignedTransaction) -> ApplyResult {
+	pub fn apply(&mut self, env_info: &EnvInfo, engine: &Engine, t: &SignedTransaction, tracing: bool) -> ApplyResult {
 //		let old = self.to_pod();
 
-		let e = try!(Executive::new(self, env_info, engine).transact(t));
+		let options = TransactOptions { tracing: tracing, check_nonce: true };
+		let e = try!(Executive::new(self, env_info, engine).transact(t, options));
 
 		// TODO uncomment once to_pod() works correctly.
 //		trace!("Applied transaction. Diff:\n{}\n", StateDiff::diff_pod(&old, &self.to_pod()));
 		self.commit();
 		let receipt = Receipt::new(self.root().clone(), e.cumulative_gas_used, e.logs);
 //		trace!("Transaction receipt: {:?}", receipt);
-		Ok(receipt)
+		Ok(ApplyOutcome{receipt: receipt, trace: e.trace})
 	}
 
 	/// Commit accounts to SecTrieDBMut. This is similar to cpp-ethereum's dev::eth::commit.
@@ -331,6 +341,18 @@ impl fmt::Debug for State {
 	}
 }
 
+impl Clone for State {
+	fn clone(&self) -> State {
+		State {
+			db: self.db.boxed_clone(),
+			root: self.root.clone(),
+			cache: RefCell::new(self.cache.borrow().clone()),
+			snapshots: RefCell::new(self.snapshots.borrow().clone()),
+			account_start_nonce: self.account_start_nonce.clone(),
+		}
+	}
+}
+
 #[cfg(test)]
 mod tests {
 
@@ -341,6 +363,748 @@ use util::rlp::*;
 use account::*;
 use tests::helpers::*;
 use devtools::*;
+use evm::factory::*;
+use env_info::*;
+use spec::*;
+use transaction::*;
+use util::log::init_log;
+use trace::trace;
+use trace::trace::{Trace};
+
+#[test]
+fn should_apply_create_transaction() {
+	init_log();
+
+	let temp = RandomTempPath::new();
+	let mut state = get_temp_state_in(temp.as_path());
+
+	let mut info = EnvInfo::default();
+	info.gas_limit = x!(1_000_000);
+	let engine = TestEngine::new(5, Factory::default());
+
+	let t = Transaction {
+		nonce: x!(0),
+		gas_price: x!(0),
+		gas: x!(100_000),
+		action: Action::Create,
+		value: x!(100),
+		data: FromHex::from_hex("601080600c6000396000f3006000355415600957005b60203560003555").unwrap(),
+	}.sign(&"".sha3());
+
+	state.add_balance(t.sender().as_ref().unwrap(), &x!(100));
+	let result = state.apply(&info, &engine, &t, true).unwrap();
+	let expected_trace = Some(Trace {
+		depth: 0,
+		action: trace::Action::Create(trace::Create {
+			from: x!("9cce34f7ab185c7aba1b7c8140d620b4bda941d6"),
+			value: x!(100),
+			gas: x!(77412),
+			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("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);
+}
+
+#[test]
+fn should_work_when_cloned() {
+	init_log();
+
+	let a = Address::zero();
+
+	let temp = RandomTempPath::new();
+	let mut state = {
+		let mut state = get_temp_state_in(temp.as_path());
+		assert_eq!(state.exists(&a), false);
+		state.inc_nonce(&a);
+		state.commit();
+		state.clone()
+	};
+
+	state.inc_nonce(&a);
+	state.commit();
+}
+
+#[test]
+fn should_trace_failed_create_transaction() {
+	init_log();
+
+	let temp = RandomTempPath::new();
+	let mut state = get_temp_state_in(temp.as_path());
+
+	let mut info = EnvInfo::default();
+	info.gas_limit = x!(1_000_000);
+	let engine = TestEngine::new(5, Factory::default());
+
+	let t = Transaction {
+		nonce: x!(0),
+		gas_price: x!(0),
+		gas: x!(100_000),
+		action: Action::Create,
+		value: x!(100),
+		data: FromHex::from_hex("5b600056").unwrap(),
+	}.sign(&"".sha3());
+
+	state.add_balance(t.sender().as_ref().unwrap(), &x!(100));
+	let result = state.apply(&info, &engine, &t, true).unwrap();
+	let expected_trace = Some(Trace {
+		depth: 0,
+		action: trace::Action::Create(trace::Create {
+			from: x!("9cce34f7ab185c7aba1b7c8140d620b4bda941d6"),
+			value: x!(100),
+			gas: x!(78792),
+			init: vec![91, 96, 0, 86],
+		}),
+		result: trace::Res::FailedCreate,
+		subs: vec![]
+	});
+
+	assert_eq!(result.trace, expected_trace);
+}
+
+#[test]
+fn should_trace_call_transaction() {
+	init_log();
+
+	let temp = RandomTempPath::new();
+	let mut state = get_temp_state_in(temp.as_path());
+
+	let mut info = EnvInfo::default();
+	info.gas_limit = x!(1_000_000);
+	let engine = TestEngine::new(5, Factory::default());
+
+	let t = Transaction {
+		nonce: x!(0),
+		gas_price: x!(0),
+		gas: x!(100_000),
+		action: Action::Call(x!(0xa)),
+		value: x!(100),
+		data: vec![],
+	}.sign(&"".sha3());
+
+	state.init_code(&x!(0xa), FromHex::from_hex("6000").unwrap());
+	state.add_balance(t.sender().as_ref().unwrap(), &x!(100));
+	let result = state.apply(&info, &engine, &t, true).unwrap();
+	let expected_trace = Some(Trace {
+		depth: 0,
+		action: trace::Action::Call(trace::Call {
+			from: x!("9cce34f7ab185c7aba1b7c8140d620b4bda941d6"),
+			to: x!(0xa),
+			value: x!(100),
+			gas: x!(79000),
+			input: vec![],
+		}),
+		result: trace::Res::Call(trace::CallResult {
+			gas_used: U256::from(3),
+			output: vec![]
+		}),
+		subs: vec![]
+	});
+
+	assert_eq!(result.trace, expected_trace);
+}
+
+#[test]
+fn should_trace_basic_call_transaction() {
+	init_log();
+
+	let temp = RandomTempPath::new();
+	let mut state = get_temp_state_in(temp.as_path());
+
+	let mut info = EnvInfo::default();
+	info.gas_limit = x!(1_000_000);
+	let engine = TestEngine::new(5, Factory::default());
+
+	let t = Transaction {
+		nonce: x!(0),
+		gas_price: x!(0),
+		gas: x!(100_000),
+		action: Action::Call(x!(0xa)),
+		value: x!(100),
+		data: vec![],
+	}.sign(&"".sha3());
+
+	state.add_balance(t.sender().as_ref().unwrap(), &x!(100));
+	let result = state.apply(&info, &engine, &t, true).unwrap();
+	let expected_trace = Some(Trace {
+		depth: 0,
+		action: trace::Action::Call(trace::Call {
+			from: x!("9cce34f7ab185c7aba1b7c8140d620b4bda941d6"),
+			to: x!(0xa),
+			value: x!(100),
+			gas: x!(79000),
+			input: vec![],
+		}),
+		result: trace::Res::Call(trace::CallResult {
+			gas_used: U256::from(0),
+			output: vec![]
+		}),
+		subs: vec![]
+	});
+
+	assert_eq!(result.trace, expected_trace);
+}
+
+#[test]
+fn should_trace_call_transaction_to_builtin() {
+	init_log();
+
+	let temp = RandomTempPath::new();
+	let mut state = get_temp_state_in(temp.as_path());
+
+	let mut info = EnvInfo::default();
+	info.gas_limit = x!(1_000_000);
+	let engine = Spec::new_test().engine;
+
+	let t = Transaction {
+		nonce: x!(0),
+		gas_price: x!(0),
+		gas: x!(100_000),
+		action: Action::Call(x!(0x1)),
+		value: x!(0),
+		data: vec![],
+	}.sign(&"".sha3());
+
+	let result = state.apply(&info, engine.deref(), &t, true).unwrap();
+
+	assert_eq!(result.trace, Some(Trace {
+		depth: 0,
+		action: trace::Action::Call(trace::Call {
+			from: x!("9cce34f7ab185c7aba1b7c8140d620b4bda941d6"),
+			to: x!("0000000000000000000000000000000000000001"),
+			value: x!(0),
+			gas: x!(79_000),
+			input: vec![],
+		}),
+		result: trace::Res::Call(trace::CallResult {
+			gas_used: U256::from(3000),
+			output: vec![]
+		}),
+		subs: vec![]
+	}));
+}
+
+#[test]
+fn should_not_trace_subcall_transaction_to_builtin() {
+	init_log();
+
+	let temp = RandomTempPath::new();
+	let mut state = get_temp_state_in(temp.as_path());
+
+	let mut info = EnvInfo::default();
+	info.gas_limit = x!(1_000_000);
+	let engine = Spec::new_test().engine;
+
+	let t = Transaction {
+		nonce: x!(0),
+		gas_price: x!(0),
+		gas: x!(100_000),
+		action: Action::Call(x!(0xa)),
+		value: x!(0),
+		data: vec![],
+	}.sign(&"".sha3());
+
+	state.init_code(&x!(0xa), FromHex::from_hex("600060006000600060006001610be0f1").unwrap());
+	let result = state.apply(&info, engine.deref(), &t, true).unwrap();
+
+	let expected_trace = Some(Trace {
+		depth: 0,
+		action: trace::Action::Call(trace::Call {
+			from: x!("9cce34f7ab185c7aba1b7c8140d620b4bda941d6"),
+			to: x!(0xa),
+			value: x!(0),
+			gas: x!(79000),
+			input: vec![],
+		}),
+		result: trace::Res::Call(trace::CallResult {
+			gas_used: U256::from(28_061),
+			output: vec![]
+		}),
+		subs: vec![]
+	});
+	assert_eq!(result.trace, expected_trace);
+}
+
+#[test]
+fn should_not_trace_callcode() {
+	init_log();
+
+	let temp = RandomTempPath::new();
+	let mut state = get_temp_state_in(temp.as_path());
+
+	let mut info = EnvInfo::default();
+	info.gas_limit = x!(1_000_000);
+	let engine = Spec::new_test().engine;
+
+	let t = Transaction {
+		nonce: x!(0),
+		gas_price: x!(0),
+		gas: x!(100_000),
+		action: Action::Call(x!(0xa)),
+		value: x!(0),
+		data: vec![],
+	}.sign(&"".sha3());
+
+	state.init_code(&x!(0xa), FromHex::from_hex("60006000600060006000600b611000f2").unwrap());
+	state.init_code(&x!(0xb), FromHex::from_hex("6000").unwrap());
+	let result = state.apply(&info, engine.deref(), &t, true).unwrap();
+
+	let expected_trace = Some(Trace {
+		depth: 0,
+		action: trace::Action::Call(trace::Call {
+			from: x!("9cce34f7ab185c7aba1b7c8140d620b4bda941d6"),
+			to: x!(0xa),
+			value: x!(0),
+			gas: x!(79000),
+			input: vec![],
+		}),
+		result: trace::Res::Call(trace::CallResult {
+			gas_used: U256::from(64),
+			output: vec![]
+		}),
+		subs: vec![]
+	});
+	assert_eq!(result.trace, expected_trace);
+}
+
+#[test]
+fn should_not_trace_delegatecall() {
+	init_log();
+
+	let temp = RandomTempPath::new();
+	let mut state = get_temp_state_in(temp.as_path());
+
+	let mut info = EnvInfo::default();
+	info.gas_limit = x!(1_000_000);
+	info.number = 0x789b0;
+	let engine = Spec::new_test().engine;
+
+	println!("schedule.have_delegate_call: {:?}", engine.schedule(&info).have_delegate_call);
+
+	let t = Transaction {
+		nonce: x!(0),
+		gas_price: x!(0),
+		gas: x!(100_000),
+		action: Action::Call(x!(0xa)),
+		value: x!(0),
+		data: vec![],
+	}.sign(&"".sha3());
+
+	state.init_code(&x!(0xa), FromHex::from_hex("6000600060006000600b618000f4").unwrap());
+	state.init_code(&x!(0xb), FromHex::from_hex("6000").unwrap());
+	let result = state.apply(&info, engine.deref(), &t, true).unwrap();
+
+	let expected_trace = Some(Trace {
+		depth: 0,
+		action: trace::Action::Call(trace::Call {
+			from: x!("9cce34f7ab185c7aba1b7c8140d620b4bda941d6"),
+			to: x!(0xa),
+			value: x!(0),
+			gas: x!(79000),
+			input: vec![],
+		}),
+		result: trace::Res::Call(trace::CallResult {
+			gas_used: U256::from(61),
+			output: vec![]
+		}),
+		subs: vec![]
+	});
+	assert_eq!(result.trace, expected_trace);
+}
+
+#[test]
+fn should_trace_failed_call_transaction() {
+	init_log();
+
+	let temp = RandomTempPath::new();
+	let mut state = get_temp_state_in(temp.as_path());
+
+	let mut info = EnvInfo::default();
+	info.gas_limit = x!(1_000_000);
+	let engine = TestEngine::new(5, Factory::default());
+
+	let t = Transaction {
+		nonce: x!(0),
+		gas_price: x!(0),
+		gas: x!(100_000),
+		action: Action::Call(x!(0xa)),
+		value: x!(100),
+		data: vec![],
+	}.sign(&"".sha3());
+
+	state.init_code(&x!(0xa), FromHex::from_hex("5b600056").unwrap());
+	state.add_balance(t.sender().as_ref().unwrap(), &x!(100));
+	let result = state.apply(&info, &engine, &t, true).unwrap();
+	let expected_trace = Some(Trace {
+		depth: 0,
+		action: trace::Action::Call(trace::Call {
+			from: x!("9cce34f7ab185c7aba1b7c8140d620b4bda941d6"),
+			to: x!(0xa),
+			value: x!(100),
+			gas: x!(79000),
+			input: vec![],
+		}),
+		result: trace::Res::FailedCall,
+		subs: vec![]
+	});
+
+	println!("trace: {:?}", result.trace);
+
+	assert_eq!(result.trace, expected_trace);
+}
+
+#[test]
+fn should_trace_call_with_subcall_transaction() {
+	init_log();
+
+	let temp = RandomTempPath::new();
+	let mut state = get_temp_state_in(temp.as_path());
+
+	let mut info = EnvInfo::default();
+	info.gas_limit = x!(1_000_000);
+	let engine = TestEngine::new(5, Factory::default());
+
+	let t = Transaction {
+		nonce: x!(0),
+		gas_price: x!(0),
+		gas: x!(100_000),
+		action: Action::Call(x!(0xa)),
+		value: x!(100),
+		data: vec![],
+	}.sign(&"".sha3());
+
+	state.init_code(&x!(0xa), FromHex::from_hex("60006000600060006000600b602b5a03f1").unwrap());
+	state.init_code(&x!(0xb), FromHex::from_hex("6000").unwrap());
+	state.add_balance(t.sender().as_ref().unwrap(), &x!(100));
+	let result = state.apply(&info, &engine, &t, true).unwrap();
+	let expected_trace = Some(Trace {
+		depth: 0,
+		action: trace::Action::Call(trace::Call {
+			from: x!("9cce34f7ab185c7aba1b7c8140d620b4bda941d6"),
+			to: x!(0xa),
+			value: x!(100),
+			gas: x!(79000),
+			input: vec![],
+		}),
+		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: x!(0xa),
+				to: x!(0xb),
+				value: x!(0),
+				gas: x!(78934),
+				input: vec![],
+			}),
+			result: trace::Res::Call(trace::CallResult {
+				gas_used: U256::from(3),
+				output: vec![]
+			}),
+			subs: vec![]
+		}]
+	});
+
+	assert_eq!(result.trace, expected_trace);
+}
+
+#[test]
+fn should_trace_call_with_basic_subcall_transaction() {
+	init_log();
+
+	let temp = RandomTempPath::new();
+	let mut state = get_temp_state_in(temp.as_path());
+
+	let mut info = EnvInfo::default();
+	info.gas_limit = x!(1_000_000);
+	let engine = TestEngine::new(5, Factory::default());
+
+	let t = Transaction {
+		nonce: x!(0),
+		gas_price: x!(0),
+		gas: x!(100_000),
+		action: Action::Call(x!(0xa)),
+		value: x!(100),
+		data: vec![],
+	}.sign(&"".sha3());
+
+	state.init_code(&x!(0xa), FromHex::from_hex("60006000600060006045600b6000f1").unwrap());
+	state.add_balance(t.sender().as_ref().unwrap(), &x!(100));
+	let result = state.apply(&info, &engine, &t, true).unwrap();
+	let expected_trace = Some(Trace {
+		depth: 0,
+		action: trace::Action::Call(trace::Call {
+			from: x!("9cce34f7ab185c7aba1b7c8140d620b4bda941d6"),
+			to: x!(0xa),
+			value: x!(100),
+			gas: x!(79000),
+			input: vec![],
+		}),
+		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: x!(0xa),
+				to: x!(0xb),
+				value: x!(69),
+				gas: x!(2300),
+				input: vec![],
+			}),
+			result: trace::Res::Call(trace::CallResult::default()),
+			subs: vec![]
+		}]
+	});
+
+	assert_eq!(result.trace, expected_trace);
+}
+
+#[test]
+fn should_not_trace_call_with_invalid_basic_subcall_transaction() {
+	init_log();
+
+	let temp = RandomTempPath::new();
+	let mut state = get_temp_state_in(temp.as_path());
+
+	let mut info = EnvInfo::default();
+	info.gas_limit = x!(1_000_000);
+	let engine = TestEngine::new(5, Factory::default());
+
+	let t = Transaction {
+		nonce: x!(0),
+		gas_price: x!(0),
+		gas: x!(100_000),
+		action: Action::Call(x!(0xa)),
+		value: x!(100),
+		data: vec![],
+	}.sign(&"".sha3());
+
+	state.init_code(&x!(0xa), FromHex::from_hex("600060006000600060ff600b6000f1").unwrap());	// not enough funds.
+	state.add_balance(t.sender().as_ref().unwrap(), &x!(100));
+	let result = state.apply(&info, &engine, &t, true).unwrap();
+	let expected_trace = Some(Trace {
+		depth: 0,
+		action: trace::Action::Call(trace::Call {
+			from: x!("9cce34f7ab185c7aba1b7c8140d620b4bda941d6"),
+			to: x!(0xa),
+			value: x!(100),
+			gas: x!(79000),
+			input: vec![],
+		}),
+		result: trace::Res::Call(trace::CallResult {
+			gas_used: U256::from(31761),
+			output: vec![]
+		}),
+		subs: vec![]
+	});
+
+	assert_eq!(result.trace, expected_trace);
+}
+
+#[test]
+fn should_trace_failed_subcall_transaction() {
+	init_log();
+
+	let temp = RandomTempPath::new();
+	let mut state = get_temp_state_in(temp.as_path());
+
+	let mut info = EnvInfo::default();
+	info.gas_limit = x!(1_000_000);
+	let engine = TestEngine::new(5, Factory::default());
+
+	let t = Transaction {
+		nonce: x!(0),
+		gas_price: x!(0),
+		gas: x!(100_000),
+		action: Action::Call(x!(0xa)),
+		value: x!(100),
+		data: vec![],//600480600b6000396000f35b600056
+	}.sign(&"".sha3());
+
+	state.init_code(&x!(0xa), FromHex::from_hex("60006000600060006000600b602b5a03f1").unwrap());
+	state.init_code(&x!(0xb), FromHex::from_hex("5b600056").unwrap());
+	state.add_balance(t.sender().as_ref().unwrap(), &x!(100));
+	let result = state.apply(&info, &engine, &t, true).unwrap();
+	let expected_trace = Some(Trace {
+		depth: 0,
+		action: trace::Action::Call(trace::Call {
+			from: x!("9cce34f7ab185c7aba1b7c8140d620b4bda941d6"),
+			to: x!(0xa),
+			value: x!(100),
+			gas: x!(79000),
+			input: vec![],
+		}),
+		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: x!(0xa),
+				to: x!(0xb),
+				value: x!(0),
+				gas: x!(78934),
+				input: vec![],
+			}),
+			result: trace::Res::FailedCall,
+			subs: vec![]
+		}]
+	});
+
+	assert_eq!(result.trace, expected_trace);
+}
+
+#[test]
+fn should_trace_call_with_subcall_with_subcall_transaction() {
+	init_log();
+
+	let temp = RandomTempPath::new();
+	let mut state = get_temp_state_in(temp.as_path());
+
+	let mut info = EnvInfo::default();
+	info.gas_limit = x!(1_000_000);
+	let engine = TestEngine::new(5, Factory::default());
+
+	let t = Transaction {
+		nonce: x!(0),
+		gas_price: x!(0),
+		gas: x!(100_000),
+		action: Action::Call(x!(0xa)),
+		value: x!(100),
+		data: vec![],
+	}.sign(&"".sha3());
+
+	state.init_code(&x!(0xa), FromHex::from_hex("60006000600060006000600b602b5a03f1").unwrap());
+	state.init_code(&x!(0xb), FromHex::from_hex("60006000600060006000600c602b5a03f1").unwrap());
+	state.init_code(&x!(0xc), FromHex::from_hex("6000").unwrap());
+	state.add_balance(t.sender().as_ref().unwrap(), &x!(100));
+	let result = state.apply(&info, &engine, &t, true).unwrap();
+	let expected_trace = Some(Trace {
+		depth: 0,
+		action: trace::Action::Call(trace::Call {
+			from: x!("9cce34f7ab185c7aba1b7c8140d620b4bda941d6"),
+			to: x!(0xa),
+			value: x!(100),
+			gas: x!(79000),
+			input: vec![],
+		}),
+		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: x!(0xa),
+				to: x!(0xb),
+				value: x!(0),
+				gas: x!(78934),
+				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: x!(0xb),
+					to: x!(0xc),
+					value: x!(0),
+					gas: x!(78868),
+					input: vec![],
+				}),
+				result: trace::Res::Call(trace::CallResult {
+					gas_used: U256::from(3),
+					output: vec![]
+				}),
+				subs: vec![]
+			}]
+		}]
+	});
+
+	assert_eq!(result.trace, expected_trace);
+}
+
+#[test]
+fn should_trace_failed_subcall_with_subcall_transaction() {
+	init_log();
+
+	let temp = RandomTempPath::new();
+	let mut state = get_temp_state_in(temp.as_path());
+
+	let mut info = EnvInfo::default();
+	info.gas_limit = x!(1_000_000);
+	let engine = TestEngine::new(5, Factory::default());
+
+	let t = Transaction {
+		nonce: x!(0),
+		gas_price: x!(0),
+		gas: x!(100_000),
+		action: Action::Call(x!(0xa)),
+		value: x!(100),
+		data: vec![],//600480600b6000396000f35b600056
+	}.sign(&"".sha3());
+
+	state.init_code(&x!(0xa), FromHex::from_hex("60006000600060006000600b602b5a03f1").unwrap());
+	state.init_code(&x!(0xb), FromHex::from_hex("60006000600060006000600c602b5a03f1505b601256").unwrap());
+	state.init_code(&x!(0xc), FromHex::from_hex("6000").unwrap());
+	state.add_balance(t.sender().as_ref().unwrap(), &x!(100));
+	let result = state.apply(&info, &engine, &t, true).unwrap();
+	let expected_trace = Some(Trace {
+		depth: 0,
+		action: trace::Action::Call(trace::Call {
+			from: x!("9cce34f7ab185c7aba1b7c8140d620b4bda941d6"),
+			to: x!(0xa),
+			value: x!(100),
+			gas: x!(79000),
+			input: vec![],
+		}),
+		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: x!(0xa),
+				to: x!(0xb),
+				value: x!(0),
+				gas: x!(78934),
+				input: vec![],
+			}),
+			result: trace::Res::FailedCall,
+			subs: vec![Trace {
+				depth: 2,
+				action: trace::Action::Call(trace::Call {
+					from: x!(0xb),
+					to: x!(0xc),
+					value: x!(0),
+					gas: x!(78868),
+					input: vec![],
+				}),
+				result: trace::Res::Call(trace::CallResult {
+					gas_used: U256::from(3),
+					output: vec![]
+				}),
+				subs: vec![]
+			}]
+		}]
+	});
+
+	assert_eq!(result.trace, expected_trace);
+}
 
 #[test]
 fn code_from_database() {

ethcore/src/state_diff.rs

@@ -20,7 +20,7 @@ use pod_state::*;
 use account_diff::*;
 
 #[derive(Debug,Clone,PartialEq,Eq)]
-/// Expression for the delta between two system states. Encoded the 
+/// Expression for the delta between two system states. Encoded the
 /// delta of every altered account.
 pub struct StateDiff (BTreeMap<Address, AccountDiff>);
 
@@ -41,6 +41,14 @@ impl fmt::Display for StateDiff {
 	}
 }
 
+impl Deref for StateDiff {
+	type Target = BTreeMap<Address, AccountDiff>;
+
+	fn deref(&self) -> &Self::Target {
+		&self.0
+	}
+}
+
 #[cfg(test)]
 mod test {
 	use common::*;

ethcore/src/substate.rs

@@ -19,32 +19,29 @@ use common::*;
 
 /// State changes which should be applied in finalize,
 /// after transaction is fully executed.
-#[derive(Debug)]
+#[derive(Debug, Default)]
 pub struct Substate {
 	/// Any accounts that have suicided.
 	pub suicides: HashSet<Address>,
+
 	/// Any logs.
 	pub logs: Vec<LogEntry>,
+
 	/// Refund counter of SSTORE nonzero -> zero.
 	pub sstore_clears_count: U256,
-	/// Created contracts.
-	pub contracts_created: Vec<Address>
-}
 
-impl Default for Substate {
-	fn default() -> Self {
-		Substate::new()
-	}
+	/// Created contracts.
+	pub contracts_created: Vec<Address>,
 }
 
 impl Substate {
 	/// Creates new substate.
 	pub fn new() -> Self {
 		Substate {
-			suicides: HashSet::new(),
-			logs: vec![],
-			sstore_clears_count: U256::zero(),
-			contracts_created: vec![]
+			suicides: Default::default(),
+			logs: Default::default(),
+			sstore_clears_count: Default::default(),
+			contracts_created: Default::default(),
 		}
 	}
 

ethcore/src/tests/client.rs

@@ -20,17 +20,10 @@ use tests::helpers::*;
 use common::*;
 use devtools::*;
 
-#[test]
-fn created() {
-	let dir = RandomTempPath::new();
-	let client_result = Client::new(ClientConfig::default(), get_test_spec(), dir.as_path(), IoChannel::disconnected());
-	assert!(client_result.is_ok());
-}
-
 #[test]
 fn imports_from_empty() {
 	let dir = RandomTempPath::new();
-	let client = Client::new(ClientConfig::default(), get_test_spec(), dir.as_path(), IoChannel::disconnected()).unwrap();
+	let client = Client::new(ClientConfig::default(), get_test_spec(), dir.as_path(), IoChannel::disconnected());
 	client.import_verified_blocks(&IoChannel::disconnected());
 	client.flush_queue();
 }
@@ -40,8 +33,7 @@ fn returns_state_root_basic() {
 	let client_result = generate_dummy_client(6);
 	let client = client_result.reference();
 	let test_spec = get_test_spec();
-	let test_engine = test_spec.to_engine().unwrap();
-	let state_root = test_engine.spec().genesis_header().state_root;
+	let state_root = test_spec.genesis_header().state_root;
 
 	assert!(client.state_data(&state_root).is_some());
 }
@@ -49,7 +41,7 @@ fn returns_state_root_basic() {
 #[test]
 fn imports_good_block() {
 	let dir = RandomTempPath::new();
-	let client = Client::new(ClientConfig::default(), get_test_spec(), dir.as_path(), IoChannel::disconnected()).unwrap();
+	let client = Client::new(ClientConfig::default(), get_test_spec(), dir.as_path(), IoChannel::disconnected());
 	let good_block = get_good_dummy_block();
 	if let Err(_) = client.import_block(good_block) {
 		panic!("error importing block being good by definition");
@@ -64,7 +56,7 @@ fn imports_good_block() {
 #[test]
 fn query_none_block() {
 	let dir = RandomTempPath::new();
-	let client = Client::new(ClientConfig::default(), get_test_spec(), dir.as_path(), IoChannel::disconnected()).unwrap();
+	let client = Client::new(ClientConfig::default(), get_test_spec(), dir.as_path(), IoChannel::disconnected());
 
     let non_existant = client.block_header(BlockId::Number(188));
 	assert!(non_existant.is_none());
@@ -144,8 +136,8 @@ fn can_mine() {
 	let client_result = get_test_client_with_blocks(vec![dummy_blocks[0].clone()]);
 	let client = client_result.reference();
 
-	let b = client.prepare_sealing(Address::default(), x!(31415926), vec![], vec![]).unwrap();
+	let b = client.prepare_sealing(Address::default(), x!(31415926), vec![], vec![]).0.unwrap();
 
 	assert_eq!(*b.block().header().parent_hash(), BlockView::new(&dummy_blocks[0]).header_view().sha3());
-	assert!(client.try_seal(b, vec![]).is_ok());
+	assert!(client.try_seal(b.lock(), vec![]).is_ok());
 }

ethcore/src/tests/helpers.rs

@@ -52,7 +52,7 @@ impl<T> GuardedTempResult<T> {
 
 pub struct TestEngine {
 	factory: Factory,
-	spec: Spec,
+	engine: Box<Engine>,
 	max_depth: usize
 }
 
@@ -60,18 +60,29 @@ impl TestEngine {
 	pub fn new(max_depth: usize, factory: Factory) -> TestEngine {
 		TestEngine {
 			factory: factory,
-			spec: ethereum::new_frontier_test(),
+			engine: ethereum::new_frontier_test().engine,
 			max_depth: max_depth
 		}
 	}
 }
 
 impl Engine for TestEngine {
-	fn name(&self) -> &str { "TestEngine" }
-	fn spec(&self) -> &Spec { &self.spec }
+	fn name(&self) -> &str {
+		"TestEngine"
+	}
+
+	fn params(&self) -> &CommonParams {
+		self.engine.params()
+	}
+
+	fn builtins(&self) -> &BTreeMap<Address, Builtin> {
+		self.engine.builtins()
+	}
+
 	fn vm_factory(&self) -> &Factory {
 		&self.factory
 	}
+
 	fn schedule(&self, _env_info: &EnvInfo) -> Schedule {
 		let mut schedule = Schedule::new_frontier();
 		schedule.max_depth = self.max_depth;
@@ -134,19 +145,19 @@ pub fn create_test_block_with_data(header: &Header, transactions: &[&SignedTrans
 pub fn generate_dummy_client(block_number: u32) -> GuardedTempResult<Arc<Client>> {
 	let dir = RandomTempPath::new();
 
-	let client = Client::new(ClientConfig::default(), get_test_spec(), dir.as_path(), IoChannel::disconnected()).unwrap();
+	let client = Client::new(ClientConfig::default(), get_test_spec(), dir.as_path(), IoChannel::disconnected());
 	let test_spec = get_test_spec();
-	let test_engine = test_spec.to_engine().unwrap();
-	let state_root = test_engine.spec().genesis_header().state_root;
-	let mut rolling_hash = test_engine.spec().genesis_header().hash();
+	let test_engine = &test_spec.engine;
+	let state_root = test_spec.genesis_header().state_root;
+	let mut rolling_hash = test_spec.genesis_header().hash();
 	let mut rolling_block_number = 1;
 	let mut rolling_timestamp = 40;
 
 	for _ in 0..block_number {
 		let mut header = Header::new();
 
-		header.gas_limit = decode(test_engine.spec().engine_params.get("minGasLimit").unwrap());
-		header.difficulty = decode(test_engine.spec().engine_params.get("minimumDifficulty").unwrap());
+		header.gas_limit = test_engine.params().min_gas_limit;
+		header.difficulty = U256::from(0x20000);
 		header.timestamp = rolling_timestamp;
 		header.number = rolling_block_number;
 		header.parent_hash = rolling_hash;
@@ -171,8 +182,9 @@ pub fn generate_dummy_client(block_number: u32) -> GuardedTempResult<Arc<Client>
 
 pub fn push_blocks_to_client(client: &Arc<Client>, timestamp_salt: u64, starting_number: usize, block_number: usize) {
 	let test_spec = get_test_spec();
-	let test_engine = test_spec.to_engine().unwrap();
-	let state_root = test_engine.spec().genesis_header().state_root;
+	let test_engine = &test_spec.engine;
+	//let test_engine = test_spec.to_engine().unwrap();
+	let state_root = test_spec.genesis_header().state_root;
 	let mut rolling_hash = client.chain_info().best_block_hash;
 	let mut rolling_block_number = starting_number as u64;
 	let mut rolling_timestamp = timestamp_salt + starting_number as u64 * 10;
@@ -180,8 +192,8 @@ pub fn push_blocks_to_client(client: &Arc<Client>, timestamp_salt: u64, starting
 	for _ in 0..block_number {
 		let mut header = Header::new();
 
-		header.gas_limit = decode(test_engine.spec().engine_params.get("minGasLimit").unwrap());
-		header.difficulty = decode(test_engine.spec().engine_params.get("minimumDifficulty").unwrap());
+		header.gas_limit = test_engine.params().min_gas_limit;
+		header.difficulty = U256::from(0x20000);
 		header.timestamp = rolling_timestamp;
 		header.number = rolling_block_number;
 		header.parent_hash = rolling_hash;
@@ -199,7 +211,7 @@ pub fn push_blocks_to_client(client: &Arc<Client>, timestamp_salt: u64, starting
 
 pub fn get_test_client_with_blocks(blocks: Vec<Bytes>) -> GuardedTempResult<Arc<Client>> {
 	let dir = RandomTempPath::new();
-	let client = Client::new(ClientConfig::default(), get_test_spec(), dir.as_path(), IoChannel::disconnected()).unwrap();
+	let client = Client::new(ClientConfig::default(), get_test_spec(), dir.as_path(), IoChannel::disconnected());
 	for block in &blocks {
 		if let Err(_) = client.import_block(block.clone()) {
 			panic!("panic importing block which is well-formed");
@@ -279,24 +291,23 @@ pub fn get_temp_state_in(path: &Path) -> State {
 
 pub fn get_good_dummy_block_seq(count: usize) -> Vec<Bytes> {
 	let test_spec = get_test_spec();
-	let test_engine = test_spec.to_engine().unwrap();
-  	get_good_dummy_block_fork_seq(1, count, &test_engine.spec().genesis_header().hash())
+  	get_good_dummy_block_fork_seq(1, count, &test_spec.genesis_header().hash())
 }
 
 pub fn get_good_dummy_block_fork_seq(start_number: usize, count: usize, parent_hash: &H256) -> Vec<Bytes> {
 	let test_spec = get_test_spec();
-	let test_engine = test_spec.to_engine().unwrap();
+	let test_engine = &test_spec.engine;
 	let mut rolling_timestamp = start_number as u64 * 10;
 	let mut parent = *parent_hash;
 	let mut r = Vec::new();
 	for i in start_number .. start_number + count + 1 {
 		let mut block_header = Header::new();
-		block_header.gas_limit = decode(test_engine.spec().engine_params.get("minGasLimit").unwrap());
+		block_header.gas_limit = test_engine.params().min_gas_limit;
 		block_header.difficulty = U256::from(i).mul(U256([0, 1, 0, 0]));
 		block_header.timestamp = rolling_timestamp;
 		block_header.number = i as u64;
 		block_header.parent_hash = parent;
-		block_header.state_root = test_engine.spec().genesis_header().state_root;
+		block_header.state_root = test_spec.genesis_header().state_root;
 
 		parent = block_header.hash();
 		rolling_timestamp = rolling_timestamp + 10;
@@ -310,13 +321,13 @@ pub fn get_good_dummy_block_fork_seq(start_number: usize, count: usize, parent_h
 pub fn get_good_dummy_block() -> Bytes {
 	let mut block_header = Header::new();
 	let test_spec = get_test_spec();
-	let test_engine = test_spec.to_engine().unwrap();
-	block_header.gas_limit = decode(test_engine.spec().engine_params.get("minGasLimit").unwrap());
-	block_header.difficulty = decode(test_engine.spec().engine_params.get("minimumDifficulty").unwrap());
+	let test_engine = &test_spec.engine;
+	block_header.gas_limit = test_engine.params().min_gas_limit;
+	block_header.difficulty = U256::from(0x20000);
 	block_header.timestamp = 40;
 	block_header.number = 1;
-	block_header.parent_hash = test_engine.spec().genesis_header().hash();
-	block_header.state_root = test_engine.spec().genesis_header().state_root;
+	block_header.parent_hash = test_spec.genesis_header().hash();
+	block_header.state_root = test_spec.genesis_header().state_root;
 
 	create_test_block(&block_header)
 }
@@ -324,12 +335,12 @@ pub fn get_good_dummy_block() -> Bytes {
 pub fn get_bad_state_dummy_block() -> Bytes {
 	let mut block_header = Header::new();
 	let test_spec = get_test_spec();
-	let test_engine = test_spec.to_engine().unwrap();
-	block_header.gas_limit = decode(test_engine.spec().engine_params.get("minGasLimit").unwrap());
-	block_header.difficulty = decode(test_engine.spec().engine_params.get("minimumDifficulty").unwrap());
+	let test_engine = &test_spec.engine;
+	block_header.gas_limit = test_engine.params().min_gas_limit;
+	block_header.difficulty = U256::from(0x20000);
 	block_header.timestamp = 40;
 	block_header.number = 1;
-	block_header.parent_hash = test_engine.spec().genesis_header().hash();
+	block_header.parent_hash = test_spec.genesis_header().hash();
 	block_header.state_root = x!(0xbad);
 
 	create_test_block(&block_header)

ethcore/src/trace/block.rs

@@ -0,0 +1,42 @@
+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/bloom.rs

@@ -0,0 +1,106 @@
+use bloomchain::Bloom;
+use bloomchain::group::{BloomGroup, GroupPosition};
+use util::rlp::*;
+use basic_types::LogBloom;
+
+/// Helper structure representing bloom of the trace.
+#[derive(Clone)]
+pub struct BlockTracesBloom(LogBloom);
+
+impl From<LogBloom> for BlockTracesBloom {
+	fn from(bloom: LogBloom) -> BlockTracesBloom {
+		BlockTracesBloom(bloom)
+	}
+}
+
+impl From<Bloom> for BlockTracesBloom {
+	fn from(bloom: Bloom) -> BlockTracesBloom {
+		let bytes: [u8; 256] = bloom.into();
+		BlockTracesBloom(LogBloom::from(bytes))
+	}
+}
+
+impl Into<Bloom> for BlockTracesBloom {
+	fn into(self) -> Bloom {
+		let log = self.0;
+		Bloom::from(log.0)
+	}
+}
+
+/// Represents group of X consecutive blooms.
+#[derive(Clone)]
+pub struct BlockTracesBloomGroup {
+	blooms: Vec<BlockTracesBloom>,
+}
+
+impl From<BloomGroup> for BlockTracesBloomGroup {
+	fn from(group: BloomGroup) -> Self {
+		let blooms = group.blooms
+			.into_iter()
+			.map(From::from)
+			.collect();
+
+		BlockTracesBloomGroup {
+			blooms: blooms
+		}
+	}
+}
+
+impl Into<BloomGroup> for BlockTracesBloomGroup {
+	fn into(self) -> BloomGroup {
+		let blooms = self.blooms
+			.into_iter()
+			.map(Into::into)
+			.collect();
+
+		BloomGroup {
+			blooms: blooms
+		}
+	}
+}
+
+impl Decodable for BlockTracesBloom {
+	fn decode<D>(decoder: &D) -> Result<Self, DecoderError> where D: Decoder {
+		Decodable::decode(decoder).map(BlockTracesBloom)
+	}
+}
+
+impl Encodable for BlockTracesBloom {
+	fn rlp_append(&self, s: &mut RlpStream) {
+		Encodable::rlp_append(&self.0, s)
+	}
+}
+
+impl Decodable for BlockTracesBloomGroup {
+	fn decode<D>(decoder: &D) -> Result<Self, DecoderError> where D: Decoder {
+		let blooms = try!(Decodable::decode(decoder));
+		let group = BlockTracesBloomGroup {
+			blooms: blooms
+		};
+		Ok(group)
+	}
+}
+
+impl Encodable for BlockTracesBloomGroup {
+	fn rlp_append(&self, s: &mut RlpStream) {
+		Encodable::rlp_append(&self.blooms, s)
+	}
+}
+
+/// Represents `BloomGroup` position in database.
+#[derive(PartialEq, Eq, Hash, Clone, Debug)]
+pub struct TraceGroupPosition {
+	/// Bloom level.
+	pub level: u8,
+	/// Group index.
+	pub index: u32,
+}
+
+impl From<GroupPosition> for TraceGroupPosition {
+	fn from(p: GroupPosition) -> Self {
+		TraceGroupPosition {
+			level: p.level as u8,
+			index: p.index as u32,
+		}
+	}
+}

ethcore/src/trace/config.rs

@@ -0,0 +1,62 @@
+// 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/>.
+
+//! Traces config.
+use bloomchain::Config as BloomConfig;
+
+/// 3-value enum.
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum Switch {
+	/// True.
+	On,
+	/// False.
+	Off,
+	/// Auto.
+	Auto,
+}
+
+impl Switch {
+	/// Tries to turn old switch to new value.
+	pub fn turn_to(&self, to: Switch) -> Result<bool, &'static str> {
+		match (*self, to) {
+			(Switch::On, Switch::On) | (Switch::On, Switch::Auto) | (Switch::Auto, Switch::On) => Ok(true),
+			(Switch::Off, Switch::On) => Err("Tracing can't be enabled"),
+			_ => Ok(false),
+		}
+	}
+}
+
+/// Traces config.
+#[derive(Debug, Clone)]
+pub struct Config {
+	/// Indicates if tracing should be enabled or not.
+	/// If it's None, it will be automatically configured.
+	pub enabled: Switch,
+	/// Traces blooms configuration.
+	pub blooms: BloomConfig,
+}
+
+impl Default for Config {
+	fn default() -> Self {
+		Config {
+			enabled: Switch::Auto,
+			blooms: BloomConfig {
+				levels: 3,
+				elements_per_index: 16,
+			}
+		}
+	}
+}

ethcore/src/trace/db.rs

@@ -0,0 +1,583 @@
+// 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/>.
+
+//! Trace database.
+use std::ptr;
+use std::ops::Deref;
+use std::collections::HashMap;
+use std::sync::{RwLock, Arc};
+use std::path::Path;
+use bloomchain::{Number, Config as BloomConfig};
+use bloomchain::group::{BloomGroupDatabase, BloomGroupChain, GroupPosition, BloomGroup};
+use util::{FixedHash, H256, H264, Database, DBTransaction};
+use header::BlockNumber;
+use trace::{BlockTraces, LocalizedTrace, Config, Switch, Filter, Database as TraceDatabase, ImportRequest,
+DatabaseExtras};
+use db::{Key, Writable, Readable, CacheUpdatePolicy};
+use super::bloom::{TraceGroupPosition, BlockTracesBloom, BlockTracesBloomGroup};
+use super::flat::{FlatTrace, FlatBlockTraces, FlatTransactionTraces};
+
+const TRACE_DB_VER: &'static [u8] = b"1.0";
+
+#[derive(Debug, Copy, Clone)]
+#[cfg_attr(feature="dev", allow(enum_variant_names))]
+enum TraceDBIndex {
+	/// Block traces index.
+	BlockTraces = 0,
+	/// Trace bloom group index.
+	BlockTracesBloomGroups = 1,
+}
+
+impl Key<BlockTraces> 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
+	}
+}
+
+/// Helper data structure created cause [u8; 6] does not implement Deref to &[u8].
+pub struct TraceGroupKey([u8; 6]);
+
+impl Deref for TraceGroupKey {
+	type Target = [u8];
+
+	fn deref(&self) -> &Self::Target {
+		&self.0
+	}
+}
+
+impl Key<BlockTracesBloomGroup> for TraceGroupPosition {
+	type Target = TraceGroupKey;
+
+	fn key(&self) -> Self::Target {
+		let mut result = [0u8; 6];
+		result[0] = TraceDBIndex::BlockTracesBloomGroups as u8;
+		result[1] = self.level;
+		unsafe {
+			ptr::copy(&[self.index] as *const u32 as *const u8, result.as_mut_ptr().offset(2), 4);
+		}
+		TraceGroupKey(result)
+	}
+}
+
+/// Trace database.
+pub struct TraceDB<T> where T: DatabaseExtras {
+	// cache
+	traces: RwLock<HashMap<H256, BlockTraces>>,
+	blooms: RwLock<HashMap<TraceGroupPosition, BlockTracesBloomGroup>>,
+	// db
+	tracesdb: Database,
+	// config,
+	bloom_config: BloomConfig,
+	// tracing enabled
+	enabled: bool,
+	// extras
+	extras: Arc<T>,
+}
+
+impl<T> BloomGroupDatabase for TraceDB<T> where T: DatabaseExtras {
+	fn blooms_at(&self, position: &GroupPosition) -> Option<BloomGroup> {
+		let position = TraceGroupPosition::from(position.clone());
+		self.tracesdb.read_with_cache(&self.blooms, &position).map(Into::into)
+	}
+}
+
+impl<T> TraceDB<T> where T: DatabaseExtras {
+	/// Creates new instance of `TraceDB`.
+	pub fn new(config: Config, path: &Path, extras: Arc<T>) -> Self {
+		let mut tracedb_path = path.to_path_buf();
+		tracedb_path.push("tracedb");
+		let tracesdb = Database::open_default(tracedb_path.to_str().unwrap()).unwrap();
+
+		// check if in previously tracing was enabled
+		let old_tracing = match tracesdb.get(b"enabled").unwrap() {
+			Some(ref value) if value as &[u8] == &[0x1] => Switch::On,
+			Some(ref value) if value as &[u8] == &[0x0] => Switch::Off,
+			Some(_) => { panic!("tracesdb is corrupted") },
+			None => Switch::Auto,
+		};
+
+		let enabled = old_tracing.turn_to(config.enabled).expect("Tracing can't be enabled. Resync required.");
+
+		let encoded_tracing = match enabled {
+			true => [0x1],
+			false => [0x0]
+		};
+
+		tracesdb.put(b"enabled", &encoded_tracing).unwrap();
+		tracesdb.put(b"version", TRACE_DB_VER).unwrap();
+
+		TraceDB {
+			traces: RwLock::new(HashMap::new()),
+			blooms: RwLock::new(HashMap::new()),
+			tracesdb: tracesdb,
+			bloom_config: config.blooms,
+			enabled: enabled,
+			extras: extras,
+		}
+	}
+
+	/// Returns traces for block with hash.
+	fn traces(&self, block_hash: &H256) -> Option<BlockTraces> {
+		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)
+	}
+
+	fn matching_block_traces(
+		&self,
+		filter: &Filter,
+		traces: FlatBlockTraces,
+		block_hash: H256,
+		block_number: BlockNumber
+	) -> Vec<LocalizedTrace> {
+		let tx_traces: Vec<FlatTransactionTraces> = traces.into();
+		tx_traces.into_iter()
+			.enumerate()
+			.flat_map(|(tx_number, tx_trace)| {
+				self.matching_transaction_traces(filter, tx_trace, block_hash.clone(), block_number, tx_number)
+			})
+			.collect()
+	}
+
+	fn matching_transaction_traces(
+		&self,
+		filter: &Filter,
+		traces: FlatTransactionTraces,
+		block_hash: H256,
+		block_number: BlockNumber,
+		tx_number: usize
+	) -> Vec<LocalizedTrace> {
+		let tx_hash = self.extras.transaction_hash(block_number, tx_number)
+			.expect("Expected to find transaction hash. Database is probably corrupted");
+
+		let flat_traces: Vec<FlatTrace> = traces.into();
+		flat_traces.into_iter()
+			.filter_map(|trace| {
+				match filter.matches(&trace) {
+					true => Some(LocalizedTrace {
+						action: trace.action,
+						result: trace.result,
+						subtraces: trace.subtraces,
+						trace_address: trace.trace_address,
+						transaction_number: tx_number,
+						transaction_hash: tx_hash.clone(),
+						block_number: block_number,
+						block_hash: block_hash
+					}),
+					false => None
+				}
+			})
+			.collect()
+	}
+}
+
+impl<T> TraceDatabase for TraceDB<T> where T: DatabaseExtras {
+	fn tracing_enabled(&self) -> bool {
+		self.enabled
+	}
+
+	/// Traces of import request's enacted blocks are expected to be already in database
+	/// or to be the currently inserted trace.
+	fn import(&self, request: ImportRequest) {
+		// fast return if tracing is disabled
+		if !self.tracing_enabled() {
+			return;
+		}
+
+		let batch = DBTransaction::new();
+
+		// at first, let's insert new block traces
+		{
+			let mut traces = self.traces.write().unwrap();
+			// it's important to use overwrite here,
+			// cause this value might be queried by hash later
+			batch.write_with_cache(&mut traces, request.block_hash, request.traces, CacheUpdatePolicy::Overwrite);
+		}
+
+		// now let's rebuild the blooms
+		{
+			let range_start = request.block_number as Number + 1 - request.enacted.len();
+			let range_end = range_start + request.retracted;
+			let replaced_range = range_start..range_end;
+			let enacted_blooms = request.enacted
+				.iter()
+				// all traces are expected to be found here. That's why `expect` has been used
+				// instead of `filter_map`. If some traces haven't been found, it meens that
+				// traces database is corrupted or incomplete.
+				.map(|block_hash| self.traces(block_hash).expect("Traces database is incomplete."))
+				.map(|block_traces| block_traces.bloom())
+				.map(BlockTracesBloom::from)
+				.map(Into::into)
+				.collect();
+
+			let chain = BloomGroupChain::new(self.bloom_config, self);
+			let trace_blooms = chain.replace(&replaced_range, enacted_blooms);
+			let blooms_to_insert = trace_blooms.into_iter()
+				.map(|p| (From::from(p.0), From::from(p.1)))
+				.collect::<HashMap<TraceGroupPosition, BlockTracesBloomGroup>>();
+
+			let mut blooms = self.blooms.write().unwrap();
+			batch.extend_with_cache(&mut blooms, blooms_to_insert, CacheUpdatePolicy::Remove);
+		}
+
+		self.tracesdb.write(batch).unwrap();
+	}
+
+	fn trace(&self, block_number: BlockNumber, tx_position: usize, trace_position: Vec<usize>) -> Option<LocalizedTrace> {
+		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))
+				.map(|trace| {
+					let tx_hash = self.extras.transaction_hash(block_number, tx_position)
+						.expect("Expected to find transaction hash. Database is probably corrupted");
+
+					LocalizedTrace {
+						action: trace.action,
+						result: trace.result,
+						subtraces: trace.subtraces,
+						trace_address: trace.trace_address,
+						transaction_number: tx_position,
+						transaction_hash: tx_hash,
+						block_number: block_number,
+						block_hash: block_hash,
+					}
+				})
+			)
+	}
+
+	fn transaction_traces(&self, block_number: BlockNumber, tx_position: usize) -> Option<Vec<LocalizedTrace>> {
+		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)
+				.map(|traces| {
+					let tx_hash = self.extras.transaction_hash(block_number, tx_position)
+						.expect("Expected to find transaction hash. Database is probably corrupted");
+
+					traces.into_iter()
+					.map(|trace| LocalizedTrace {
+						action: trace.action,
+						result: trace.result,
+						subtraces: trace.subtraces,
+						trace_address: trace.trace_address,
+						transaction_number: tx_position,
+						transaction_hash: tx_hash.clone(),
+						block_number: block_number,
+						block_hash: block_hash
+					})
+					.collect()
+				})
+			)
+	}
+
+	fn block_traces(&self, block_number: BlockNumber) -> Option<Vec<LocalizedTrace>> {
+		self.extras.block_hash(block_number)
+			.and_then(|block_hash| self.transactions_traces(&block_hash)
+				.map(|traces| {
+					traces.into_iter()
+						.map(Into::<Vec<FlatTrace>>::into)
+						.enumerate()
+						.flat_map(|(tx_position, traces)| {
+							let tx_hash = self.extras.transaction_hash(block_number, tx_position)
+								.expect("Expected to find transaction hash. Database is probably corrupted");
+
+							traces.into_iter()
+								.map(|trace| LocalizedTrace {
+									action: trace.action,
+									result: trace.result,
+									subtraces: trace.subtraces,
+									trace_address: trace.trace_address,
+									transaction_number: tx_position,
+									transaction_hash: tx_hash.clone(),
+									block_number: block_number,
+									block_hash: block_hash,
+								})
+								.collect::<Vec<LocalizedTrace>>()
+						})
+						.collect::<Vec<LocalizedTrace>>()
+				})
+			)
+	}
+
+	fn filter(&self, filter: &Filter) -> Vec<LocalizedTrace> {
+		let chain = BloomGroupChain::new(self.bloom_config, self);
+		let numbers = chain.filter(filter);
+		numbers.into_iter()
+			.flat_map(|n| {
+				let number = n as BlockNumber;
+				let hash = self.extras.block_hash(number)
+					.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)
+			})
+			.collect()
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use std::collections::HashMap;
+	use std::sync::Arc;
+	use util::{Address, U256, H256};
+	use devtools::RandomTempPath;
+	use header::BlockNumber;
+	use trace::{Config, Switch, TraceDB, Database, DatabaseExtras, ImportRequest};
+	use trace::{BlockTraces, Trace, Filter, LocalizedTrace, AddressesFilter};
+	use trace::trace::{Call, Action, Res};
+
+	struct NoopExtras;
+
+	impl DatabaseExtras for NoopExtras {
+		fn block_hash(&self, _block_number: BlockNumber) -> Option<H256> {
+			unimplemented!();
+		}
+
+		fn transaction_hash(&self, _block_number: BlockNumber, _tx_position: usize) -> Option<H256> {
+			unimplemented!();
+		}
+	}
+
+	struct Extras {
+		block_hashes: HashMap<BlockNumber, H256>,
+		transaction_hashes: HashMap<BlockNumber, Vec<H256>>,
+	}
+
+	impl Default for Extras {
+		fn default() -> Self {
+			Extras {
+				block_hashes: HashMap::new(),
+				transaction_hashes: HashMap::new(),
+			}
+		}
+	}
+
+	impl DatabaseExtras for Extras {
+		fn block_hash(&self, block_number: BlockNumber) -> Option<H256> {
+			self.block_hashes.get(&block_number).cloned()
+		}
+
+		fn transaction_hash(&self, block_number: BlockNumber, tx_position: usize) -> Option<H256> {
+			self.transaction_hashes.get(&block_number)
+				.and_then(|hashes| hashes.iter().cloned().nth(tx_position))
+		}
+	}
+
+	#[test]
+	fn test_reopening_db_with_tracing_off() {
+		let temp = RandomTempPath::new();
+		let mut config = Config::default();
+
+		// set autotracing
+		config.enabled = Switch::Auto;
+
+		{
+			let tracedb = TraceDB::new(config.clone(), temp.as_path(), Arc::new(NoopExtras));
+			assert_eq!(tracedb.tracing_enabled(), false);
+		}
+
+		{
+			let tracedb = TraceDB::new(config.clone(), temp.as_path(), Arc::new(NoopExtras));
+			assert_eq!(tracedb.tracing_enabled(), false);
+		}
+
+		config.enabled = Switch::Off;
+
+		{
+			let tracedb = TraceDB::new(config.clone(), temp.as_path(), Arc::new(NoopExtras));
+			assert_eq!(tracedb.tracing_enabled(), false);
+		}
+	}
+
+	#[test]
+	fn test_reopening_db_with_tracing_on() {
+		let temp = RandomTempPath::new();
+		let mut config = Config::default();
+
+		// set tracing on
+		config.enabled = Switch::On;
+
+		{
+			let tracedb = TraceDB::new(config.clone(), temp.as_path(), Arc::new(NoopExtras));
+			assert_eq!(tracedb.tracing_enabled(), true);
+		}
+
+		{
+			let tracedb = TraceDB::new(config.clone(), temp.as_path(), Arc::new(NoopExtras));
+			assert_eq!(tracedb.tracing_enabled(), true);
+		}
+
+		config.enabled = Switch::Auto;
+
+		{
+			let tracedb = TraceDB::new(config.clone(), temp.as_path(), Arc::new(NoopExtras));
+			assert_eq!(tracedb.tracing_enabled(), true);
+		}
+
+		config.enabled = Switch::Off;
+
+		{
+			let tracedb = TraceDB::new(config.clone(), temp.as_path(), Arc::new(NoopExtras));
+			assert_eq!(tracedb.tracing_enabled(), false);
+		}
+	}
+
+	#[test]
+	#[should_panic]
+	fn test_invalid_reopening_db() {
+		let temp = RandomTempPath::new();
+		let mut config = Config::default();
+
+		// set tracing on
+		config.enabled = Switch::Off;
+
+		{
+			let tracedb = TraceDB::new(config.clone(), temp.as_path(), Arc::new(NoopExtras));
+			assert_eq!(tracedb.tracing_enabled(), true);
+		}
+
+		config.enabled = Switch::On;
+		TraceDB::new(config.clone(), temp.as_path(), Arc::new(NoopExtras)); // should panic!
+	}
+
+	fn create_simple_import_request(block_number: BlockNumber, block_hash: H256) -> ImportRequest {
+		ImportRequest {
+			traces: BlockTraces::from(vec![Trace {
+				depth: 0,
+				action: Action::Call(Call {
+					from: Address::from(1),
+					to: Address::from(2),
+					value: U256::from(3),
+					gas: U256::from(4),
+					input: vec![],
+				}),
+				result: Res::FailedCall,
+				subs: vec![],
+			}]),
+			block_hash: block_hash.clone(),
+			block_number: block_number,
+			enacted: vec![block_hash],
+			retracted: 0,
+		}
+	}
+
+	fn create_simple_localized_trace(block_number: BlockNumber, block_hash: H256, tx_hash: H256) -> LocalizedTrace {
+		LocalizedTrace {
+			action: Action::Call(Call {
+				from: Address::from(1),
+				to: Address::from(2),
+				value: U256::from(3),
+				gas: U256::from(4),
+				input: vec![],
+			}),
+			result: Res::FailedCall,
+			trace_address: vec![],
+			subtraces: 0,
+			transaction_number: 0,
+			transaction_hash: tx_hash,
+			block_number: block_number,
+			block_hash: block_hash,
+		}
+	}
+
+
+	#[test]
+	fn test_import() {
+		let temp = RandomTempPath::new();
+		let mut config = Config::default();
+		config.enabled = Switch::On;
+		let block_0 = H256::from(0xa1);
+		let block_1 = H256::from(0xa2);
+		let tx_0 = H256::from(0xff);
+		let tx_1 = H256::from(0xaf);
+
+		let mut extras = Extras::default();
+		extras.block_hashes.insert(0, block_0.clone());
+		extras.block_hashes.insert(1, block_1.clone());
+		extras.transaction_hashes.insert(0, vec![tx_0.clone()]);
+		extras.transaction_hashes.insert(1, vec![tx_1.clone()]);
+
+		let tracedb = TraceDB::new(config, temp.as_path(), Arc::new(extras));
+
+		// import block 0
+		let request = create_simple_import_request(0, block_0.clone());
+		tracedb.import(request);
+
+		let filter = Filter {
+			range: (0..0),
+			from_address: AddressesFilter::from(vec![Address::from(1)]),
+			to_address: AddressesFilter::from(vec![]),
+		};
+
+		let traces = tracedb.filter(&filter);
+		assert_eq!(traces.len(), 1);
+		assert_eq!(traces[0], create_simple_localized_trace(0, block_0.clone(), tx_0.clone()));
+
+		// import block 1
+		let request = create_simple_import_request(1, block_1.clone());
+		tracedb.import(request);
+
+		let filter = Filter {
+			range: (0..1),
+			from_address: AddressesFilter::from(vec![Address::from(1)]),
+			to_address: AddressesFilter::from(vec![]),
+		};
+
+		let traces = tracedb.filter(&filter);
+		assert_eq!(traces.len(), 2);
+		assert_eq!(traces[0], create_simple_localized_trace(0, block_0.clone(), tx_0.clone()));
+		assert_eq!(traces[1], create_simple_localized_trace(1, block_1.clone(), tx_1.clone()));
+
+		let traces = tracedb.block_traces(0).unwrap();
+		assert_eq!(traces.len(), 1);
+		assert_eq!(traces[0], create_simple_localized_trace(0, block_0.clone(), tx_0.clone()));
+
+		let traces = tracedb.block_traces(1).unwrap();
+		assert_eq!(traces.len(), 1);
+		assert_eq!(traces[0], create_simple_localized_trace(1, block_1.clone(), tx_1.clone()));
+
+		assert_eq!(None, tracedb.block_traces(2));
+
+		let traces = tracedb.transaction_traces(0, 0).unwrap();
+		assert_eq!(traces.len(), 1);
+		assert_eq!(traces[0], create_simple_localized_trace(0, block_0.clone(), tx_0.clone()));
+
+		let traces = tracedb.transaction_traces(1, 0).unwrap();
+		assert_eq!(traces.len(), 1);
+		assert_eq!(traces[0], create_simple_localized_trace(1, block_1.clone(), tx_1.clone()));
+
+		assert_eq!(None, tracedb.transaction_traces(1, 1));
+
+		assert_eq!(tracedb.trace(0, 0, vec![]).unwrap(), create_simple_localized_trace(0, block_0.clone(), tx_0.clone()));
+		assert_eq!(tracedb.trace(1, 0, vec![]).unwrap(), create_simple_localized_trace(1, block_1.clone(), tx_1.clone()));
+	}
+}

ethcore/src/trace/executive_tracer.rs

@@ -0,0 +1,108 @@
+// 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/>.
+
+//! Simple executive tracer.
+
+use util::{Bytes, Address, U256};
+use action_params::ActionParams;
+use trace::trace::{Trace, Call, Create, Action, Res, CreateResult, CallResult};
+use trace::Tracer;
+
+/// Simple executive tracer. Traces all calls and creates. Ignores delegatecalls.
+#[derive(Default)]
+pub struct ExecutiveTracer {
+	traces: Vec<Trace>
+}
+
+impl Tracer for ExecutiveTracer {
+	fn prepare_trace_call(&self, params: &ActionParams) -> Option<Call> {
+		Some(Call::from(params.clone()))
+	}
+
+	fn prepare_trace_create(&self, params: &ActionParams) -> Option<Create> {
+		Some(Create::from(params.clone()))
+	}
+
+	fn prepare_trace_output(&self) -> Option<Bytes> {
+		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,
+			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);
+	}
+
+	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,
+			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
+			})
+		};
+		self.traces.push(trace);
+	}
+
+	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,
+			action: Action::Call(call.expect("self.prepare_trace_call().is_some(): so we must be tracing: qed")),
+			result: Res::FailedCall,
+		};
+		self.traces.push(trace);
+	}
+
+	fn trace_failed_create(&mut self, create: Option<Create>, depth: usize, subs: Vec<Trace>) {
+		let trace = Trace {
+			depth: depth,
+			subs: subs,
+			action: Action::Create(create.expect("self.prepare_trace_create().is_some(): so we must be tracing: qed")),
+			result: Res::FailedCreate,
+		};
+		self.traces.push(trace);
+	}
+
+	fn subtracer(&self) -> Self {
+		ExecutiveTracer::default()
+	}
+
+	fn traces(self) -> Vec<Trace> {
+		self.traces
+	}
+}

ethcore/src/trace/filter.rs

@@ -0,0 +1,283 @@
+// 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 std::ops::Range;
+use bloomchain::{Filter as BloomFilter, Bloom, Number};
+use util::{Address, FixedHash};
+use util::sha3::Hashable;
+use basic_types::LogBloom;
+use super::flat::FlatTrace;
+use super::trace::Action;
+
+/// Addresses filter.
+///
+/// Used to create bloom possibilities and match filters.
+pub struct AddressesFilter(Vec<Address>);
+
+impl From<Vec<Address>> for AddressesFilter {
+	fn from(addresses: Vec<Address>) -> Self {
+		AddressesFilter(addresses)
+	}
+}
+
+impl AddressesFilter {
+	/// Returns true if address matches one of the searched addresses.
+	pub fn matches(&self, address: &Address) -> bool {
+		self.matches_all() || self.0.contains(address)
+	}
+
+	/// Returns true if this address filter matches everything.
+	pub fn matches_all(&self) -> bool {
+		self.0.is_empty()
+	}
+
+	/// Returns blooms of this addresses filter.
+	pub fn blooms(&self) -> Vec<LogBloom> {
+		match self.0.is_empty() {
+			true => vec![LogBloom::new()],
+			false => self.0.iter()
+				.map(|address| LogBloom::from_bloomed(&address.sha3()))
+				.collect()
+		}
+	}
+
+	/// Returns vector of blooms zipped with blooms of this addresses filter.
+	pub fn with_blooms(&self, blooms: Vec<LogBloom>) -> Vec<LogBloom> {
+		match self.0.is_empty() {
+			true => blooms,
+			false => blooms
+				.into_iter()
+				.flat_map(|bloom| self.0.iter()
+					.map(|address| bloom.with_bloomed(&address.sha3()))
+					.collect::<Vec<_>>())
+				.collect()
+		}
+	}
+}
+
+/// Traces filter.
+pub struct Filter {
+	/// Block range.
+	pub range: Range<usize>,
+
+	/// From address filter.
+	pub from_address: AddressesFilter,
+
+	/// To address filter.
+	pub to_address: AddressesFilter,
+}
+
+impl BloomFilter for Filter {
+	fn bloom_possibilities(&self) -> Vec<Bloom> {
+		self.bloom_possibilities()
+			.into_iter()
+			.map(|b| Bloom::from(b.0))
+			.collect()
+	}
+
+	fn range(&self) -> Range<Number> {
+		self.range.clone()
+	}
+}
+
+impl Filter {
+	/// Returns combinations of each address.
+	fn bloom_possibilities(&self) -> Vec<LogBloom> {
+		self.to_address.with_blooms(self.from_address.blooms())
+	}
+
+	/// Returns true if given trace matches the filter.
+	pub fn matches(&self, trace: &FlatTrace) -> bool {
+		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
+			}
+		}
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use util::{FixedHash, Address, U256};
+	use util::sha3::Hashable;
+	use trace::trace::{Action, Call, Res};
+	use trace::flat::FlatTrace;
+	use trace::{Filter, AddressesFilter};
+	use basic_types::LogBloom;
+
+	#[test]
+	fn empty_trace_filter_bloom_possibilities() {
+		let filter = Filter {
+			range: (0..0),
+			from_address: AddressesFilter::from(vec![]),
+			to_address: AddressesFilter::from(vec![]),
+		};
+
+		let blooms = filter.bloom_possibilities();
+		assert_eq!(blooms, vec![LogBloom::new()]);
+	}
+
+	#[test]
+	fn single_trace_filter_bloom_possibility() {
+		let filter = Filter {
+			range: (0..0),
+			from_address: AddressesFilter::from(vec![Address::from(1)]),
+			to_address: AddressesFilter::from(vec![Address::from(2)]),
+		};
+
+		let blooms = filter.bloom_possibilities();
+		assert_eq!(blooms.len(), 1);
+
+		assert!(blooms[0].contains_bloomed(&Address::from(1).sha3()));
+		assert!(blooms[0].contains_bloomed(&Address::from(2).sha3()));
+		assert!(!blooms[0].contains_bloomed(&Address::from(3).sha3()));
+	}
+
+	#[test]
+	fn only_from_trace_filter_bloom_possibility() {
+		let filter = Filter {
+			range: (0..0),
+			from_address: AddressesFilter::from(vec![Address::from(1)]),
+			to_address: AddressesFilter::from(vec![]),
+		};
+
+		let blooms = filter.bloom_possibilities();
+		assert_eq!(blooms.len(), 1);
+
+		assert!(blooms[0].contains_bloomed(&Address::from(1).sha3()));
+		assert!(!blooms[0].contains_bloomed(&Address::from(2).sha3()));
+	}
+
+	#[test]
+	fn only_to_trace_filter_bloom_possibility() {
+		let filter = Filter {
+			range: (0..0),
+			from_address: AddressesFilter::from(vec![]),
+			to_address: AddressesFilter::from(vec![Address::from(1)]),
+		};
+
+		let blooms = filter.bloom_possibilities();
+		assert_eq!(blooms.len(), 1);
+
+		assert!(blooms[0].contains_bloomed(&Address::from(1).sha3()));
+		assert!(!blooms[0].contains_bloomed(&Address::from(2).sha3()));
+	}
+
+	#[test]
+	fn multiple_trace_filter_bloom_possibility() {
+		let filter = Filter {
+			range: (0..0),
+			from_address: AddressesFilter::from(vec![Address::from(1), Address::from(3)]),
+			to_address: AddressesFilter::from(vec![Address::from(2), Address::from(4)]),
+		};
+
+		let blooms = filter.bloom_possibilities();
+		assert_eq!(blooms.len(), 4);
+
+		assert!(blooms[0].contains_bloomed(&Address::from(1).sha3()));
+		assert!(blooms[0].contains_bloomed(&Address::from(2).sha3()));
+		assert!(!blooms[0].contains_bloomed(&Address::from(3).sha3()));
+		assert!(!blooms[0].contains_bloomed(&Address::from(4).sha3()));
+
+		assert!(blooms[1].contains_bloomed(&Address::from(1).sha3()));
+		assert!(blooms[1].contains_bloomed(&Address::from(4).sha3()));
+		assert!(!blooms[1].contains_bloomed(&Address::from(2).sha3()));
+		assert!(!blooms[1].contains_bloomed(&Address::from(3).sha3()));
+
+		assert!(blooms[2].contains_bloomed(&Address::from(2).sha3()));
+		assert!(blooms[2].contains_bloomed(&Address::from(3).sha3()));
+		assert!(!blooms[2].contains_bloomed(&Address::from(1).sha3()));
+		assert!(!blooms[2].contains_bloomed(&Address::from(4).sha3()));
+
+		assert!(blooms[3].contains_bloomed(&Address::from(3).sha3()));
+		assert!(blooms[3].contains_bloomed(&Address::from(4).sha3()));
+		assert!(!blooms[3].contains_bloomed(&Address::from(1).sha3()));
+		assert!(!blooms[3].contains_bloomed(&Address::from(2).sha3()));
+	}
+
+	#[test]
+	fn filter_matches() {
+		let f0 = Filter {
+			range: (0..0),
+			from_address: AddressesFilter::from(vec![Address::from(1)]),
+			to_address: AddressesFilter::from(vec![]),
+		};
+
+		let f1 = Filter {
+			range: (0..0),
+			from_address: AddressesFilter::from(vec![Address::from(3), Address::from(1)]),
+			to_address: AddressesFilter::from(vec![]),
+		};
+
+		let f2 = Filter {
+			range: (0..0),
+			from_address: AddressesFilter::from(vec![]),
+			to_address: AddressesFilter::from(vec![]),
+		};
+
+		let f3 = Filter {
+			range: (0..0),
+			from_address: AddressesFilter::from(vec![]),
+			to_address: AddressesFilter::from(vec![Address::from(2)]),
+		};
+
+		let f4 = Filter {
+			range: (0..0),
+			from_address: AddressesFilter::from(vec![]),
+			to_address: AddressesFilter::from(vec![Address::from(2), Address::from(3)]),
+		};
+
+		let f5 = Filter {
+			range: (0..0),
+			from_address: AddressesFilter::from(vec![Address::from(1)]),
+			to_address: AddressesFilter::from(vec![Address::from(2), Address::from(3)]),
+		};
+
+		let f6 = Filter {
+			range: (0..0),
+			from_address: AddressesFilter::from(vec![Address::from(1)]),
+			to_address: AddressesFilter::from(vec![Address::from(4)]),
+		};
+
+		let trace = FlatTrace {
+			action: Action::Call(Call {
+				from: Address::from(1),
+				to: Address::from(2),
+				value: U256::from(3),
+				gas: U256::from(4),
+				input: vec![0x5],
+			}),
+			result: Res::FailedCall,
+			trace_address: vec![0],
+			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/trace/flat.rs

@@ -0,0 +1,181 @@
+// 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 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

@@ -0,0 +1,36 @@
+// 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/>.
+
+//! Traces import request.
+use util::H256;
+use header::BlockNumber;
+use trace::BlockTraces;
+
+/// Traces import request.
+pub struct ImportRequest {
+	/// Traces to import.
+	pub traces: BlockTraces,
+	/// Hash of traces block.
+	pub block_hash: H256,
+	/// Number of traces block.
+	pub block_number: BlockNumber,
+	/// Blocks enacted by this import.
+	///
+	/// They should be ordered from oldest to newest.
+	pub enacted: Vec<H256>,
+	/// Number of blocks retracted by this import.
+	pub retracted: usize,
+}

ethcore/src/trace/localized.rs

@@ -0,0 +1,42 @@
+// 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::H256;
+use super::trace::{Action, Res};
+use header::BlockNumber;
+
+/// Localized trace.
+#[derive(Debug, PartialEq)]
+pub struct LocalizedTrace {
+	/// 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>,
+	/// Transaction number within the block.
+	pub transaction_number: usize,
+	/// Signed transaction hash.
+	pub transaction_hash: H256,
+	/// Block number.
+	pub block_number: BlockNumber,
+	/// Block hash.
+	pub block_hash: H256,
+}

ethcore/src/trace/mod.rs

@@ -0,0 +1,120 @@
+// 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/>.
+
+//! Tracing
+
+mod block;
+mod bloom;
+mod config;
+mod db;
+mod executive_tracer;
+mod filter;
+mod flat;
+mod import;
+mod localized;
+mod noop_tracer;
+pub mod trace;
+
+pub use self::block::BlockTraces;
+pub use self::config::{Config, Switch};
+pub use self::db::TraceDB;
+pub use self::trace::Trace;
+pub use self::noop_tracer::NoopTracer;
+pub use self::executive_tracer::ExecutiveTracer;
+pub use self::filter::{Filter, AddressesFilter};
+pub use self::import::ImportRequest;
+pub use self::localized::LocalizedTrace;
+use util::{Bytes, Address, U256, H256};
+use self::trace::{Call, Create};
+use action_params::ActionParams;
+use header::BlockNumber;
+
+/// This trait is used by executive to build traces.
+pub trait Tracer: Send {
+	/// Prepares call trace for given params. Noop tracer should return None.
+	fn prepare_trace_call(&self, params: &ActionParams) -> Option<Call>;
+
+	/// Prepares create trace for given params. Noop tracer should return None.
+	fn prepare_trace_create(&self, params: &ActionParams) -> Option<Create>;
+
+	/// Prepare trace output. Noop tracer should return None.
+	fn prepare_trace_output(&self) -> Option<Bytes>;
+
+	/// Stores trace call info.
+	fn trace_call(
+		&mut self,
+		call: Option<Call>,
+		gas_used: U256,
+		output: Option<Bytes>,
+		depth: usize,
+		subs: Vec<Trace>,
+		delegate_call: bool
+	);
+
+	/// Stores trace create info.
+	fn trace_create(
+		&mut self,
+		create: Option<Create>,
+		gas_used: U256,
+		code: Option<Bytes>,
+		address: Address,
+		depth: usize,
+		subs: Vec<Trace>
+	);
+
+	/// Stores failed call trace.
+	fn trace_failed_call(&mut self, call: Option<Call>, depth: usize, subs: Vec<Trace>, delegate_call: bool);
+
+	/// Stores failed create trace.
+	fn trace_failed_create(&mut self, create: Option<Create>, depth: usize, subs: Vec<Trace>);
+
+	/// Spawn subracer 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>;
+}
+
+/// `DbExtras` provides an interface to query extra data which is not stored in tracesdb,
+/// but necessary to work correctly.
+pub trait DatabaseExtras {
+	/// Returns hash of given block number.
+	fn block_hash(&self, block_number: BlockNumber) -> Option<H256>;
+
+	/// Returns hash of transaction at given position.
+	fn transaction_hash(&self, block_number: BlockNumber, tx_position: usize) -> Option<H256>;
+}
+
+/// Db provides an interface to query tracesdb.
+pub trait Database {
+	/// Returns true if tracing is enabled. Otherwise false.
+	fn tracing_enabled(&self) -> bool;
+
+	/// Imports new block traces.
+	fn import(&self, request: ImportRequest);
+
+	/// Returns localized trace at given position.
+	fn trace(&self, block_number: BlockNumber, tx_position: usize, trace_position: Vec<usize>) -> Option<LocalizedTrace>;
+
+	/// Returns localized traces created by a single transaction.
+	fn transaction_traces(&self, block_number: BlockNumber, tx_position: usize) -> Option<Vec<LocalizedTrace>>;
+
+	/// Returns localized traces created in given block.
+	fn block_traces(&self, block_number: BlockNumber) -> Option<Vec<LocalizedTrace>>;
+
+	/// Filter traces matching given filter.
+	fn filter(&self, filter: &Filter) -> Vec<LocalizedTrace>;
+}

ethcore/src/trace/noop_tracer.rs

@@ -0,0 +1,65 @@
+// 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/>.
+
+//! Nonoperative tracer.
+
+use util::{Bytes, Address, U256};
+use action_params::ActionParams;
+use trace::Tracer;
+use trace::trace::{Trace, Call, Create};
+
+/// Nonoperative tracer. Does not trace anything.
+pub struct NoopTracer;
+
+impl Tracer for NoopTracer {
+	fn prepare_trace_call(&self, _: &ActionParams) -> Option<Call> {
+		None
+	}
+
+	fn prepare_trace_create(&self, _: &ActionParams) -> Option<Create> {
+		None
+	}
+
+	fn prepare_trace_output(&self) -> Option<Bytes> {
+		None
+	}
+
+	fn trace_call(&mut self, call: Option<Call>, _: U256, output: Option<Bytes>, _: usize, _: Vec<Trace>, _: bool) {
+		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>) {
+		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) {
+		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>) {
+		assert!(create.is_none(), "self.prepare_trace_create().is_none(): so we can't be tracing: qed");
+	}
+
+	fn subtracer(&self) -> Self {
+		NoopTracer
+	}
+
+	fn traces(self) -> Vec<Trace> {
+		vec![]
+	}
+}

ethcore/src/trace/trace.rs

@@ -0,0 +1,428 @@
+// 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/>.
+
+//! Tracing datatypes.
+use util::{U256, Bytes, Address, FixedHash};
+use util::rlp::*;
+use util::sha3::Hashable;
+use action_params::ActionParams;
+use basic_types::LogBloom;
+
+/// `Call` result.
+#[derive(Debug, Clone, PartialEq, Default)]
+pub struct CallResult {
+	/// Gas used by call.
+	pub gas_used: U256,
+	/// Call Output.
+	pub output: Bytes,
+}
+
+impl Encodable for CallResult {
+	fn rlp_append(&self, s: &mut RlpStream) {
+		s.begin_list(2);
+		s.append(&self.gas_used);
+		s.append(&self.output);
+	}
+}
+
+impl Decodable for CallResult {
+	fn decode<D>(decoder: &D) -> Result<Self, DecoderError> where D: Decoder {
+		let d = decoder.as_rlp();
+		let res = CallResult {
+			gas_used: try!(d.val_at(0)),
+			output: try!(d.val_at(1)),
+		};
+
+		Ok(res)
+	}
+}
+
+/// `Create` result.
+#[derive(Debug, Clone, PartialEq)]
+pub struct CreateResult {
+	/// Gas used by create.
+	pub gas_used: U256,
+	/// Code of the newly created contract.
+	pub code: Bytes,
+	/// Address of the newly created contract.
+	pub address: Address,
+}
+
+impl Encodable for CreateResult {
+	fn rlp_append(&self, s: &mut RlpStream) {
+		s.begin_list(3);
+		s.append(&self.gas_used);
+		s.append(&self.code);
+		s.append(&self.address);
+	}
+}
+
+impl Decodable for CreateResult {
+	fn decode<D>(decoder: &D) -> Result<Self, DecoderError> where D: Decoder {
+		let d = decoder.as_rlp();
+		let res = CreateResult {
+			gas_used: try!(d.val_at(0)),
+			code: try!(d.val_at(1)),
+			address: try!(d.val_at(2)),
+		};
+
+		Ok(res)
+	}
+}
+
+/// Description of a _call_ action, either a `CALL` operation or a message transction.
+#[derive(Debug, Clone, PartialEq)]
+pub struct Call {
+	/// The sending account.
+	pub from: Address,
+	/// The destination account.
+	pub to: Address,
+	/// The value transferred to the destination account.
+	pub value: U256,
+	/// The gas available for executing the call.
+	pub gas: U256,
+	/// The input data provided to the call.
+	pub input: Bytes,
+}
+
+impl From<ActionParams> for Call {
+	fn from(p: ActionParams) -> Self {
+		Call {
+			from: p.sender,
+			to: p.address,
+			value: p.value.value(),
+			gas: p.gas,
+			input: p.data.unwrap_or_else(Vec::new),
+		}
+	}
+}
+
+impl Encodable for Call {
+	fn rlp_append(&self, s: &mut RlpStream) {
+		s.begin_list(5);
+		s.append(&self.from);
+		s.append(&self.to);
+		s.append(&self.value);
+		s.append(&self.gas);
+		s.append(&self.input);
+	}
+}
+
+impl Decodable for Call {
+	fn decode<D>(decoder: &D) -> Result<Self, DecoderError> where D: Decoder {
+		let d = decoder.as_rlp();
+		let res = Call {
+			from: try!(d.val_at(0)),
+			to: try!(d.val_at(1)),
+			value: try!(d.val_at(2)),
+			gas: try!(d.val_at(3)),
+			input: try!(d.val_at(4)),
+		};
+
+		Ok(res)
+	}
+}
+
+impl Call {
+	/// Returns call action bloom.
+	/// The bloom contains from and to addresses.
+	pub fn bloom(&self) -> LogBloom {
+		LogBloom::from_bloomed(&self.from.sha3())
+			.with_bloomed(&self.to.sha3())
+	}
+}
+
+/// Description of a _create_ action, either a `CREATE` operation or a create transction.
+#[derive(Debug, Clone, PartialEq)]
+pub struct Create {
+	/// The address of the creator.
+	pub from: Address,
+	/// The value with which the new account is endowed.
+	pub value: U256,
+	/// The gas available for the creation init code.
+	pub gas: U256,
+	/// The init code.
+	pub init: Bytes,
+}
+
+impl From<ActionParams> for Create {
+	fn from(p: ActionParams) -> Self {
+		Create {
+			from: p.sender,
+			value: p.value.value(),
+			gas: p.gas,
+			init: p.code.unwrap_or_else(Vec::new),
+		}
+	}
+}
+
+impl Encodable for Create {
+	fn rlp_append(&self, s: &mut RlpStream) {
+		s.begin_list(4);
+		s.append(&self.from);
+		s.append(&self.value);
+		s.append(&self.gas);
+		s.append(&self.init);
+	}
+}
+
+impl Decodable for Create {
+	fn decode<D>(decoder: &D) -> Result<Self, DecoderError> where D: Decoder {
+		let d = decoder.as_rlp();
+		let res = Create {
+			from: try!(d.val_at(0)),
+			value: try!(d.val_at(1)),
+			gas: try!(d.val_at(2)),
+			init: try!(d.val_at(3)),
+		};
+
+		Ok(res)
+	}
+}
+
+impl Create {
+	/// Returns bloom create action bloom.
+	/// The bloom contains only from address.
+	pub fn bloom(&self) -> LogBloom {
+		LogBloom::from_bloomed(&self.from.sha3())
+	}
+}
+
+/// Description of an action that we trace; will be either a call or a create.
+#[derive(Debug, Clone, PartialEq)]
+pub enum Action {
+	/// It's a call action.
+	Call(Call),
+	/// It's a create action.
+	Create(Create),
+}
+
+impl Encodable for Action {
+	fn rlp_append(&self, s: &mut RlpStream) {
+		s.begin_list(2);
+		match *self {
+			Action::Call(ref call) => {
+				s.append(&0u8);
+				s.append(call);
+			},
+			Action::Create(ref create) => {
+				s.append(&1u8);
+				s.append(create);
+			}
+		}
+	}
+}
+
+impl Decodable for Action {
+	fn decode<D>(decoder: &D) -> Result<Self, DecoderError> where D: Decoder {
+		let d = decoder.as_rlp();
+		let action_type: u8 = try!(d.val_at(0));
+		match action_type {
+			0 => d.val_at(1).map(Action::Call),
+			1 => d.val_at(1).map(Action::Create),
+			_ => Err(DecoderError::Custom("Invalid action type.")),
+		}
+	}
+}
+
+impl Action {
+	/// Returns action bloom.
+	pub fn bloom(&self) -> LogBloom {
+		match *self {
+			Action::Call(ref call) => call.bloom(),
+			Action::Create(ref create) => create.bloom(),
+		}
+	}
+}
+
+/// The result of the performed action.
+#[derive(Debug, Clone, PartialEq)]
+pub enum Res {
+	/// Successful call action result.
+	Call(CallResult),
+	/// Successful create action result.
+	Create(CreateResult),
+	/// Failed call.
+	FailedCall,
+	/// Failed create.
+	FailedCreate,
+}
+
+impl Encodable for Res {
+	fn rlp_append(&self, s: &mut RlpStream) {
+		match *self {
+			Res::Call(ref call) => {
+				s.begin_list(2);
+				s.append(&0u8);
+				s.append(call);
+			},
+			Res::Create(ref create) => {
+				s.begin_list(2);
+				s.append(&1u8);
+				s.append(create);
+			},
+			Res::FailedCall => {
+				s.begin_list(1);
+				s.append(&2u8);
+			},
+			Res::FailedCreate => {
+				s.begin_list(1);
+				s.append(&3u8);
+			}
+		}
+	}
+}
+
+impl Decodable for Res {
+	fn decode<D>(decoder: &D) -> Result<Self, DecoderError> where D: Decoder {
+		let d = decoder.as_rlp();
+		let action_type: u8 = try!(d.val_at(0));
+		match action_type {
+			0 => d.val_at(1).map(Res::Call),
+			1 => d.val_at(1).map(Res::Create),
+			2 => Ok(Res::FailedCall),
+			3 => Ok(Res::FailedCreate),
+			_ => Err(DecoderError::Custom("Invalid result type.")),
+		}
+	}
+}
+
+#[derive(Debug, Clone, PartialEq)]
+/// 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.
+	pub fn bloom(&self) -> LogBloom {
+		self.subs.iter().fold(self.action.bloom(), |b, s| b | s.bloom())
+	}
+}
+
+#[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/transaction.rs

@@ -20,6 +20,7 @@ use util::*;
 use error::*;
 use evm::Schedule;
 use header::BlockNumber;
+use ethjson;
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 /// Transaction action type.
@@ -79,33 +80,43 @@ impl Transaction {
 	}
 }
 
-impl FromJson for SignedTransaction {
-	#[cfg_attr(feature="dev", allow(single_char_pattern))]
-	fn from_json(json: &Json) -> SignedTransaction {
-		let t = Transaction {
-			nonce: xjson!(&json["nonce"]),
-			gas_price: xjson!(&json["gasPrice"]),
-			gas: xjson!(&json["gasLimit"]),
-			action: match Bytes::from_json(&json["to"]) {
-				ref x if x.is_empty() => Action::Create,
-				ref x => Action::Call(Address::from_slice(x)),
+impl From<ethjson::state::Transaction> for SignedTransaction {
+	fn from(t: ethjson::state::Transaction) -> Self {
+		let to: Option<_> = t.to.into();
+		Transaction {
+			nonce: t.nonce.into(),
+			gas_price: t.gas_price.into(),
+			gas: t.gas_limit.into(),
+			action: match to {
+				Some(to) => Action::Call(to.into()),
+				None => Action::Create
 			},
-			value: xjson!(&json["value"]),
-			data: xjson!(&json["data"]),
-		};
-		match json.find("secretKey") {
-			Some(&Json::String(ref secret_key)) => t.sign(&h256_from_hex(clean(secret_key))),
-			_ => SignedTransaction {
-				unsigned: t,
-				v: match json.find("v") { Some(ref j) => u16::from_json(j) as u8, None => 0 },
-				r: match json.find("r") { Some(j) => xjson!(j), None => x!(0) },
-				s: match json.find("s") { Some(j) => xjson!(j), None => x!(0) },
-				hash: Cell::new(None),
-				sender: match json.find("sender") {
-					Some(&Json::String(ref sender)) => Cell::new(Some(address_from_hex(clean(sender)))),
-					_ => Cell::new(None),
-				}
-			}
+			value: t.value.into(),
+			data: t.data.into(),
+		}.sign(&t.secret.into())
+	}
+}
+
+impl From<ethjson::transaction::Transaction> for SignedTransaction {
+	fn from(t: ethjson::transaction::Transaction) -> Self {
+		let to: Option<_> = t.to.into();
+		SignedTransaction {
+			unsigned: Transaction {
+				nonce: t.nonce.into(),
+				gas_price: t.gas_price.into(),
+				gas: t.gas_limit.into(),
+				action: match to {
+					Some(to) => Action::Call(to.into()),
+					None => Action::Create
+				},
+				value: t.value.into(),
+				data: t.data.into(),
+			},
+			r: t.r.into(),
+			s: t.s.into(),
+			v: t.v.into(),
+			sender: Cell::new(None),
+			hash: Cell::new(None)
 		}
 	}
 }
@@ -134,7 +145,7 @@ impl Transaction {
 
 	/// Useful for test incorrectly signed transactions.
 	#[cfg(test)]
-	pub fn fake_sign(self) -> SignedTransaction {
+	pub fn invalid_sign(self) -> SignedTransaction {
 		SignedTransaction {
 			unsigned: self,
 			r: U256::zero(),
@@ -145,6 +156,18 @@ impl Transaction {
 		}
 	}
 
+	/// Specify the sender; this won't survive the serialize/deserialize process, but can be cloned.
+	pub fn fake_sign(self, from: Address) -> SignedTransaction {
+		SignedTransaction {
+			unsigned: self,
+			r: U256::zero(),
+			s: U256::zero(),
+			v: 0,
+			hash: Cell::new(None),
+			sender: Cell::new(Some(from)),
+		}
+	}
+
 	/// Get the transaction cost in gas for the given params.
 	pub fn gas_required_for(is_create: bool, data: &[u8], schedule: &Schedule) -> u64 {
 		data.iter().fold(
@@ -342,3 +365,19 @@ fn signing() {
 	}.sign(&key.secret());
 	assert_eq!(Address::from(key.public().sha3()), t.sender().unwrap());
 }
+
+#[test]
+fn fake_signing() {
+	let t = Transaction {
+		action: Action::Create,
+		nonce: U256::from(42),
+		gas_price: U256::from(3000),
+		gas: U256::from(50_000),
+		value: U256::from(1),
+		data: b"Hello!".to_vec()
+	}.fake_sign(Address::from(0x69));
+	assert_eq!(Address::from(0x69), t.sender().unwrap());
+
+	let t = t.clone();
+	assert_eq!(Address::from(0x69), t.sender().unwrap());
+}

ethcore/src/verification/verification.rs

@@ -55,7 +55,7 @@ pub fn verify_block_basic(header: &Header, bytes: &[u8], engine: &Engine) -> Res
 
 /// Phase 2 verification. Perform costly checks such as transaction signatures and block nonce for ethash.
 /// Still operates on a individual block
-/// Returns a PreverifiedBlock structure populated with transactions
+/// Returns a `PreverifiedBlock` structure populated with transactions
 pub fn verify_block_unordered(header: Header, bytes: Bytes, engine: &Engine) -> Result<PreverifiedBlock, Error> {
 	try!(engine.verify_block_unordered(&header, Some(&bytes)));
 	for u in Rlp::new(&bytes).at(2).iter().map(|rlp| rlp.as_val::<Header>()) {
@@ -183,7 +183,7 @@ fn verify_header(header: &Header, engine: &Engine) -> Result<(), Error> {
 	if header.gas_used > header.gas_limit {
 		return Err(From::from(BlockError::TooMuchGasUsed(OutOfBounds { max: Some(header.gas_limit), min: None, found: header.gas_used })));
 	}
-	let min_gas_limit = decode(engine.spec().engine_params.get("minGasLimit").unwrap());
+	let min_gas_limit = engine.params().min_gas_limit;
 	if header.gas_limit < min_gas_limit {
 		return Err(From::from(BlockError::InvalidGasLimit(OutOfBounds { min: Some(min_gas_limit), max: None, found: header.gas_limit })));
 	}
@@ -329,16 +329,15 @@ mod tests {
 	}
 
 	#[test]
+	#[cfg_attr(feature="dev", allow(similar_names))]
 	fn test_verify_block() {
 		// Test against morden
 		let mut good = Header::new();
 		let spec = Spec::new_test();
-		let engine = spec.to_engine().unwrap();
+		let engine = &spec.engine;
 
-		let min_gas_limit = decode(engine.spec().engine_params.get("minGasLimit").unwrap());
-		let min_difficulty = decode(engine.spec().engine_params.get("minimumDifficulty").unwrap());
+		let min_gas_limit = engine.params().min_gas_limit;
 		good.gas_limit = min_gas_limit;
-		good.difficulty = min_difficulty;
 		good.timestamp = 40;
 		good.number = 10;
 

ethcore/src/views.rs

@@ -256,6 +256,9 @@ impl<'a> HeaderView<'a> {
 		}
 	}
 
+	/// Returns header hash.
+	pub fn hash(&self) -> H256 { self.sha3() }
+
 	/// Returns raw rlp.
 	pub fn rlp(&self) -> &Rlp<'a> { &self.rlp }
 

fmt.sh

@@ -0,0 +1,15 @@
+#!/bin/sh
+
+RUSTFMT="rustfmt --write-mode overwrite"
+
+$RUSTFMT ./ethash/src/lib.rs
+$RUSTFMT ./ethcore/src/lib.rs
+$RUSTFMT ./evmjit/src/lib.rs
+$RUSTFMT ./json/src/lib.rs
+$RUSTFMT ./miner/src/lib.rs
+$RUSTFMT ./parity/main.rs
+$RUSTFMT ./rpc/src/lib.rs
+$RUSTFMT ./webapp/src/lib.rs
+$RUSTFMT ./sync/src/lib.rs
+$RUSTFMT ./util/src/lib.rs
+

hook.sh

@@ -4,9 +4,9 @@ echo "#!/bin/sh\n" > $FILE
 # Exit on any error
 echo "set -e" >> $FILE
 # Run release build
-echo "cargo build --release --features dev" >> $FILE
+echo "cargo build --features dev" >> $FILE
 # Build tests
 echo "cargo test --no-run --features dev \\" >> $FILE
-echo "	-p ethash -p ethcore-util -p ethcore -p ethsync -p ethcore-rpc -p parity -p ethminer" >> $FILE
+echo "	-p ethash -p ethcore-util -p ethcore -p ethsync -p ethcore-rpc -p parity -p ethminer -p ethcore-webapp" >> $FILE
 echo "" >> $FILE
 chmod +x $FILE

install-deps.sh

@@ -664,9 +664,6 @@ function run_installer()
 
 		[ ! -d "www" ] && git clone https://github.com/cubedro/eth-net-intelligence-api netstats
 		cd netstats
-		git pull
-		git checkout 95d595258239a0fdf56b97dedcfb2be62f6170e6
-
 		sudo npm install
 		sudo npm install pm2 -g
 

install-parity.sh

@@ -1,6 +1,6 @@
 #!/usr/bin/env bash
 
-PARITY_DEB_URL=https://github.com/ethcore/parity/releases/download/beta-0.9/parity_linux_0.9.0-0_amd64.deb
+PARITY_DEB_URL=https://github.com/ethcore/parity/releases/download/v1.0.2/parity_linux_1.0.2-0_amd64.deb
 
 
 function run_installer()
@@ -435,13 +435,8 @@ function run_installer()
 		echo
 
 		info "Installing parity"
-		if [[ $isEth == true ]]
-		then
-			brew reinstall parity
-		else
-			brew install parity
-			brew linkapps parity
-		fi
+		brew reinstall parity
+		brew linkapps parity
 		echo
 	}
 	
@@ -497,9 +492,6 @@ function run_installer()
 		[ ! -d "www" ] && git clone https://github.com/cubedro/eth-net-intelligence-api netstats
 		oldpwd= $(pwd)
 		cd netstats
-		git pull
-		git checkout 95d595258239a0fdf56b97dedcfb2be62f6170e6
-
 		sudo npm install
 		sudo npm install pm2 -g
 

ipc/codegen/Cargo.toml

@@ -0,0 +1,26 @@
+[package]
+name = "ethcore-ipc-codegen"
+version = "1.1.0"
+authors = ["Nikolay Volf"]
+license = "GPL-3.0"
+description = "Macros to auto-generate implementations for ipc call"
+build = "build.rs"
+keywords = ["ipc", "codegen"]
+
+[features]
+default = ["with-syntex"]
+nightly = ["quasi_macros"]
+nightly-testing = ["clippy"]
+with-syntex = ["quasi/with-syntex", "quasi_codegen", "quasi_codegen/with-syntex", "syntex", "syntex_syntax"]
+
+[build-dependencies]
+quasi_codegen = { version = "*", optional = true }
+syntex = { version = "*", optional = true }
+
+[dependencies]
+aster = { version = "^0.15.0", default-features = false }
+clippy = { version = "^0.*", optional = true }
+quasi = { version = "*", default-features = false }
+quasi_macros = { version = "*", optional = true }
+syntex = { version = "*", optional = true }
+syntex_syntax = { version = "*", optional = true }

ipc/codegen/build.rs

@@ -0,0 +1,45 @@
+// 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/>.
+
+
+#[cfg(feature = "with-syntex")]
+mod inner {
+	extern crate syntex;
+	extern crate quasi_codegen;
+
+	use std::env;
+	use std::path::Path;
+
+	pub fn main() {
+		let out_dir = env::var_os("OUT_DIR").unwrap();
+		let mut registry = syntex::Registry::new();
+		quasi_codegen::register(&mut registry);
+
+		let src = Path::new("src/lib.rs.in");
+		let dst = Path::new(&out_dir).join("lib.rs");
+
+		registry.expand("", &src, &dst).unwrap();
+	}
+}
+
+#[cfg(not(feature = "with-syntex"))]
+mod inner {
+	pub fn main() {}
+}
+
+fn main() {
+	inner::main();
+}

ipc/codegen/src/codegen.rs

@@ -0,0 +1,799 @@
+// 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 aster;
+
+use syntax::ast::{
+	MetaItem,
+	Item,
+	ImplItemKind,
+	ImplItem,
+	MethodSig,
+	Arg,
+	PatKind,
+	FunctionRetTy,
+	Ty,
+	TraitRef,
+	Ident,
+	Generics,
+};
+
+use syntax::ast;
+use syntax::codemap::Span;
+use syntax::ext::base::{Annotatable, ExtCtxt};
+use syntax::ext::build::AstBuilder;
+use syntax::ptr::P;
+
+pub struct Error;
+
+const RESERVED_MESSAGE_IDS: u16 = 16;
+
+pub fn expand_ipc_implementation(
+	cx: &mut ExtCtxt,
+	span: Span,
+	meta_item: &MetaItem,
+	annotatable: &Annotatable,
+	push: &mut FnMut(Annotatable)
+) {
+	let item = match *annotatable {
+		Annotatable::Item(ref item) => item,
+		_ => {
+			cx.span_err(meta_item.span, "`#[derive(Ipc)]` may only be applied to struct implementations");
+			return;
+		},
+	};
+
+	let builder = aster::AstBuilder::new().span(span);
+
+	let interface_map = match implement_interface(cx, &builder, &item, push) {
+		Ok(interface_map) => interface_map,
+		Err(Error) => { return; },
+	};
+
+	push_client(cx, &builder, &interface_map, push);
+	push_handshake_struct(cx, push);
+
+	push(Annotatable::Item(interface_map.item));
+}
+
+fn push_handshake_struct(cx: &ExtCtxt, push: &mut FnMut(Annotatable)) {
+	let handshake_item = quote_item!(cx,
+		#[derive(Binary)]
+		pub struct BinHandshake {
+			api_version: String,
+			protocol_version: String,
+			reserved: Vec<u8>,
+		}
+	).unwrap();
+
+	push(Annotatable::Item(handshake_item));
+}
+
+fn field_name(builder: &aster::AstBuilder, arg: &Arg) -> ast::Ident {
+	match arg.pat.node {
+		PatKind::Ident(_, ref ident, _) => builder.id(ident.node),
+		_ => { panic!("unexpected param in interface: {:?}", arg.pat.node) }
+	}
+}
+
+fn push_invoke_signature_aster(
+	builder: &aster::AstBuilder,
+	implement: &ImplItem,
+	signature: &MethodSig,
+	push: &mut FnMut(Annotatable),
+) -> Dispatch {
+	let inputs = &signature.decl.inputs;
+	let (input_type_name, input_arg_names, input_arg_tys) = if inputs.len() > 0 {
+		let first_field_name = field_name(builder, &inputs[0]).name.as_str();
+		if first_field_name == "self" && inputs.len() == 1 { (None, vec![], vec![]) }
+		else {
+			let skip = if first_field_name == "self" { 2 } else { 1 };
+			let name_str = format!("{}_input", implement.ident.name.as_str());
+
+			let mut arg_names = Vec::new();
+			let mut arg_tys = Vec::new();
+
+			let arg_name = format!("{}", field_name(builder, &inputs[skip-1]).name);
+			let arg_ty = &inputs[skip-1].ty;
+
+			let mut tree = builder.item()
+				.attr().word("derive(Binary)")
+				.attr().word("allow(non_camel_case_types)")
+				.struct_(name_str.as_str())
+				.field(arg_name.as_str()).ty()
+				.build(strip_ptr(arg_ty));
+
+			arg_names.push(arg_name);
+			arg_tys.push(arg_ty.clone());
+			for arg in inputs.iter().skip(skip) {
+				let arg_name = format!("{}", field_name(builder, &arg));
+				let arg_ty = &arg.ty;
+
+				tree = tree.field(arg_name.as_str()).ty().build(strip_ptr(arg_ty));
+				arg_names.push(arg_name);
+				arg_tys.push(arg_ty.clone());
+			}
+
+			push(Annotatable::Item(tree.build()));
+			(Some(name_str.to_owned()), arg_names, arg_tys)
+		}
+	}
+	else {
+		(None, vec![], vec![])
+	};
+
+	let return_type_ty = match signature.decl.output {
+		FunctionRetTy::Ty(ref ty) => {
+			let name_str = format!("{}_output", implement.ident.name.as_str());
+			let tree = builder.item()
+				.attr().word("derive(Binary)")
+				.attr().word("allow(non_camel_case_types)")
+				.struct_(name_str.as_str())
+				.field(format!("payload")).ty().build(ty.clone());
+			push(Annotatable::Item(tree.build()));
+			Some(ty.clone())
+		}
+		_ => None
+	};
+
+	Dispatch {
+		function_name: format!("{}", implement.ident.name.as_str()),
+		input_type_name: input_type_name,
+		input_arg_names: input_arg_names,
+		input_arg_tys: input_arg_tys,
+		return_type_ty: return_type_ty,
+	}
+}
+
+struct Dispatch {
+	function_name: String,
+	input_type_name: Option<String>,
+	input_arg_names: Vec<String>,
+	input_arg_tys: Vec<P<Ty>>,
+	return_type_ty: Option<P<Ty>>,
+}
+
+//	This is the expanded version of this:
+//
+//	let invoke_serialize_stmt = quote_stmt!(cx, {
+//		::bincode::serde::serialize(& $output_type_id { payload: self. $function_name ($hand_param_a, $hand_param_b) }, ::bincode::SizeLimit::Infinite).unwrap()
+//  });
+//
+// But the above does not allow comma-separated expressions for arbitrary number
+// of parameters ...$hand_param_a, $hand_param_b, ... $hand_param_n
+fn implement_dispatch_arm_invoke_stmt(
+	cx: &ExtCtxt,
+	builder: &aster::AstBuilder,
+	dispatch: &Dispatch,
+) -> ast::Stmt
+{
+	let function_name = builder.id(dispatch.function_name.as_str());
+
+	let input_args_exprs = dispatch.input_arg_names.iter().enumerate().map(|(arg_index, arg_name)| {
+		let arg_ident = builder.id(arg_name);
+		let expr = quote_expr!(cx, input. $arg_ident);
+		if has_ptr(&dispatch.input_arg_tys[arg_index]) { quote_expr!(cx, & $expr) }
+		else { expr }
+	}).collect::<Vec<P<ast::Expr>>>();
+
+	let ext_cx = &*cx;
+	::quasi::parse_stmt_panic(&mut ::syntax::parse::new_parser_from_tts(
+		ext_cx.parse_sess(),
+		ext_cx.cfg(),
+		{
+			let _sp = ext_cx.call_site();
+			let mut tt = ::std::vec::Vec::new();
+			tt.push(::syntax::ast::TokenTree::Token(_sp, ::syntax::parse::token::OpenDelim(::syntax::parse::token::Brace)));
+			tt.push(::syntax::ast::TokenTree::Token(_sp, ::syntax::parse::token::ModSep));
+			tt.push(::syntax::ast::TokenTree::Token(_sp, ::syntax::parse::token::Ident(ext_cx.ident_of("ipc"), ::syntax::parse::token::ModName)));
+			tt.push(::syntax::ast::TokenTree::Token(_sp, ::syntax::parse::token::ModSep));
+			tt.push(::syntax::ast::TokenTree::Token(_sp, ::syntax::parse::token::Ident(ext_cx.ident_of("binary"), ::syntax::parse::token::ModName)));
+			tt.push(::syntax::ast::TokenTree::Token(_sp, ::syntax::parse::token::ModSep));
+			tt.push(::syntax::ast::TokenTree::Token(_sp, ::syntax::parse::token::Ident(ext_cx.ident_of("serialize"), ::syntax::parse::token::Plain)));
+			tt.push(::syntax::ast::TokenTree::Token(_sp, ::syntax::parse::token::OpenDelim(::syntax::parse::token::Paren)));
+			tt.push(::syntax::ast::TokenTree::Token(_sp, ::syntax::parse::token::BinOp(::syntax::parse::token::And)));
+			tt.push(::syntax::ast::TokenTree::Token(_sp, ::syntax::parse::token::Ident(ext_cx.ident_of("self"), ::syntax::parse::token::Plain)));
+			tt.push(::syntax::ast::TokenTree::Token(_sp, ::syntax::parse::token::Dot));
+			tt.extend(::quasi::ToTokens::to_tokens(&function_name, ext_cx).into_iter());
+			tt.push(::syntax::ast::TokenTree::Token(_sp, ::syntax::parse::token::OpenDelim(::syntax::parse::token::Paren)));
+
+			for arg_expr in input_args_exprs {
+				tt.extend(::quasi::ToTokens::to_tokens(&arg_expr, ext_cx).into_iter());
+				tt.push(::syntax::ast::TokenTree::Token(_sp, ::syntax::parse::token::Comma));
+			}
+
+			tt.push(::syntax::ast::TokenTree::Token(_sp, ::syntax::parse::token::CloseDelim(::syntax::parse::token::Paren)));
+			tt.push(::syntax::ast::TokenTree::Token(_sp, ::syntax::parse::token::CloseDelim(::syntax::parse::token::Paren)));
+			tt.push(::syntax::ast::TokenTree::Token(_sp, ::syntax::parse::token::Dot));
+			tt.push(::syntax::ast::TokenTree::Token(_sp, ::syntax::parse::token::Ident(ext_cx.ident_of("unwrap"), ::syntax::parse::token::Plain)));
+			tt.push(::syntax::ast::TokenTree::Token(_sp, ::syntax::parse::token::OpenDelim(::syntax::parse::token::Paren)));
+			tt.push(::syntax::ast::TokenTree::Token(_sp, ::syntax::parse::token::CloseDelim(::syntax::parse::token::Paren)));
+			tt.push(::syntax::ast::TokenTree::Token(_sp, ::syntax::parse::token::CloseDelim(::syntax::parse::token::Brace)));
+			tt
+		})).unwrap()
+}
+
+fn implement_dispatch_arm_invoke(
+	cx: &ExtCtxt,
+	builder: &aster::AstBuilder,
+	dispatch: &Dispatch,
+	buffer: bool,
+) -> P<ast::Expr>
+{
+	let deserialize_expr = if buffer {
+		quote_expr!(cx, ::ipc::binary::deserialize(buf).expect("ipc deserialization error, aborting"))
+	} else {
+		quote_expr!(cx, ::ipc::binary::deserialize_from(r).expect("ipc deserialization error, aborting"))
+	};
+
+	let invoke_serialize_stmt = implement_dispatch_arm_invoke_stmt(cx, builder, dispatch);
+	dispatch.input_type_name.as_ref().map(|val| {
+			let input_type_id = builder.id(val.clone().as_str());
+			quote_expr!(cx, {
+				let input: $input_type_id = $deserialize_expr;
+				$invoke_serialize_stmt
+			})
+		}).unwrap_or(quote_expr!(cx, { $invoke_serialize_stmt }))
+}
+
+/// generates dispatch match for method id
+fn implement_dispatch_arm(
+	cx: &ExtCtxt,
+	builder: &aster::AstBuilder,
+	index: u32,
+	dispatch: &Dispatch,
+	buffer: bool,
+) -> ast::Arm
+{
+	let index_ident = builder.id(format!("{}", index + (RESERVED_MESSAGE_IDS as u32)).as_str());
+	let invoke_expr = implement_dispatch_arm_invoke(cx, builder, dispatch, buffer);
+	quote_arm!(cx, $index_ident => { $invoke_expr } )
+}
+
+fn implement_dispatch_arms(
+	cx: &ExtCtxt,
+	builder: &aster::AstBuilder,
+	dispatches: &[Dispatch],
+	buffer: bool,
+) -> Vec<ast::Arm>
+{
+	let mut index = -1;
+	dispatches.iter()
+		.map(|dispatch| { index = index + 1; implement_dispatch_arm(cx, builder, index as u32, dispatch, buffer) }).collect()
+}
+
+pub fn strip_ptr(ty: &P<ast::Ty>) -> P<ast::Ty> {
+	if let ast::TyKind::Rptr(_, ref ptr_mut) = ty.node {
+		ptr_mut.ty.clone()
+	}
+	else { ty.clone() }
+}
+
+pub fn has_ptr(ty: &P<ast::Ty>) -> bool {
+	if let ast::TyKind::Rptr(_, ref _ptr_mut) = ty.node {
+		true
+	}
+	else { false }
+}
+
+/// returns an expression with the body for single operation that is being sent to server
+/// operation itself serializes input, writes to socket and waits for socket to respond
+/// (the latter only if original method signature returns anyting)
+///
+/// assuming expanded class contains method
+///   fn commit(&self, f: u32) -> u32
+///
+/// the expanded implementation will generate method for the client like that
+///    #[derive(Serialize)]
+///    struct Request<'a> {
+///	     f: &'a u32,
+///    }
+///    let payload = Request{f: &f,};
+///    let mut socket_ref = self.socket.borrow_mut();
+///    let mut socket = socket_ref.deref_mut();
+///    let serialized_payload = ::bincode::serde::serialize(&payload, ::bincode::SizeLimit::Infinite).unwrap();
+///    ::ipc::invoke(0, &Some(serialized_payload), &mut socket);
+///    while !socket.ready().load(::std::sync::atomic::Ordering::Relaxed) { }
+///    ::bincode::serde::deserialize_from::<_, u32>(&mut socket, ::bincode::SizeLimit::Infinite).unwrap()
+fn implement_client_method_body(
+	cx: &ExtCtxt,
+	builder: &aster::AstBuilder,
+	index: u16,
+	interface_map: &InterfaceMap,
+) -> P<ast::Expr>
+{
+	let dispatch = &interface_map.dispatches[index as usize];
+	let index_ident = builder.id(format!("{}", index + RESERVED_MESSAGE_IDS).as_str());
+
+	let request = if dispatch.input_arg_names.len() > 0 {
+
+		let arg_name = dispatch.input_arg_names[0].as_str();
+		let static_ty = strip_ptr(&dispatch.input_arg_tys[0]);
+		let arg_ty = builder
+			.ty().ref_()
+			.lifetime("'a")
+			.ty()
+			.build(static_ty.clone());
+
+		let mut tree = builder.item()
+			.attr().word("derive(Binary)")
+			.struct_("Request")
+			.generics()
+			.lifetime_name("'a")
+			.build()
+			.field(arg_name).ty()
+			.build(arg_ty);
+
+		for arg_idx in 1..dispatch.input_arg_names.len() {
+			let arg_name = dispatch.input_arg_names[arg_idx].as_str();
+			let static_ty = strip_ptr(&dispatch.input_arg_tys[arg_idx]);
+
+			let arg_ty = builder
+				.ty().ref_()
+				.lifetime("'a")
+				.ty()
+				.build(static_ty);
+			tree = tree.field(arg_name).ty().build(arg_ty);
+
+		}
+		let mut request_serialization_statements = Vec::new();
+
+		let struct_tree = tree.build();
+		let struct_stmt = quote_stmt!(cx, $struct_tree);
+		request_serialization_statements.push(struct_stmt);
+
+		// actually this is just expanded version of this:
+		//   request_serialization_statements.push(quote_stmt!(cx, let payload = Request { p1: &p1, p2: &p2, ... pn: &pn, }));
+		// again, cannot dynamically create expression with arbitrary number of comma-separated members
+		request_serialization_statements.push({
+			let ext_cx = &*cx;
+			::quasi::parse_stmt_panic(&mut ::syntax::parse::new_parser_from_tts(
+				ext_cx.parse_sess(),
+				ext_cx.cfg(),
+				{
+					let _sp = ext_cx.call_site();
+					let mut tt = ::std::vec::Vec::new();
+					tt.push(::syntax::ast::TokenTree::Token(_sp, ::syntax::parse::token::Ident(ext_cx.ident_of("let"), ::syntax::parse::token::Plain)));
+					tt.push(::syntax::ast::TokenTree::Token(_sp, ::syntax::parse::token::Ident(ext_cx.ident_of("payload"), ::syntax::parse::token::Plain)));
+					tt.push(::syntax::ast::TokenTree::Token(_sp, ::syntax::parse::token::Eq));
+					tt.push(::syntax::ast::TokenTree::Token(_sp, ::syntax::parse::token::Ident(ext_cx.ident_of("Request"), ::syntax::parse::token::Plain)));
+					tt.push(::syntax::ast::TokenTree::Token(_sp, ::syntax::parse::token::OpenDelim(::syntax::parse::token::Brace)));
+
+					for arg in dispatch.input_arg_names.iter() {
+						tt.push(::syntax::ast::TokenTree::Token(_sp, ::syntax::parse::token::Ident(ext_cx.ident_of(arg.as_str()), ::syntax::parse::token::Plain)));
+						tt.push(::syntax::ast::TokenTree::Token(_sp, ::syntax::parse::token::Colon));
+						tt.push(::syntax::ast::TokenTree::Token(_sp, ::syntax::parse::token::BinOp(::syntax::parse::token::And)));
+
+						tt.push(::syntax::ast::TokenTree::Token(_sp, ::syntax::parse::token::Ident(ext_cx.ident_of(arg.as_str()), ::syntax::parse::token::Plain)));
+						tt.push(::syntax::ast::TokenTree::Token(_sp, ::syntax::parse::token::Comma));
+					}
+
+					tt.push(::syntax::ast::TokenTree::Token(_sp, ::syntax::parse::token::CloseDelim(::syntax::parse::token::Brace)));
+					tt
+				}))
+			});
+
+		request_serialization_statements.push(
+			quote_stmt!(cx, let mut socket_ref = self.socket.borrow_mut()));
+
+		request_serialization_statements.push(
+			quote_stmt!(cx, let mut socket = socket_ref.deref_mut()));
+
+		request_serialization_statements.push(
+			quote_stmt!(cx, let serialized_payload = ::ipc::binary::serialize(&payload).unwrap()));
+
+		request_serialization_statements.push(
+			quote_stmt!(cx, ::ipc::invoke($index_ident, &Some(serialized_payload), &mut socket)));
+
+
+		request_serialization_statements
+	}
+	else {
+		let mut request_serialization_statements = Vec::new();
+		request_serialization_statements.push(
+			quote_stmt!(cx, let mut socket_ref = self.socket.borrow_mut()));
+		request_serialization_statements.push(
+			quote_stmt!(cx, let mut socket = socket_ref.deref_mut()));
+		request_serialization_statements.push(
+			quote_stmt!(cx, ::ipc::invoke($index_ident, Vec::new(), &mut socket)));
+		request_serialization_statements
+	};
+
+	if let Some(ref return_ty) = dispatch.return_type_ty {
+		let return_expr = quote_expr!(cx,
+			::ipc::binary::deserialize_from::<$return_ty, _>(&mut socket).unwrap()
+		);
+		quote_expr!(cx, {
+			$request
+			$return_expr
+		})
+	}
+	else {
+		quote_expr!(cx, {
+			$request
+		})
+	}
+}
+
+/// Generates signature and body (see `implement_client_method_body`)
+/// for the client (signature is identical to the original method)
+fn implement_client_method(
+	cx: &ExtCtxt,
+	builder: &aster::AstBuilder,
+	index: u16,
+	interface_map: &InterfaceMap,
+)
+	-> ast::ImplItem
+{
+	let dispatch = &interface_map.dispatches[index as usize];
+	let method_name = builder.id(dispatch.function_name.as_str());
+	let body = implement_client_method_body(cx, builder, index, interface_map);
+
+	let ext_cx = &*cx;
+	// expanded version of this
+	//   pub fn $method_name(&self, p1: p1_ty, p2: p2_ty ... pn: pn_ty, ) [-> return_ty] { $body }
+	// looks like it's tricky to build function declaration with aster if body already generated
+	let signature = ::syntax::parse::parser::Parser::parse_impl_item(
+		&mut ::syntax::parse::new_parser_from_tts(
+			ext_cx.parse_sess(),
+			ext_cx.cfg(),
+			{
+				let _sp = ext_cx.call_site();
+				let mut tt = ::std::vec::Vec::new();
+				tt.push(::syntax::ast::TokenTree::Token(_sp, ::syntax::parse::token::Ident(ext_cx.ident_of("fn"), ::syntax::parse::token::Plain)));
+				tt.extend(::quasi::ToTokens::to_tokens(&method_name, ext_cx).into_iter());
+				tt.push(::syntax::ast::TokenTree::Token(_sp, ::syntax::parse::token::OpenDelim(::syntax::parse::token::Paren)));
+				tt.push(::syntax::ast::TokenTree::Token(_sp, ::syntax::parse::token::BinOp(::syntax::parse::token::And)));
+				tt.push(::syntax::ast::TokenTree::Token(_sp, ::syntax::parse::token::Ident(ext_cx.ident_of("self"), ::syntax::parse::token::Plain)));
+				tt.push(::syntax::ast::TokenTree::Token(_sp, ::syntax::parse::token::Comma));
+
+				for arg_idx in 0..dispatch.input_arg_names.len() {
+					let arg_name = dispatch.input_arg_names[arg_idx].as_str();
+					let arg_ty = dispatch.input_arg_tys[arg_idx].clone();
+
+					tt.push(::syntax::ast::TokenTree::Token(_sp, ::syntax::parse::token::Ident(ext_cx.ident_of(arg_name), ::syntax::parse::token::Plain)));
+					tt.push(::syntax::ast::TokenTree::Token(_sp, ::syntax::parse::token::Colon));
+					tt.extend(::quasi::ToTokens::to_tokens(&arg_ty, ext_cx).into_iter());
+					tt.push(::syntax::ast::TokenTree::Token(_sp, ::syntax::parse::token::Comma));
+				}
+				tt.push(::syntax::ast::TokenTree::Token(_sp, ::syntax::parse::token::CloseDelim(::syntax::parse::token::Paren)));
+
+				if let Some(ref return_ty) = dispatch.return_type_ty {
+					tt.push(::syntax::ast::TokenTree::Token(_sp, ::syntax::parse::token::RArrow));
+					tt.extend(::quasi::ToTokens::to_tokens(return_ty, ext_cx).into_iter());
+				}
+
+				tt.push(::syntax::ast::TokenTree::Token(_sp, ::syntax::parse::token::OpenDelim(::syntax::parse::token::Brace)));
+				tt.extend(::quasi::ToTokens::to_tokens(&body, ext_cx).into_iter());
+				tt.push(::syntax::ast::TokenTree::Token(_sp, ::syntax::parse::token::CloseDelim(::syntax::parse::token::Brace)));
+
+				tt
+			}));
+
+	signature.unwrap()
+}
+
+fn client_generics(builder: &aster::AstBuilder, interface_map: &InterfaceMap) -> Generics {
+	let ty_param = aster::ty_param::TyParamBuilder::new(
+		builder.id("S")).trait_bound(
+			builder.path().global().ids(&["ipc", "IpcSocket"]).build()
+		).build().build();
+
+	builder.from_generics(interface_map.generics.clone())
+		.with_ty_param(ty_param)
+		.build()
+}
+
+fn client_qualified_ident(builder: &aster::AstBuilder, interface_map: &InterfaceMap) -> P<Ty> {
+	let generics = client_generics(builder, interface_map);
+	aster::ty::TyBuilder::new().path().segment(interface_map.ident_map.client_ident(builder))
+		.with_generics(generics).build()
+		.build()
+}
+
+fn client_phantom_ident(builder: &aster::AstBuilder, interface_map: &InterfaceMap) -> P<Ty> {
+	let generics = client_generics(builder, interface_map);
+	aster::ty::TyBuilder::new().phantom_data()
+		.tuple().with_tys(generics.ty_params.iter().map(|x| aster::ty::TyBuilder::new().id(x.ident)))
+		.build()
+}
+
+/// generates client type for specified server type
+/// for say `Service` it generates `ServiceClient`
+fn push_client_struct(cx: &ExtCtxt, builder: &aster::AstBuilder, interface_map: &InterfaceMap, push: &mut FnMut(Annotatable)) {
+	let generics = client_generics(builder, interface_map);
+	let client_short_ident = interface_map.ident_map.client_ident(builder);
+	let phantom = client_phantom_ident(builder, interface_map);
+
+	let client_struct_item = quote_item!(cx,
+		pub struct $client_short_ident $generics {
+			socket: ::std::cell::RefCell<S>,
+			phantom: $phantom,
+		});
+
+	push(Annotatable::Item(client_struct_item.expect(&format!("could not generate client struct for {:?}", client_short_ident.name))));
+}
+
+/// pushes generated code for the client class (type declaration and method invocation implementations)
+fn push_client(
+	cx: &ExtCtxt,
+	builder: &aster::AstBuilder,
+	interface_map: &InterfaceMap,
+	push: &mut FnMut(Annotatable),
+) {
+	push_client_struct(cx, builder, interface_map, push);
+	push_client_implementation(cx, builder, interface_map, push);
+	push_with_socket_client_implementation(cx, builder, interface_map, push);
+}
+
+
+fn push_with_socket_client_implementation(
+	cx: &ExtCtxt,
+	builder: &aster::AstBuilder,
+	interface_map: &InterfaceMap,
+	push: &mut FnMut(Annotatable))
+{
+	let generics = client_generics(builder, interface_map);
+	let client_ident = client_qualified_ident(builder, interface_map);
+	let where_clause = &generics.where_clause;
+	let client_short_ident = interface_map.ident_map.client_ident(builder);
+
+	let implement = quote_item!(cx,
+		impl $generics ::ipc::WithSocket<S> for $client_ident $where_clause {
+			fn init(socket: S) -> $client_ident {
+				$client_short_ident {
+					socket: ::std::cell::RefCell::new(socket),
+					phantom: ::std::marker::PhantomData,
+				}
+			}
+		}).unwrap();
+	push(Annotatable::Item(implement));
+}
+
+/// pushes full client side code for the original class exposed via ipc
+fn push_client_implementation(
+	cx: &ExtCtxt,
+	builder: &aster::AstBuilder,
+	interface_map: &InterfaceMap,
+	push: &mut FnMut(Annotatable),
+) {
+	let item_ident = interface_map.ident_map.qualified_ident(builder);
+
+	let mut index = -1i32;
+	let items = interface_map.dispatches.iter()
+		.map(|_| { index = index + 1; P(implement_client_method(cx, builder, index as u16, interface_map)) })
+		.collect::<Vec<P<ast::ImplItem>>>();
+
+	let generics = client_generics(builder, interface_map);
+	let client_ident = client_qualified_ident(builder, interface_map);
+	let where_clause = &generics.where_clause;
+
+	let handshake_item = quote_impl_item!(cx,
+		pub fn handshake(&self) -> Result<(), ::ipc::Error> {
+			let payload = BinHandshake {
+				protocol_version: $item_ident::protocol_version().to_string(),
+				api_version: $item_ident::api_version().to_string(),
+				reserved: vec![0u8; 64],
+			};
+
+			let mut socket_ref = self.socket.borrow_mut();
+			let mut socket = socket_ref.deref_mut();
+			::ipc::invoke(
+				0,
+				&Some(::ipc::binary::serialize(&payload).unwrap()),
+				&mut socket);
+
+			let mut result = vec![0u8; 1];
+			if try!(socket.read(&mut result).map_err(|_| ::ipc::Error::HandshakeFailed)) == 1 {
+				match result[0] {
+					1 => Ok(()),
+					_ => Err(::ipc::Error::RemoteServiceUnsupported),
+				}
+			}
+			else { Err(::ipc::Error::HandshakeFailed) }
+		}).unwrap();
+
+	let socket_item = quote_impl_item!(cx,
+		#[cfg(test)]
+		pub fn socket(&self) -> &::std::cell::RefCell<S> {
+			&self.socket
+		}).unwrap();
+
+	let generic_items = vec![P(handshake_item), P(socket_item)];
+
+	if interface_map.impl_trait.is_some() {
+		let trait_ty = builder.id(
+			::syntax::print::pprust::path_to_string(
+				&interface_map.impl_trait.as_ref().unwrap().path));
+
+		let implement_trait =
+			quote_item!(cx,
+				impl $generics $trait_ty for $client_ident $where_clause {
+					$items
+				}
+			).unwrap();
+		push(Annotatable::Item(implement_trait));
+
+		let implement =
+			quote_item!(cx,
+				impl $generics $client_ident $where_clause {
+					$generic_items
+				}
+			).unwrap();
+		push(Annotatable::Item(implement));
+	}
+	else {
+		let pub_items = items.iter().map(|item| {
+			let pub_item = item.clone();
+			pub_item.map(|mut val| { val.vis = ast::Visibility::Public; val })
+		}).collect::<Vec<P<ast::ImplItem>>>();
+
+		let implement = quote_item!(cx,
+			impl $generics $client_ident $where_clause {
+				$pub_items
+				$generic_items
+			}).unwrap();
+		push(Annotatable::Item(implement));
+	}
+
+}
+
+/// implements dispatching of system handshake invocation (method_num 0)
+fn implement_handshake_arm(
+	cx: &ExtCtxt,
+) -> (ast::Arm, ast::Arm)
+{
+	let handshake_deserialize = quote_stmt!(&cx,
+		let handshake_payload = ::ipc::binary::deserialize_from::<BinHandshake, _>(r).unwrap();
+	);
+
+	let handshake_deserialize_buf = quote_stmt!(&cx,
+		let handshake_payload = ::ipc::binary::deserialize::<BinHandshake>(buf).unwrap();
+	);
+
+	let handshake_serialize = quote_expr!(&cx,
+		::ipc::binary::serialize::<bool>(&Self::handshake(&::ipc::Handshake {
+			api_version: ::semver::Version::parse(&handshake_payload.api_version).unwrap(),
+			protocol_version: ::semver::Version::parse(&handshake_payload.protocol_version).unwrap(),
+		})).unwrap()
+	);
+
+	(
+		quote_arm!(&cx, 0 => {
+			$handshake_deserialize
+			$handshake_serialize
+		}),
+		quote_arm!(&cx, 0 => {
+			$handshake_deserialize_buf
+			$handshake_serialize
+		}),
+	)
+}
+
+
+struct InterfaceMap {
+	pub original_item: Item,
+	pub item: P<ast::Item>,
+	pub dispatches: Vec<Dispatch>,
+	pub generics: Generics,
+	pub impl_trait: Option<TraitRef>,
+	pub ident_map: IdentMap,
+}
+
+struct IdentMap {
+	original_path: ast::Path,
+}
+
+impl IdentMap {
+	fn ident(&self, builder: &aster::AstBuilder) -> Ident {
+		builder.id(format!("{}", ::syntax::print::pprust::path_to_string(&self.original_path)))
+	}
+
+	fn client_ident(&self, builder: &aster::AstBuilder) -> Ident {
+		builder.id(format!("{}Client", self.original_path.segments[0].identifier))
+	}
+
+	fn qualified_ident(&self, builder: &aster::AstBuilder) -> Ident {
+		builder.id(format!("{}", ::syntax::print::pprust::path_to_string(&self.original_path).replace("<", "::<")))
+	}
+}
+
+fn ty_ident_map(original_ty: &P<Ty>) -> IdentMap {
+	let original_path = match original_ty.node {
+		::syntax::ast::TyKind::Path(_, ref path) => path.clone(),
+		_ => { panic!("incompatible implementation"); }
+	};
+	let ident_map = IdentMap { original_path: original_path };
+	ident_map
+}
+
+/// implements `IpcInterface<C>` for the given class `C`
+fn implement_interface(
+	cx: &ExtCtxt,
+	builder: &aster::AstBuilder,
+	item: &Item,
+	push: &mut FnMut(Annotatable),
+) -> Result<InterfaceMap, Error> {
+	let (generics, impl_trait, original_ty, impl_items) = match item.node {
+		ast::ItemKind::Impl(_, _, ref generics, ref impl_trait, ref ty, ref impl_items) => (generics, impl_trait, ty, impl_items),
+		_ => {
+			cx.span_err(
+				item.span,
+				"`#[derive(Ipc)]` may only be applied to item implementations");
+			return Err(Error);
+		},
+	};
+	let impl_generics = builder.from_generics(generics.clone()).build();
+	let where_clause = &impl_generics.where_clause;
+
+	let mut method_signatures = Vec::new();
+	for impl_item in impl_items {
+		if let ImplItemKind::Method(ref signature, _) = impl_item.node {
+			method_signatures.push((impl_item, signature))
+		}
+	}
+
+	let dispatch_table = method_signatures.iter().map(|&(impl_item, signature)|
+			push_invoke_signature_aster(builder, impl_item, signature, push))
+		.collect::<Vec<Dispatch>>();
+
+	let dispatch_arms = implement_dispatch_arms(cx, builder, &dispatch_table, false);
+	let dispatch_arms_buffered = implement_dispatch_arms(cx, builder, &dispatch_table, true);
+
+	let (handshake_arm, handshake_arm_buf) = implement_handshake_arm(cx);
+
+	let ty = ty_ident_map(&original_ty).ident(builder);
+	let ipc_item = quote_item!(cx,
+		impl $impl_generics ::ipc::IpcInterface<$ty> for $ty $where_clause {
+			fn dispatch<R>(&self, r: &mut R) -> Vec<u8>
+				where R: ::std::io::Read
+			{
+				let mut method_num = vec![0u8;2];
+				match r.read(&mut method_num) {
+					Ok(size) if size == 0 => { panic!("method id not supplied" ); }
+					Err(e) => { panic!("ipc read error: {:?}, aborting", e); }
+					_ => { }
+				}
+
+				// method_num is a 16-bit little-endian unsigned number
+				match method_num[1] as u16 + (method_num[0] as u16)*256 {
+					// handshake
+					$handshake_arm
+					// user methods
+					$dispatch_arms
+					_ => vec![]
+				}
+			}
+
+			fn dispatch_buf(&self, method_num: u16, buf: &[u8]) -> Vec<u8>
+			{
+				match method_num {
+					$handshake_arm_buf
+					$dispatch_arms_buffered
+					_ => vec![]
+				}
+			}
+		}
+	).unwrap();
+
+	Ok(InterfaceMap {
+		ident_map: ty_ident_map(&original_ty),
+		original_item: item.clone(),
+		item: ipc_item,
+		dispatches: dispatch_table,
+		generics: generics.clone(),
+		impl_trait: impl_trait.clone(),
+	})
+}

ipc/codegen/src/lib.rs

@@ -0,0 +1,70 @@
+// 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/>.
+
+//! Codegen for IPC RPC
+
+#![cfg_attr(feature = "nightly-testing", plugin(clippy))]
+#![cfg_attr(feature = "nightly-testing", feature(plugin))]
+#![cfg_attr(feature = "nightly-testing", allow(used_underscore_binding))]
+#![cfg_attr(not(feature = "with-syntex"), feature(rustc_private, plugin))]
+#![cfg_attr(not(feature = "with-syntex"), plugin(quasi_macros))]
+
+extern crate aster;
+extern crate quasi;
+
+#[cfg(feature = "with-syntex")]
+extern crate syntex;
+
+#[cfg(feature = "with-syntex")]
+#[macro_use]
+extern crate syntex_syntax as syntax;
+
+#[cfg(not(feature = "with-syntex"))]
+#[macro_use]
+extern crate syntax;
+
+#[cfg(not(feature = "with-syntex"))]
+extern crate rustc_plugin;
+
+#[cfg(not(feature = "with-syntex"))]
+use syntax::feature_gate::AttributeType;
+
+#[cfg(feature = "with-syntex")]
+include!(concat!(env!("OUT_DIR"), "/lib.rs"));
+
+#[cfg(not(feature = "with-syntex"))]
+include!("lib.rs.in");
+
+#[cfg(feature = "with-syntex")]
+pub fn register(reg: &mut syntex::Registry) {
+	reg.add_attr("feature(custom_derive)");
+	reg.add_attr("feature(custom_attribute)");
+
+	reg.add_decorator("derive_Ipc", codegen::expand_ipc_implementation);
+	reg.add_decorator("derive_Binary", serialization::expand_serialization_implementation);
+}
+
+#[cfg(not(feature = "with-syntex"))]
+pub fn register(reg: &mut rustc_plugin::Registry) {
+	reg.register_syntax_extension(
+		syntax::parse::token::intern("derive_Ipc"),
+		syntax::ext::base::MultiDecorator(
+			Box::new(codegen::expand_ipc_implementation)));
+	reg.register_syntax_extension(
+		syntax::parse::token::intern("derive_Binary"),
+		syntax::ext::base::MultiDecorator(
+			Box::new(serialization::expand_serialization_implementation)));
+}

ipc/codegen/src/lib.rs.in

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

ipc/codegen/src/serialization.rs

@@ -0,0 +1,600 @@
+// 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 aster;
+
+use syntax::ast::{
+	MetaItem,
+	Item,
+	Ident,
+};
+
+use syntax::ast;
+use syntax::codemap::Span;
+use syntax::ext::base::{Annotatable, ExtCtxt};
+use syntax::ext::build::AstBuilder;
+use syntax::ptr::P;
+
+pub struct Error;
+
+use super::codegen;
+
+pub fn expand_serialization_implementation(
+	cx: &mut ExtCtxt,
+	span: Span,
+	meta_item: &MetaItem,
+	annotatable: &Annotatable,
+	push: &mut FnMut(Annotatable)
+) {
+	let item = match *annotatable {
+		Annotatable::Item(ref item) => item,
+		_ => {
+			cx.span_err(meta_item.span, "`#[derive(Binary)]` may only be applied to structs and enums");
+			return;
+		},
+	};
+
+	let builder = aster::AstBuilder::new().span(span);
+
+	let impl_item = match serialize_item(cx, &builder, &item) {
+		Ok(item) => item,
+		Err(Error) => {
+			// An error occured, but it should have been reported already.
+			return;
+		},
+	};
+
+	push(Annotatable::Item(impl_item))
+}
+
+fn serialize_item(
+	cx: &ExtCtxt,
+	builder: &aster::AstBuilder,
+	item: &Item,
+) -> Result<P<ast::Item>, Error> {
+	let generics = match item.node {
+		ast::ItemKind::Struct(_, ref generics) => generics,
+		ast::ItemKind::Enum(_, ref generics) => generics,
+		_ => {
+			cx.span_err(
+				item.span,
+				"`#[derive(Binary)]` may only be applied to structs and enums");
+			return Err(Error);
+		},
+	};
+
+	let ty = builder.ty().path()
+		.segment(item.ident).with_generics(generics.clone()).build()
+		.build();
+
+	let where_clause = &generics.where_clause;
+
+	let binary_expressions = try!(binary_expr(cx,
+		&builder,
+		&item,
+		&generics,
+		ty.clone()));
+
+	let (size_expr, read_expr, write_expr) =
+		(binary_expressions.size, binary_expressions.read, binary_expressions.write);
+
+	Ok(quote_item!(cx,
+		impl $generics ::ipc::BinaryConvertable for $ty $where_clause {
+			fn size(&self) -> usize {
+				$size_expr
+			}
+
+			fn to_bytes(&self, buffer: &mut [u8], length_stack: &mut VecDeque<usize>) -> Result<(), BinaryConvertError> {
+				$write_expr
+			}
+
+			fn from_bytes(buffer: &[u8], length_stack: &mut VecDeque<usize>) -> Result<Self, BinaryConvertError> {
+				$read_expr
+			}
+
+			fn len_params() -> usize {
+				1
+			}
+        }
+    ).unwrap())
+}
+
+#[allow(unreachable_code)]
+fn binary_expr(
+	cx: &ExtCtxt,
+	builder: &aster::AstBuilder,
+	item: &Item,
+	impl_generics: &ast::Generics,
+	ty: P<ast::Ty>,
+) -> Result<BinaryExpressions, Error> {
+	match item.node {
+		ast::ItemKind::Struct(ref variant_data, _) => {
+			binary_expr_item_struct(
+				cx,
+				builder,
+				impl_generics,
+				ty,
+				item.span,
+				variant_data,
+			)
+		},
+		ast::ItemKind::Enum(ref enum_def, _) => {
+			binary_expr_enum(
+				cx,
+				builder,
+				item.ident,
+				impl_generics,
+				ty,
+				item.span,
+				enum_def,
+			)
+		},
+		_ => {
+			cx.span_bug(item.span,
+						"expected ItemStruct or ItemEnum in #[derive(Binary)]");
+			Err(Error)
+		},
+	}
+}
+
+struct BinaryExpressions {
+	pub size: P<ast::Expr>,
+	pub write: P<ast::Expr>,
+	pub read: P<ast::Expr>,
+}
+
+fn replace_qualified(s: &str) -> String {
+	if let Some(pos) = s.find("<") {
+		let mut source = s.to_owned();
+		source.insert(pos, ':');
+		source.insert(pos, ':');
+		source
+	}
+	else { s.to_owned() }
+}
+
+fn binary_expr_struct(
+	cx: &ExtCtxt,
+	builder: &aster::AstBuilder,
+	ty: P<ast::Ty>,
+	fields: &[ast::StructField],
+	value_ident: Option<ast::Ident>,
+	instance_ident: Option<ast::Ident>,
+) -> Result<BinaryExpressions, Error> {
+
+	let size_exprs: Vec<P<ast::Expr>> = fields.iter().enumerate().map(|(index, field)| {
+		let field_type_ident = builder.id(
+			&::syntax::print::pprust::ty_to_string(&codegen::strip_ptr(&field.ty)));
+
+		let field_type_ident_qualified = builder.id(
+			replace_qualified(&::syntax::print::pprust::ty_to_string(&codegen::strip_ptr(&field.ty))));
+
+		let index_ident = builder.id(format!("__field{}", index));
+		value_ident.and_then(|x| {
+				let field_id = builder.id(field.ident.unwrap());
+				Some(quote_expr!(cx,
+					match $field_type_ident_qualified::len_params() {
+						0 => mem::size_of::<$field_type_ident>(),
+						_ => $x. $field_id .size(),
+					}))
+			})
+			.unwrap_or_else(|| quote_expr!(cx, match $field_type_ident_qualified::len_params() {
+				0 => mem::size_of::<$field_type_ident>(),
+				_ => $index_ident .size(),
+			}))
+	}).collect();
+
+	let first_size_expr = size_exprs[0].clone();
+	let mut total_size_expr = quote_expr!(cx, 0usize + $first_size_expr);
+	for index in 1..size_exprs.len() {
+		let next_expr = size_exprs[index].clone();
+		total_size_expr = quote_expr!(cx, $total_size_expr + $next_expr);
+	}
+
+	let mut write_stmts = Vec::<ast::Stmt>::new();
+	write_stmts.push(quote_stmt!(cx, let mut offset = 0usize;).unwrap());
+
+	let mut map_stmts = Vec::<ast::Stmt>::new();
+	let field_amount = builder.id(&format!("{}",fields.len()));
+	map_stmts.push(quote_stmt!(cx, let mut map = vec![0usize; $field_amount];).unwrap());
+	map_stmts.push(quote_stmt!(cx, let mut total = 0usize;).unwrap());
+	for (index, field) in fields.iter().enumerate() {
+		let field_type_ident = builder.id(
+			&::syntax::print::pprust::ty_to_string(&codegen::strip_ptr(&field.ty)));
+
+		let field_type_ident_qualified = builder.id(
+			replace_qualified(&::syntax::print::pprust::ty_to_string(&codegen::strip_ptr(&field.ty))));
+
+		let member_expr = match value_ident {
+			Some(x) => {
+				let field_id = builder.id(field.ident.unwrap());
+				quote_expr!(cx, $x . $field_id)
+			},
+			None => {
+				let index_ident = builder.id(format!("__field{}", index));
+				quote_expr!(cx, $index_ident)
+			},
+		};
+
+		write_stmts.push(quote_stmt!(cx, let next_line = offset + match $field_type_ident_qualified::len_params() {
+				0 => mem::size_of::<$field_type_ident>(),
+				_ => { let size = $member_expr .size(); length_stack.push_back(size); size },
+			}).unwrap());
+
+		write_stmts.push(quote_stmt!(cx,
+			if let Err(e) = $member_expr .to_bytes(&mut buffer[offset..next_line], length_stack) { return Err(e) };).unwrap());
+
+		write_stmts.push(quote_stmt!(cx, offset = next_line; ).unwrap());
+
+		let field_index = builder.id(&format!("{}", index));
+		map_stmts.push(quote_stmt!(cx, map[$field_index] = total;).unwrap());
+		map_stmts.push(quote_stmt!(cx, let size = match $field_type_ident_qualified::len_params() {
+				0 => mem::size_of::<$field_type_ident>(),
+				_ => length_stack.pop_front().unwrap(),
+			}).unwrap());
+		map_stmts.push(quote_stmt!(cx, total = total + size;).unwrap());
+	};
+
+	let read_expr = match fields.iter().any(|f| codegen::has_ptr(&f.ty)) {
+		true => {
+			// cannot create structs with pointers
+			quote_expr!(cx, Err(::ipc::binary::BinaryConvertError))
+		},
+		false => {
+			if value_ident.is_some() {
+				let instance_create = named_fields_sequence(cx, &ty, fields);
+				quote_expr!(cx, { $map_stmts; $instance_create; Ok(result) })
+			}
+			else {
+				let map_variant = P(fields_sequence(cx, &ty, fields, &instance_ident.unwrap_or(builder.id("Self"))));
+				quote_expr!(cx, { $map_stmts; Ok($map_variant) })
+			}
+		},
+	};
+
+    Ok(BinaryExpressions {
+		size: total_size_expr,
+		write: quote_expr!(cx, { $write_stmts; Ok(()) } ),
+		read: read_expr,
+	})
+}
+
+#[allow(unreachable_code)]
+fn binary_expr_item_struct(
+	cx: &ExtCtxt,
+	builder: &aster::AstBuilder,
+	_impl_generics: &ast::Generics,
+	ty: P<ast::Ty>,
+	span: Span,
+	variant_data: &ast::VariantData,
+) -> Result<BinaryExpressions, Error> {
+	match *variant_data {
+		ast::VariantData::Tuple(ref fields, _) => {
+			binary_expr_struct(
+				cx,
+				&builder,
+				ty,
+				fields,
+				Some(builder.id("self")),
+				None,
+			)
+		},
+		ast::VariantData::Struct(ref fields, _) => {
+			binary_expr_struct(
+				cx,
+				&builder,
+				ty,
+				fields,
+				Some(builder.id("self")),
+				None,
+			)
+		},
+		_ => {
+			cx.span_bug(span,
+				&format!("#[derive(Binary)] Unsupported struct content, expected tuple/struct, found: {:?}",
+					variant_data));
+			Err(Error)
+		},
+	}
+}
+
+fn binary_expr_enum(
+	cx: &ExtCtxt,
+	builder: &aster::AstBuilder,
+	type_ident: Ident,
+	impl_generics: &ast::Generics,
+	ty: P<ast::Ty>,
+	span: Span,
+	enum_def: &ast::EnumDef,
+) -> Result<BinaryExpressions, Error> {
+	let arms: Vec<_> = try!(
+		enum_def.variants.iter()
+			.enumerate()
+			.map(|(variant_index, variant)| {
+				binary_expr_variant(
+					cx,
+					builder,
+					type_ident,
+					impl_generics,
+					ty.clone(),
+					span,
+					variant,
+					variant_index,
+				)
+			})
+			.collect()
+	);
+
+	let (size_arms, write_arms, mut read_arms) = (
+		arms.iter().map(|x| x.size.clone()).collect::<Vec<ast::Arm>>(),
+		arms.iter().map(|x| x.write.clone()).collect::<Vec<ast::Arm>>(),
+		arms.iter().map(|x| x.read.clone()).collect::<Vec<ast::Arm>>());
+
+	read_arms.push(quote_arm!(cx, _ => { Err(BinaryConvertError) } ));
+
+	Ok(BinaryExpressions {
+		size: quote_expr!(cx, 1usize + match *self { $size_arms }),
+		write: quote_expr!(cx, match *self { $write_arms }; ),
+		read: quote_expr!(cx, match buffer[0] { $read_arms }),
+	})
+}
+
+struct BinaryArm {
+	size: ast::Arm,
+	write: ast::Arm,
+	read: ast::Arm,
+}
+
+fn fields_sequence(
+	ext_cx: &ExtCtxt,
+	_ty: &P<ast::Ty>,
+	fields: &[ast::StructField],
+	variant_ident: &ast::Ident,
+) -> ast::Expr {
+	use syntax::parse::token;
+	use syntax::ast::TokenTree::Token;
+
+	::quasi::parse_expr_panic(&mut ::syntax::parse::new_parser_from_tts(
+		ext_cx.parse_sess(),
+		ext_cx.cfg(),
+		{
+			let _sp = ext_cx.call_site();
+			let mut tt = ::std::vec::Vec::new();
+			tt.push(Token(_sp, token::Ident(variant_ident.clone(), token::Plain)));
+			tt.push(Token(_sp, token::OpenDelim(token::Paren)));
+
+			for (idx, field) in fields.iter().enumerate() {
+				if field.ident.is_some() {
+					tt.push(Token(_sp, token::Ident(field.ident.clone().unwrap(), token::Plain)));
+					tt.push(Token(_sp, token::Colon));
+				}
+
+				tt.push(Token(_sp, token::Ident(ext_cx.ident_of("try!"), token::Plain)));
+				tt.push(Token(_sp, token::OpenDelim(token::Paren)));
+				tt.push(Token(
+					_sp,
+					token::Ident(
+						ext_cx.ident_of(&replace_qualified(&::syntax::print::pprust::ty_to_string(&field.ty))),
+						token::Plain)));
+				tt.push(Token(_sp, token::ModSep));
+				tt.push(Token(_sp, token::Ident(ext_cx.ident_of("from_bytes"), token::Plain)));
+				tt.push(Token(_sp, token::OpenDelim(token::Paren)));
+
+				tt.push(Token(_sp, token::BinOp(token::And)));
+				tt.push(Token(_sp, token::Ident(ext_cx.ident_of("buffer"), token::Plain)));
+
+				tt.push(Token(_sp, token::OpenDelim(token::Bracket)));
+				tt.push(Token(_sp, token::Ident(ext_cx.ident_of("map"), token::Plain)));
+				tt.push(Token(_sp, token::OpenDelim(token::Bracket)));
+				tt.push(Token(_sp, token::Ident(ext_cx.ident_of(&format!("{}", idx)), token::Plain)));
+				tt.push(Token(_sp, token::CloseDelim(token::Bracket)));
+				tt.push(Token(_sp, token::DotDot));
+
+				if idx+1 != fields.len() {
+					tt.push(Token(_sp, token::Ident(ext_cx.ident_of("map"), token::Plain)));
+					tt.push(Token(_sp, token::OpenDelim(token::Bracket)));
+					tt.push(Token(_sp, token::Ident(ext_cx.ident_of(&format!("{}", idx+1)), token::Plain)));
+					tt.push(Token(_sp, token::CloseDelim(token::Bracket)));
+				}
+
+				tt.push(Token(_sp, token::CloseDelim(token::Bracket)));
+
+				tt.push(Token(_sp, token::Comma));
+				tt.push(Token(_sp, token::Ident(ext_cx.ident_of("length_stack"), token::Plain)));
+
+				tt.push(Token(_sp, token::CloseDelim(token::Paren)));
+				tt.push(Token(_sp, token::CloseDelim(token::Paren)));
+				tt.push(Token(_sp, token::Comma));
+			}
+			tt.push(Token(_sp, token::CloseDelim(token::Paren)));
+
+			tt
+		})
+	).unwrap()
+}
+
+fn named_fields_sequence(
+	ext_cx: &ExtCtxt,
+	ty: &P<ast::Ty>,
+	fields: &[ast::StructField],
+) -> ast::Stmt {
+	use syntax::parse::token;
+	use syntax::ast::TokenTree::Token;
+
+	::quasi::parse_stmt_panic(&mut ::syntax::parse::new_parser_from_tts(
+		ext_cx.parse_sess(),
+		ext_cx.cfg(),
+		{
+			let _sp = ext_cx.call_site();
+			let mut tt = ::std::vec::Vec::new();
+			tt.push(Token(_sp, token::Ident(ext_cx.ident_of("let"), token::Plain)));
+			tt.push(Token(_sp, token::Ident(ext_cx.ident_of("result"), token::Plain)));
+			tt.push(Token(_sp, token::Eq));
+
+			tt.push(Token(
+				_sp,
+			  	token::Ident(
+					ext_cx.ident_of(&::syntax::print::pprust::ty_to_string(ty)),
+			 		token::Plain)));
+
+			tt.push(Token(_sp, token::OpenDelim(token::Brace)));
+
+			for (idx, field) in fields.iter().enumerate() {
+				tt.push(Token(_sp, token::Ident(field.ident.clone().unwrap(), token::Plain)));
+				tt.push(Token(_sp, token::Colon));
+
+				tt.push(Token(_sp, token::Ident(ext_cx.ident_of("try!"), token::Plain)));
+				tt.push(Token(_sp, token::OpenDelim(token::Paren)));
+				tt.push(Token(
+					_sp,
+					token::Ident(
+						ext_cx.ident_of(&replace_qualified(&::syntax::print::pprust::ty_to_string(&field.ty))),
+						token::Plain)));
+				tt.push(Token(_sp, token::ModSep));
+				tt.push(Token(_sp, token::Ident(ext_cx.ident_of("from_bytes"), token::Plain)));
+				tt.push(Token(_sp, token::OpenDelim(token::Paren)));
+
+				tt.push(Token(_sp, token::BinOp(token::And)));
+				tt.push(Token(_sp, token::Ident(ext_cx.ident_of("buffer"), token::Plain)));
+
+				tt.push(Token(_sp, token::OpenDelim(token::Bracket)));
+				tt.push(Token(_sp, token::Ident(ext_cx.ident_of("map"), token::Plain)));
+				tt.push(Token(_sp, token::OpenDelim(token::Bracket)));
+				tt.push(Token(_sp, token::Ident(ext_cx.ident_of(&format!("{}", idx)), token::Plain)));
+				tt.push(Token(_sp, token::CloseDelim(token::Bracket)));
+				tt.push(Token(_sp, token::DotDot));
+				if idx + 1 != fields.len() {
+					tt.push(Token(_sp, token::Ident(ext_cx.ident_of("map"), token::Plain)));
+					tt.push(Token(_sp, token::OpenDelim(token::Bracket)));
+					tt.push(Token(_sp, token::Ident(ext_cx.ident_of(&format!("{}", idx+1)), token::Plain)));
+					tt.push(Token(_sp, token::CloseDelim(token::Bracket)));
+				}
+
+				tt.push(Token(_sp, token::CloseDelim(token::Bracket)));
+
+				tt.push(Token(_sp, token::Comma));
+				tt.push(Token(_sp, token::Ident(ext_cx.ident_of("length_stack"), token::Plain)));
+
+
+				tt.push(Token(_sp, token::CloseDelim(token::Paren)));
+				tt.push(Token(_sp, token::CloseDelim(token::Paren)));
+				tt.push(Token(_sp, token::Comma));
+			}
+
+			tt.push(Token(_sp, token::CloseDelim(token::Brace)));
+			tt
+		})
+	).unwrap()
+}
+
+fn binary_expr_variant(
+	cx: &ExtCtxt,
+	builder: &aster::AstBuilder,
+	type_ident: Ident,
+	_generics: &ast::Generics,
+	ty: P<ast::Ty>,
+	_span: Span,
+	variant: &ast::Variant,
+	variant_index: usize,
+) -> Result<BinaryArm, Error> {
+	let variant_ident = variant.node.name;
+	let variant_index_ident = builder.id(format!("{}", variant_index));
+
+	match variant.node.data {
+		ast::VariantData::Unit(_) => {
+			let pat = builder.pat().path()
+				.id(type_ident).id(variant_ident)
+				.build();
+
+			let variant_val = builder.id(format!("{}::{}", type_ident, variant_ident));
+
+			Ok(BinaryArm {
+				size: quote_arm!(cx, $pat => { 0usize } ),
+				write: quote_arm!(cx, $pat => { buffer[0] = $variant_index_ident; Ok(()) } ),
+				read: quote_arm!(cx, $variant_index_ident => { Ok($variant_val) } ),
+			})
+		},
+		ast::VariantData::Tuple(ref fields, _) => {
+			let field_names: Vec<ast::Ident> = (0 .. fields.len())
+				.map(|i| builder.id(format!("__field{}", i)))
+				.collect();
+
+			let pat = builder.pat().enum_()
+				.id(type_ident).id(variant_ident).build()
+				.with_pats(
+					field_names.iter()
+						.map(|field| builder.pat().ref_id(field))
+				)
+				.build();
+
+			let binary_expr = try!(binary_expr_struct(
+				cx,
+				&builder,
+				ty,
+				fields,
+				None,
+				Some(builder.id(format!("{}::{}", type_ident, variant_ident))),
+			));
+
+			let (size_expr, write_expr, read_expr) = (binary_expr.size, vec![binary_expr.write], binary_expr.read);
+			Ok(BinaryArm {
+				size: quote_arm!(cx, $pat => { $size_expr } ),
+				write: quote_arm!(cx,
+					$pat => {
+						buffer[0] = $variant_index_ident;
+						let buffer = &mut buffer[1..];
+						$write_expr
+				}),
+				read: quote_arm!(cx, $variant_index_ident => { $read_expr } ),
+			})
+		},
+		ast::VariantData::Struct(ref fields, _) => {
+			let field_names: Vec<_> = (0 .. fields.len())
+				.map(|i| builder.id(format!("__field{}", i)))
+				.collect();
+
+			let pat = builder.pat().struct_()
+				.id(type_ident).id(variant_ident).build()
+				.with_pats(
+					field_names.iter()
+						.zip(fields.iter())
+						.map(|(id, field)|(field.ident.unwrap(), builder.pat().ref_id(id))))
+				.build();
+
+
+			let binary_expr = try!(binary_expr_struct(
+				cx,
+				&builder,
+				ty,
+				fields,
+				None,
+				Some(builder.id(format!("{}::{}", type_ident, variant_ident))),
+			));
+
+			let (size_expr, write_expr, read_expr) = (binary_expr.size, vec![binary_expr.write], binary_expr.read);
+
+			Ok(BinaryArm {
+				size: quote_arm!(cx, $pat => { $size_expr } ),
+				write: quote_arm!(cx,
+					$pat => {
+						buffer[0] = $variant_index_ident;
+						let buffer = &mut buffer[1..];
+						$write_expr
+				}),
+				read: quote_arm!(cx, $pat => { $read_expr } ),
+			})
+		},
+	}
+}