Merge branch 'master' into ui-2

2017-08-07 12:02:39 +02:00 · 2017-08-07 12:02:39 +02:00 · a48f321fac
commit a48f321fac
parent 0371dcb7bd bdeea80032
252 changed files with 3490 additions and 1985 deletions
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@ -1,41 +1,45 @@
-## Parity [v1.6.10](https://github.com/paritytech/parity/releases/tag/v1.6.10) (2017-07-23)
+## Parity [v1.7.0](https://github.com/paritytech/parity/releases/tag/v1.7.0) (2017-07-28)
 This is a hotfix release for the stable channel addressing the recent [multi-signature wallet vulnerability](https://blog.parity.io/security-alert-high-2/). Note, upgrading is not mandatory, and all future multi-sig wallets created by any version of Parity are secure.
 All Changes:
 - Backports for stable [#6116](https://github.com/paritytech/parity/pull/6116)
  - Remove chunk to restore from pending set only upon successful import [#6112](https://github.com/paritytech/parity/pull/6112)
  - Blacklist bad snapshot manifest hashes upon failure [#5874](https://github.com/paritytech/parity/pull/5874)
  - Bump snap version and tweak importing detection logic [#6079](https://github.com/paritytech/parity/pull/6079) (modified to work)
 - Fix docker build for stable [#6118](https://github.com/paritytech/parity/pull/6118)
 - Backported wallet fix [#6104](https://github.com/paritytech/parity/pull/6104)
  - Fix initialisation bug. ([#6102](https://github.com/paritytech/parity/pull/6102))
  - Update wallet library modifiers ([#6103](https://github.com/paritytech/parity/pull/6103))
 - Bump to v1.6.10
 ## Parity [v1.7.0](https://github.com/paritytech/parity/releases/tag/v1.7.0) (2017-07-23)
 Parity 1.7.0 is a major release introducing several important features:
- **Experimental [Light client](https://github.com/paritytech/parity/wiki/The-Parity-Light-Protocol-(PIP)) support**. Start Parity with `--light` to enable light mode.
+- **Experimental [Light client](https://github.com/paritytech/parity/wiki/The-Parity-Light-Protocol-(PIP)) support**. Start Parity with `--light` to enable light mode. Please, note: The wallet UI integration for the light client is not included, yet.
 - **Experimental web wallet**. A hosted version of Parity that keeps the keys and signs transactions using your browser storage. Try it at https://wallet.parity.io or run your own with `--public-node`.
 - **WASM contract support**. Private networks can run contracts compiled into WASM bytecode. _More information and documentation to follow_.
 - **DApps and RPC server merge**. DApp and RPC are now available through a single API endpoint. DApp server related settings are deprecated.
 - **Export accounts from the wallet**. Backing up your keys can now simply be managed through the wallet interface.
- **PoA/Kovan validator set contract**. The PoA network validator-set management via smart contract is now supported by warp and light sync.
+- **PoA/Kovan validator set contract**. The PoA network validator-set management via smart contract is now supported by warp and, in the near future, light sync.
 - **PubSub API**. https://github.com/paritytech/parity/wiki/JSONRPC-Parity-Pub-Sub-module
 - **Signer apps for IOS and Android**.
 Full list of included changes:
 - Backports [#6163](https://github.com/paritytech/parity/pull/6163)
  - Light client improvements ([#6156](https://github.com/paritytech/parity/pull/6156))
    - No seal checking
    - Import command and --no-seal-check for light client
    - Fix eth_call
    - Tweak registry dapps lookup
    - Ignore failed requests to non-server peers
  - Fix connecting to wildcard addresses. ([#6167](https://github.com/paritytech/parity/pull/6167))
  - Don't display an overlay in case the time sync check fails. ([#6164](https://github.com/paritytech/parity/pull/6164))
    - Small improvements to time estimation.
    - Temporarily disable NTP time check by default.
 - Light client fixes ([#6148](https://github.com/paritytech/parity/pull/6148)) [#6151](https://github.com/paritytech/parity/pull/6151)
  - Light client fixes
  - Fix memory-lru-cache
  - Clear pending reqs on disconnect
 - Filter tokens logs from current block, not genesis ([#6128](https://github.com/paritytech/parity/pull/6128)) [#6141](https://github.com/paritytech/parity/pull/6141)
 - Fix QR scanner returning null on confirm [#6122](https://github.com/paritytech/parity/pull/6122)
 - Check QR before lowercase ([#6119](https://github.com/paritytech/parity/pull/6119)) [#6120](https://github.com/paritytech/parity/pull/6120)
 - Remove chunk to restore from pending set only upon successful import [#6117](https://github.com/paritytech/parity/pull/6117)
 - Fixed node address detection on incoming connection [#6094](https://github.com/paritytech/parity/pull/6094)
 - Place RETURNDATA behind block number gate [#6095](https://github.com/paritytech/parity/pull/6095)
 - Update wallet library binaries [#6108](https://github.com/paritytech/parity/pull/6108)
 - Backported wallet fix [#6105](https://github.com/paritytech/parity/pull/6105)
  - Fix initialisation bug. ([#6102](https://github.com/paritytech/parity/pull/6102))
  - Update wallet library modifiers ([#6103](https://github.com/paritytech/parity/pull/6103))
 - Place RETURNDATA behind block number gate [#6095](https://github.com/paritytech/parity/pull/6095)
 - Fixed node address detection on incoming connection [#6094](https://github.com/paritytech/parity/pull/6094)
 - Bump snap version and tweak importing detection logic ([#6079](https://github.com/paritytech/parity/pull/6079)) [#6081](https://github.com/paritytech/parity/pull/6081)
  - bump last tick just before printing info and restore sync detection
  - bump kovan snapshot version
@ -439,6 +443,23 @@ Full list of included changes:
 - Update the Wallet Library Registry key [#4817](https://github.com/paritytech/parity/pull/4817)
 - Update Wallet to new Wallet Code [#4805](https://github.com/paritytech/parity/pull/4805)
 ## Parity [v1.6.10](https://github.com/paritytech/parity/releases/tag/v1.6.10) (2017-07-25)
 This is a hotfix release for the stable channel addressing the recent [multi-signature wallet vulnerability](https://blog.parity.io/security-alert-high-2/). Note, upgrading is not mandatory, and all future multi-sig wallets created by any version of Parity are secure.
 All Changes:
 - Backports for stable [#6116](https://github.com/paritytech/parity/pull/6116)
  - Remove chunk to restore from pending set only upon successful import [#6112](https://github.com/paritytech/parity/pull/6112)
  - Blacklist bad snapshot manifest hashes upon failure [#5874](https://github.com/paritytech/parity/pull/5874)
  - Bump snap version and tweak importing detection logic [#6079](https://github.com/paritytech/parity/pull/6079) (modified to work)
 - Fix docker build for stable [#6118](https://github.com/paritytech/parity/pull/6118)
 - Update wallet library binaries [#6108](https://github.com/paritytech/parity/pull/6108)
 - Backported wallet fix [#6104](https://github.com/paritytech/parity/pull/6104)
  - Fix initialisation bug. ([#6102](https://github.com/paritytech/parity/pull/6102))
  - Update wallet library modifiers ([#6103](https://github.com/paritytech/parity/pull/6103))
 - Bump to v1.6.10
 ## Parity [v1.6.9](https://github.com/paritytech/parity/releases/tag/v1.6.9) (2017-07-16)
 This is a first stable release of 1.6 series. It contains a number of minor fixes and introduces the `--reseal-on-uncles` option for miners.
--- a/Cargo.lock
+++ b/Cargo.lock
@ -1,6 +1,15 @@
 [root]
-name = "using_queue"
+name = "wasm"
 version = "0.1.0"
 dependencies = [
 "byteorder 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "ethcore-logger 1.8.0",
 "ethcore-util 1.8.0",
 "log 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "parity-wasm 0.12.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "vm 0.1.0",
 "wasm-utils 0.1.0 (git+https://github.com/paritytech/wasm-utils)",
 ]
 [[package]]
 name = "advapi32-sys"
@ -181,6 +190,14 @@ name = "blastfig"
 version = "0.3.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 [[package]]
 name = "bloomable"
 version = "0.1.0"
 dependencies = [
 "ethcore-bigint 0.1.3",
 "tiny-keccak 1.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 [[package]]
 name = "bloomchain"
 version = "0.1.0"
@ -220,6 +237,15 @@ name = "cfg-if"
 version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 [[package]]
 name = "chainspec"
 version = "0.1.0"
 dependencies = [
 "ethjson 0.1.0",
 "serde_ignored 0.0.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_json 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 [[package]]
 name = "cid"
 version = "0.2.2"
@ -271,6 +297,7 @@ dependencies = [
 name = "common-types"
 version = "0.1.0"
 dependencies = [
 "bloomable 0.1.0",
 "ethcore-util 1.8.0",
 "ethjson 0.1.0",
 "rlp 0.2.0",
@ -443,7 +470,7 @@ dependencies = [
 "serde 1.0.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_derive 1.0.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_json 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)",
- "tiny-keccak 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "tiny-keccak 1.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 [[package]]
@ -462,6 +489,7 @@ name = "ethcore"
 version = "1.8.0"
 dependencies = [
 "bit-set 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "bloomable 0.1.0",
 "bloomchain 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "bn 0.4.4 (git+https://github.com/paritytech/bn)",
 "byteorder 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
@ -502,8 +530,12 @@ dependencies = [
 "rustc-hex 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "semver 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "stats 0.1.0",
 "table 0.1.0",
 "time 0.1.35 (registry+https://github.com/rust-lang/crates.io-index)",
 "transient-hashmap 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "using_queue 0.1.0",
 "vm 0.1.0",
 "wasm 0.1.0",
 ]
 [[package]]
@ -625,6 +657,7 @@ dependencies = [
 "smallvec 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "stats 0.1.0",
 "time 0.1.35 (registry+https://github.com/rust-lang/crates.io-index)",
 "vm 0.1.0",
 ]
 [[package]]
@ -656,6 +689,7 @@ dependencies = [
 "ethcrypto 0.1.0",
 "ethkey 0.2.0",
 "igd 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "ipnetwork 0.12.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.21 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "mio 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)",
@ -668,7 +702,7 @@ dependencies = [
 "rustc-serialize 0.3.19 (registry+https://github.com/rust-lang/crates.io-index)",
 "slab 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "time 0.1.35 (registry+https://github.com/rust-lang/crates.io-index)",
- "tiny-keccak 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "tiny-keccak 1.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 [[package]]
@ -751,11 +785,9 @@ dependencies = [
 "rustc-hex 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc_version 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "sha3 0.1.0",
 "table 0.1.0",
 "target_info 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "time 0.1.35 (registry+https://github.com/rust-lang/crates.io-index)",
- "tiny-keccak 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "tiny-keccak 1.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "using_queue 0.1.0",
 "vergen 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
@ -768,7 +800,7 @@ dependencies = [
 "ethkey 0.2.0",
 "rust-crypto 0.2.36 (registry+https://github.com/rust-lang/crates.io-index)",
 "subtle 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "tiny-keccak 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "tiny-keccak 1.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 [[package]]
@ -776,7 +808,7 @@ name = "ethjson"
 version = "0.1.0"
 dependencies = [
 "clippy 0.0.103 (registry+https://github.com/rust-lang/crates.io-index)",
- "ethcore-util 1.8.0",
+ "ethcore-bigint 0.1.3",
 "rustc-hex 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_derive 1.0.9 (registry+https://github.com/rust-lang/crates.io-index)",
@ -794,7 +826,7 @@ dependencies = [
 "rand 0.3.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "rust-crypto 0.2.36 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc-hex 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "tiny-keccak 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "tiny-keccak 1.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 [[package]]
@ -830,7 +862,7 @@ dependencies = [
 "smallvec 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "tempdir 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "time 0.1.35 (registry+https://github.com/rust-lang/crates.io-index)",
- "tiny-keccak 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "tiny-keccak 1.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 [[package]]
@ -862,6 +894,7 @@ dependencies = [
 "ethcore-util 1.8.0",
 "ethkey 0.2.0",
 "heapsize 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "ipnetwork 0.12.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "parking_lot 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.3.14 (registry+https://github.com/rust-lang/crates.io-index)",
@ -878,6 +911,7 @@ dependencies = [
 "bit-set 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "byteorder 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "common-types 0.1.0",
 "ethcore-logger 1.8.0",
 "ethcore-util 1.8.0",
 "ethjson 0.1.0",
 "evmjit 1.8.0",
@ -886,6 +920,7 @@ dependencies = [
 "parity-wasm 0.12.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "rlp 0.2.0",
 "rustc-hex 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "vm 0.1.0",
 "wasm-utils 0.1.0 (git+https://github.com/paritytech/wasm-utils)",
 ]
@ -901,13 +936,14 @@ dependencies = [
 "rustc-hex 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_derive 1.0.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "vm 0.1.0",
 ]
 [[package]]
 name = "evmjit"
 version = "1.8.0"
 dependencies = [
- "tiny-keccak 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "tiny-keccak 1.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 [[package]]
@ -1149,6 +1185,11 @@ dependencies = [
 "semver 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 [[package]]
 name = "ipnetwork"
 version = "0.12.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 [[package]]
 name = "isatty"
 version = "0.1.1"
@ -1504,7 +1545,7 @@ version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
 "ring 0.9.5 (registry+https://github.com/rust-lang/crates.io-index)",
- "tiny-keccak 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "tiny-keccak 1.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 [[package]]
@ -1763,6 +1804,7 @@ dependencies = [
 "ethcore-ipc-tests 0.1.0",
 "ethcore-light 1.8.0",
 "ethcore-logger 1.8.0",
 "ethcore-network 1.8.0",
 "ethcore-secretstore 1.0.0",
 "ethcore-stratum 1.8.0",
 "ethcore-util 1.8.0",
@ -1771,6 +1813,7 @@ dependencies = [
 "fdlimit 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures-cpupool 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "ipnetwork 0.12.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "isatty 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "jsonrpc-core 7.0.0 (git+https://github.com/paritytech/jsonrpc.git?branch=parity-1.7)",
 "log 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
@ -1924,7 +1967,6 @@ dependencies = [
 "ethkey 0.2.0",
 "ethstore 0.1.0",
 "ethsync 1.8.0",
 "evm 0.1.0",
 "fetch 0.1.0",
 "futures 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures-cpupool 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
@ -1953,6 +1995,7 @@ dependencies = [
 "time 0.1.35 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-timer 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "transient-hashmap 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "vm 0.1.0",
 ]
 [[package]]
@ -2009,7 +2052,7 @@ dependencies = [
 [[package]]
 name = "parity-ui-precompiled"
 version = "1.4.0"
-source = "git+https://github.com/paritytech/js-precompiled.git#9394d746f859365082ae375119ee70a0a18956a5"
+source = "git+https://github.com/paritytech/js-precompiled.git#dfb9367a495d5ca3eac3c92a4197cf8652756d37"
 dependencies = [
 "parity-dapps-glue 1.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
@ -2070,7 +2113,7 @@ dependencies = [
 "slab 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "time 0.1.35 (registry+https://github.com/rust-lang/crates.io-index)",
- "tiny-keccak 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "tiny-keccak 1.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 [[package]]
@ -2558,6 +2601,14 @@ dependencies = [
 "synom 0.11.3 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 [[package]]
 name = "serde_ignored"
 version = "0.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
 "serde 1.0.9 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 [[package]]
 name = "serde_json"
 version = "1.0.2"
@ -2812,7 +2863,7 @@ dependencies = [
 [[package]]
 name = "tiny-keccak"
-version = "1.2.1"
+version = "1.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 [[package]]
@ -3035,6 +3086,10 @@ dependencies = [
 "winapi-build 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 [[package]]
 name = "using_queue"
 version = "0.1.0"
 [[package]]
 name = "utf8-ranges"
 version = "1.0.0"
@ -3063,6 +3118,20 @@ dependencies = [
 "time 0.1.35 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 [[package]]
 name = "vm"
 version = "0.1.0"
 dependencies = [
 "byteorder 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "common-types 0.1.0",
 "ethcore-util 1.8.0",
 "ethjson 0.1.0",
 "evmjit 1.8.0",
 "lazy_static 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "rlp 0.2.0",
 ]
 [[package]]
 name = "void"
 version = "1.0.2"
@ -3071,7 +3140,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 [[package]]
 name = "wasm-utils"
 version = "0.1.0"
-source = "git+https://github.com/paritytech/wasm-utils#fee06b6d5826c2dc1fc1aa183b0c2c75e3e140c3"
+source = "git+https://github.com/paritytech/wasm-utils#9462bcc0680f0ec2c876abdf75bae981dd4344a5"
 dependencies = [
 "clap 2.24.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "env_logger 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
@ -3226,6 +3295,7 @@ dependencies = [
 "checksum igd 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)" = "356a0dc23a4fa0f8ce4777258085d00a01ea4923b2efd93538fc44bf5e1bda76"
 "checksum integer-encoding 1.0.3 (registry+https://github.com/rust-lang/crates.io-index)" = "a053c9c7dcb7db1f2aa012c37dc176c62e4cdf14898dee0eecc606de835b8acb"
 "checksum iovec 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "29d062ee61fccdf25be172e70f34c9f6efc597e1fb8f6526e8437b2046ab26be"
 "checksum ipnetwork 0.12.6 (registry+https://github.com/rust-lang/crates.io-index)" = "232e76922883005380e831068f731ef0305541c9f77b30df3a1635047b16f370"
 "checksum isatty 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "7408a548dc0e406b7912d9f84c261cc533c1866e047644a811c133c56041ac0c"
 "checksum itertools 0.5.9 (registry+https://github.com/rust-lang/crates.io-index)" = "d95557e7ba6b71377b0f2c3b3ae96c53f1b75a926a6901a500f557a370af730a"
 "checksum itoa 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "91fd9dc2c587067de817fec4ad355e3818c3d893a78cab32a0a474c7a15bb8d5"
@ -3345,6 +3415,7 @@ dependencies = [
 "checksum serde 1.0.9 (registry+https://github.com/rust-lang/crates.io-index)" = "6a7c6b751a2e8d5df57a5ff71b5b4fc8aaee9ee28ff1341d640dd130bb5f4f7a"
 "checksum serde_derive 1.0.9 (registry+https://github.com/rust-lang/crates.io-index)" = "2f6ca58905ebd3c3b285a8a6d4f3ac92b92c0d7951d5649b1bdd212549c06639"
 "checksum serde_derive_internals 0.15.1 (registry+https://github.com/rust-lang/crates.io-index)" = "37aee4e0da52d801acfbc0cc219eb1eda7142112339726e427926a6f6ee65d3a"
 "checksum serde_ignored 0.0.4 (registry+https://github.com/rust-lang/crates.io-index)" = "190e9765dcedb56be63b6e0993a006c7e3b071a016a304736e4a315dc01fb142"
 "checksum serde_json 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)" = "48b04779552e92037212c3615370f6bd57a40ebba7f20e554ff9f55e41a69a7b"
 "checksum serde_urlencoded 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)" = "ce0fd303af908732989354c6f02e05e2e6d597152870f2c6990efb0577137480"
 "checksum sha1 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "cc30b1e1e8c40c121ca33b86c23308a090d19974ef001b4bf6e61fd1a0fb095c"
@ -3375,7 +3446,7 @@ dependencies = [
 "checksum thread-id 3.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "4437c97558c70d129e40629a5b385b3fb1ffac301e63941335e4d354081ec14a"
 "checksum thread_local 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)" = "c85048c6260d17cf486ceae3282d9fb6b90be220bf5b28c400f5485ffc29f0c7"
 "checksum time 0.1.35 (registry+https://github.com/rust-lang/crates.io-index)" = "3c7ec6d62a20df54e07ab3b78b9a3932972f4b7981de295563686849eb3989af"
-"checksum tiny-keccak 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "0b50173faa6ee499206f77b189d7ff3bef40f6969f228c9ec22b82080df9aa41"
+"checksum tiny-keccak 1.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "d52d12ad79e4063e0cb0ca5efa202ed7244b6ce4d25f4d3abe410b2a66128292"
 "checksum tokio-core 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)" = "99e958104a67877907c1454386d5482fe8e965a55d60be834a15a44328e7dc76"
 "checksum tokio-io 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "48f55df1341bb92281f229a6030bc2abffde2c7a44c6d6b802b7687dd8be0775"
 "checksum tokio-minihttp 0.1.0 (git+https://github.com/tomusdrw/tokio-minihttp)" = "<none>"
--- a/Cargo.toml
+++ b/Cargo.toml
@ -41,6 +41,7 @@ ethcore-ipc-hypervisor = { path = "ipc/hypervisor" }
 ethcore-light = { path = "ethcore/light" }
 ethcore-logger = { path = "logger" }
 ethcore-stratum = { path = "stratum" }
 ethcore-network = { path = "util/network" }
 ethkey = { path = "ethkey" }
 rlp = { path = "util/rlp" }
 rpc-cli = { path = "rpc_cli" }
@ -65,6 +66,7 @@ rustc_version = "0.2"
 [dev-dependencies]
 ethcore-ipc-tests = { path = "ipc/tests" }
 pretty_assertions = "0.1"
 ipnetwork = "0.12.6"
 [target.'cfg(windows)'.dependencies]
 winapi = "0.2"
@ -108,4 +110,4 @@ lto = false
 panic = "abort"
 [workspace]
-members = ["ethstore/cli", "ethkey/cli", "evmbin", "whisper"]
+members = ["ethstore/cli", "ethkey/cli", "evmbin", "whisper", "chainspec"]
--- a/SECURITY.md
+++ b/SECURITY.md
@ -42,3 +42,13 @@ ETBD1Q==
 =K9Qw
 -----END PGP PUBLIC KEY BLOCK-----
 ```
 Important Legal Information:
 Your submission might be eligible for a bug bounty. The bug bounty program is an experimental and discretionary rewards program for the Parity community to reward those who are helping to improve the Parity software. Rewards are at the sole discretion of Parity Technologies Ltd.. 
 We are not able to issue rewards to individuals who are on sanctions lists or who are in countries on sanctions lists (e.g. North Korea, Iran, etc). 
 You are responsible for all taxes. All rewards are subject to applicable law. 
 Finally, your testing must not violate any law or compromise any data that is not yours.
--- a/chainspec/Cargo.toml
+++ b/chainspec/Cargo.toml
@ -0,0 +1,9 @@
 [package]
 name = "chainspec"
 version = "0.1.0"
 authors = ["debris <marek.kotewicz@gmail.com>"]
 [dependencies]
 ethjson = { path = "../json" }
 serde_json = "1.0"
 serde_ignored = "0.0.4"
--- a/chainspec/src/main.rs
+++ b/chainspec/src/main.rs
@ -0,0 +1,48 @@
 extern crate serde_json;
 extern crate serde_ignored;
 extern crate ethjson;
 use std::collections::BTreeSet;
 use std::{fs, env, process};
 use ethjson::spec::Spec;
 fn quit(s: &str) -> ! {
 	println!("{}", s);
 	process::exit(1);
 }
 fn main() {
 	let mut args = env::args();
 	if args.len() != 2 {
 		quit("You need to specify chainspec.json\n\
 		\n\
 		./chainspec <chainspec.json>");
 	}
 	let path = args.nth(1).expect("args.len() == 2; qed");
 	let file = match fs::File::open(&path) {
 		Ok(file) => file,
 		Err(_) => quit(&format!("{} could not be opened", path)),
 	};
 	let mut unused = BTreeSet::new();
 	let mut deserializer = serde_json::Deserializer::from_reader(file);
 	let spec: Result<Spec, _> = serde_ignored::deserialize(&mut deserializer, |field| {
 		unused.insert(field.to_string());
 	});
 	if let Err(err) = spec {
 		quit(&format!("{} {}", path, err.to_string()));
 	}
 	if !unused.is_empty() {
 		let err = unused.into_iter()
 			.map(|field| format!("{} unexpected field `{}`", path, field))
 			.collect::<Vec<_>>()
 			.join("\n");
 		quit(&err);
 	}
 	println!("{} is valid", path);
 }
--- a/dapps/src/api/time.rs
+++ b/dapps/src/api/time.rs
@ -33,13 +33,14 @@
 use std::io;
 use std::{fmt, mem, time};
-
+use std::sync::Arc;
 use std::collections::VecDeque;
 use futures::{self, Future, BoxFuture};
 use futures_cpupool::CpuPool;
 use ntp;
 use time::{Duration, Timespec};
-use util::{Arc, RwLock};
+use util::RwLock;
 /// Time checker error.
 #[derive(Debug, Clone, PartialEq)]
@ -100,6 +101,10 @@ impl SimpleNtp {
 impl Ntp for SimpleNtp {
 	fn drift(&self) -> BoxFuture<Duration, Error> {
 		let address = self.address.clone();
 		if &*address == "none" {
 			return futures::future::err(Error::Ntp("NTP server is not provided.".into())).boxed();
 		}
 		self.pool.spawn_fn(move || {
 			let packet = ntp::request(&*address)?;
 			let dest_time = ::time::now_utc().to_timespec();
@ -114,7 +119,9 @@ impl Ntp for SimpleNtp {
 	}
 }
-const MAX_RESULTS: usize = 4;
+// NOTE In a positive scenario first results will be seen after:
 // MAX_RESULTS * UPDATE_TIMEOUT_OK_SECS seconds.
 const MAX_RESULTS: usize = 7;
 const UPDATE_TIMEOUT_OK_SECS: u64 = 30;
 const UPDATE_TIMEOUT_ERR_SECS: u64 = 2;
@ -225,7 +232,7 @@ mod tests {
 	fn time_checker() -> TimeChecker<FakeNtp> {
 		let last_result = Arc::new(RwLock::new(
-			(Instant::now(), vec![Err(Error::Ntp("NTP server unavailable.".into()))].into())
+			(Instant::now(), vec![Err(Error::Ntp("NTP server unavailable".into()))].into())
 		));
 		TimeChecker {
--- a/ethash/src/compute.rs
+++ b/ethash/src/compute.rs
@ -123,7 +123,9 @@ impl Light {
 		}
 		let num_nodes = cache_size / NODE_BYTES;
 		let mut nodes: Vec<Node> = Vec::with_capacity(num_nodes);
-		nodes.resize(num_nodes, unsafe { mem::uninitialized() });
+
 		unsafe { nodes.set_len(num_nodes) };
 		let buf = unsafe { slice::from_raw_parts_mut(nodes.as_mut_ptr() as *mut u8, cache_size) };
 		file.read_exact(buf)?;
 		Ok(Light {
@ -208,17 +210,20 @@ pub fn slow_get_seedhash(block_number: u64) -> H256 {
 	SeedHashCompute::resume_compute_seedhash([0u8; 32], 0, block_number / ETHASH_EPOCH_LENGTH)
 }
 #[inline]
 fn fnv_hash(x: u32, y: u32) -> u32 {
 	return x.wrapping_mul(FNV_PRIME) ^ y;
 }
 #[inline]
 fn sha3_512(input: &[u8], output: &mut [u8]) {
 	unsafe { sha3::sha3_512(output.as_mut_ptr(), output.len(), input.as_ptr(), input.len()) };
 }
-#[inline]
+fn sha3_512_inplace(input: &mut [u8]) {
 	// This is safe since `sha3_*` uses an internal buffer and copies the result to the output. This
 	// means that we can reuse the input buffer for both input and output.
 	unsafe { sha3::sha3_512(input.as_mut_ptr(), input.len(), input.as_ptr(), input.len()) };
 }
 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;
@ -228,7 +233,6 @@ fn get_cache_size(block_number: u64) -> usize {
 	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;
@ -238,7 +242,6 @@ fn get_data_size(block_number: u64) -> usize {
 	sz as usize
 }
 /// Difficulty quick check for POW preverification
 ///
 /// `header_hash`      The hash of the header
@ -246,17 +249,27 @@ fn get_data_size(block_number: u64) -> usize {
 /// `mix_hash`         The mix digest hash
 /// Boundary recovered from mix hash
 pub fn quick_get_difficulty(header_hash: &H256, nonce: u64, mix_hash: &H256) -> H256 {
-	let mut buf = [0u8; 64 + 32];
+	unsafe {
-	unsafe { ptr::copy_nonoverlapping(header_hash.as_ptr(), buf.as_mut_ptr(), 32) };
+		// This is safe - the `sha3_512` call below reads the first 40 bytes (which we explicitly set
-	unsafe { ptr::copy_nonoverlapping(mem::transmute(&nonce), buf[32..].as_mut_ptr(), 8) };
+		// with two `copy_nonoverlapping` calls) but writes the first 64, and then we explicitly write
 		// the next 32 bytes before we read the whole thing with `sha3_256`.
 		//
 		// This cannot be elided by the compiler as it doesn't know the implementation of
 		// `sha3_512`.
 		let mut buf: [u8; 64 + 32] = mem::uninitialized();
-	unsafe { sha3::sha3_512(buf.as_mut_ptr(), 64, buf.as_ptr(), 40) };
+		ptr::copy_nonoverlapping(header_hash.as_ptr(), buf.as_mut_ptr(), 32);
-	unsafe { ptr::copy_nonoverlapping(mix_hash.as_ptr(), buf[64..].as_mut_ptr(), 32) };
+		ptr::copy_nonoverlapping(mem::transmute(&nonce), buf[32..].as_mut_ptr(), 8);
-	let mut hash = [0u8; 32];
+		sha3::sha3_512(buf.as_mut_ptr(), 64, buf.as_ptr(), 40);
-	unsafe { sha3::sha3_256(hash.as_mut_ptr(), hash.len(), buf.as_ptr(), buf.len()) };
+		ptr::copy_nonoverlapping(mix_hash.as_ptr(), buf[64..].as_mut_ptr(), 32);
-	hash.as_mut_ptr();
+
-	hash
+		// This is initialized in `sha3_256`
 		let mut hash: [u8; 32] = mem::uninitialized();
 		sha3::sha3_256(hash.as_mut_ptr(), hash.len(), buf.as_ptr(), buf.len());
 		hash
 	}
 }
 /// Calculate the light client data
@ -269,118 +282,194 @@ pub fn light_compute(light: &Light, header_hash: &H256, nonce: u64) -> ProofOfWo
 }
 fn hash_compute(light: &Light, full_size: usize, header_hash: &H256, nonce: u64) -> ProofOfWork {
 	macro_rules! make_const_array {
 		($n:expr, $value:expr) => {{
 			// We use explicit lifetimes to ensure that val's borrow is invalidated until the
 			// transmuted val dies.
 			unsafe fn make_const_array<'a, T, U>(val: &'a mut [T]) -> &'a mut [U; $n] {
 				use ::std::mem;
 				debug_assert_eq!(val.len() * mem::size_of::<T>(), $n * mem::size_of::<U>());
 				mem::transmute(val.as_mut_ptr())
 			}
 			make_const_array($value)
 		}}
 	}
 	#[repr(C)]
 	struct MixBuf {
 		half_mix: Node,
 		compress_bytes: [u8; MIX_WORDS],
 	};
 	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()];
 	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) };
-	// compute sha3-512 hash and replicate across mix
+	// You may be asking yourself: what in the name of Crypto Jesus is going on here? So: we need
-	unsafe {
+	// `half_mix` and `compress_bytes` in a single array later down in the code (we hash them
-		sha3::sha3_512(s_mix.get_unchecked_mut(0).bytes.as_mut_ptr(), NODE_BYTES, s_mix.get_unchecked(0).bytes.as_ptr(), 40);
+	// together to create `value`) so that we can hash the full array. However, we do a bunch of
-		let (f_mix, mut mix) = s_mix.split_at_mut(1);
+	// reading and writing to these variables first. We originally allocated two arrays and then
-		for w in 0..MIX_WORDS {
+	// stuck them together with `ptr::copy_nonoverlapping` at the end, but this method is
-			*mix.get_unchecked_mut(0).as_words_mut().get_unchecked_mut(w) = *f_mix.get_unchecked(0).as_words().get_unchecked(w % NODE_WORDS);
+	// _significantly_ faster - by my benchmarks, a consistent 3-5%. This is the most ridiculous
-		}
+	// optimization I have ever done and I am so sorry. I can only chalk it up to cache locality
 	// improvements, since I can't imagine that 3-5% of our runtime is taken up by catting two
 	// arrays together.
 	let mut buf: MixBuf = MixBuf {
 		half_mix: unsafe {
 			// Pack `header_hash` and `nonce` together
 			// We explicitly write the first 40 bytes, leaving the last 24 as uninitialized. Then
 			// `sha3_512` reads the first 40 bytes (4th parameter) and overwrites the entire array,
 			// leaving it fully initialized.
 			let mut out: [u8; NODE_BYTES] = mem::uninitialized();
-		let page_size = 4 * MIX_WORDS;
+			ptr::copy_nonoverlapping(
-		let num_full_pages = (full_size / page_size) as u32;
+				header_hash.as_ptr(),
-		let cache: &[Node] = &light.cache;  // deref once for better performance
+				out.as_mut_ptr(),
 				header_hash.len(),
 			);
 			ptr::copy_nonoverlapping(
 				mem::transmute(&nonce),
 				out[header_hash.len()..].as_mut_ptr(),
 				mem::size_of::<u64>(),
 			);
-		debug_assert_eq!(ETHASH_ACCESSES, 64);
+			// compute sha3-512 hash and replicate across mix
-		debug_assert_eq!(MIX_NODES, 2);
+			sha3::sha3_512(
-		debug_assert_eq!(NODE_WORDS, 16);
+				out.as_mut_ptr(),
 				NODE_BYTES,
 				out.as_ptr(),
 				header_hash.len() + mem::size_of::<u64>()
 			);
 			Node { bytes: out }
 		},
 		// This is fully initialized before being read, see `let mut compress = ...` below
 		compress_bytes: unsafe { mem::uninitialized() },
 	};
 	let mut mix: [_; MIX_NODES] = [buf.half_mix.clone(), buf.half_mix.clone()];
 	let page_size = 4 * MIX_WORDS;
 	let num_full_pages = (full_size / page_size) as u32;
 	// deref once for better performance
 	let cache: &[Node] = &light.cache;
 	let first_val = buf.half_mix.as_words()[0];
 	debug_assert_eq!(MIX_NODES, 2);
 	debug_assert_eq!(NODE_WORDS, 16);
 	for i in 0..ETHASH_ACCESSES as u32 {
 		let index = {
 			// This is trivially safe, but does not work on big-endian. The safety of this is
 			// asserted in debug builds (see the definition of `make_const_array!`).
 			let mix_words: &mut [u32; MIX_WORDS] = unsafe {
 				make_const_array!(MIX_WORDS, &mut mix)
 			};
 			fnv_hash(
 				first_val ^ i,
 				mix_words[i as usize % MIX_WORDS]
 			) % num_full_pages
 		};
 		unroll! {
-			// ETHASH_ACCESSES
+			// MIX_NODES
-			for i_usize in 0..64 {
+			for n in 0..2 {
-				let i = i_usize as u32;
+				let tmp_node = calculate_dag_item(
-
+					index * MIX_NODES as u32 + n as u32,
-				let index = fnv_hash(
+					cache,
-					f_mix.get_unchecked(0).as_words().get_unchecked(0) ^ i,
+				);
 					*mix.get_unchecked(0).as_words().get_unchecked(i as usize % MIX_WORDS)
 				) % num_full_pages;
 				unroll! {
-					// MIX_NODES
+					// NODE_WORDS
-					for n in 0..2 {
+					for w in 0..16 {
-						let tmp_node = calculate_dag_item(
+						mix[n].as_words_mut()[w] =
-							index * MIX_NODES as u32 + n as u32,
+							fnv_hash(
-							cache,
+								mix[n].as_words()[w],
-						);
+								tmp_node.as_words()[w],
-
+							);
 						unroll! {
 							// NODE_WORDS
 							for w in 0..16 {
 								*mix.get_unchecked_mut(n).as_words_mut().get_unchecked_mut(w) =
 									fnv_hash(
 										*mix.get_unchecked(n).as_words().get_unchecked(w),
 										*tmp_node.as_words().get_unchecked(w),
 									);
 							}
 						}
 					}
 				}
 			}
 		}
 	}
 	let mix_words: [u32; MIX_WORDS] = unsafe { mem::transmute(mix) };
 	{
 		// This is an uninitialized buffer to begin with, but we iterate precisely `compress.len()`
 		// times and set each index, leaving the array fully initialized. THIS ONLY WORKS ON LITTLE-
 		// ENDIAN MACHINES. See a future PR to make this and the rest of the code work correctly on
 		// big-endian arches like mips.
 		let mut compress: &mut [u32; MIX_WORDS / 4] = unsafe {
 			make_const_array!(MIX_WORDS / 4, &mut buf.compress_bytes)
 		};
 		// Compress mix
 		debug_assert_eq!(MIX_WORDS / 4, 8);
 		// compress mix
 		unroll! {
 			for i in 0..8 {
 				let w = i * 4;
-				let mut reduction = *mix.get_unchecked(0).as_words().get_unchecked(w + 0);
+
-				reduction = reduction.wrapping_mul(FNV_PRIME) ^ *mix.get_unchecked(0).as_words().get_unchecked(w + 1);
+				let mut reduction = mix_words[w + 0];
-				reduction = reduction.wrapping_mul(FNV_PRIME) ^ *mix.get_unchecked(0).as_words().get_unchecked(w + 2);
+				reduction = reduction.wrapping_mul(FNV_PRIME) ^ mix_words[w + 1];
-				reduction = reduction.wrapping_mul(FNV_PRIME) ^ *mix.get_unchecked(0).as_words().get_unchecked(w + 3);
+				reduction = reduction.wrapping_mul(FNV_PRIME) ^ mix_words[w + 2];
-				*mix.get_unchecked_mut(0).as_words_mut().get_unchecked_mut(i) = reduction;
+				reduction = reduction.wrapping_mul(FNV_PRIME) ^ mix_words[w + 3];
 				compress[i] = reduction;
 			}
 		}
 	}
-		let mut mix_hash = [0u8; 32];
+	let mix_hash = buf.compress_bytes;
-		let mut buf = [0u8; 32 + 64];
+
-		ptr::copy_nonoverlapping(f_mix.get_unchecked_mut(0).bytes.as_ptr(), buf.as_mut_ptr(), 64);
+	let value: H256 = unsafe {
-		ptr::copy_nonoverlapping(mix.get_unchecked_mut(0).bytes.as_ptr(), buf[64..].as_mut_ptr(), 32);
+		// We can interpret the buffer as an array of `u8`s, since it's `repr(C)`.
-		ptr::copy_nonoverlapping(mix.get_unchecked_mut(0).bytes.as_ptr(), mix_hash.as_mut_ptr(), 32);
+		let read_ptr: *const u8 = mem::transmute(&buf);
-		let mut value: H256 = [0u8; 32];
+		// We overwrite the second half since `sha3_256` has an internal buffer and so allows
-		sha3::sha3_256(value.as_mut_ptr(), value.len(), buf.as_ptr(), buf.len());
+		// overlapping arrays as input.
-		ProofOfWork {
+		let write_ptr: *mut u8 = mem::transmute(&mut buf.compress_bytes);
-			mix_hash: mix_hash,
+		sha3::sha3_256(
-			value: value,
+			write_ptr,
-		}
+			buf.compress_bytes.len(),
 			read_ptr,
 			buf.half_mix.bytes.len() + buf.compress_bytes.len(),
 		);
 		buf.compress_bytes
 	};
 	ProofOfWork {
 		mix_hash: mix_hash,
 		value: value,
 	}
 }
 fn calculate_dag_item(node_index: u32, cache: &[Node]) -> Node {
-	unsafe {
+	let num_parent_nodes = cache.len();
-		let num_parent_nodes = cache.len();
+	let mut ret = cache[node_index as usize % num_parent_nodes].clone();
-		let init = cache.get_unchecked(node_index as usize % num_parent_nodes);
+	ret.as_words_mut()[0] ^= node_index;
 		let mut ret = init.clone();
 		*ret.as_words_mut().get_unchecked_mut(0) ^= node_index;
 		sha3::sha3_512(ret.bytes.as_mut_ptr(), ret.bytes.len(), ret.bytes.as_ptr(), ret.bytes.len());
-		debug_assert_eq!(NODE_WORDS, 16);
+	sha3_512_inplace(&mut ret.bytes);
 		for i in 0..ETHASH_DATASET_PARENTS as u32 {
 			let parent_index = fnv_hash(node_index ^ i, *ret.as_words().get_unchecked(i as usize % NODE_WORDS)) % num_parent_nodes as u32;
 			let parent = cache.get_unchecked(parent_index as usize);
-			unroll! {
+	debug_assert_eq!(NODE_WORDS, 16);
-				for w in 0..16 {
+	for i in 0..ETHASH_DATASET_PARENTS as u32 {
-					*ret.as_words_mut().get_unchecked_mut(w) =
+		let parent_index = fnv_hash(
-						fnv_hash(
+			node_index ^ i,
-							*ret.as_words().get_unchecked(w),
+			ret.as_words()[i as usize % NODE_WORDS],
-							*parent.as_words().get_unchecked(w)
+		) % num_parent_nodes as u32;
-						);
+		let parent = &cache[parent_index as usize];
-				}
+
 		unroll! {
 			for w in 0..16 {
 				ret.as_words_mut()[w] = fnv_hash(ret.as_words()[w], parent.as_words()[w]);
 			}
 		}
 		sha3::sha3_512(ret.bytes.as_mut_ptr(), ret.bytes.len(), ret.bytes.as_ptr(), ret.bytes.len());
 		ret
 	}
 	sha3_512_inplace(&mut ret.bytes);
 	ret
 }
 fn light_new<T: AsRef<Path>>(cache_dir: T, block_number: u64) -> Light {
@ -391,9 +480,11 @@ fn light_new<T: AsRef<Path>>(cache_dir: T, block_number: u64) -> Light {
 	assert!(cache_size % NODE_BYTES == 0, "Unaligned cache size");
 	let num_nodes = cache_size / NODE_BYTES;
-	let mut nodes = Vec::with_capacity(num_nodes);
+	let mut nodes: Vec<Node> = Vec::with_capacity(num_nodes);
 	nodes.resize(num_nodes, Node::default());
 	unsafe {
 		// Use uninit instead of unnecessarily writing `size_of::<Node>() * num_nodes` 0s
 		nodes.set_len(num_nodes);
 		sha3_512(&seedhash[0..32], &mut nodes.get_unchecked_mut(0).bytes);
 		for i in 1..num_nodes {
 			sha3::sha3_512(nodes.get_unchecked_mut(i).bytes.as_mut_ptr(), NODE_BYTES, nodes.get_unchecked(i - 1).bytes.as_ptr(), NODE_BYTES);
--- a/ethash/src/lib.rs
+++ b/ethash/src/lib.rs
@ -143,9 +143,11 @@ mod benchmarks {
 	#[bench]
 	fn bench_light_compute(b: &mut Bencher) {
 		use ::std::env;
 		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 nonce = 0xd7b3ac70a301a249;
-		let light = Light::new(486382);
+		let light = Light::new(env::temp_dir(), 486382);
 		b.iter(|| light_compute(&light, &hash, nonce));
 	}
--- a/ethcore/Cargo.toml
+++ b/ethcore/Cargo.toml
@ -53,6 +53,11 @@ semver = "0.6"
 stats = { path = "../util/stats" }
 time = "0.1"
 transient-hashmap = "0.4"
 using_queue = { path = "../util/using_queue" }
 table = { path = "../util/table" }
 bloomable = { path = "../util/bloomable" }
 vm = { path = "vm" }
 wasm = { path = "wasm" }
 [dev-dependencies]
 native-contracts = { path = "native_contracts", features = ["test_contracts"] }
--- a/ethcore/evm/Cargo.toml
+++ b/ethcore/evm/Cargo.toml
@ -13,7 +13,9 @@ ethjson = { path = "../../json" }
 lazy_static = "0.2"
 log = "0.3"
 rlp = { path = "../../util/rlp" }
 vm = { path = "../vm" }
 parity-wasm = "0.12"
 ethcore-logger = { path = "../../logger" }
 wasm-utils = { git = "https://github.com/paritytech/wasm-utils" }
 [dev-dependencies]
--- a/ethcore/evm/src/benches/mod.rs
+++ b/ethcore/evm/src/benches/mod.rs
@ -25,7 +25,7 @@ extern crate test;
 use self::test::{Bencher, black_box};
 use util::*;
-use evm::action_params::ActionParams;
+use vm::ActionParams;
 use evm::{self, Factory, VMType};
 use evm::tests::FakeExt;
--- a/ethcore/evm/src/evm.rs
+++ b/ethcore/evm/src/evm.rs
@ -17,142 +17,8 @@
 //! Evm interface.
 use std::{ops, cmp, fmt};
-use util::{U128, U256, U512, trie};
+use util::{U128, U256, U512};
-use action_params::ActionParams;
+use vm::{Ext, Result, ReturnData, GasLeft, Error};
 use {Ext};
 use super::wasm;
 /// Evm errors.
 #[derive(Debug, Clone, PartialEq)]
 pub enum Error {
 	/// `OutOfGas` is returned when transaction execution runs out of gas.
 	/// The state should be reverted to the state from before the
 	/// transaction execution. But it does not mean that transaction
 	/// was invalid. Balance still should be transfered and nonce
 	/// should be increased.
 	OutOfGas,
 	/// `BadJumpDestination` is returned when execution tried to move
 	/// to position that wasn't marked with JUMPDEST instruction
 	BadJumpDestination {
 		/// Position the code tried to jump to.
 		destination: usize
 	},
 	/// `BadInstructions` is returned when given instruction is not supported
 	BadInstruction {
 		/// Unrecognized opcode
 		instruction: u8,
 	},
 	/// `StackUnderflow` when there is not enough stack elements to execute instruction
 	StackUnderflow {
 		/// Invoked instruction
 		instruction: &'static str,
 		/// How many stack elements was requested by instruction
 		wanted: usize,
 		/// How many elements were on stack
 		on_stack: usize
 	},
 	/// When execution would exceed defined Stack Limit
 	OutOfStack {
 		/// Invoked instruction
 		instruction: &'static str,
 		/// How many stack elements instruction wanted to push
 		wanted: usize,
 		/// What was the stack limit
 		limit: usize
 	},
 	/// Built-in contract failed on given input
 	BuiltIn(&'static str),
 	/// When execution tries to modify the state in static context
 	MutableCallInStaticContext,
 	/// Likely to cause consensus issues.
 	Internal(String),
 	/// Wasm runtime error
 	Wasm(String),
 }
 impl From<Box<trie::TrieError>> for Error {
 	fn from(err: Box<trie::TrieError>) -> Self {
 		Error::Internal(format!("Internal error: {}", err))
 	}
 }
 impl From<wasm::RuntimeError> for Error {
 	fn from(err: wasm::RuntimeError) -> Self {
 		Error::Wasm(format!("Runtime error: {:?}", err))
 	}
 }
 impl fmt::Display for Error {
 	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 		use self::Error::*;
 		match *self {
 			OutOfGas => write!(f, "Out of gas"),
 			BadJumpDestination { destination } => write!(f, "Bad jump destination {:x}", destination),
 			BadInstruction { instruction } => write!(f, "Bad instruction {:x}",  instruction),
 			StackUnderflow { instruction, wanted, on_stack } => write!(f, "Stack underflow {} {}/{}", instruction, wanted, on_stack),
 			OutOfStack { instruction, wanted, limit } => write!(f, "Out of stack {} {}/{}", instruction, wanted, limit),
 			BuiltIn(name) => write!(f, "Built-in failed: {}", name),
 			Internal(ref msg) => write!(f, "Internal error: {}", msg),
 			MutableCallInStaticContext => write!(f, "Mutable call in static context"),
 			Wasm(ref msg) => write!(f, "Internal error: {}", msg),
 		}
 	}
 }
 /// A specialized version of Result over EVM errors.
 pub type Result<T> = ::std::result::Result<T, Error>;
 /// Return data buffer. Holds memory from a previous call and a slice into that memory.
 #[derive(Debug)]
 pub struct ReturnData {
 	mem: Vec<u8>,
 	offset: usize,
 	size: usize,
 }
 impl ::std::ops::Deref for ReturnData {
 	type Target = [u8];
 	fn deref(&self) -> &[u8] {
 		&self.mem[self.offset..self.offset + self.size]
 	}
 }
 impl ReturnData {
 	/// Create empty `ReturnData`.
 	pub fn empty() -> Self {
 		ReturnData {
 			mem: Vec::new(),
 			offset: 0,
 			size: 0,
 		}
 	}
 	/// Create `ReturnData` from give buffer and slice.
 	pub fn new(mem: Vec<u8>, offset: usize, size: usize) -> Self {
 		ReturnData {
 			mem: mem,
 			offset: offset,
 			size: size,
 		}
 	}
 }
 /// Gas Left: either it is a known value, or it needs to be computed by processing
 /// a return instruction.
 #[derive(Debug)]
 pub enum GasLeft {
 	/// Known gas left
 	Known(U256),
 	/// Return or Revert instruction must be processed.
 	NeedsReturn {
 		/// Amount of gas left.
 		gas_left: U256,
 		/// Return data buffer.
 		data: ReturnData,
 		/// Apply or revert state changes on revert.
 		apply_state: bool
 	},
 }
 /// Finalization result. Gas Left: either it is a known value, or it needs to be computed by processing
 /// a return instruction.
@ -281,15 +147,6 @@ impl CostType for usize {
 	}
 }
 /// Evm interface
 pub trait Evm {
 	/// This function should be used to execute transaction.
 	///
 	/// It returns either an error, a known amount of gas left, or parameters to be used
 	/// to compute the final gas left.
 	fn exec(&mut self, params: ActionParams, ext: &mut Ext) -> Result<GasLeft>;
 }
 #[cfg(test)]
 mod tests {
 	use util::U256;
--- a/ethcore/evm/src/factory.rs
+++ b/ethcore/evm/src/factory.rs
@ -17,7 +17,7 @@
 //! Evm factory.
 //!
 use std::sync::Arc;
-use evm::Evm;
+use vm::Vm;
 use util::U256;
 use super::interpreter::SharedCache;
 use super::vmtype::VMType;
@ -33,7 +33,7 @@ impl Factory {
 	/// Create fresh instance of VM
 	/// Might choose implementation depending on supplied gas.
 	#[cfg(feature = "jit")]
-	pub fn create(&self, gas: U256) -> Box<Evm> {
+	pub fn create(&self, gas: U256) -> Box<Vm> {
 		match self.evm {
 			VMType::Jit => {
 				Box::new(super::jit::JitEvm::default())
@ -49,7 +49,7 @@ impl Factory {
 	/// Create fresh instance of VM
 	/// Might choose implementation depending on supplied gas.
 	#[cfg(not(feature = "jit"))]
-	pub fn create(&self, gas: U256) -> Box<Evm> {
+	pub fn create(&self, gas: U256) -> Box<Vm> {
 		match self.evm {
 			VMType::Interpreter => if Self::can_fit_in_usize(gas) {
 				Box::new(super::interpreter::Interpreter::<usize>::new(self.evm_cache.clone()))
--- a/ethcore/evm/src/interpreter/gasometer.rs
+++ b/ethcore/evm/src/interpreter/gasometer.rs
@ -14,18 +14,19 @@
 // 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::cmp;
 use util::*;
 use super::u256_to_address;
-use {evm, ext};
+use {evm, vm};
 use instructions::{self, Instruction, InstructionInfo};
 use interpreter::stack::Stack;
-use schedule::Schedule;
+use vm::Schedule;
 macro_rules! overflowing {
 	($x: expr) => {{
 		let (v, overflow) = $x;
-		if overflow { return Err(evm::Error::OutOfGas); }
+		if overflow { return Err(vm::Error::OutOfGas); }
 		v
 	}}
 }
@ -59,16 +60,16 @@ impl<Gas: evm::CostType> Gasometer<Gas> {
 		}
 	}
-	pub fn verify_gas(&self, gas_cost: &Gas) -> evm::Result<()> {
+	pub fn verify_gas(&self, gas_cost: &Gas) -> vm::Result<()> {
 		match &self.current_gas < gas_cost {
-			true => Err(evm::Error::OutOfGas),
+			true => Err(vm::Error::OutOfGas),
 			false => Ok(())
 		}
 	}
 	/// How much gas is provided to a CALL/CREATE, given that we need to deduct `needed` for this operation
 	/// and that we `requested` some.
-	pub fn gas_provided(&self, schedule: &Schedule, needed: Gas, requested: Option<U256>) -> evm::Result<Gas> {
+	pub fn gas_provided(&self, schedule: &Schedule, needed: Gas, requested: Option<U256>) -> vm::Result<Gas> {
 		// Try converting requested gas to `Gas` (`U256/u64`)
 		// but in EIP150 even if we request more we should never fail from OOG
 		let requested = requested.map(Gas::from_u256);
@ -82,7 +83,7 @@ impl<Gas: evm::CostType> Gasometer<Gas> {
 				};
 				if let Some(Ok(r)) = requested {
-					Ok(min(r, max_gas_provided))
+					Ok(cmp::min(r, max_gas_provided))
 				} else {
 					Ok(max_gas_provided)
 				}
@ -107,12 +108,12 @@ impl<Gas: evm::CostType> Gasometer<Gas> {
 	/// it will be the amount of gas that the current context provides to the child context.
 	pub fn requirements(
 		&mut self,
-		ext: &ext::Ext,
+		ext: &vm::Ext,
 		instruction: Instruction,
 		info: &InstructionInfo,
 		stack: &Stack<U256>,
 		current_mem_size: usize,
-	) -> evm::Result<InstructionRequirements<Gas>> {
+	) -> vm::Result<InstructionRequirements<Gas>> {
 		let schedule = ext.schedule();
 		let tier = instructions::get_tier_idx(info.tier);
 		let default_gas = Gas::from(schedule.tier_step_gas[tier]);
@ -291,7 +292,7 @@ impl<Gas: evm::CostType> Gasometer<Gas> {
 		})
 	}
-	fn mem_gas_cost(&self, schedule: &Schedule, current_mem_size: usize, mem_size: &Gas) -> evm::Result<(Gas, Gas, usize)> {
+	fn mem_gas_cost(&self, schedule: &Schedule, current_mem_size: usize, mem_size: &Gas) -> vm::Result<(Gas, Gas, usize)> {
 		let gas_for_mem = |mem_size: Gas| {
 			let s = mem_size >> 5;
 			// s * memory_gas + s * s / quad_coeff_div
@ -319,12 +320,12 @@ impl<Gas: evm::CostType> Gasometer<Gas> {
 #[inline]
-fn mem_needed_const<Gas: evm::CostType>(mem: &U256, add: usize) -> evm::Result<Gas> {
+fn mem_needed_const<Gas: evm::CostType>(mem: &U256, add: usize) -> vm::Result<Gas> {
 	Gas::from_u256(overflowing!(mem.overflowing_add(U256::from(add))))
 }
 #[inline]
-fn mem_needed<Gas: evm::CostType>(offset: &U256, size: &U256) -> evm::Result<Gas> {
+fn mem_needed<Gas: evm::CostType>(offset: &U256, size: &U256) -> vm::Result<Gas> {
 	if size.is_zero() {
 		return Ok(Gas::from(0));
 	}
--- a/ethcore/evm/src/interpreter/memory.rs
+++ b/ethcore/evm/src/interpreter/memory.rs
@ -15,7 +15,7 @@
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 use util::U256;
-use {ReturnData};
+use vm::ReturnData;
 const MAX_RETURN_WASTE_BYTES: usize = 16384;
--- a/ethcore/evm/src/interpreter/mod.rs
+++ b/ethcore/evm/src/interpreter/mod.rs
@ -23,17 +23,23 @@ mod stack;
 mod memory;
 mod shared_cache;
 use std::marker::PhantomData;
 use std::{cmp, mem};
 use std::sync::Arc;
 use vm::{
 	self, ActionParams, ActionValue, CallType, MessageCallResult,
 	ContractCreateResult, CreateContractAddress, ReturnData, GasLeft
 };
 use evm::CostType;
 use instructions::{self, Instruction, InstructionInfo};
 use self::gasometer::Gasometer;
 use self::stack::{Stack, VecStack};
 use self::memory::Memory;
 pub use self::shared_cache::SharedCache;
 use std::marker::PhantomData;
 use action_params::{ActionParams, ActionValue};
 use call_type::CallType;
 use instructions::{self, Instruction, InstructionInfo};
 use evm::{self, GasLeft, CostType, ReturnData};
 use ext::{self, MessageCallResult, ContractCreateResult, CreateContractAddress};
 use bit_set::BitSet;
 use util::*;
@ -107,8 +113,8 @@ pub struct Interpreter<Cost: CostType> {
 	_type: PhantomData<Cost>,
 }
-impl<Cost: CostType> evm::Evm for Interpreter<Cost> {
+impl<Cost: CostType> vm::Vm for Interpreter<Cost> {
-	fn exec(&mut self, params: ActionParams, ext: &mut ext::Ext) -> evm::Result<GasLeft> {
+	fn exec(&mut self, params: ActionParams, ext: &mut vm::Ext) -> vm::Result<GasLeft> {
 		self.mem.clear();
 		let mut informant = informant::EvmInformant::new(ext.depth());
@ -205,7 +211,7 @@ impl<Cost: CostType> Interpreter<Cost> {
 		}
 	}
-	fn verify_instruction(&self, ext: &ext::Ext, instruction: Instruction, info: &InstructionInfo, stack: &Stack<U256>) -> evm::Result<()> {
+	fn verify_instruction(&self, ext: &vm::Ext, instruction: Instruction, info: &InstructionInfo, stack: &Stack<U256>) -> vm::Result<()> {
 		let schedule = ext.schedule();
 		if (instruction == instructions::DELEGATECALL && !schedule.have_delegate_call) ||
@ -214,25 +220,25 @@ impl<Cost: CostType> Interpreter<Cost> {
 			((instruction == instructions::RETURNDATACOPY || instruction == instructions::RETURNDATASIZE) && !schedule.have_return_data) ||
 			(instruction == instructions::REVERT && !schedule.have_revert) {
-			return Err(evm::Error::BadInstruction {
+			return Err(vm::Error::BadInstruction {
 				instruction: instruction
 			});
 		}
 		if info.tier == instructions::GasPriceTier::Invalid {
-			return Err(evm::Error::BadInstruction {
+			return Err(vm::Error::BadInstruction {
 				instruction: instruction
 			});
 		}
 		if !stack.has(info.args) {
-			Err(evm::Error::StackUnderflow {
+			Err(vm::Error::StackUnderflow {
 				instruction: info.name,
 				wanted: info.args,
 				on_stack: stack.size()
 			})
 		} else if stack.size() - info.args + info.ret > schedule.stack_limit {
-			Err(evm::Error::OutOfStack {
+			Err(vm::Error::OutOfStack {
 				instruction: info.name,
 				wanted: info.ret - info.args,
 				limit: schedule.stack_limit
@ -272,12 +278,12 @@ impl<Cost: CostType> Interpreter<Cost> {
 		&mut self,
 		gas: Cost,
 		params: &ActionParams,
-		ext: &mut ext::Ext,
+		ext: &mut vm::Ext,
 		instruction: Instruction,
 		code: &mut CodeReader,
 		stack: &mut Stack<U256>,
 		provided: Option<Cost>
-	) -> evm::Result<InstructionResult<Cost>> {
+	) -> vm::Result<InstructionResult<Cost>> {
 		match instruction {
 			instructions::JUMP => {
 				let jump = stack.pop_back();
@ -593,13 +599,13 @@ impl<Cost: CostType> Interpreter<Cost> {
 		}
 	}
-	fn verify_jump(&self, jump_u: U256, valid_jump_destinations: &BitSet) -> evm::Result<usize> {
+	fn verify_jump(&self, jump_u: U256, valid_jump_destinations: &BitSet) -> vm::Result<usize> {
 		let jump = jump_u.low_u64() as usize;
 		if valid_jump_destinations.contains(jump) && U256::from(jump) == jump_u {
 			Ok(jump)
 		} else {
-			Err(evm::Error::BadJumpDestination {
+			Err(vm::Error::BadJumpDestination {
 				destination: jump
 			})
 		}
@ -617,7 +623,7 @@ impl<Cost: CostType> Interpreter<Cost> {
 		}
 	}
-	fn exec_stack_instruction(&self, instruction: Instruction, stack: &mut Stack<U256>) -> evm::Result<()> {
+	fn exec_stack_instruction(&self, instruction: Instruction, stack: &mut Stack<U256>) -> vm::Result<()> {
 		match instruction {
 			instructions::DUP1...instructions::DUP16 => {
 				let position = instructions::get_dup_position(instruction);
@ -822,7 +828,7 @@ impl<Cost: CostType> Interpreter<Cost> {
 				}
 			},
 			_ => {
-				return Err(evm::Error::BadInstruction {
+				return Err(vm::Error::BadInstruction {
 					instruction: instruction
 				});
 			}
--- a/ethcore/evm/src/jit.rs
+++ b/ethcore/evm/src/jit.rs
@ -19,6 +19,7 @@ use util::*;
 use evmjit;
 use evm::{self, GasLeft};
 use evm::CallType;
 use vm::{self, Vm};
 /// Should be used to convert jit types to ethcore
 trait FromJit<T>: Sized {
@ -318,7 +319,7 @@ pub struct JitEvm {
 	context: Option<evmjit::ContextHandle>,
 }
-impl evm::Evm for JitEvm {
+impl vm::Vm for JitEvm {
 	fn exec(&mut self, params: ActionParams, ext: &mut evm::Ext) -> evm::Result<GasLeft> {
 		// Dirty hack. This is unsafe, but we interact with ffi, so it's justified.
 		let ext_adapter: ExtAdapter<'static> = unsafe { ::std::mem::transmute(ExtAdapter::new(ext, params.address.clone())) };
@ -370,8 +371,8 @@ impl evm::Evm for JitEvm {
 				ext.suicide(&Address::from_jit(&context.suicide_refund_address()));
 				Ok(GasLeft::Known(U256::from(context.gas_left())))
 			},
-			evmjit::ReturnCode::OutOfGas => Err(evm::Error::OutOfGas),
+			evmjit::ReturnCode::OutOfGas => Err(vm::Error::OutOfGas),
-			_err => Err(evm::Error::Internal)
+			_err => Err(vm::Error::Internal)
 		}
 	}
 }
--- a/ethcore/evm/src/lib.rs
+++ b/ethcore/evm/src/lib.rs
@ -24,11 +24,12 @@ extern crate ethjson;
 extern crate rlp;
 extern crate parity_wasm;
 extern crate wasm_utils;
 extern crate ethcore_logger;
 extern crate vm;
 #[macro_use]
 extern crate lazy_static;
 #[macro_use]
 extern crate log;
 #[cfg(feature = "jit")]
@ -37,14 +38,8 @@ extern crate evmjit;
 #[cfg(test)]
 extern crate rustc_hex;
 pub mod action_params;
 pub mod call_type;
 pub mod env_info;
 pub mod ext;
 pub mod evm;
 pub mod interpreter;
 pub mod schedule;
 pub mod wasm;
 #[macro_use]
 pub mod factory;
@ -59,12 +54,12 @@ mod tests;
 #[cfg(all(feature="benches", test))]
 mod benches;
-pub use self::action_params::ActionParams;
+pub use vm::{
-pub use self::call_type::CallType;
+    Schedule, CleanDustMode, EnvInfo, CallType, ActionParams, Ext,
-pub use self::env_info::EnvInfo;
+    ContractCreateResult, MessageCallResult, CreateContractAddress,
-pub use self::evm::{Evm, Error, Finalize, FinalizationResult, GasLeft, Result, CostType, ReturnData};
+    GasLeft, ReturnData
-pub use self::ext::{Ext, ContractCreateResult, MessageCallResult, CreateContractAddress};
+};
 pub use self::evm::{Finalize, FinalizationResult, CostType};
 pub use self::instructions::{InstructionInfo, INSTRUCTIONS, push_bytes};
 pub use self::vmtype::VMType;
 pub use self::factory::Factory;
 pub use self::schedule::{Schedule, CleanDustMode};
--- a/ethcore/evm/src/tests.rs
+++ b/ethcore/evm/src/tests.rs
@ -15,212 +15,17 @@
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 use std::fmt::Debug;
 use std::str::FromStr;
 use std::hash::Hash;
 use std::sync::Arc;
 use std::collections::{HashMap, HashSet};
 use rustc_hex::FromHex;
 use util::*;
-use action_params::{ActionParams, ActionValue};
+use vm::{self, ActionParams, ActionValue};
-use env_info::EnvInfo;
+use vm::tests::{FakeExt, FakeCall, FakeCallType, test_finalize};
 use call_type::CallType;
 use schedule::Schedule;
 use evm::{self, GasLeft, ReturnData};
 use ext::{Ext, ContractCreateResult, MessageCallResult, CreateContractAddress};
 use factory::Factory;
 use vmtype::VMType;
 pub struct FakeLogEntry {
 	topics: Vec<H256>,
 	data: Bytes
 }
 #[derive(PartialEq, Eq, Hash, Debug)]
 pub enum FakeCallType {
 	Call, Create
 }
 #[derive(PartialEq, Eq, Hash, Debug)]
 pub struct FakeCall {
 	pub call_type: FakeCallType,
 	pub gas: U256,
 	pub sender_address: Option<Address>,
 	pub receive_address: Option<Address>,
 	pub value: Option<U256>,
 	pub data: Bytes,
 	pub code_address: Option<Address>,
 }
 /// Fake externalities test structure.
 ///
 /// Can't do recursive calls.
 #[derive(Default)]
 pub struct FakeExt {
 	pub store: HashMap<H256, H256>,
 	pub suicides: HashSet<Address>,
 	pub calls: HashSet<FakeCall>,
 	sstore_clears: usize,
 	depth: usize,
 	blockhashes: HashMap<U256, H256>,
 	codes: HashMap<Address, Arc<Bytes>>,
 	logs: Vec<FakeLogEntry>,
 	info: EnvInfo,
 	schedule: Schedule,
 	balances: HashMap<Address, U256>,
 }
 // similar to the normal `finalize` function, but ignoring NeedsReturn.
 fn test_finalize(res: Result<GasLeft, evm::Error>) -> Result<U256, evm::Error> {
 	match res {
 		Ok(GasLeft::Known(gas)) => Ok(gas),
 		Ok(GasLeft::NeedsReturn{..}) => unimplemented!(), // since ret is unimplemented.
 		Err(e) => Err(e),
 	}
 }
 impl FakeExt {
 	pub fn new() -> Self {
 		FakeExt::default()
 	}
 }
 impl Default for Schedule {
 	fn default() -> Self {
 		Schedule::new_frontier()
 	}
 }
 impl Ext for FakeExt {
 	fn storage_at(&self, key: &H256) -> evm::Result<H256> {
 		Ok(self.store.get(key).unwrap_or(&H256::new()).clone())
 	}
 	fn set_storage(&mut self, key: H256, value: H256) -> evm::Result<()> {
 		self.store.insert(key, value);
 		Ok(())
 	}
 	fn exists(&self, address: &Address) -> evm::Result<bool> {
 		Ok(self.balances.contains_key(address))
 	}
 	fn exists_and_not_null(&self, address: &Address) -> evm::Result<bool> {
 		Ok(self.balances.get(address).map_or(false, |b| !b.is_zero()))
 	}
 	fn origin_balance(&self) -> evm::Result<U256> {
 		unimplemented!()
 	}
 	fn balance(&self, address: &Address) -> evm::Result<U256> {
 		Ok(self.balances[address])
 	}
 	fn blockhash(&mut self, number: &U256) -> H256 {
 		self.blockhashes.get(number).unwrap_or(&H256::new()).clone()
 	}
 	fn create(&mut self, gas: &U256, value: &U256, code: &[u8], _address: CreateContractAddress) -> ContractCreateResult {
 		self.calls.insert(FakeCall {
 			call_type: FakeCallType::Create,
 			gas: *gas,
 			sender_address: None,
 			receive_address: None,
 			value: Some(*value),
 			data: code.to_vec(),
 			code_address: None
 		});
 		ContractCreateResult::Failed
 	}
 	fn call(&mut self,
 			gas: &U256,
 			sender_address: &Address,
 			receive_address: &Address,
 			value: Option<U256>,
 			data: &[u8],
 			code_address: &Address,
 			_output: &mut [u8],
 			_call_type: CallType
 		) -> MessageCallResult {
 		self.calls.insert(FakeCall {
 			call_type: FakeCallType::Call,
 			gas: *gas,
 			sender_address: Some(sender_address.clone()),
 			receive_address: Some(receive_address.clone()),
 			value: value,
 			data: data.to_vec(),
 			code_address: Some(code_address.clone())
 		});
 		MessageCallResult::Success(*gas, ReturnData::empty())
 	}
 	fn extcode(&self, address: &Address) -> evm::Result<Arc<Bytes>> {
 		Ok(self.codes.get(address).unwrap_or(&Arc::new(Bytes::new())).clone())
 	}
 	fn extcodesize(&self, address: &Address) -> evm::Result<usize> {
 		Ok(self.codes.get(address).map_or(0, |c| c.len()))
 	}
 	fn log(&mut self, topics: Vec<H256>, data: &[u8]) -> evm::Result<()> {
 		self.logs.push(FakeLogEntry {
 			topics: topics,
 			data: data.to_vec()
 		});
 		Ok(())
 	}
 	fn ret(self, _gas: &U256, _data: &ReturnData) -> evm::Result<U256> {
 		unimplemented!();
 	}
 	fn suicide(&mut self, refund_address: &Address) -> evm::Result<()> {
 		self.suicides.insert(refund_address.clone());
 		Ok(())
 	}
 	fn schedule(&self) -> &Schedule {
 		&self.schedule
 	}
 	fn env_info(&self) -> &EnvInfo {
 		&self.info
 	}
 	fn depth(&self) -> usize {
 		self.depth
 	}
 	fn inc_sstore_clears(&mut self) {
 		self.sstore_clears += 1;
 	}
 }
 #[test]
 fn test_stack_underflow() {
 	let address = Address::from_str("0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6").unwrap();
 	let code = "01600055".from_hex().unwrap();
 	let mut params = ActionParams::default();
 	params.address = address.clone();
 	params.gas = U256::from(100_000);
 	params.code = Some(Arc::new(code));
 	let mut ext = FakeExt::new();
 	let err = {
 		let mut vm : Box<evm::Evm> = Box::new(super::interpreter::Interpreter::<usize>::new(Arc::new(super::interpreter::SharedCache::default())));
 		test_finalize(vm.exec(params, &mut ext)).unwrap_err()
 	};
 	match err {
 		evm::Error::StackUnderflow {wanted, on_stack, ..} => {
 			assert_eq!(wanted, 2);
 			assert_eq!(on_stack, 0);
 		}
 		_ => {
 			assert!(false, "Expected StackUndeflow")
 		}
 	};
 }
 evm_test!{test_add: test_add_jit, test_add_int}
 fn test_add(factory: super::Factory) {
  let address = Address::from_str("0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6").unwrap();
@ -849,7 +654,7 @@ fn test_badinstruction_int() {
 	};
 	match err {
-		evm::Error::BadInstruction { instruction: 0xaf } => (),
+		vm::Error::BadInstruction { instruction: 0xaf } => (),
 		_ => assert!(false, "Expected bad instruction")
 	}
 }
--- a/ethcore/light/Cargo.toml
+++ b/ethcore/light/Cargo.toml
@ -19,6 +19,7 @@ ethcore-io = { path = "../../util/io" }
 ethcore-ipc = { path = "../../ipc/rpc", optional = true }
 ethcore-devtools = { path = "../../devtools" }
 evm = { path = "../evm" }
 vm = { path = "../vm" }
 rlp = { path = "../../util/rlp" }
 time = "0.1"
 smallvec = "0.4"
--- a/ethcore/light/src/client/header_chain.rs
+++ b/ethcore/light/src/client/header_chain.rs
@ -405,6 +405,7 @@ impl HeaderChain {
 		match id {
 			BlockId::Earliest | BlockId::Number(0) => Some(self.genesis_header.clone()),
 			BlockId::Hash(hash) if hash == self.genesis_hash() => { Some(self.genesis_header.clone()) }
 			BlockId::Hash(hash) => load_from_db(hash),
 			BlockId::Number(num) => {
 				if self.best_block.read().number < num { return None }
@ -781,4 +782,18 @@ mod tests {
 		assert_eq!(chain.block_header(BlockId::Latest).unwrap().number(), 10);
 		assert!(chain.candidates.read().get(&100).is_some())
 	}
 	#[test]
 	fn genesis_header_available() {
 		let spec = Spec::new_test();
 		let genesis_header = spec.genesis_header();
 		let db = make_db();
 		let cache = Arc::new(Mutex::new(Cache::new(Default::default(), Duration::hours(6))));
 		let chain = HeaderChain::new(db.clone(), None, &::rlp::encode(&genesis_header), cache.clone()).unwrap();
 		assert!(chain.block_header(BlockId::Earliest).is_some());
 		assert!(chain.block_header(BlockId::Number(0)).is_some());
 		assert!(chain.block_header(BlockId::Hash(genesis_header.hash())).is_some());
 	}
 }
--- a/ethcore/light/src/client/mod.rs
+++ b/ethcore/light/src/client/mod.rs
@ -58,6 +58,8 @@ pub struct Config {
 	pub db_wal: bool,
 	/// Should it do full verification of blocks?
 	pub verify_full: bool,
 	/// Should it check the seal of blocks?
 	pub check_seal: bool,
 }
 impl Default for Config {
@ -69,6 +71,7 @@ impl Default for Config {
 			db_compaction: CompactionProfile::default(),
 			db_wal: true,
 			verify_full: true,
 			check_seal: true,
 		}
 	}
 }
@ -168,7 +171,7 @@ impl Client {
 		let gh = ::rlp::encode(&spec.genesis_header());
 		Ok(Client {
-			queue: HeaderQueue::new(config.queue, spec.engine.clone(), io_channel, true),
+			queue: HeaderQueue::new(config.queue, spec.engine.clone(), io_channel, config.check_seal),
 			engine: spec.engine.clone(),
 			chain: HeaderChain::new(db.clone(), chain_col, &gh, cache)?,
 			report: RwLock::new(ClientReport::default()),
@ -282,6 +285,7 @@ impl Client {
 		let mut good = Vec::new();
 		for verified_header in self.queue.drain(MAX) {
 			let (num, hash) = (verified_header.number(), verified_header.hash());
 			trace!(target: "client", "importing block {}", num);
 			if self.verify_full && !self.check_header(&mut bad, &verified_header) {
 				continue
@ -381,13 +385,17 @@ impl Client {
 		}
 	}
-	// return true if should skip, false otherwise. may push onto bad if
+	// return false if should skip, true otherwise. may push onto bad if
 	// should skip.
 	fn check_header(&self, bad: &mut Vec<H256>, verified_header: &Header) -> bool {
 		let hash = verified_header.hash();
 		let parent_header = match self.chain.block_header(BlockId::Hash(*verified_header.parent_hash())) {
 			Some(header) => header,
-			None => return false, // skip import of block with missing parent.
+			None => {
 				trace!(target: "client", "No parent for block ({}, {})",
 					verified_header.number(), hash);
 				return false // skip import of block with missing parent.
 			}
 		};
 		// Verify Block Family
--- a/ethcore/light/src/lib.rs
+++ b/ethcore/light/src/lib.rs
@ -80,6 +80,7 @@ extern crate serde;
 extern crate smallvec;
 extern crate stats;
 extern crate time;
 extern crate vm;
 #[cfg(feature = "ipc")]
 extern crate ethcore_ipc as ipc;
--- a/ethcore/light/src/net/mod.rs
+++ b/ethcore/light/src/net/mod.rs
@ -806,6 +806,9 @@ impl LightProtocol {
 		trace!(target: "pip", "Connected peer with chain head {:?}", (status.head_hash, status.head_num));
 		if (status.network_id, status.genesis_hash) != (self.network_id, self.genesis_hash) {
 			trace!(target: "pip", "peer {} wrong network: network_id is {} vs our {}, gh is {} vs our {}",
 				peer, status.network_id, self.network_id, status.genesis_hash, self.genesis_hash);
 			return Err(Error::WrongNetwork);
 		}
--- a/ethcore/light/src/on_demand/mod.rs
+++ b/ethcore/light/src/on_demand/mod.rs
@ -54,13 +54,21 @@ struct Peer {
 }
 impl Peer {
-	// whether this peer can fulfill the
+	// whether this peer can fulfill the necessary capabilities for the given
-	fn can_fulfill(&self, c: &Capabilities) -> bool {
+	// request.
-		let caps = &self.capabilities;
+	fn can_fulfill(&self, request: &Capabilities) -> bool {
 		let local_caps = &self.capabilities;
 		let can_serve_since = |req, local| {
 			match (req, local) {
 				(Some(request_block), Some(serve_since)) => request_block >= serve_since,
 				(Some(_), None) => false,
 				(None, _) => true,
 			}
 		};
-		caps.serve_headers == c.serve_headers &&
+		local_caps.serve_headers >= request.serve_headers &&
-			caps.serve_chain_since >= c.serve_chain_since &&
+		    can_serve_since(request.serve_chain_since, local_caps.serve_chain_since) &&
-			caps.serve_state_since >= c.serve_chain_since
+		    can_serve_since(request.serve_state_since, local_caps.serve_state_since)
 	}
 }
@ -244,7 +252,7 @@ impl OnDemand {
 			peers: RwLock::new(HashMap::new()),
 			in_transit: RwLock::new(HashMap::new()),
 			cache: cache,
-			no_immediate_dispatch: true,
+			no_immediate_dispatch: false,
 		}
 	}
@ -266,7 +274,6 @@ impl OnDemand {
 		-> Result<Receiver<Vec<Response>>, basic_request::NoSuchOutput>
 	{
 		let (sender, receiver) = oneshot::channel();
 		if requests.is_empty() {
 			assert!(sender.send(Vec::new()).is_ok(), "receiver still in scope; qed");
 			return Ok(receiver);
@ -335,6 +342,7 @@ impl OnDemand {
 	// dispatch pending requests, and discard those for which the corresponding
 	// receiver has been dropped.
 	fn dispatch_pending(&self, ctx: &BasicContext) {
 		// wrapper future for calling `poll_cancel` on our `Senders` to preserve
 		// the invariant that it's always within a task.
 		struct CheckHangup<'a, T: 'a>(&'a mut Sender<T>);
@ -360,6 +368,8 @@ impl OnDemand {
 		if self.pending.read().is_empty() { return }
 		let mut pending = self.pending.write();
 		debug!(target: "on_demand", "Attempting to dispatch {} pending requests", pending.len());
 		// iterate over all pending requests, and check them for hang-up.
 		// then, try and find a peer who can serve it.
 		let peers = self.peers.read();
@ -378,16 +388,21 @@ impl OnDemand {
 					match ctx.request_from(*peer_id, pending.net_requests.clone()) {
 						Ok(req_id) => {
 							trace!(target: "on_demand", "Dispatched request {} to peer {}", req_id, peer_id);
 							self.in_transit.write().insert(req_id, pending);
 							return None
 						}
-						Err(net::Error::NoCredits) => {}
+						Err(net::Error::NoCredits) | Err(net::Error::NotServer) => {}
 						Err(e) => debug!(target: "on_demand", "Error dispatching request to peer: {}", e),
 					}
 				}
 				// TODO: maximum number of failures _when we have peers_.
 				Some(pending)
 			})
 			.collect(); // `pending` now contains all requests we couldn't dispatch.
 		debug!(target: "on_demand", "Was unable to dispatch {} requests.", pending.len());
 	}
 	// submit a pending request set. attempts to answer from cache before
@ -395,6 +410,7 @@ impl OnDemand {
 	fn submit_pending(&self, ctx: &BasicContext, mut pending: Pending) {
 		// answer as many requests from cache as we can, and schedule for dispatch
 		// if incomplete.
 		pending.answer_from_cache(&*self.cache);
 		if let Some(mut pending) = pending.try_complete() {
 			pending.update_net_requests();
--- a/ethcore/light/src/on_demand/request.rs
+++ b/ethcore/light/src/on_demand/request.rs
@ -24,7 +24,7 @@ use ethcore::engines::Engine;
 use ethcore::receipt::Receipt;
 use ethcore::state::{self, ProvedExecution};
 use ethcore::transaction::SignedTransaction;
-use evm::env_info::EnvInfo;
+use vm::EnvInfo;
 use request::{self as net_request, IncompleteRequest, CompleteRequest, Output, OutputKind, Field};
--- a/ethcore/res/authority_round.json
+++ b/ethcore/res/authority_round.json
@ -3,7 +3,6 @@
 	"engine": {
 		"authorityRound": {
 			"params": {
 				"gasLimitBoundDivisor": "0x0400",
 				"stepDuration": 1,
 				"startStep": 2,
 				"validators": {
@ -17,6 +16,7 @@
 		}
 	},
 	"params": {
 		"gasLimitBoundDivisor": "0x0400",
 		"accountStartNonce": "0x0",
 		"maximumExtraDataSize": "0x20",
 		"minGasLimit": "0x1388",
--- a/ethcore/res/basic_authority.json
+++ b/ethcore/res/basic_authority.json
@ -3,7 +3,6 @@
 	"engine": {
 		"basicAuthority": {
 			"params": {
 				"gasLimitBoundDivisor": "0x0400",
 				"durationLimit": "0x0d",
 				"validators": {
 					"list": ["0x9cce34f7ab185c7aba1b7c8140d620b4bda941d6"]
@ -12,6 +11,7 @@
 		}
 	},
 	"params": {
 		"gasLimitBoundDivisor": "0x0400",
 		"accountStartNonce": "0x0100000",
 		"maximumExtraDataSize": "0x20",
 		"minGasLimit": "0x1388",
--- a/ethcore/res/constructor.json
+++ b/ethcore/res/constructor.json
@ -4,6 +4,7 @@
 		"null": null
 	},
 	"params": {
 		"gasLimitBoundDivisor": "0x0400",
 		"accountStartNonce": "0x0",
 		"maximumExtraDataSize": "0x20",
 		"minGasLimit": "0x1388",
--- a/ethcore/res/ethereum/classic.json
+++ b/ethcore/res/ethereum/classic.json
@ -4,15 +4,11 @@
 	"engine": {
 		"Ethash": {
 			"params": {
 				"gasLimitBoundDivisor": "0x0400",
 				"minimumDifficulty": "0x020000",
 				"difficultyBoundDivisor": "0x0800",
 				"durationLimit": "0x0d",
 				"blockReward": "0x4563918244F40000",
 				"registrar" : "0xc6d9d2cd449a754c494264e1809c50e34d64562b",
 				"homesteadTransition": 1150000,
 				"eip150Transition": 2500000,
 				"eip155Transition": 3000000,
 				"eip160Transition": 3000000,
 				"ecip1010PauseTransition": 3000000,
 				"ecip1010ContinueTransition": 5000000,
@ -24,6 +20,9 @@
 		}
 	},
 	"params": {
 		"gasLimitBoundDivisor": "0x0400",
 		"blockReward": "0x4563918244F40000",
 		"registrar" : "0xc6d9d2cd449a754c494264e1809c50e34d64562b",
 		"accountStartNonce": "0x00",
 		"maximumExtraDataSize": "0x20",
 		"minGasLimit": "0x1388",
@ -31,6 +30,8 @@
 		"chainID": "0x3d",
 		"forkBlock": "0x1d4c00",
 		"forkCanonHash": "0x94365e3a8c0b35089c1d1195081fe7489b528a84b22199c916180db8b28ade7f",
 		"eip155Transition": 3000000,
 		"eip98Transition": "0x7fffffffffffff",
 		"eip86Transition": "0x7fffffffffffff"
 	},
--- a/ethcore/res/ethereum/eip150_test.json
+++ b/ethcore/res/ethereum/eip150_test.json
@ -3,15 +3,11 @@
 	"engine": {
 		"Ethash": {
 			"params": {
 				"gasLimitBoundDivisor": "0x0400",
 				"minimumDifficulty": "0x020000",
 				"difficultyBoundDivisor": "0x0800",
 				"durationLimit": "0x0d",
 				"blockReward": "0x4563918244F40000",
 				"registrar" : "0xc6d9d2cd449a754c494264e1809c50e34d64562b",
 				"homesteadTransition": "0x0",
 				"eip150Transition": "0x0",
 				"eip155Transition": "0x7fffffffffffffff",
 				"eip160Transition": "0x7fffffffffffffff",
 				"eip161abcTransition": "0x7fffffffffffffff",
 				"eip161dTransition": "0x7fffffffffffffff",
@ -20,12 +16,16 @@
 		}
 	},
 	"params": {
 		"gasLimitBoundDivisor": "0x0400",
 		"blockReward": "0x4563918244F40000",
 		"registrar" : "0xc6d9d2cd449a754c494264e1809c50e34d64562b",
 		"accountStartNonce": "0x00",
 		"maximumExtraDataSize": "0x20",
 		"minGasLimit": "0x1388",
 		"networkID" : "0x1",
 		"eip98Transition": "0x7fffffffffffffff",
-		"eip86Transition": "0x7fffffffffffffff"
+		"eip86Transition": "0x7fffffffffffffff",
 		"eip155Transition": "0x7fffffffffffffff"
 	},
 	"genesis": {
 		"seal": {
--- a/ethcore/res/ethereum/eip161_test.json
+++ b/ethcore/res/ethereum/eip161_test.json
@ -3,15 +3,11 @@
 	"engine": {
 		"Ethash": {
 			"params": {
 				"gasLimitBoundDivisor": "0x0400",
 				"minimumDifficulty": "0x020000",
 				"difficultyBoundDivisor": "0x0800",
 				"durationLimit": "0x0d",
 				"blockReward": "0x4563918244F40000",
 				"registrar" : "0xc6d9d2cd449a754c494264e1809c50e34d64562b",
 				"homesteadTransition": "0x0",
 				"eip150Transition": "0x0",
 				"eip155Transition": "0x7fffffffffffffff",
 				"eip160Transition": "0x0",
 				"eip161abcTransition": "0x0",
 				"eip161dTransition": "0x0",
@ -20,12 +16,16 @@
 		}
 	},
 	"params": {
 		"gasLimitBoundDivisor": "0x0400",
 		"blockReward": "0x4563918244F40000",
 		"registrar" : "0xc6d9d2cd449a754c494264e1809c50e34d64562b",
 		"accountStartNonce": "0x00",
 		"maximumExtraDataSize": "0x20",
 		"minGasLimit": "0x1388",
 		"networkID" : "0x1",
 		"eip98Transition": "0x7fffffffffffffff",
-		"eip86Transition": "0x7fffffffffffffff"
+		"eip86Transition": "0x7fffffffffffffff",
 		"eip155Transition": "0x7fffffffffffffff"
 	},
 	"genesis": {
 		"seal": {
--- a/ethcore/res/ethereum/expanse.json
+++ b/ethcore/res/ethereum/expanse.json
@ -4,19 +4,15 @@
 	"engine": {
 		"Ethash": {
 			"params": {
 				"gasLimitBoundDivisor": "0x0400",
 				"minimumDifficulty": "0x020000",
 				"difficultyBoundDivisor": "0x0800",
 				"difficultyIncrementDivisor": "60",
 				"durationLimit": "0x3C",
 				"blockReward": "0x6f05b59d3b200000",
 				"registrar" : "0x6c221ca53705f3497ec90ca7b84c59ae7382fc21",
 				"homesteadTransition": "0x30d40",
 				"difficultyHardforkTransition": "0x59d9",
 				"difficultyHardforkBoundDivisor": "0x0200",
 				"bombDefuseTransition": "0x30d40",
 				"eip150Transition": "0x927C0",
 				"eip155Transition": "0x927C0",
 				"eip160Transition": "0x927C0",
 				"eip161abcTransition": "0x927C0",
 				"eip161dTransition": "0x927C0"
@ -24,6 +20,9 @@
 		}
 	},
 	"params": {
 		"gasLimitBoundDivisor": "0x0400",
 		"blockReward": "0x6f05b59d3b200000",
 		"registrar" : "0x6c221ca53705f3497ec90ca7b84c59ae7382fc21",
 		"accountStartNonce": "0x00",
 		"maximumExtraDataSize": "0x20",
 		"minGasLimit": "0x1388",
@ -31,7 +30,8 @@
 		"chainID": "0x2",
 		"subprotocolName": "exp",
 		"eip98Transition": "0x7fffffffffffff",
-		"eip86Transition": "0x7fffffffffffff"
+		"eip86Transition": "0x7fffffffffffff",
 		"eip155Transition": "0x927C0"
 	},
 	"genesis": {
 		"seal": {
--- a/ethcore/res/ethereum/foundation.json
+++ b/ethcore/res/ethereum/foundation.json
@ -4,12 +4,9 @@
 	"engine": {
 		"Ethash": {
 			"params": {
 				"gasLimitBoundDivisor": "0x0400",
 				"minimumDifficulty": "0x020000",
 				"difficultyBoundDivisor": "0x0800",
 				"durationLimit": "0x0d",
 				"blockReward": "0x4563918244F40000",
 				"registrar" : "0xe3389675d0338462dC76C6f9A3e432550c36A142",
 				"homesteadTransition": "0x118c30",
 				"daoHardforkTransition": "0x1d4c00",
 				"daoHardforkBeneficiary": "0xbf4ed7b27f1d666546e30d74d50d173d20bca754",
@ -132,7 +129,6 @@
 					"0x807640a13483f8ac783c557fcdf27be11ea4ac7a"
 				],
 				"eip150Transition": "0x259518",
 				"eip155Transition": 2675000,
 				"eip160Transition": 2675000,
 				"eip161abcTransition": 2675000,
 				"eip161dTransition": 2675000,
@ -141,12 +137,17 @@
 		}
 	},
 	"params": {
 		"gasLimitBoundDivisor": "0x0400",
 		"blockReward": "0x4563918244F40000",
 		"registrar" : "0xe3389675d0338462dC76C6f9A3e432550c36A142",
 		"accountStartNonce": "0x00",
 		"maximumExtraDataSize": "0x20",
 		"minGasLimit": "0x1388",
 		"networkID" : "0x1",
 		"forkBlock": "0x1d4c00",
 		"forkCanonHash": "0x4985f5ca3d2afbec36529aa96f74de3cc10a2a4a6c44f2157a57d2c6059a11bb",
 		"eip155Transition": 2675000,
 		"eip98Transition": "0x7fffffffffffff",
 		"eip86Transition": "0x7fffffffffffff"
 	},
--- a/ethcore/res/ethereum/frontier_like_test.json
+++ b/ethcore/res/ethereum/frontier_like_test.json
@ -3,12 +3,9 @@
 	"engine": {
 		"Ethash": {
 			"params": {
 				"gasLimitBoundDivisor": "0x0400",
 				"minimumDifficulty": "0x020000",
 				"difficultyBoundDivisor": "0x0800",
 				"durationLimit": "0x0d",
 				"blockReward": "0x4563918244F40000",
 				"registrar" : "0xc6d9d2cd449a754c494264e1809c50e34d64562b",
 				"homesteadTransition": "0x118c30",
 				"daoHardforkTransition": "0x1d4c00",
 				"daoHardforkBeneficiary": "0xbf4ed7b27f1d666546e30d74d50d173d20bca754",
@ -131,7 +128,6 @@
 					"0x807640a13483f8ac783c557fcdf27be11ea4ac7a"
 				],
 				"eip150Transition": "0x7fffffffffffffff",
 				"eip155Transition": "0x7fffffffffffffff",
 				"eip160Transition": "0x7fffffffffffffff",
 				"eip161abcTransition": "0x7fffffffffffffff",
 				"eip161dTransition": "0x7fffffffffffffff"
@ -139,12 +135,16 @@
 		}
 	},
 	"params": {
 		"gasLimitBoundDivisor": "0x0400",
 		"blockReward": "0x4563918244F40000",
 		"registrar" : "0xc6d9d2cd449a754c494264e1809c50e34d64562b",
 		"accountStartNonce": "0x00",
 		"maximumExtraDataSize": "0x20",
 		"minGasLimit": "0x1388",
 		"networkID" : "0x1",
 		"eip98Transition": "0x7fffffffffffff",
-		"eip86Transition": "0x7fffffffffffff"
+		"eip86Transition": "0x7fffffffffffff",
 		"eip155Transition": "0x7fffffffffffffff"
 	},
 	"genesis": {
 		"seal": {
--- a/ethcore/res/ethereum/frontier_test.json
+++ b/ethcore/res/ethereum/frontier_test.json
@ -3,15 +3,11 @@
 	"engine": {
 		"Ethash": {
 			"params": {
 				"gasLimitBoundDivisor": "0x0400",
 				"minimumDifficulty": "0x020000",
 				"difficultyBoundDivisor": "0x0800",
 				"durationLimit": "0x0d",
 				"blockReward": "0x4563918244F40000",
 				"registrar" : "0xc6d9d2cd449a754c494264e1809c50e34d64562b",
 				"homesteadTransition": "0x7fffffffffffffff",
 				"eip150Transition": "0x7fffffffffffffff",
 				"eip155Transition": "0x7fffffffffffffff",
 				"eip160Transition": "0x7fffffffffffffff",
 				"eip161abcTransition": "0x7fffffffffffffff",
 				"eip161dTransition": "0x7fffffffffffffff"
@ -19,12 +15,16 @@
 		}
 	},
 	"params": {
 		"gasLimitBoundDivisor": "0x0400",
 		"blockReward": "0x4563918244F40000",
 		"registrar" : "0xc6d9d2cd449a754c494264e1809c50e34d64562b",
 		"accountStartNonce": "0x00",
 		"maximumExtraDataSize": "0x20",
 		"minGasLimit": "0x1388",
 		"networkID" : "0x1",
 		"eip98Transition": "0x7fffffffffffff",
-		"eip86Transition": "0x7fffffffffffff"
+		"eip86Transition": "0x7fffffffffffff",
 		"eip155Transition": "0x7fffffffffffffff"
 	},
 	"genesis": {
 		"seal": {
--- a/ethcore/res/ethereum/homestead_test.json
+++ b/ethcore/res/ethereum/homestead_test.json
@ -3,15 +3,11 @@
 	"engine": {
 		"Ethash": {
 			"params": {
 				"gasLimitBoundDivisor": "0x0400",
 				"minimumDifficulty": "0x020000",
 				"difficultyBoundDivisor": "0x0800",
 				"durationLimit": "0x0d",
 				"blockReward": "0x4563918244F40000",
 				"registrar" : "0xc6d9d2cd449a754c494264e1809c50e34d64562b",
 				"homesteadTransition": "0x0",
 				"eip150Transition": "0x7fffffffffffffff",
 				"eip155Transition": "0x7fffffffffffffff",
 				"eip160Transition": "0x7fffffffffffffff",
 				"eip161abcTransition": "0x7fffffffffffffff",
 				"eip161dTransition": "0x7fffffffffffffff"
@ -19,12 +15,16 @@
 		}
 	},
 	"params": {
 		"gasLimitBoundDivisor": "0x0400",
 		"blockReward": "0x4563918244F40000",
 		"registrar" : "0xc6d9d2cd449a754c494264e1809c50e34d64562b",
 		"accountStartNonce": "0x00",
 		"maximumExtraDataSize": "0x20",
 		"minGasLimit": "0x1388",
 		"networkID" : "0x1",
 		"eip98Transition": "0x7fffffffffffff",
-		"eip86Transition": "0x7fffffffffffff"
+		"eip86Transition": "0x7fffffffffffff",
 		"eip155Transition": "0x7fffffffffffffff"
 	},
 	"genesis": {
 		"seal": {
--- a/ethcore/res/ethereum/kovan.json
+++ b/ethcore/res/ethereum/kovan.json
@ -4,10 +4,7 @@
  "engine": {
    "authorityRound": {
      "params": {
        "gasLimitBoundDivisor": "0x400",
        "registrar" : "0xfAb104398BBefbd47752E7702D9fE23047E1Bca3",
        "stepDuration": "4",
        "blockReward": "0x4563918244F40000",
        "validators" : {
          "list": [
            "0x00D6Cc1BA9cf89BD2e58009741f4F7325BAdc0ED",
@ -25,16 +22,19 @@
          ]
        },
        "validateScoreTransition": 1000000,
        "eip155Transition": 1000000,
        "validateStepTransition": 1500000
      }
    }
  },
  "params": {
-    "maximumExtraDataSize": "0x20",
+    "gasLimitBoundDivisor": "0x400",
    "registrar" : "0xfAb104398BBefbd47752E7702D9fE23047E1Bca3",
    "blockReward": "0x4563918244F40000",
 	"maximumExtraDataSize": "0x20",
    "minGasLimit": "0x1388",
    "networkID" : "0x2A",
-    "validateReceiptsTransition" : 1000000
+    "validateReceiptsTransition" : 1000000,
    "eip155Transition": 1000000
  },
  "genesis": {
    "seal": {
--- a/ethcore/res/ethereum/metropolis_test.json
+++ b/ethcore/res/ethereum/metropolis_test.json
@ -3,15 +3,12 @@
 	"engine": {
 		"Ethash": {
 			"params": {
 				"gasLimitBoundDivisor": "0x0400",
 				"minimumDifficulty": "0x020000",
 				"difficultyBoundDivisor": "0x0800",
 				"durationLimit": "0x0d",
-				"blockReward": "0x4563918244F40000",
+
 				"registrar" : "0xc6d9d2cd449a754c494264e1809c50e34d64562b",
 				"homesteadTransition": "0x0",
 				"eip150Transition": "0x0",
 				"eip155Transition": "0x0",
 				"eip160Transition": "0x0",
 				"eip161abcTransition": "0x0",
 				"eip161dTransition": "0x0",
@ -20,6 +17,9 @@
 		}
 	},
 	"params": {
 		"gasLimitBoundDivisor": "0x0400",
 		"blockReward": "0x4563918244F40000",
 		"registrar" : "0xc6d9d2cd449a754c494264e1809c50e34d64562b",
 		"accountStartNonce": "0x00",
 		"maximumExtraDataSize": "0x20",
 		"minGasLimit": "0x1388",
@ -27,7 +27,8 @@
 		"eip98Transition": "0x0",
 		"eip86Transition": "0x0",
 		"eip140Transition": "0x0",
-		"eip210Transition": "0x0"
+		"eip210Transition": "0x0",
 		"eip155Transition": "0x0"
 	},
 	"genesis": {
 		"seal": {
--- a/ethcore/res/ethereum/morden.json
+++ b/ethcore/res/ethereum/morden.json
@ -4,15 +4,11 @@
 	"engine": {
 		"Ethash": {
 			"params": {
 				"gasLimitBoundDivisor": "0x0400",
 				"minimumDifficulty": "0x020000",
 				"difficultyBoundDivisor": "0x0800",
 				"durationLimit": "0x0d",
 				"blockReward": "0x4563918244F40000",
 				"registrar": "0x52dff57a8a1532e6afb3dc07e2af58bb9eb05b3d",
 				"homesteadTransition": 494000,
 				"eip150Transition": 1783000,
 				"eip155Transition": 1915000,
 				"eip160Transition": 1915000,
 				"ecip1010PauseTransition": 1915000,
 				"ecip1010ContinueTransition": 3415000,
@ -23,6 +19,9 @@
 		}
 	},
 	"params": {
 		"gasLimitBoundDivisor": "0x0400",
 		"blockReward": "0x4563918244F40000",
 		"registrar": "0x52dff57a8a1532e6afb3dc07e2af58bb9eb05b3d",
 		"accountStartNonce": "0x0100000",
 		"maximumExtraDataSize": "0x20",
 		"minGasLimit": "0x1388",
@ -30,6 +29,8 @@
 		"chainID": "0x3e",
 		"forkBlock": "0x1b34d8",
 		"forkCanonHash": "0xf376243aeff1f256d970714c3de9fd78fa4e63cf63e32a51fe1169e375d98145",
 		"eip155Transition": 1915000,
 		"eip98Transition": "0x7fffffffffffff",
 		"eip86Transition": "0x7fffffffffffff"
 	},
--- a/ethcore/res/ethereum/olympic.json
+++ b/ethcore/res/ethereum/olympic.json
@ -3,15 +3,11 @@
 	"engine": {
 		"Ethash": {
 			"params": {
 				"gasLimitBoundDivisor": "0x0400",
 				"minimumDifficulty": "0x020000",
 				"difficultyBoundDivisor": "0x0800",
 				"durationLimit": "0x08",
 				"blockReward": "0x14D1120D7B160000",
 				"registrar": "5e70c0bbcd5636e0f9f9316e9f8633feb64d4050",
 				"homesteadTransition": "0x7fffffffffffffff",
 				"eip150Transition": "0x7fffffffffffffff",
 				"eip155Transition": "0x7fffffffffffffff",
 				"eip160Transition": "0x7fffffffffffffff",
 				"eip161abcTransition": "0x7fffffffffffffff",
 				"eip161dTransition": "0x7fffffffffffffff"
@ -19,12 +15,16 @@
 		}
 	},
 	"params": {
 		"gasLimitBoundDivisor": "0x0400",
 		"blockReward": "0x14D1120D7B160000",
 		"registrar": "5e70c0bbcd5636e0f9f9316e9f8633feb64d4050",
 		"accountStartNonce": "0x00",
 		"maximumExtraDataSize": "0x0400",
 		"minGasLimit": "125000",
 		"networkID" : "0x0",
 		"eip98Transition": "0x7fffffffffffff",
-		"eip86Transition": "0x7fffffffffffff"
+		"eip86Transition": "0x7fffffffffffff",
 		"eip155Transition": "0x7fffffffffffffff"
 	},
 	"genesis": {
 		"seal": {
--- a/ethcore/res/ethereum/ropsten.json
+++ b/ethcore/res/ethereum/ropsten.json
@ -4,15 +4,11 @@
 	"engine": {
 		"Ethash": {
 			"params": {
 				"gasLimitBoundDivisor": "0x0400",
 				"minimumDifficulty": "0x020000",
 				"difficultyBoundDivisor": "0x0800",
 				"durationLimit": "0x0d",
 				"blockReward": "0x4563918244F40000",
 				"registrar": "0x81a4b044831c4f12ba601adb9274516939e9b8a2",
 				"homesteadTransition": 0,
 				"eip150Transition": 0,
 				"eip155Transition": 10,
 				"eip160Transition": 10,
 				"eip161abcTransition": 10,
 				"eip161dTransition": 10,
@ -21,12 +17,17 @@
 		}
 	},
 	"params": {
 		"gasLimitBoundDivisor": "0x0400",
 		"blockReward": "0x4563918244F40000",
 		"registrar": "0x81a4b044831c4f12ba601adb9274516939e9b8a2",
 		"accountStartNonce": "0x0",
 		"maximumExtraDataSize": "0x20",
 		"minGasLimit": "0x1388",
 		"networkID" : "0x3",
 		"forkBlock": 641350,
 		"forkCanonHash": "0x8033403e9fe5811a7b6d6b469905915de1c59207ce2172cbcf5d6ff14fa6a2eb",
 		"eip155Transition": 10,
 		"eip98Transition": "0x7fffffffffffff",
 		"eip86Transition": "0x7fffffffffffff"
 	},
--- a/ethcore/res/ethereum/transition_test.json
+++ b/ethcore/res/ethereum/transition_test.json
@ -3,12 +3,9 @@
 	"engine": {
 		"Ethash": {
 			"params": {
 				"gasLimitBoundDivisor": "0x0400",
 				"minimumDifficulty": "0x020000",
 				"difficultyBoundDivisor": "0x0800",
 				"durationLimit": "0x0d",
 				"blockReward": "0x4563918244F40000",
 				"registrar" : "0xc6d9d2cd449a754c494264e1809c50e34d64562b",
 				"homesteadTransition": "0x5",
 				"daoHardforkTransition": "0x8",
 				"daoHardforkBeneficiary": "0xbf4ed7b27f1d666546e30d74d50d173d20bca754",
@ -131,7 +128,6 @@
 					"0x807640a13483f8ac783c557fcdf27be11ea4ac7a"
 				],
 				"eip150Transition": "0xa",
 				"eip155Transition": "0x7fffffffffffffff",
 				"eip160Transition": "0x7fffffffffffffff",
 				"eip161abcTransition": "0x7fffffffffffffff",
 				"eip161dTransition": "0x7fffffffffffffff"
@ -139,12 +135,16 @@
 		}
 	},
 	"params": {
 		"gasLimitBoundDivisor": "0x0400",
 		"blockReward": "0x4563918244F40000",
 		"registrar" : "0xc6d9d2cd449a754c494264e1809c50e34d64562b",
 		"accountStartNonce": "0x00",
 		"maximumExtraDataSize": "0x20",
 		"minGasLimit": "0x1388",
 		"networkID" : "0x1",
 		"eip98Transition": "0x7fffffffffffff",
-		"eip86Transition": "0x7fffffffffffff"
+		"eip86Transition": "0x7fffffffffffff",
 		"eip155Transition": "0x7fffffffffffffff"
 	},
 	"genesis": {
 		"seal": {
--- a/ethcore/res/instant_seal.json
+++ b/ethcore/res/instant_seal.json
@ -1,13 +1,10 @@
 {
 	"name": "DevelopmentChain",
 	"engine": {
-		"instantSeal": {
+		"instantSeal": null
 			"params": {
 				"registrar": "0x0000000000000000000000000000000000000005"
 			}
 		}
 	},
 	"params": {
 		"gasLimitBoundDivisor": "0x0400",
 		"accountStartNonce": "0x0",
 		"maximumExtraDataSize": "0x20",
 		"minGasLimit": "0x1388",
--- a/ethcore/res/null.json
+++ b/ethcore/res/null.json
@ -4,6 +4,7 @@
 		"null": null
 	},
 	"params": {
 		"gasLimitBoundDivisor": "0x0400",
 		"accountStartNonce": "0x0",
 		"maximumExtraDataSize": "0x20",
 		"minGasLimit": "0x1388",
--- a/ethcore/res/null_morden.json
+++ b/ethcore/res/null_morden.json
@ -4,6 +4,7 @@
 		"null": null
 	},
 	"params": {
 		"gasLimitBoundDivisor": "0x0400",
 		"accountStartNonce": "0x0",
 		"maximumExtraDataSize": "0x20",
 		"minGasLimit": "0x1388",
--- a/ethcore/res/tendermint.json
+++ b/ethcore/res/tendermint.json
@ -3,7 +3,6 @@
 	"engine": {
 		"tendermint": {
 			"params": {
 				"gasLimitBoundDivisor": "0x0400",
 				"validators" : {
 					"list": [
 						"0x82a978b3f5962a5b0957d9ee9eef472ee55b42f1",
@ -18,6 +17,7 @@
 		}
 	},
 	"params": {
 		"gasLimitBoundDivisor": "0x0400",
 		"accountStartNonce": "0x0",
 		"maximumExtraDataSize": "0x20",
 		"minGasLimit": "0x1388",
--- a/ethcore/res/validator_contract.json
+++ b/ethcore/res/validator_contract.json
@ -3,7 +3,6 @@
 	"engine": {
 		"authorityRound": {
 			"params": {
 				"gasLimitBoundDivisor": "0x0400",
 				"stepDuration": 1,
 				"startStep": 2,
 				"validators": {
@ -14,6 +13,7 @@
 		}
 	},
 	"params": {
 		"gasLimitBoundDivisor": "0x0400",
 		"accountStartNonce": "0x0",
 		"maximumExtraDataSize": "0x20",
 		"minGasLimit": "0x1388",
--- a/ethcore/res/validator_multi.json
+++ b/ethcore/res/validator_multi.json
@ -3,7 +3,6 @@
 	"engine": {
 		"basicAuthority": {
 			"params": {
 				"gasLimitBoundDivisor": "0x0400",
 				"durationLimit": "0x0d",
 				"validators": {
 					"multi": {
@ -15,6 +14,7 @@
 		}
 	},
 	"params": {
 		"gasLimitBoundDivisor": "0x0400",
 		"accountStartNonce": "0x0",
 		"maximumExtraDataSize": "0x20",
 		"minGasLimit": "0x1388",
--- a/ethcore/res/validator_safe_contract.json
+++ b/ethcore/res/validator_safe_contract.json
@ -3,7 +3,6 @@
 	"engine": {
 		"basicAuthority": {
 			"params": {
 				"gasLimitBoundDivisor": "0x0400",
 				"durationLimit": "0x0d",
 				"validators": {
 					"safeContract": "0x0000000000000000000000000000000000000005"
@ -12,6 +11,7 @@
 		}
 	},
 	"params": {
 		"gasLimitBoundDivisor": "0x0400",
 		"accountStartNonce": "0x0",
 		"maximumExtraDataSize": "0x20",
 		"minGasLimit": "0x1388",
--- a/ethcore/src/account_db.rs
+++ b/ethcore/src/account_db.rs
@ -15,6 +15,7 @@
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 //! DB backend wrapper for Account trie
 use std::collections::HashMap;
 use util::*;
 use rlp::NULL_RLP;
--- a/ethcore/src/block.rs
+++ b/ethcore/src/block.rs
@ -25,7 +25,7 @@ use util::{Bytes, Address, Hashable, U256, H256, ordered_trie_root, SHA3_NULL_RL
 use util::error::{Mismatch, OutOfBounds};
 use basic_types::{LogBloom, Seal};
-use evm::env_info::{EnvInfo, LastHashes};
+use vm::{EnvInfo, LastHashes};
 use engines::Engine;
 use error::{Error, BlockError, TransactionError};
 use factory::Factories;
@ -667,7 +667,7 @@ mod tests {
 	use tests::helpers::*;
 	use super::*;
 	use engines::Engine;
-	use evm::env_info::LastHashes;
+	use vm::LastHashes;
 	use error::Error;
 	use header::Header;
 	use factory::Factories;
--- a/ethcore/src/blockchain/blockchain.rs
+++ b/ethcore/src/blockchain/blockchain.rs
@ -16,6 +16,9 @@
 //! Blockchain database.
 use std::collections::{HashMap, HashSet};
 use std::sync::Arc;
 use std::mem;
 use bloomchain as bc;
 use util::*;
 use rlp::*;
--- a/ethcore/src/blockchain/extras.rs
+++ b/ethcore/src/blockchain/extras.rs
@ -16,6 +16,8 @@
 //! Blockchain DB extras.
 use std::ops;
 use std::io::Write;
 use bloomchain;
 use blooms::{GroupPosition, BloomGroup};
 use db::Key;
@ -56,7 +58,7 @@ fn with_index(hash: &H256, i: ExtrasIndex) -> H264 {
 pub struct BlockNumberKey([u8; 5]);
-impl Deref for BlockNumberKey {
+impl ops::Deref for BlockNumberKey {
 	type Target = [u8];
 	fn deref(&self) -> &Self::Target {
@ -88,7 +90,7 @@ impl Key<BlockDetails> for H256 {
 pub struct LogGroupKey([u8; 6]);
-impl Deref for LogGroupKey {
+impl ops::Deref for LogGroupKey {
 	type Target = [u8];
 	fn deref(&self) -> &Self::Target {
@ -160,7 +162,8 @@ pub const EPOCH_KEY_PREFIX: &'static [u8; DB_PREFIX_LEN] = &[
 ];
 pub struct EpochTransitionsKey([u8; EPOCH_KEY_LEN]);
-impl Deref for EpochTransitionsKey {
+
 impl ops::Deref for EpochTransitionsKey {
 	type Target = [u8];
 	fn deref(&self) -> &[u8] { &self.0[..] }
--- a/ethcore/src/builtin.rs
+++ b/ethcore/src/builtin.rs
@ -36,9 +36,9 @@ impl From<&'static str> for Error {
 	}
 }
-impl Into<::evm::Error> for Error {
+impl Into<::vm::Error> for Error {
-	fn into(self) -> ::evm::Error {
+	fn into(self) -> ::vm::Error {
-		::evm::Error::BuiltIn(self.0)
+		::vm::Error::BuiltIn(self.0)
 	}
 }
--- a/ethcore/src/client/client.rs
+++ b/ethcore/src/client/client.rs
@ -42,9 +42,8 @@ use client::{
 };
 use encoded;
 use engines::{Engine, EpochTransition};
 use evm::env_info::EnvInfo;
 use evm::env_info::LastHashes;
 use error::{ImportError, ExecutionError, CallError, BlockError, ImportResult, Error as EthcoreError};
 use vm::{EnvInfo, LastHashes};
 use evm::{Factory as EvmFactory, Schedule};
 use executive::{Executive, Executed, TransactOptions, contract_address};
 use factory::Factories;
@ -907,7 +906,7 @@ impl Client {
 	pub fn state_at(&self, id: BlockId) -> Option<State<StateDB>> {
 		// fast path for latest state.
 		match id.clone() {
-			BlockId::Pending => return self.miner.pending_state().or_else(|| Some(self.state())),
+			BlockId::Pending => return self.miner.pending_state(self.chain.read().best_block_number()).or_else(|| Some(self.state())),
 			BlockId::Latest => return Some(self.state()),
 			_ => {},
 		}
@ -1056,19 +1055,20 @@ impl Client {
 		self.history
 	}
-	fn block_hash(chain: &BlockChain, id: BlockId) -> Option<H256> {
+	fn block_hash(chain: &BlockChain, miner: &Miner, id: BlockId) -> Option<H256> {
 		match id {
 			BlockId::Hash(hash) => Some(hash),
 			BlockId::Number(number) => chain.block_hash(number),
 			BlockId::Earliest => chain.block_hash(0),
-			BlockId::Latest | BlockId::Pending => Some(chain.best_block_hash()),
+			BlockId::Latest => Some(chain.best_block_hash()),
 			BlockId::Pending => miner.pending_block_header(chain.best_block_number()).map(|header| header.hash())
 		}
 	}
 	fn transaction_address(&self, id: TransactionId) -> Option<TransactionAddress> {
 		match id {
 			TransactionId::Hash(ref hash) => self.chain.read().transaction_address(hash),
-			TransactionId::Location(id, index) => Self::block_hash(&self.chain.read(), id).map(|hash| TransactionAddress {
+			TransactionId::Location(id, index) => Self::block_hash(&self.chain.read(), &self.miner, id).map(|hash| TransactionAddress {
 				block_hash: hash,
 				index: index,
 			})
@ -1111,6 +1111,31 @@ impl Client {
 			data: data,
 		}.fake_sign(from)
 	}
 	fn do_call(&self, env_info: &EnvInfo, state: &mut State<StateDB>, increase_balance: bool, t: &SignedTransaction, analytics: CallAnalytics) -> Result<Executed, CallError> {
 		let original_state = if analytics.state_diffing { Some(state.clone()) } else { None };
 		// give the sender a sufficient balance (if calling in pending block)
 		if increase_balance {
 			let sender = t.sender();
 			let balance = state.balance(&sender).map_err(ExecutionError::from)?;
 			let needed_balance = t.value + t.gas * t.gas_price;
 			if balance < needed_balance {
 				state.add_balance(&sender, &(needed_balance - balance), state::CleanupMode::NoEmpty)
 					.map_err(ExecutionError::from)?;
 			}
 		}
 		let options = TransactOptions { tracing: analytics.transaction_tracing, vm_tracing: analytics.vm_tracing, check_nonce: false };
 		let mut ret = Executive::new(state, env_info, &*self.engine).transact_virtual(t, options)?;
 		// TODO gav move this into Executive.
 		if let Some(original) = original_state {
 			ret.state_diff = Some(state.diff_from(original).map_err(ExecutionError::from)?);
 		}
 		Ok(ret)
 	}
 }
 impl snapshot::DatabaseRestore for Client {
@ -1135,23 +1160,31 @@ impl snapshot::DatabaseRestore for Client {
 }
 impl BlockChainClient for Client {
-	fn call(&self, t: &SignedTransaction, block: BlockId, analytics: CallAnalytics) -> Result<Executed, CallError> {
+	fn call(&self, transaction: &SignedTransaction, analytics: CallAnalytics, block: BlockId) -> Result<Executed, CallError> {
 		let mut env_info = self.env_info(block).ok_or(CallError::StatePruned)?;
 		env_info.gas_limit = U256::max_value();
 		// that's just a copy of the state.
 		let mut state = self.state_at(block).ok_or(CallError::StatePruned)?;
 		let original_state = if analytics.state_diffing { Some(state.clone()) } else { None };
-		let options = TransactOptions { tracing: analytics.transaction_tracing, vm_tracing: analytics.vm_tracing, check_nonce: false };
+		self.do_call(&env_info, &mut state, block == BlockId::Pending, transaction, analytics)
-		let mut ret = Executive::new(&mut state, &env_info, &*self.engine).transact_virtual(t, options)?;
+	}
-		// TODO gav move this into Executive.
+	fn call_many(&self, transactions: &[(SignedTransaction, CallAnalytics)], block: BlockId) -> Result<Vec<Executed>, CallError> {
-		if let Some(original) = original_state {
+		let mut env_info = self.env_info(block).ok_or(CallError::StatePruned)?;
-			ret.state_diff = Some(state.diff_from(original).map_err(ExecutionError::from)?);
+		env_info.gas_limit = U256::max_value();
 		// that's just a copy of the state.
 		let mut state = self.state_at(block).ok_or(CallError::StatePruned)?;
 		let mut results = Vec::with_capacity(transactions.len());
 		for &(ref t, analytics) in transactions {
 			let ret = self.do_call(&env_info, &mut state, block == BlockId::Pending, t, analytics)?;
 			env_info.gas_used = ret.cumulative_gas_used;
 			results.push(ret);
 		}
-		Ok(ret)
+		Ok(results)
 	}
 	fn estimate_gas(&self, t: &SignedTransaction, block: BlockId) -> Result<U256, CallError> {
@ -1304,7 +1337,16 @@ impl BlockChainClient for Client {
 	fn block_header(&self, id: BlockId) -> Option<::encoded::Header> {
 		let chain = self.chain.read();
-		Self::block_hash(&chain, id).and_then(|hash| chain.block_header_data(&hash))
+
 		if let BlockId::Pending = id {
 			if let Some(block) = self.miner.pending_block(chain.best_block_number()) {
 				return Some(encoded::Header::new(block.header.rlp(Seal::Without)));
 			}
 			// fall back to latest
 			return self.block_header(BlockId::Latest);
 		}
 		Self::block_hash(&chain, &self.miner, id).and_then(|hash| chain.block_header_data(&hash))
 	}
 	fn block_number(&self, id: BlockId) -> Option<BlockNumber> {
@ -1312,30 +1354,48 @@ impl BlockChainClient for Client {
 			BlockId::Number(number) => Some(number),
 			BlockId::Hash(ref hash) => self.chain.read().block_number(hash),
 			BlockId::Earliest => Some(0),
-			BlockId::Latest | BlockId::Pending => Some(self.chain.read().best_block_number()),
+			BlockId::Latest => Some(self.chain.read().best_block_number()),
 			BlockId::Pending => Some(self.chain.read().best_block_number() + 1),
 		}
 	}
 	fn block_body(&self, id: BlockId) -> Option<encoded::Body> {
 		let chain = self.chain.read();
-		Self::block_hash(&chain, id).and_then(|hash| chain.block_body(&hash))
+
 		if let BlockId::Pending = id {
 			if let Some(block) = self.miner.pending_block(chain.best_block_number()) {
 				return Some(encoded::Body::new(BlockChain::block_to_body(&block.rlp_bytes(Seal::Without))));
 			}
 			// fall back to latest
 			return self.block_body(BlockId::Latest);
 		}
 		Self::block_hash(&chain, &self.miner, id).and_then(|hash| chain.block_body(&hash))
 	}
 	fn block(&self, id: BlockId) -> Option<encoded::Block> {
 		let chain = self.chain.read();
 		if let BlockId::Pending = id {
-			if let Some(block) = self.miner.pending_block() {
+			if let Some(block) = self.miner.pending_block(chain.best_block_number()) {
 				return Some(encoded::Block::new(block.rlp_bytes(Seal::Without)));
 			}
 			// fall back to latest
 			return self.block(BlockId::Latest);
 		}
-		let chain = self.chain.read();
+
-		Self::block_hash(&chain, id).and_then(|hash| {
+		Self::block_hash(&chain, &self.miner, id).and_then(|hash| {
 			chain.block(&hash)
 		})
 	}
 	fn block_status(&self, id: BlockId) -> BlockStatus {
 		if let BlockId::Pending = id {
 			return BlockStatus::Pending;
 		}
 		let chain = self.chain.read();
-		match Self::block_hash(&chain, id) {
+		match Self::block_hash(&chain, &self.miner, id) {
 			Some(ref hash) if chain.is_known(hash) => BlockStatus::InChain,
 			Some(hash) => self.block_queue.status(&hash).into(),
 			None => BlockStatus::Unknown
@ -1343,13 +1403,18 @@ impl BlockChainClient for Client {
 	}
 	fn block_total_difficulty(&self, id: BlockId) -> Option<U256> {
 		if let BlockId::Pending = id {
 			if let Some(block) = self.miner.pending_block() {
 				return Some(*block.header.difficulty() + self.block_total_difficulty(BlockId::Latest).expect("blocks in chain have details; qed"));
 			}
 		}
 		let chain = self.chain.read();
-		Self::block_hash(&chain, id).and_then(|hash| chain.block_details(&hash)).map(|d| d.total_difficulty)
+		if let BlockId::Pending = id {
 			let latest_difficulty = self.block_total_difficulty(BlockId::Latest).expect("blocks in chain have details; qed");
 			let pending_difficulty = self.miner.pending_block_header(chain.best_block_number()).map(|header| *header.difficulty());
 			if let Some(difficulty) = pending_difficulty {
 				return Some(difficulty + latest_difficulty);
 			}
 			// fall back to latest
 			return Some(latest_difficulty);
 		}
 		Self::block_hash(&chain, &self.miner, id).and_then(|hash| chain.block_details(&hash)).map(|d| d.total_difficulty)
 	}
 	fn nonce(&self, address: &Address, id: BlockId) -> Option<U256> {
@ -1362,7 +1427,7 @@ impl BlockChainClient for Client {
 	fn block_hash(&self, id: BlockId) -> Option<H256> {
 		let chain = self.chain.read();
-		Self::block_hash(&chain, id)
+		Self::block_hash(&chain, &self.miner, id)
 	}
 	fn code(&self, address: &Address, id: BlockId) -> Option<Option<Bytes>> {
@ -1527,7 +1592,8 @@ impl BlockChainClient for Client {
 			if self.chain.read().is_known(&unverified.hash()) {
 				return Err(BlockImportError::Import(ImportError::AlreadyInChain));
 			}
-			if self.block_status(BlockId::Hash(unverified.parent_hash())) == BlockStatus::Unknown {
+			let status = self.block_status(BlockId::Hash(unverified.parent_hash()));
 			if status == BlockStatus::Unknown || status == BlockStatus::Pending {
 				return Err(BlockImportError::Block(BlockError::UnknownParent(unverified.parent_hash())));
 			}
 		}
@ -1541,7 +1607,8 @@ impl BlockChainClient for Client {
 			if self.chain.read().is_known(&header.hash()) {
 				return Err(BlockImportError::Import(ImportError::AlreadyInChain));
 			}
-			if self.block_status(BlockId::Hash(header.parent_hash())) == BlockStatus::Unknown {
+			let status = self.block_status(BlockId::Hash(header.parent_hash()));
 			if  status == BlockStatus::Unknown || status == BlockStatus::Pending {
 				return Err(BlockImportError::Block(BlockError::UnknownParent(header.parent_hash())));
 			}
 		}
@ -1687,7 +1754,7 @@ impl BlockChainClient for Client {
 	fn call_contract(&self, block_id: BlockId, address: Address, data: Bytes) -> Result<Bytes, String> {
 		let transaction = self.contract_call_tx(block_id, address, data);
-		self.call(&transaction, block_id, Default::default())
+		self.call(&transaction, Default::default(), block_id)
 			.map_err(|e| format!("{:?}", e))
 			.map(|executed| {
 				executed.output
--- a/ethcore/src/client/evm_test_client.rs
+++ b/ethcore/src/client/evm_test_client.rs
@ -23,7 +23,7 @@ use util::kvdb::{self, KeyValueDB};
 use {state, state_db, client, executive, trace, db, spec};
 use factory::Factories;
 use evm::{self, VMType};
-use evm::action_params::ActionParams;
+use vm::{self, ActionParams};
 /// EVM test Error.
 #[derive(Debug)]
@ -31,7 +31,7 @@ pub enum EvmTestError {
 	/// Trie integrity error.
 	Trie(util::TrieError),
 	/// EVM error.
-	Evm(evm::Error),
+	Evm(vm::Error),
 	/// Initialization error.
 	Initialization(::error::Error),
 	/// Low-level database error.
--- a/ethcore/src/client/mod.rs
+++ b/ethcore/src/client/mod.rs
@ -40,7 +40,7 @@ pub use types::pruning_info::PruningInfo;
 pub use types::call_analytics::CallAnalytics;
 pub use executive::{Executed, Executive, TransactOptions};
-pub use evm::env_info::{LastHashes, EnvInfo};
+pub use vm::{LastHashes, EnvInfo};
 pub use error::{BlockImportError, TransactionImportError, TransactionImportResult};
 pub use verification::VerifierType;
--- a/ethcore/src/client/test_client.rs
+++ b/ethcore/src/client/test_client.rs
@ -17,6 +17,9 @@
 //! Test client.
 use std::sync::atomic::{AtomicUsize, Ordering as AtomicOrder};
 use std::sync::Arc;
 use std::collections::{HashMap, BTreeMap};
 use std::mem;
 use rustc_hex::FromHex;
 use util::*;
 use rlp::*;
@ -36,7 +39,8 @@ use log_entry::LocalizedLogEntry;
 use receipt::{Receipt, LocalizedReceipt};
 use blockchain::extras::BlockReceipts;
 use error::{ImportResult, Error as EthcoreError};
-use evm::{Factory as EvmFactory, VMType, Schedule};
+use evm::{Factory as EvmFactory, VMType};
 use vm::Schedule;
 use miner::{Miner, MinerService, TransactionImportResult};
 use spec::Spec;
 use types::basic_account::BasicAccount;
@ -397,10 +401,18 @@ impl MiningBlockChainClient for TestBlockChainClient {
 }
 impl BlockChainClient for TestBlockChainClient {
-	fn call(&self, _t: &SignedTransaction, _block: BlockId, _analytics: CallAnalytics) -> Result<Executed, CallError> {
+	fn call(&self, _t: &SignedTransaction, _analytics: CallAnalytics, _block: BlockId) -> Result<Executed, CallError> {
 		self.execution_result.read().clone().unwrap()
 	}
 	fn call_many(&self, txs: &[(SignedTransaction, CallAnalytics)], block: BlockId) -> Result<Vec<Executed>, CallError> {
 		let mut res = Vec::with_capacity(txs.len());
 		for &(ref tx, analytics) in txs {
 			res.push(self.call(tx, analytics, block)?);
 		}
 		Ok(res)
 	}
 	fn estimate_gas(&self, _t: &SignedTransaction, _block: BlockId) -> Result<U256, CallError> {
 		Ok(21000.into())
 	}
@ -419,7 +431,7 @@ impl BlockChainClient for TestBlockChainClient {
 	fn nonce(&self, address: &Address, id: BlockId) -> Option<U256> {
 		match id {
-			BlockId::Latest => Some(self.nonces.read().get(address).cloned().unwrap_or(self.spec.params().account_start_nonce)),
+			BlockId::Latest | BlockId::Pending => Some(self.nonces.read().get(address).cloned().unwrap_or(self.spec.params().account_start_nonce)),
 			_ => None,
 		}
 	}
@ -434,16 +446,15 @@ impl BlockChainClient for TestBlockChainClient {
 	fn code(&self, address: &Address, id: BlockId) -> Option<Option<Bytes>> {
 		match id {
-			BlockId::Latest => Some(self.code.read().get(address).cloned()),
+			BlockId::Latest | BlockId::Pending => Some(self.code.read().get(address).cloned()),
 			_ => None,
 		}
 	}
 	fn balance(&self, address: &Address, id: BlockId) -> Option<U256> {
-		if let BlockId::Latest = id {
+		match id {
-			Some(self.balances.read().get(address).cloned().unwrap_or_else(U256::zero))
+			BlockId::Latest | BlockId::Pending => Some(self.balances.read().get(address).cloned().unwrap_or_else(U256::zero)),
-		} else {
+			_ => None,
 			None
 		}
 	}
@ -452,10 +463,9 @@ impl BlockChainClient for TestBlockChainClient {
 	}
 	fn storage_at(&self, address: &Address, position: &H256, id: BlockId) -> Option<H256> {
-		if let BlockId::Latest = id {
+		match id {
-			Some(self.storage.read().get(&(address.clone(), position.clone())).cloned().unwrap_or_else(H256::new))
+			BlockId::Latest | BlockId::Pending => Some(self.storage.read().get(&(address.clone(), position.clone())).cloned().unwrap_or_else(H256::new)),
-		} else {
+			_ => None,
 			None
 		}
 	}
@ -544,7 +554,8 @@ impl BlockChainClient for TestBlockChainClient {
 		match id {
 			BlockId::Number(number) if (number as usize) < self.blocks.read().len() => BlockStatus::InChain,
 			BlockId::Hash(ref hash) if self.blocks.read().get(hash).is_some() => BlockStatus::InChain,
-			BlockId::Latest | BlockId::Pending | BlockId::Earliest => BlockStatus::InChain,
+			BlockId::Latest | BlockId::Earliest => BlockStatus::InChain,
 			BlockId::Pending => BlockStatus::Pending,
 			_ => BlockStatus::Unknown,
 		}
 	}
--- a/ethcore/src/client/traits.rs
+++ b/ethcore/src/client/traits.rs
@ -19,7 +19,7 @@ use std::collections::BTreeMap;
 use block::{OpenBlock, SealedBlock, ClosedBlock};
 use blockchain::TreeRoute;
 use encoded;
-use evm::env_info::LastHashes;
+use vm::LastHashes;
 use error::{ImportResult, CallError, Error as EthcoreError};
 use error::{TransactionImportResult, BlockImportError};
 use evm::{Factory as EvmFactory, Schedule};
@ -182,7 +182,11 @@ pub trait BlockChainClient : Sync + Send {
 	fn logs(&self, filter: Filter) -> Vec<LocalizedLogEntry>;
 	/// Makes a non-persistent transaction call.
-	fn call(&self, t: &SignedTransaction, block: BlockId, analytics: CallAnalytics) -> Result<Executed, CallError>;
+	fn call(&self, tx: &SignedTransaction, analytics: CallAnalytics, block: BlockId) -> Result<Executed, CallError>;
 	/// Makes multiple non-persistent but dependent transaction calls.
 	/// Returns a vector of successes or a failure if any of the transaction fails.
 	fn call_many(&self, txs: &[(SignedTransaction, CallAnalytics)], block: BlockId) -> Result<Vec<Executed>, CallError>;
 	/// Estimates how much gas will be necessary for a call.
 	fn estimate_gas(&self, t: &SignedTransaction, block: BlockId) -> Result<U256, CallError>;
--- a/ethcore/src/engines/authority_round/mod.rs
+++ b/ethcore/src/engines/authority_round/mod.rs
@ -17,8 +17,10 @@
 //! A blockchain engine that supports a non-instant BFT proof-of-authority.
 use std::sync::atomic::{AtomicUsize, AtomicBool, Ordering as AtomicOrdering};
-use std::sync::Weak;
+use std::sync::{Weak, Arc};
 use std::time::{UNIX_EPOCH, Duration};
 use std::collections::{BTreeMap, HashSet, HashMap};
 use std::cmp;
 use account_provider::AccountProvider;
 use block::*;
@ -47,22 +49,14 @@ mod finality;
 /// `AuthorityRound` params.
 pub struct AuthorityRoundParams {
 	/// Gas limit divisor.
 	pub gas_limit_bound_divisor: U256,
 	/// Time to wait before next block or authority switching.
 	pub step_duration: Duration,
 	/// Block reward.
 	pub block_reward: U256,
 	/// Namereg contract address.
 	pub registrar: Address,
 	/// Starting step,
 	pub start_step: Option<u64>,
 	/// Valid validators.
 	pub validators: Box<ValidatorSet>,
 	/// Chain score validation transition block.
 	pub validate_score_transition: u64,
 	/// Number of first block where EIP-155 rules are validated.
 	pub eip155_transition: u64,
 	/// Monotonic step validation transition block.
 	pub validate_step_transition: u64,
 	/// Immediate transitions.
@ -72,14 +66,10 @@ pub struct AuthorityRoundParams {
 impl From<ethjson::spec::AuthorityRoundParams> for AuthorityRoundParams {
 	fn from(p: ethjson::spec::AuthorityRoundParams) -> Self {
 		AuthorityRoundParams {
 			gas_limit_bound_divisor: p.gas_limit_bound_divisor.into(),
 			step_duration: Duration::from_secs(p.step_duration.into()),
 			validators: new_validator_set(p.validators),
 			block_reward: p.block_reward.map_or_else(U256::zero, Into::into),
 			registrar: p.registrar.map_or_else(Address::new, Into::into),
 			start_step: p.start_step.map(Into::into),
 			validate_score_transition: p.validate_score_transition.map_or(0, Into::into),
 			eip155_transition: p.eip155_transition.map_or(0, Into::into),
 			validate_step_transition: p.validate_step_transition.map_or(0, Into::into),
 			immediate_transitions: p.immediate_transitions.unwrap_or(false),
 		}
@ -214,9 +204,6 @@ impl EpochManager {
 /// Engine using `AuthorityRound` proof-of-authority BFT consensus.
 pub struct AuthorityRound {
 	params: CommonParams,
 	gas_limit_bound_divisor: U256,
 	block_reward: U256,
 	registrar: Address,
 	builtins: BTreeMap<Address, Builtin>,
 	transition_service: IoService<()>,
 	step: Arc<Step>,
@ -225,7 +212,6 @@ pub struct AuthorityRound {
 	signer: RwLock<EngineSigner>,
 	validators: Box<ValidatorSet>,
 	validate_score_transition: u64,
 	eip155_transition: u64,
 	validate_step_transition: u64,
 	epoch_manager: Mutex<EpochManager>,
 	immediate_transitions: bool,
@ -362,9 +348,6 @@ impl AuthorityRound {
 		let engine = Arc::new(
 			AuthorityRound {
 				params: params,
 				gas_limit_bound_divisor: our_params.gas_limit_bound_divisor,
 				block_reward: our_params.block_reward,
 				registrar: our_params.registrar,
 				builtins: builtins,
 				transition_service: IoService::<()>::start()?,
 				step: Arc::new(Step {
@ -377,7 +360,6 @@ impl AuthorityRound {
 				signer: Default::default(),
 				validators: our_params.validators,
 				validate_score_transition: our_params.validate_score_transition,
 				eip155_transition: our_params.eip155_transition,
 				validate_step_transition: our_params.validate_step_transition,
 				epoch_manager: Mutex::new(EpochManager::blank()),
 				immediate_transitions: our_params.immediate_transitions,
@ -433,7 +415,9 @@ impl Engine for AuthorityRound {
 	fn params(&self) -> &CommonParams { &self.params }
-	fn additional_params(&self) -> HashMap<String, String> { hash_map!["registrar".to_owned() => self.registrar.hex()] }
+	fn additional_params(&self) -> HashMap<String, String> {
 		hash_map!["registrar".to_owned() => self.params().registrar.hex()]
 	}
 	fn builtins(&self) -> &BTreeMap<Address, Builtin> { &self.builtins }
@ -461,11 +445,11 @@ impl Engine for AuthorityRound {
 		header.set_difficulty(new_difficulty);
 		header.set_gas_limit({
 			let gas_limit = parent.gas_limit().clone();
-			let bound_divisor = self.gas_limit_bound_divisor;
+			let bound_divisor = self.params().gas_limit_bound_divisor;
 			if gas_limit < gas_floor_target {
-				min(gas_floor_target, gas_limit + gas_limit / bound_divisor - 1.into())
+				cmp::min(gas_floor_target, gas_limit + gas_limit / bound_divisor - 1.into())
 			} else {
-				max(gas_floor_target, gas_limit - gas_limit / bound_divisor + 1.into())
+				cmp::max(gas_floor_target, gas_limit - gas_limit / bound_divisor + 1.into())
 			}
 		});
 	}
@ -476,8 +460,8 @@ impl Engine for AuthorityRound {
 	/// Attempt to seal the block internally.
 	///
-	/// This operation is synchronous and may (quite reasonably) not be available, in which `false` will
+	/// This operation is synchronous and may (quite reasonably) not be available, in which case
-	/// be returned.
+	/// `Seal::None` will be returned.
 	fn generate_seal(&self, block: &ExecutedBlock) -> Seal {
 		// first check to avoid generating signature most of the time
 		// (but there's still a race to the `compare_and_swap`)
@ -532,7 +516,7 @@ impl Engine for AuthorityRound {
 	fn on_new_block(
 		&self,
 		block: &mut ExecutedBlock,
-		last_hashes: Arc<::evm::env_info::LastHashes>,
+		last_hashes: Arc<::vm::LastHashes>,
 		epoch_begin: bool,
 	) -> Result<(), Error> {
 		let parent_hash = block.fields().header.parent_hash().clone();
@ -564,7 +548,8 @@ impl Engine for AuthorityRound {
 	fn on_close_block(&self, block: &mut ExecutedBlock) -> Result<(), Error> {
 		let fields = block.fields_mut();
 		// Bestow block reward
-		let res = fields.state.add_balance(fields.header.author(), &self.block_reward, CleanupMode::NoEmpty)
+		let reward = self.params().block_reward;
 		let res = fields.state.add_balance(fields.header.author(), &reward, CleanupMode::NoEmpty)
 			.map_err(::error::Error::from)
 			.and_then(|_| fields.state.commit());
 		// Commit state so that we can actually figure out the state root.
@ -629,7 +614,7 @@ impl Engine for AuthorityRound {
 			}
 		}
-		let gas_limit_divisor = self.gas_limit_bound_divisor;
+		let gas_limit_divisor = self.params().gas_limit_bound_divisor;
 		let min_gas = parent.gas_limit().clone() - parent.gas_limit().clone() / gas_limit_divisor;
 		let max_gas = parent.gas_limit().clone() + parent.gas_limit().clone() / gas_limit_divisor;
 		if header.gas_limit() <= &min_gas || header.gas_limit() >= &max_gas {
@ -815,11 +800,11 @@ impl Engine for AuthorityRound {
 		}
 	}
-	fn verify_transaction_basic(&self, t: &UnverifiedTransaction, header: &Header) -> result::Result<(), Error> {
+	fn verify_transaction_basic(&self, t: &UnverifiedTransaction, header: &Header) -> Result<(), Error> {
 		t.check_low_s()?;
 		if let Some(n) = t.network_id() {
-			if header.number() >= self.eip155_transition && n != self.params().chain_id {
+			if header.number() >= self.params().eip155_transition && n != self.params().chain_id {
 				return Err(TransactionError::InvalidNetworkId.into());
 			}
 		}
@ -851,6 +836,7 @@ impl Engine for AuthorityRound {
 #[cfg(test)]
 mod tests {
 	use std::sync::Arc;
 	use std::sync::atomic::{AtomicUsize, Ordering as AtomicOrdering};
 	use util::*;
 	use header::Header;
@ -941,10 +927,10 @@ mod tests {
 		let addr = tap.insert_account("0".sha3().into(), "0").unwrap();
 		let mut parent_header: Header = Header::default();
 		parent_header.set_seal(vec![encode(&0usize).into_vec()]);
-		parent_header.set_gas_limit(U256::from_str("222222").unwrap());
+		parent_header.set_gas_limit("222222".parse::<U256>().unwrap());
 		let mut header: Header = Header::default();
 		header.set_number(1);
-		header.set_gas_limit(U256::from_str("222222").unwrap());
+		header.set_gas_limit("222222".parse::<U256>().unwrap());
 		header.set_author(addr);
 		let engine = Spec::new_test_round().engine;
@ -967,10 +953,10 @@ mod tests {
 		let mut parent_header: Header = Header::default();
 		parent_header.set_seal(vec![encode(&0usize).into_vec()]);
-		parent_header.set_gas_limit(U256::from_str("222222").unwrap());
+		parent_header.set_gas_limit("222222".parse::<U256>().unwrap());
 		let mut header: Header = Header::default();
 		header.set_number(1);
-		header.set_gas_limit(U256::from_str("222222").unwrap());
+		header.set_gas_limit("222222".parse::<U256>().unwrap());
 		header.set_author(addr);
 		let engine = Spec::new_test_round().engine;
@ -993,10 +979,10 @@ mod tests {
 		let mut parent_header: Header = Header::default();
 		parent_header.set_seal(vec![encode(&4usize).into_vec()]);
-		parent_header.set_gas_limit(U256::from_str("222222").unwrap());
+		parent_header.set_gas_limit("222222".parse::<U256>().unwrap());
 		let mut header: Header = Header::default();
 		header.set_number(1);
-		header.set_gas_limit(U256::from_str("222222").unwrap());
+		header.set_gas_limit("222222".parse::<U256>().unwrap());
 		header.set_author(addr);
 		let engine = Spec::new_test_round().engine;
@ -1014,25 +1000,26 @@ mod tests {
 	fn reports_skipped() {
 		let last_benign = Arc::new(AtomicUsize::new(0));
 		let params = AuthorityRoundParams {
 			gas_limit_bound_divisor: U256::from_str("400").unwrap(),
 			step_duration: Default::default(),
 			block_reward: Default::default(),
 			registrar: Default::default(),
 			start_step: Some(1),
 			validators: Box::new(TestSet::new(Default::default(), last_benign.clone())),
 			validate_score_transition: 0,
 			validate_step_transition: 0,
 			eip155_transition: 0,
 			immediate_transitions: true,
 		};
-		let aura = AuthorityRound::new(Default::default(), params, Default::default()).unwrap();
+
 		let aura = {
 			let mut c_params = ::spec::CommonParams::default();
 			c_params.gas_limit_bound_divisor = 5.into();
 			AuthorityRound::new(c_params, params, Default::default()).unwrap()
 		};
 		let mut parent_header: Header = Header::default();
 		parent_header.set_seal(vec![encode(&1usize).into_vec()]);
-		parent_header.set_gas_limit(U256::from_str("222222").unwrap());
+		parent_header.set_gas_limit("222222".parse::<U256>().unwrap());
 		let mut header: Header = Header::default();
 		header.set_number(1);
-		header.set_gas_limit(U256::from_str("222222").unwrap());
+		header.set_gas_limit("222222".parse::<U256>().unwrap());
 		header.set_seal(vec![encode(&3usize).into_vec()]);
 		// Do not report when signer not present.
--- a/ethcore/src/engines/basic_authority.rs
+++ b/ethcore/src/engines/basic_authority.rs
@ -16,7 +16,9 @@
 //! A blockchain engine that supports a basic, non-BFT proof-of-authority.
-use std::sync::Weak;
+use std::sync::{Weak, Arc};
 use std::collections::BTreeMap;
 use std::cmp;
 use util::*;
 use ethkey::{recover, public_to_address, Signature};
 use account_provider::AccountProvider;
@ -35,8 +37,6 @@ use super::validator_set::{ValidatorSet, SimpleList, new_validator_set};
 /// `BasicAuthority` params.
 #[derive(Debug, PartialEq)]
 pub struct BasicAuthorityParams {
 	/// Gas limit divisor.
 	pub gas_limit_bound_divisor: U256,
 	/// Valid signatories.
 	pub validators: ethjson::spec::ValidatorSet,
 }
@ -44,7 +44,6 @@ pub struct BasicAuthorityParams {
 impl From<ethjson::spec::BasicAuthorityParams> for BasicAuthorityParams {
 	fn from(p: ethjson::spec::BasicAuthorityParams) -> Self {
 		BasicAuthorityParams {
 			gas_limit_bound_divisor: p.gas_limit_bound_divisor.into(),
 			validators: p.validators,
 		}
 	}
@ -80,7 +79,6 @@ fn verify_external(header: &Header, validators: &ValidatorSet) -> Result<(), Err
 /// Engine using `BasicAuthority`, trivial proof-of-authority consensus.
 pub struct BasicAuthority {
 	params: CommonParams,
 	gas_limit_bound_divisor: U256,
 	builtins: BTreeMap<Address, Builtin>,
 	signer: RwLock<EngineSigner>,
 	validators: Box<ValidatorSet>,
@ -91,7 +89,6 @@ impl BasicAuthority {
 	pub fn new(params: CommonParams, our_params: BasicAuthorityParams, builtins: BTreeMap<Address, Builtin>) -> Self {
 		BasicAuthority {
 			params: params,
 			gas_limit_bound_divisor: our_params.gas_limit_bound_divisor,
 			builtins: builtins,
 			validators: new_validator_set(our_params.validators),
 			signer: Default::default(),
@ -119,11 +116,11 @@ impl Engine for BasicAuthority {
 		header.set_difficulty(parent.difficulty().clone());
 		header.set_gas_limit({
 			let gas_limit = parent.gas_limit().clone();
-			let bound_divisor = self.gas_limit_bound_divisor;
+			let bound_divisor = self.params().gas_limit_bound_divisor;
 			if gas_limit < gas_floor_target {
-				min(gas_floor_target, gas_limit + gas_limit / bound_divisor - 1.into())
+				cmp::min(gas_floor_target, gas_limit + gas_limit / bound_divisor - 1.into())
 			} else {
-				max(gas_floor_target, gas_limit - gas_limit / bound_divisor + 1.into())
+				cmp::max(gas_floor_target, gas_limit - gas_limit / bound_divisor + 1.into())
 			}
 		});
 	}
@ -147,7 +144,7 @@ impl Engine for BasicAuthority {
 		Seal::None
 	}
-	fn verify_block_basic(&self, header: &Header, _block: Option<&[u8]>) -> result::Result<(), Error> {
+	fn verify_block_basic(&self, header: &Header, _block: Option<&[u8]>) -> Result<(), Error> {
 		// check the seal fields.
 		// TODO: pull this out into common code.
 		if header.seal().len() != self.seal_fields() {
@ -158,11 +155,11 @@ impl Engine for BasicAuthority {
 		Ok(())
 	}
-	fn verify_block_unordered(&self, _header: &Header, _block: Option<&[u8]>) -> result::Result<(), Error> {
+	fn verify_block_unordered(&self, _header: &Header, _block: Option<&[u8]>) -> Result<(), Error> {
 		Ok(())
 	}
-	fn verify_block_family(&self, header: &Header, parent: &Header, _block: Option<&[u8]>) -> result::Result<(), Error> {
+	fn verify_block_family(&self, header: &Header, parent: &Header, _block: Option<&[u8]>) -> Result<(), Error> {
 		// Do not calculate difficulty for genesis blocks.
 		if header.number() == 0 {
 			return Err(From::from(BlockError::RidiculousNumber(OutOfBounds { min: Some(1), max: None, found: header.number() })));
@ -172,7 +169,7 @@ impl Engine for BasicAuthority {
 		if header.difficulty() != parent.difficulty() {
 			return Err(From::from(BlockError::InvalidDifficulty(Mismatch { expected: *parent.difficulty(), found: *header.difficulty() })))
 		}
-		let gas_limit_divisor = self.gas_limit_bound_divisor;
+		let gas_limit_divisor = self.params().gas_limit_bound_divisor;
 		let min_gas = parent.gas_limit().clone() - parent.gas_limit().clone() / gas_limit_divisor;
 		let max_gas = parent.gas_limit().clone() + parent.gas_limit().clone() / gas_limit_divisor;
 		if header.gas_limit() <= &min_gas || header.gas_limit() >= &max_gas {
@ -254,6 +251,7 @@ impl Engine for BasicAuthority {
 #[cfg(test)]
 mod tests {
 	use std::sync::Arc;
 	use util::*;
 	use block::*;
 	use error::{BlockError, Error};
--- a/ethcore/src/engines/epoch_verifier.rs
+++ b/ethcore/src/engines/epoch_verifier.rs
@ -1,49 +0,0 @@
 // Copyright 2015-2017 Parity Technologies (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/>.
 // Epoch verifiers.
 use error::Error;
 use header::Header;
 /// Verifier for all blocks within an epoch with self-contained state.
 ///
 /// See docs on `Engine` relating to proving functions for more details.
 pub trait EpochVerifier: Send + Sync {
 	/// Get the epoch number.
 	fn epoch_number(&self) -> u64;
 	/// Lightly verify the next block header.
 	/// This may not be a header belonging to a different epoch.
 	fn verify_light(&self, header: &Header) -> Result<(), Error>;
 	/// Perform potentially heavier checks on the next block header.
 	fn verify_heavy(&self, header: &Header) -> Result<(), Error> {
 		self.verify_light(header)
 	}
 	/// Check if the header is the end of an epoch.
 	fn is_epoch_end(&self, header: &Header, Ancestry) -> EpochChange;
 }
 /// Special "no-op" verifier for stateless, epoch-less engines.
 pub struct NoOp;
 impl EpochVerifier for NoOp {
 	fn epoch_number(&self) -> u64 { 0 }
 	fn verify_light(&self, _header: &Header) -> Result<(), Error> { Ok(()) }
 }
--- a/ethcore/src/engines/instant_seal.rs
+++ b/ethcore/src/engines/instant_seal.rs
@ -14,26 +14,24 @@
 // 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 std::collections::{BTreeMap, HashMap};
-use util::{Address, HashMap};
+use util::Address;
 use builtin::Builtin;
 use engines::{Engine, Seal};
 use spec::CommonParams;
-use block::ExecutedBlock;
+use block::{ExecutedBlock, IsBlock};
 /// An engine which does not provide any consensus mechanism, just seals blocks internally.
 pub struct InstantSeal {
 	params: CommonParams,
 	registrar: Address,
 	builtins: BTreeMap<Address, Builtin>,
 }
 impl InstantSeal {
 	/// Returns new instance of InstantSeal with default VM Factory
-	pub fn new(params: CommonParams, registrar: Address, builtins: BTreeMap<Address, Builtin>) -> Self {
+	pub fn new(params: CommonParams, builtins: BTreeMap<Address, Builtin>) -> Self {
 		InstantSeal {
 			params: params,
 			registrar: registrar,
 			builtins: builtins,
 		}
 	}
@ -49,7 +47,7 @@ impl Engine for InstantSeal {
 	}
 	fn additional_params(&self) -> HashMap<String, String> {
-		hash_map!["registrar".to_owned() => self.registrar.hex()]
+		hash_map!["registrar".to_owned() => self.params().registrar.hex()]
 	}
 	fn builtins(&self) -> &BTreeMap<Address, Builtin> {
@ -58,13 +56,14 @@ impl Engine for InstantSeal {
 	fn seals_internally(&self) -> Option<bool> { Some(true) }
-	fn generate_seal(&self, _block: &ExecutedBlock) -> Seal {
+	fn generate_seal(&self, block: &ExecutedBlock) -> Seal {
-		Seal::Regular(Vec::new())
+		if block.transactions().is_empty() { Seal::None } else { Seal::Regular(Vec::new()) }
 	}
 }
 #[cfg(test)]
 mod tests {
 	use std::sync::Arc;
 	use util::*;
 	use tests::helpers::*;
 	use spec::Spec;
--- a/ethcore/src/engines/mod.rs
+++ b/ethcore/src/engines/mod.rs
@ -35,7 +35,9 @@ pub use self::instant_seal::InstantSeal;
 pub use self::null_engine::NullEngine;
 pub use self::tendermint::Tendermint;
-use std::sync::Weak;
+use std::sync::{Weak, Arc};
 use std::collections::{BTreeMap, HashMap};
 use std::fmt;
 use self::epoch::PendingTransition;
@ -43,15 +45,13 @@ use account_provider::AccountProvider;
 use block::ExecutedBlock;
 use builtin::Builtin;
 use client::Client;
-use evm::env_info::{EnvInfo, LastHashes};
+use vm::{EnvInfo, LastHashes, Schedule, CreateContractAddress};
 use error::Error;
 use evm::Schedule;
 use header::{Header, BlockNumber};
 use receipt::Receipt;
 use snapshot::SnapshotComponents;
 use spec::CommonParams;
 use transaction::{UnverifiedTransaction, SignedTransaction};
 use evm::CreateContractAddress;
 use ethkey::Signature;
 use util::*;
@ -393,13 +393,12 @@ pub trait Engine : Sync + Send {
 /// Common engine utilities
 pub mod common {
 	use std::sync::Arc;
 	use block::ExecutedBlock;
 	use evm::env_info::{EnvInfo, LastHashes};
 	use error::Error;
 	use transaction::SYSTEM_ADDRESS;
 	use executive::Executive;
-	use evm::CallType;
+	use vm::{CallType, ActionParams, ActionValue, EnvInfo, LastHashes};
 	use evm::action_params::{ActionParams, ActionValue};
 	use trace::{NoopTracer, NoopVMTracer};
 	use state::Substate;
--- a/ethcore/src/engines/signer.rs
+++ b/ethcore/src/engines/signer.rs
@ -16,7 +16,8 @@
 //! A signer used by Engines which need to sign messages.
-use util::{Arc, H256, Address};
+use std::sync::Arc;
 use util::{H256, Address};
 use ethkey::Signature;
 use account_provider::{self, AccountProvider};
--- a/ethcore/src/engines/tendermint/message.rs
+++ b/ethcore/src/engines/tendermint/message.rs
@ -16,6 +16,7 @@
 //! Tendermint message handling.
 use std::cmp;
 use util::*;
 use super::{Height, View, BlockHash, Step};
 use error::Error;
@ -110,13 +111,13 @@ impl Default for VoteStep {
 }
 impl PartialOrd for VoteStep {
-	fn partial_cmp(&self, m: &VoteStep) -> Option<Ordering> {
+	fn partial_cmp(&self, m: &VoteStep) -> Option<cmp::Ordering> {
 		Some(self.cmp(m))
 	}
 }
 impl Ord for VoteStep {
-	fn cmp(&self, m: &VoteStep) -> Ordering {
+	fn cmp(&self, m: &VoteStep) -> cmp::Ordering {
 		if self.height != m.height {
 			self.height.cmp(&m.height)
 		} else if self.view != m.view {
@ -198,6 +199,7 @@ pub fn message_hash(vote_step: VoteStep, block_hash: H256) -> H256 {
 #[cfg(test)]
 mod tests {
 	use std::sync::Arc;
 	use util::*;
 	use rlp::*;
 	use account_provider::AccountProvider;
--- a/ethcore/src/engines/tendermint/mod.rs
+++ b/ethcore/src/engines/tendermint/mod.rs
@ -25,23 +25,25 @@
 mod message;
 mod params;
-use std::sync::Weak;
+use std::sync::{Weak, Arc};
 use std::sync::atomic::{AtomicUsize, Ordering as AtomicOrdering};
 use std::collections::{HashSet, BTreeMap, HashMap};
 use std::cmp;
 use util::*;
 use client::{Client, EngineClient};
 use error::{Error, BlockError};
 use header::{Header, BlockNumber};
 use builtin::Builtin;
 use rlp::UntrustedRlp;
-use ethkey::{recover, public_to_address, Signature};
+use ethkey::{Message, public_to_address, recover, Signature};
 use account_provider::AccountProvider;
 use block::*;
 use spec::CommonParams;
-use engines::{Engine, Seal, EngineError};
+use engines::{Engine, Seal, EngineError, ConstructedVerifier};
 use state::CleanupMode;
 use io::IoService;
 use super::signer::EngineSigner;
-use super::validator_set::ValidatorSet;
+use super::validator_set::{ValidatorSet, SimpleList};
 use super::transition::TransitionHandler;
 use super::vote_collector::VoteCollector;
 use self::message::*;
@ -71,12 +73,9 @@ pub type BlockHash = H256;
 /// Engine using `Tendermint` consensus algorithm, suitable for EVM chain.
 pub struct Tendermint {
 	params: CommonParams,
 	gas_limit_bound_divisor: U256,
 	builtins: BTreeMap<Address, Builtin>,
 	step_service: IoService<Step>,
 	client: RwLock<Option<Weak<EngineClient>>>,
 	block_reward: U256,
 	registrar: Address,
 	/// Blockchain height.
 	height: AtomicUsize,
 	/// Consensus view.
@ -101,18 +100,74 @@ pub struct Tendermint {
 	validators: Box<ValidatorSet>,
 }
 struct EpochVerifier<F>
 	where F: Fn(&Signature, &Message) -> Result<Address, Error> + Send + Sync
 {
 	subchain_validators: SimpleList,
 	recover: F
 }
 impl <F> super::EpochVerifier for EpochVerifier<F>
 	where F: Fn(&Signature, &Message) -> Result<Address, Error> + Send + Sync
 {
 	fn verify_light(&self, header: &Header) -> Result<(), Error> {
 		let message = header.bare_hash();
 		let mut addresses = HashSet::new();
 		let ref header_signatures_field = header.seal().get(2).ok_or(BlockError::InvalidSeal)?;
 		for rlp in UntrustedRlp::new(header_signatures_field).iter() {
 			let signature: H520 = rlp.as_val()?;
 			let address = (self.recover)(&signature.into(), &message)?;
 			if !self.subchain_validators.contains(header.parent_hash(), &address) {
 				return Err(EngineError::NotAuthorized(address.to_owned()).into());
 			}
 			addresses.insert(address);
 		}
 		let n = addresses.len();
 		let threshold = self.subchain_validators.len() * 2/3;
 		if n > threshold {
 			Ok(())
 		} else {
 			Err(EngineError::BadSealFieldSize(OutOfBounds {
 				min: Some(threshold),
 				max: None,
 				found: n
 			}).into())
 		}
 	}
 	fn check_finality_proof(&self, proof: &[u8]) -> Option<Vec<H256>> {
 		let header: Header = ::rlp::decode(proof);
 		self.verify_light(&header).ok().map(|_| vec![header.hash()])
 	}
 }
 fn combine_proofs(signal_number: BlockNumber, set_proof: &[u8], finality_proof: &[u8]) -> Vec<u8> {
 	let mut stream = ::rlp::RlpStream::new_list(3);
 	stream.append(&signal_number).append(&set_proof).append(&finality_proof);
 	stream.out()
 }
 fn destructure_proofs(combined: &[u8]) -> Result<(BlockNumber, &[u8], &[u8]), Error> {
 	let rlp = UntrustedRlp::new(combined);
 	Ok((
 		rlp.at(0)?.as_val()?,
 		rlp.at(1)?.data()?,
 		rlp.at(2)?.data()?,
 	))
 }
 impl Tendermint {
 	/// Create a new instance of Tendermint engine
 	pub fn new(params: CommonParams, our_params: TendermintParams, builtins: BTreeMap<Address, Builtin>) -> Result<Arc<Self>, Error> {
 		let engine = Arc::new(
 			Tendermint {
 				params: params,
 				gas_limit_bound_divisor: our_params.gas_limit_bound_divisor,
 				builtins: builtins,
 				client: RwLock::new(None),
 				step_service: IoService::<Step>::start()?,
 				block_reward: our_params.block_reward,
 				registrar: our_params.registrar,
 				height: AtomicUsize::new(1),
 				view: AtomicUsize::new(0),
 				step: RwLock::new(Step::Propose),
@ -387,7 +442,9 @@ impl Engine for Tendermint {
 	fn params(&self) -> &CommonParams { &self.params }
-	fn additional_params(&self) -> HashMap<String, String> { hash_map!["registrar".to_owned() => self.registrar.hex()] }
+	fn additional_params(&self) -> HashMap<String, String> {
 		hash_map!["registrar".to_owned() => self.params().registrar.hex()]
 	}
 	fn builtins(&self) -> &BTreeMap<Address, Builtin> { &self.builtins }
@ -412,11 +469,11 @@ impl Engine for Tendermint {
 		header.set_difficulty(new_difficulty);
 		header.set_gas_limit({
 			let gas_limit = parent.gas_limit().clone();
-			let bound_divisor = self.gas_limit_bound_divisor;
+			let bound_divisor = self.params().gas_limit_bound_divisor;
 			if gas_limit < gas_floor_target {
-				min(gas_floor_target, gas_limit + gas_limit / bound_divisor - 1.into())
+				cmp::min(gas_floor_target, gas_limit + gas_limit / bound_divisor - 1.into())
 			} else {
-				max(gas_floor_target, gas_limit - gas_limit / bound_divisor + 1.into())
+				cmp::max(gas_floor_target, gas_limit - gas_limit / bound_divisor + 1.into())
 			}
 		});
 	}
@ -427,6 +484,9 @@ impl Engine for Tendermint {
 	}
 	/// Attempt to seal generate a proposal seal.
 	///
 	/// This operation is synchronous and may (quite reasonably) not be available, in which case
 	/// `Seal::None` will be returned.
 	fn generate_seal(&self, block: &ExecutedBlock) -> Seal {
 		let header = block.header();
 		let author = header.author();
@ -483,7 +543,8 @@ impl Engine for Tendermint {
 	fn on_close_block(&self, block: &mut ExecutedBlock) -> Result<(), Error>{
 		let fields = block.fields_mut();
 		// Bestow block reward
-		let res = fields.state.add_balance(fields.header.author(), &self.block_reward, CleanupMode::NoEmpty)
+		let reward = self.params().block_reward;
 		let res = fields.state.add_balance(fields.header.author(), &reward, CleanupMode::NoEmpty)
 			.map_err(::error::Error::from)
 			.and_then(|_| fields.state.commit());
 		// Commit state so that we can actually figure out the state root.
@ -555,7 +616,7 @@ impl Engine for Tendermint {
 			self.check_above_threshold(origins.len())?
 		}
-		let gas_limit_divisor = self.gas_limit_bound_divisor;
+		let gas_limit_divisor = self.params().gas_limit_bound_divisor;
 		let min_gas = parent.gas_limit().clone() - parent.gas_limit().clone() / gas_limit_divisor;
 		let max_gas = parent.gas_limit().clone() + parent.gas_limit().clone() / gas_limit_divisor;
 		if header.gas_limit() <= &min_gas || header.gas_limit() >= &max_gas {
@ -566,6 +627,57 @@ impl Engine for Tendermint {
 		Ok(())
 	}
 	fn signals_epoch_end(&self, header: &Header, block: Option<&[u8]>, receipts: Option<&[::receipt::Receipt]>)
 		-> super::EpochChange
 	{
 		let first = header.number() == 0;
 		self.validators.signals_epoch_end(first, header, block, receipts)
 	}
 	fn is_epoch_end(
 		&self,
 		chain_head: &Header,
 		_chain: &super::Headers,
 		transition_store: &super::PendingTransitionStore,
 	) -> Option<Vec<u8>> {
 		let first = chain_head.number() == 0;
 		if let Some(change) = self.validators.is_epoch_end(first, chain_head) {
 			return Some(change)
 		} else if let Some(pending) = transition_store(chain_head.hash()) {
 			let signal_number = chain_head.number();
 			let finality_proof = ::rlp::encode(chain_head);
 			return Some(combine_proofs(signal_number, &pending.proof, &finality_proof))
 		}
 		None
 	}
 	fn epoch_verifier<'a>(&self, _header: &Header, proof: &'a [u8]) -> ConstructedVerifier<'a> {
 		let (signal_number, set_proof, finality_proof) = match destructure_proofs(proof) {
 			Ok(x) => x,
 			Err(e) => return ConstructedVerifier::Err(e),
 		};
 		let first = signal_number == 0;
 		match self.validators.epoch_set(first, self, signal_number, set_proof) {
 			Ok((list, finalize)) => {
 				let verifier = Box::new(EpochVerifier {
 					subchain_validators: list,
 					recover: |signature: &Signature, message: &Message| {
 						Ok(public_to_address(&::ethkey::recover(&signature, &message)?))
 					},
 				});
 				match finalize {
 					Some(finalize) => ConstructedVerifier::Unconfirmed(verifier, finality_proof, finalize),
 					None => ConstructedVerifier::Trusted(verifier),
 				}
 			}
 			Err(e) => ConstructedVerifier::Err(e),
 		}
 	}
 	fn set_signer(&self, ap: Arc<AccountProvider>, address: Address, password: String) {
 		{
 			self.signer.write().set(ap, address, password);
@ -577,6 +689,10 @@ impl Engine for Tendermint {
 		self.signer.read().sign(hash).map_err(Into::into)
 	}
 	fn snapshot_components(&self) -> Option<Box<::snapshot::SnapshotComponents>> {
 		Some(Box::new(::snapshot::PoaSnapshot))
 	}
 	fn stop(&self) {
 		self.step_service.stop()
 	}
@ -654,6 +770,7 @@ impl Engine for Tendermint {
 #[cfg(test)]
 mod tests {
 	use std::str::FromStr;
 	use rustc_hex::FromHex;
 	use util::*;
 	use block::*;
@ -665,6 +782,7 @@ mod tests {
 	use account_provider::AccountProvider;
 	use spec::Spec;
 	use engines::{Engine, EngineError, Seal};
 	use engines::epoch::EpochVerifier;
 	use super::*;
 	/// Accounts inserted with "0" and "1" are validators. First proposer is "0".
@ -932,7 +1050,7 @@ mod tests {
 		client.miner().import_own_transaction(client.as_ref(), transaction.into()).unwrap();
 		// Propose
-		let proposal = Some(client.miner().pending_block().unwrap().header.bare_hash());
+		let proposal = Some(client.miner().pending_block(0).unwrap().header.bare_hash());
 		// Propose timeout
 		engine.step();
@ -949,4 +1067,76 @@ mod tests {
 		vote(engine, |mh| tap.sign(v0, None, mh).map(H520::from), h, r, Step::Precommit, proposal);
 		assert_eq!(client.chain_info().best_block_number, 1);
 	}
 	#[test]
 	fn epoch_verifier_verify_light() {
 		use ethkey::Error as EthkeyError;
 		let (spec, tap) = setup();
 		let engine = spec.engine;
 		let mut parent_header: Header = Header::default();
 		parent_header.set_gas_limit(U256::from_str("222222").unwrap());
 		let mut header = Header::default();
 		header.set_number(2);
 		header.set_gas_limit(U256::from_str("222222").unwrap());
 		let proposer = insert_and_unlock(&tap, "1");
 		header.set_author(proposer);
 		let mut seal = proposal_seal(&tap, &header, 0);
 		let vote_info = message_info_rlp(&VoteStep::new(2, 0, Step::Precommit), Some(header.bare_hash()));
 		let signature1 = tap.sign(proposer, None, vote_info.sha3()).unwrap();
 		let voter = insert_and_unlock(&tap, "0");
 		let signature0 = tap.sign(voter, None, vote_info.sha3()).unwrap();
 		seal[1] = ::rlp::NULL_RLP.to_vec();
 		seal[2] = ::rlp::encode_list(&vec![H520::from(signature1.clone())]).into_vec();
 		header.set_seal(seal.clone());
 		let epoch_verifier = super::EpochVerifier {
 			subchain_validators: SimpleList::new(vec![proposer.clone(), voter.clone()]),
 			recover: {
 				let signature1 = signature1.clone();
 				let signature0 = signature0.clone();
 				let proposer = proposer.clone();
 				let voter = voter.clone();
 				move |s: &Signature, _: &Message| {
 					if *s == signature1 {
 						Ok(proposer)
 					} else if *s == signature0 {
 						Ok(voter)
 					} else {
 						Err(Error::Ethkey(EthkeyError::InvalidSignature))
 					}
 				}
 			},
 		};
 		// One good signature is not enough.
 		match epoch_verifier.verify_light(&header) {
 			Err(Error::Engine(EngineError::BadSealFieldSize(_))) => {},
 			_ => panic!(),
 		}
 		seal[2] = ::rlp::encode_list(&vec![H520::from(signature1.clone()), H520::from(signature0.clone())]).into_vec();
 		header.set_seal(seal.clone());
 		assert!(epoch_verifier.verify_light(&header).is_ok());
 		let bad_voter = insert_and_unlock(&tap, "101");
 		let bad_signature = tap.sign(bad_voter, None, vote_info.sha3()).unwrap();
 		seal[2] = ::rlp::encode_list(&vec![H520::from(signature1), H520::from(bad_signature)]).into_vec();
 		header.set_seal(seal);
 		// One good and one bad signature.
 		match epoch_verifier.verify_light(&header) {
 			Err(Error::Ethkey(EthkeyError::InvalidSignature)) => {},
 			_ => panic!(),
 		};
 		engine.stop();
 	}
 }
--- a/ethcore/src/engines/tendermint/params.rs
+++ b/ethcore/src/engines/tendermint/params.rs
@ -17,7 +17,6 @@
 //! Tendermint specific parameters.
 use ethjson;
 use util::{U256, Address};
 use time::Duration;
 use super::super::validator_set::{ValidatorSet, new_validator_set};
 use super::super::transition::Timeouts;
@ -25,16 +24,10 @@ use super::Step;
 /// `Tendermint` params.
 pub struct TendermintParams {
 	/// Gas limit divisor.
 	pub gas_limit_bound_divisor: U256,
 	/// List of validators.
 	pub validators: Box<ValidatorSet>,
 	/// Timeout durations for different steps.
 	pub timeouts: TendermintTimeouts,
 	/// Block reward.
 	pub block_reward: U256,
 	/// Namereg contract address.
 	pub registrar: Address,
 }
 /// Base timeout of each step in ms.
@ -81,7 +74,6 @@ impl From<ethjson::spec::TendermintParams> for TendermintParams {
 	fn from(p: ethjson::spec::TendermintParams) -> Self {
 		let dt = TendermintTimeouts::default();
 		TendermintParams {
 			gas_limit_bound_divisor: p.gas_limit_bound_divisor.into(),
 			validators: new_validator_set(p.validators),
 			timeouts: TendermintTimeouts {
 				propose: p.timeout_propose.map_or(dt.propose, to_duration),
@ -89,8 +81,6 @@ impl From<ethjson::spec::TendermintParams> for TendermintParams {
 				precommit: p.timeout_precommit.map_or(dt.precommit, to_duration),
 				commit: p.timeout_commit.map_or(dt.commit, to_duration),
 			},
 			block_reward: p.block_reward.map_or_else(U256::zero, Into::into),
 			registrar: p.registrar.map_or_else(Address::new, Into::into),
 		}
 	}
 }
--- a/ethcore/src/engines/validator_set/contract.rs
+++ b/ethcore/src/engines/validator_set/contract.rs
@ -126,6 +126,7 @@ impl ValidatorSet for ValidatorContract {
 #[cfg(test)]
 mod tests {
 	use std::sync::Arc;
 	use rustc_hex::FromHex;
 	use util::*;
 	use rlp::encode;
@ -142,11 +143,11 @@ mod tests {
 	#[test]
 	fn fetches_validators() {
 		let client = generate_dummy_client_with_spec_and_accounts(Spec::new_validator_contract, None);
-		let vc = Arc::new(ValidatorContract::new(Address::from_str("0000000000000000000000000000000000000005").unwrap()));
+		let vc = Arc::new(ValidatorContract::new("0000000000000000000000000000000000000005".parse::<Address>().unwrap()));
 		vc.register_contract(Arc::downgrade(&client));
 		let last_hash = client.best_block_header().hash();
-		assert!(vc.contains(&last_hash, &Address::from_str("7d577a597b2742b498cb5cf0c26cdcd726d39e6e").unwrap()));
+		assert!(vc.contains(&last_hash, &"7d577a597b2742b498cb5cf0c26cdcd726d39e6e".parse::<Address>().unwrap()));
-		assert!(vc.contains(&last_hash, &Address::from_str("82a978b3f5962a5b0957d9ee9eef472ee55b42f1").unwrap()));
+		assert!(vc.contains(&last_hash, &"82a978b3f5962a5b0957d9ee9eef472ee55b42f1".parse::<Address>().unwrap()));
 	}
 	#[test]
@ -155,7 +156,7 @@ mod tests {
 		let v1 = tap.insert_account("1".sha3().into(), "").unwrap();
 		let client = generate_dummy_client_with_spec_and_accounts(Spec::new_validator_contract, Some(tap.clone()));
 		client.engine().register_client(Arc::downgrade(&client));
-		let validator_contract = Address::from_str("0000000000000000000000000000000000000005").unwrap();
+		let validator_contract = "0000000000000000000000000000000000000005".parse::<Address>().unwrap();
 		// Make sure reporting can be done.
 		client.miner().set_gas_floor_target(1_000_000.into());
--- a/ethcore/src/engines/validator_set/multi.rs
+++ b/ethcore/src/engines/validator_set/multi.rs
@ -142,6 +142,8 @@ impl ValidatorSet for Multi {
 #[cfg(test)]
 mod tests {
 	use std::sync::Arc;
 	use std::collections::BTreeMap;
 	use account_provider::AccountProvider;
 	use client::{BlockChainClient, EngineClient};
 	use engines::EpochChange;
--- a/ethcore/src/engines/validator_set/safe_contract.rs
+++ b/ethcore/src/engines/validator_set/safe_contract.rs
@ -16,7 +16,7 @@
 /// Validator set maintained in a contract, updated using `getValidators` method.
-use std::sync::Weak;
+use std::sync::{Weak, Arc};
 use futures::Future;
 use native_contracts::ValidatorSet as Provider;
@ -299,7 +299,7 @@ impl ValidatorSet for ValidatorSafeContract {
 			let (old_header, state_items) = decode_first_proof(&rlp)?;
 			let old_hash = old_header.hash();
-			let env_info = ::evm::env_info::EnvInfo {
+			let env_info = ::vm::EnvInfo {
 				number: old_header.number(),
 				author: *old_header.author(),
 				difficulty: *old_header.difficulty(),
@ -422,6 +422,7 @@ impl ValidatorSet for ValidatorSafeContract {
 #[cfg(test)]
 mod tests {
 	use std::sync::Arc;
 	use rustc_hex::FromHex;
 	use util::*;
 	use types::ids::BlockId;
@ -438,11 +439,11 @@ mod tests {
 	#[test]
 	fn fetches_validators() {
 		let client = generate_dummy_client_with_spec_and_accounts(Spec::new_validator_safe_contract, None);
-		let vc = Arc::new(ValidatorSafeContract::new(Address::from_str("0000000000000000000000000000000000000005").unwrap()));
+		let vc = Arc::new(ValidatorSafeContract::new("0000000000000000000000000000000000000005".parse::<Address>().unwrap()));
 		vc.register_contract(Arc::downgrade(&client));
 		let last_hash = client.best_block_header().hash();
-		assert!(vc.contains(&last_hash, &Address::from_str("7d577a597b2742b498cb5cf0c26cdcd726d39e6e").unwrap()));
+		assert!(vc.contains(&last_hash, &"7d577a597b2742b498cb5cf0c26cdcd726d39e6e".parse::<Address>().unwrap()));
-		assert!(vc.contains(&last_hash, &Address::from_str("82a978b3f5962a5b0957d9ee9eef472ee55b42f1").unwrap()));
+		assert!(vc.contains(&last_hash, &"82a978b3f5962a5b0957d9ee9eef472ee55b42f1".parse::<Address>().unwrap()));
 	}
 	#[test]
@ -454,7 +455,7 @@ mod tests {
 		let network_id = Spec::new_validator_safe_contract().network_id();
 		let client = generate_dummy_client_with_spec_and_accounts(Spec::new_validator_safe_contract, Some(tap));
 		client.engine().register_client(Arc::downgrade(&client));
-		let validator_contract = Address::from_str("0000000000000000000000000000000000000005").unwrap();
+		let validator_contract = "0000000000000000000000000000000000000005".parse::<Address>().unwrap();
 		client.miner().set_engine_signer(v1, "".into()).unwrap();
 		// Remove "1" validator.
@ -520,7 +521,7 @@ mod tests {
 		let client = generate_dummy_client_with_spec_and_accounts(Spec::new_validator_safe_contract, None);
 		let engine = client.engine().clone();
-		let validator_contract = Address::from_str("0000000000000000000000000000000000000005").unwrap();
+		let validator_contract = "0000000000000000000000000000000000000005".parse::<Address>().unwrap();
 		let last_hash = client.best_block_header().hash();
 		let mut new_header = Header::default();
--- a/ethcore/src/engines/validator_set/test.rs
+++ b/ethcore/src/engines/validator_set/test.rs
@ -17,8 +17,9 @@
 /// Used for Engine testing.
 use std::str::FromStr;
 use std::sync::Arc;
 use std::sync::atomic::{AtomicUsize, Ordering as AtomicOrdering};
-use util::{Arc, Bytes, H256, Address, HeapSizeOf};
+use util::{Bytes, H256, Address, HeapSizeOf};
 use engines::{Call, Engine};
 use header::{Header, BlockNumber};
--- a/ethcore/src/engines/vote_collector.rs
+++ b/ethcore/src/engines/vote_collector.rs
@ -17,6 +17,8 @@
 //! Collects votes on hashes at each Message::Round.
 use std::fmt::Debug;
 use std::collections::{BTreeMap, HashSet, HashMap};
 use std::hash::Hash;
 use util::*;
 use rlp::{Encodable, RlpStream};
--- a/ethcore/src/error.rs
+++ b/ethcore/src/error.rs
@ -16,6 +16,7 @@
 //! General error types for use in ethcore.
 use std::fmt;
 use util::*;
 use io::*;
 use header::BlockNumber;
--- a/ethcore/src/ethereum/ethash.rs
+++ b/ethcore/src/ethereum/ethash.rs
@ -15,11 +15,14 @@
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 use std::path::Path;
 use std::cmp;
 use std::collections::{BTreeMap, HashMap};
 use std::sync::Arc;
 use ethash::{quick_get_difficulty, slow_get_seedhash, EthashManager};
 use util::*;
 use block::*;
 use builtin::Builtin;
-use evm::env_info::EnvInfo;
+use vm::EnvInfo;
 use error::{BlockError, Error, TransactionError};
 use header::{Header, BlockNumber};
 use state::CleanupMode;
@ -29,7 +32,7 @@ use engines::{self, Engine};
 use evm::Schedule;
 use ethjson;
 use rlp::{self, UntrustedRlp};
-use evm::env_info::LastHashes;
+use vm::LastHashes;
 /// Parity tries to round block.gas_limit to multiple of this constant
 pub const PARITY_GAS_LIMIT_DETERMINANT: U256 = U256([37, 0, 0, 0]);
@ -41,8 +44,6 @@ const SNAPSHOT_BLOCKS: u64 = 30000;
 /// Ethash params.
 #[derive(Debug, PartialEq)]
 pub struct EthashParams {
 	/// Gas limit divisor.
 	pub gas_limit_bound_divisor: U256,
 	/// Minimum difficulty.
 	pub minimum_difficulty: U256,
 	/// Difficulty bound divisor.
@ -53,10 +54,6 @@ pub struct EthashParams {
 	pub metropolis_difficulty_increment_divisor: u64,
 	/// Block duration.
 	pub duration_limit: u64,
 	/// Block reward.
 	pub block_reward: U256,
 	/// Namereg contract address.
 	pub registrar: Address,
 	/// Homestead transition block number.
 	pub homestead_transition: u64,
 	/// DAO hard-fork transition block (X).
@ -75,8 +72,6 @@ pub struct EthashParams {
 	pub eip100b_transition: u64,
 	/// Number of first block where EIP-150 rules begin.
 	pub eip150_transition: u64,
 	/// Number of first block where EIP-155 rules begin.
 	pub eip155_transition: u64,
 	/// Number of first block where EIP-160 rules begin.
 	pub eip160_transition: u64,
 	/// Number of first block where EIP-161.abc begin.
@ -104,14 +99,11 @@ pub struct EthashParams {
 impl From<ethjson::spec::EthashParams> for EthashParams {
 	fn from(p: ethjson::spec::EthashParams) -> Self {
 		EthashParams {
 			gas_limit_bound_divisor: p.gas_limit_bound_divisor.into(),
 			minimum_difficulty: p.minimum_difficulty.into(),
 			difficulty_bound_divisor: p.difficulty_bound_divisor.into(),
 			difficulty_increment_divisor: p.difficulty_increment_divisor.map_or(10, Into::into),
 			metropolis_difficulty_increment_divisor: p.metropolis_difficulty_increment_divisor.map_or(9, Into::into),
 			duration_limit: p.duration_limit.map_or(0, Into::into),
 			block_reward: p.block_reward.into(),
 			registrar: p.registrar.map_or_else(Address::new, Into::into),
 			homestead_transition: p.homestead_transition.map_or(0, Into::into),
 			dao_hardfork_transition: p.dao_hardfork_transition.map_or(u64::max_value(), Into::into),
 			dao_hardfork_beneficiary: p.dao_hardfork_beneficiary.map_or_else(Address::new, Into::into),
@ -121,7 +113,6 @@ impl From<ethjson::spec::EthashParams> for EthashParams {
 			bomb_defuse_transition: p.bomb_defuse_transition.map_or(u64::max_value(), Into::into),
 			eip100b_transition: p.eip100b_transition.map_or(u64::max_value(), Into::into),
 			eip150_transition: p.eip150_transition.map_or(0, Into::into),
 			eip155_transition: p.eip155_transition.map_or(0, Into::into),
 			eip160_transition: p.eip160_transition.map_or(0, Into::into),
 			eip161abc_transition: p.eip161abc_transition.map_or(0, Into::into),
 			eip161d_transition: p.eip161d_transition.map_or(u64::max_value(), Into::into),
@ -185,7 +176,7 @@ impl Engine for Arc<Ethash> {
 	fn seal_fields(&self) -> usize { 2 }
 	fn params(&self) -> &CommonParams { &self.params }
-	fn additional_params(&self) -> HashMap<String, String> { hash_map!["registrar".to_owned() => self.ethash_params.registrar.hex()] }
+	fn additional_params(&self) -> HashMap<String, String> { hash_map!["registrar".to_owned() => self.params().registrar.hex()] }
 	fn builtins(&self) -> &BTreeMap<Address, Builtin> {
 		&self.builtins
@ -216,7 +207,7 @@ impl Engine for Arc<Ethash> {
 	}
 	fn signing_network_id(&self, env_info: &EnvInfo) -> Option<u64> {
-		if env_info.number >= self.ethash_params.eip155_transition {
+		if env_info.number >= self.params().eip155_transition {
 			Some(self.params().chain_id)
 		} else {
 			None
@ -231,19 +222,19 @@ impl Engine for Arc<Ethash> {
 		}
 		let gas_limit = {
 			let gas_limit = parent.gas_limit().clone();
-			let bound_divisor = self.ethash_params.gas_limit_bound_divisor;
+			let bound_divisor = self.params().gas_limit_bound_divisor;
 			let lower_limit = gas_limit - gas_limit / bound_divisor + 1.into();
 			let upper_limit = gas_limit + gas_limit / bound_divisor - 1.into();
 			let gas_limit = if gas_limit < gas_floor_target {
-				let gas_limit = min(gas_floor_target, upper_limit);
+				let gas_limit = cmp::min(gas_floor_target, upper_limit);
 				round_block_gas_limit(gas_limit, lower_limit, upper_limit)
 			} else if gas_limit > gas_ceil_target {
-				let gas_limit = max(gas_ceil_target, lower_limit);
+				let gas_limit = cmp::max(gas_ceil_target, lower_limit);
 				round_block_gas_limit(gas_limit, lower_limit, upper_limit)
 			} else {
-				let total_lower_limit = max(lower_limit, gas_floor_target);
+				let total_lower_limit = cmp::max(lower_limit, gas_floor_target);
-				let total_upper_limit = min(upper_limit, gas_ceil_target);
+				let total_upper_limit = cmp::min(upper_limit, gas_ceil_target);
-				let gas_limit = max(gas_floor_target, min(total_upper_limit,
+				let gas_limit = cmp::max(gas_floor_target, cmp::min(total_upper_limit,
 					lower_limit + (header.gas_used().clone() * 6.into() / 5.into()) / bound_divisor));
 				round_block_gas_limit(gas_limit, total_lower_limit, total_upper_limit)
 			};
@ -284,7 +275,7 @@ impl Engine for Arc<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) -> Result<(), Error> {
-		let reward = self.ethash_params.block_reward;
+		let reward = self.params().block_reward;
 		let fields = block.fields_mut();
 		let eras_rounds = self.ethash_params.ecip1017_era_rounds;
 		let (eras, reward) = ecip1017_eras_block_reward(eras_rounds, reward, fields.header.number());
@ -319,7 +310,7 @@ impl Engine for Arc<Ethash> {
 		Ok(())
 	}
-	fn verify_block_basic(&self, header: &Header, _block: Option<&[u8]>) -> result::Result<(), Error> {
+	fn verify_block_basic(&self, header: &Header, _block: Option<&[u8]>) -> Result<(), Error> {
 		// check the seal fields.
 		if header.seal().len() != self.seal_fields() {
 			return Err(From::from(BlockError::InvalidSealArity(
@ -357,7 +348,7 @@ impl Engine for Arc<Ethash> {
 		Ok(())
 	}
-	fn verify_block_unordered(&self, header: &Header, _block: Option<&[u8]>) -> result::Result<(), Error> {
+	fn verify_block_unordered(&self, header: &Header, _block: Option<&[u8]>) -> Result<(), Error> {
 		if header.seal().len() != self.seal_fields() {
 			return Err(From::from(BlockError::InvalidSealArity(
 				Mismatch { expected: self.seal_fields(), found: header.seal().len() }
@ -376,7 +367,7 @@ impl Engine for Arc<Ethash> {
 		Ok(())
 	}
-	fn verify_block_family(&self, header: &Header, parent: &Header, _block: Option<&[u8]>) -> result::Result<(), Error> {
+	fn verify_block_family(&self, header: &Header, parent: &Header, _block: Option<&[u8]>) -> Result<(), Error> {
 		// we should not calculate difficulty for genesis blocks
 		if header.number() == 0 {
 			return Err(From::from(BlockError::RidiculousNumber(OutOfBounds { min: Some(1), max: None, found: header.number() })));
@ -387,7 +378,7 @@ impl Engine for Arc<Ethash> {
 		if header.difficulty() != &expected_difficulty {
 			return Err(From::from(BlockError::InvalidDifficulty(Mismatch { expected: expected_difficulty, found: header.difficulty().clone() })))
 		}
-		let gas_limit_divisor = self.ethash_params.gas_limit_bound_divisor;
+		let gas_limit_divisor = self.params().gas_limit_bound_divisor;
 		let parent_gas_limit = *parent.gas_limit();
 		let min_gas = parent_gas_limit - parent_gas_limit / gas_limit_divisor;
 		let max_gas = parent_gas_limit + parent_gas_limit / gas_limit_divisor;
@ -400,13 +391,13 @@ impl Engine for Arc<Ethash> {
 		Ok(())
 	}
-	fn verify_transaction_basic(&self, t: &UnverifiedTransaction, header: &Header) -> result::Result<(), Error> {
+	fn verify_transaction_basic(&self, t: &UnverifiedTransaction, header: &Header) -> Result<(), Error> {
 		if header.number() >= self.ethash_params.min_gas_price_transition && t.gas_price < self.ethash_params.min_gas_price {
 			return Err(TransactionError::InsufficientGasPrice { minimal: self.ethash_params.min_gas_price, got: t.gas_price }.into());
 		}
 		let check_low_s = header.number() >= self.ethash_params.homestead_transition;
-		let network_id = if header.number() >= self.ethash_params.eip155_transition { Some(self.params().chain_id) } else { None };
+		let network_id = if header.number() >= self.params().eip155_transition { Some(self.params().chain_id) } else { None };
 		t.verify_basic(check_low_s, network_id, false)?;
 		Ok(())
 	}
@ -493,28 +484,28 @@ impl Ethash {
 			if diff_inc <= threshold {
 				*parent.difficulty() + *parent.difficulty() / difficulty_bound_divisor * (threshold - diff_inc).into()
 			} else {
-				let multiplier = min(diff_inc - threshold, 99).into();
+				let multiplier = cmp::min(diff_inc - threshold, 99).into();
 				parent.difficulty().saturating_sub(
 					*parent.difficulty() / difficulty_bound_divisor * multiplier
 				)
 			}
 		};
-		target = max(min_difficulty, target);
+		target = cmp::max(min_difficulty, target);
 		if header.number() < self.ethash_params.bomb_defuse_transition {
 			if header.number() < self.ethash_params.ecip1010_pause_transition {
 				let period = ((parent.number() + 1) / EXP_DIFF_PERIOD) as usize;
 				if period > 1 {
-					target = max(min_difficulty, target + (U256::from(1) << (period - 2)));
+					target = cmp::max(min_difficulty, target + (U256::from(1) << (period - 2)));
 				}
 			}
 			else if header.number() < self.ethash_params.ecip1010_continue_transition {
 				let fixed_difficulty = ((self.ethash_params.ecip1010_pause_transition / EXP_DIFF_PERIOD) - 2) as usize;
-				target = max(min_difficulty, target + (U256::from(1) << fixed_difficulty));
+				target = cmp::max(min_difficulty, target + (U256::from(1) << fixed_difficulty));
 			}
 			else {
 				let period = ((parent.number() + 1) / EXP_DIFF_PERIOD) as usize;
 				let delay = ((self.ethash_params.ecip1010_continue_transition - self.ethash_params.ecip1010_pause_transition) / EXP_DIFF_PERIOD) as usize;
-				target = max(min_difficulty, target + (U256::from(1) << (period - delay - 2)));
+				target = cmp::max(min_difficulty, target + (U256::from(1) << (period - delay - 2)));
 			}
 		}
 		target
@ -559,6 +550,9 @@ impl Header {
 #[cfg(test)]
 mod tests {
 	use std::str::FromStr;
 	use std::collections::BTreeMap;
 	use std::sync::Arc;
 	use util::*;
 	use block::*;
 	use tests::helpers::*;
@ -809,36 +803,32 @@ mod tests {
 	#[test]
 	fn has_valid_ecip1017_eras_block_reward() {
-		let ethparams = EthashParams {
+		let eras_rounds = 5000000;
-			// see ethcore/res/ethereum/classic.json
+
-			ecip1017_era_rounds: 5000000,
+		let start_reward: U256 = "4563918244F40000".parse().unwrap();
-			block_reward: U256::from_str("4563918244F40000").unwrap(),
+
 			..get_default_ethash_params()
 		};
 		let eras_rounds = ethparams.ecip1017_era_rounds;
 		let reward = ethparams.block_reward;
 		let block_number = 0;
-		let (eras, reward) = ecip1017_eras_block_reward(eras_rounds, reward, block_number);
+		let (eras, reward) = ecip1017_eras_block_reward(eras_rounds, start_reward, block_number);
 		assert_eq!(0, eras);
 		assert_eq!(U256::from_str("4563918244F40000").unwrap(), reward);
-		let reward = ethparams.block_reward;
+
 		let block_number = 5000000;
-		let (eras, reward) = ecip1017_eras_block_reward(eras_rounds, reward, block_number);
+		let (eras, reward) = ecip1017_eras_block_reward(eras_rounds, start_reward, block_number);
 		assert_eq!(0, eras);
 		assert_eq!(U256::from_str("4563918244F40000").unwrap(), reward);
-		let reward = ethparams.block_reward;
+
 		let block_number = 10000000;
-		let (eras, reward) = ecip1017_eras_block_reward(eras_rounds, reward, block_number);
+		let (eras, reward) = ecip1017_eras_block_reward(eras_rounds, start_reward, block_number);
 		assert_eq!(1, eras);
 		assert_eq!(U256::from_str("3782DACE9D900000").unwrap(), reward);
-		let reward = ethparams.block_reward;
+
 		let block_number = 20000000;
-		let (eras, reward) = ecip1017_eras_block_reward(eras_rounds, reward, block_number);
+		let (eras, reward) = ecip1017_eras_block_reward(eras_rounds, start_reward, block_number);
 		assert_eq!(3, eras);
 		assert_eq!(U256::from_str("2386F26FC1000000").unwrap(), reward);
-		let reward = ethparams.block_reward;
+
 		let block_number = 80000000;
-		let (eras, reward) = ecip1017_eras_block_reward(eras_rounds, reward, block_number);
+		let (eras, reward) = ecip1017_eras_block_reward(eras_rounds, start_reward, block_number);
 		assert_eq!(15, eras);
 		assert_eq!(U256::from_str("271000000000000").unwrap(), reward);
 	}
--- a/ethcore/src/ethereum/mod.rs
+++ b/ethcore/src/ethereum/mod.rs
@ -134,23 +134,4 @@ mod tests {
 		let _ = frontier.engine;
 	}
 	#[test]
 	fn all_spec_files_valid() {
 		let tmp = ::std::env::temp_dir();
 		new_olympic(&tmp);
 		new_foundation(&tmp);
 		new_classic(&tmp);
 		new_expanse(&tmp);
 		new_kovan(&tmp);
 		new_ropsten(&tmp);
 		new_morden(&tmp);
 		new_frontier_test();
 		new_homestead_test();
 		new_eip150_test();
 		new_eip161_test();
 		new_transition_test();
 		new_mainnet_like();
 		new_metropolis_test();
 	}
 }
--- a/ethcore/src/executed.rs
+++ b/ethcore/src/executed.rs
@ -17,7 +17,7 @@
 //! Transaction execution format module.
 use util::{Bytes, U256, Address, U512, trie};
-use evm;
+use vm;
 use trace::{VMTrace, FlatTrace};
 use log_entry::LogEntry;
 use state_diff::StateDiff;
@ -28,7 +28,7 @@ use std::fmt;
 #[derive(Debug, PartialEq, Clone)]
 pub struct Executed {
 	/// True if the outer call/create resulted in an exceptional exit.
-	pub exception: Option<evm::Error>,
+	pub exception: Option<vm::Error>,
 	/// Gas paid up front for execution of transaction.
 	pub gas: U256,
--- a/ethcore/src/executive.rs
+++ b/ethcore/src/executive.rs
@ -15,14 +15,16 @@
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 //! Transaction Execution environment.
 use std::cmp;
 use std::sync::Arc;
 use util::*;
 use evm::action_params::{ActionParams, ActionValue};
 use state::{Backend as StateBackend, State, Substate, CleanupMode};
 use engines::Engine;
-use evm::CallType;
+use vm::EnvInfo;
 use evm::env_info::EnvInfo;
 use error::ExecutionError;
-use evm::{self, wasm, Factory, Ext, Finalize, CreateContractAddress, FinalizationResult, ReturnData, CleanDustMode};
+use evm::{CallType, Factory, Finalize, FinalizationResult};
 use vm::{self, Ext, CreateContractAddress, ReturnData, CleanDustMode, ActionParams, ActionValue};
 use wasm;
 use externalities::*;
 use trace::{FlatTrace, Tracer, NoopTracer, ExecutiveTracer, VMTrace, VMTracer, ExecutiveVMTracer, NoopVMTracer};
 use transaction::{Action, SignedTransaction};
@ -74,8 +76,8 @@ pub struct TransactOptions {
 	pub check_nonce: bool,
 }
-pub fn executor<E>(engine: &E, vm_factory: &Factory, params: &ActionParams) 
+pub fn executor<E>(engine: &E, vm_factory: &Factory, params: &ActionParams)
-	-> Box<evm::Evm> where E: Engine + ?Sized
+	-> Box<vm::Vm> where E: Engine + ?Sized
 {
 	if engine.supports_wasm() && params.code.as_ref().map_or(false, |code| code.len() > 4 && &code[0..4] == WASM_MAGIC_NUMBER) {
 		Box::new(
@ -269,7 +271,7 @@ impl<'a, B: 'a + StateBackend, E: Engine + ?Sized> Executive<'a, B, E> {
 		output_policy: OutputPolicy,
 		tracer: &mut T,
 		vm_tracer: &mut V
-	) -> evm::Result<FinalizationResult> where T: Tracer, V: VMTracer {
+	) -> vm::Result<FinalizationResult> where T: Tracer, V: VMTracer {
 		let depth_threshold = ::io::LOCAL_STACK_SIZE.with(|sz| sz.get() / STACK_SIZE_PER_DEPTH);
 		let static_call = params.call_type == CallType::StaticCall;
@ -299,7 +301,7 @@ impl<'a, B: 'a + StateBackend, E: Engine + ?Sized> Executive<'a, B, E> {
 	/// Calls contract function with given contract params.
 	/// 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`.
+	/// Returns either gas_left or `vm::Error`.
 	pub fn call<T, V>(
 		&mut self,
 		params: ActionParams,
@ -307,14 +309,14 @@ impl<'a, B: 'a + StateBackend, E: Engine + ?Sized> Executive<'a, B, E> {
 		mut output: BytesRef,
 		tracer: &mut T,
 		vm_tracer: &mut V
-	) -> evm::Result<(U256, ReturnData)> where T: Tracer, V: VMTracer {
+	) -> vm::Result<(U256, ReturnData)> where T: Tracer, V: VMTracer {
 		trace!("Executive::call(params={:?}) self.env_info={:?}", params, self.info);
 		if (params.call_type == CallType::StaticCall ||
 				((params.call_type == CallType::Call || params.call_type == CallType::DelegateCall) &&
 				 self.static_flag))
 			&& params.value.value() > 0.into() {
-			return Err(evm::Error::MutableCallInStaticContext);
+			return Err(vm::Error::MutableCallInStaticContext);
 		}
 		// backup used in case of running out of gas
@ -344,7 +346,7 @@ impl<'a, B: 'a + StateBackend, E: Engine + ?Sized> Executive<'a, B, E> {
 			if cost <= params.gas {
 				if let Err(e) = builtin.execute(data, &mut output) {
 					self.state.revert_to_checkpoint();
-					let evm_err: evm::evm::Error = e.into();
+					let evm_err: vm::Error = e.into();
 					tracer.trace_failed_call(trace_info, vec![], evm_err.clone().into());
 					Err(evm_err)
 				} else {
@ -371,9 +373,9 @@ impl<'a, B: 'a + StateBackend, E: Engine + ?Sized> Executive<'a, B, E> {
 				// just drain the whole gas
 				self.state.revert_to_checkpoint();
-				tracer.trace_failed_call(trace_info, vec![], evm::Error::OutOfGas.into());
+				tracer.trace_failed_call(trace_info, vec![], vm::Error::OutOfGas.into());
-				Err(evm::Error::OutOfGas)
+				Err(vm::Error::OutOfGas)
 			}
 		} else {
 			let trace_info = tracer.prepare_trace_call(&params);
@ -432,17 +434,17 @@ impl<'a, B: 'a + StateBackend, E: Engine + ?Sized> Executive<'a, B, E> {
 		substate: &mut Substate,
 		tracer: &mut T,
 		vm_tracer: &mut V,
-	) -> evm::Result<(U256, ReturnData)> where T: Tracer, V: VMTracer {
+	) -> vm::Result<(U256, ReturnData)> where T: Tracer, V: VMTracer {
 		let scheme = self.engine.create_address_scheme(self.info.number);
 		if scheme != CreateContractAddress::FromSenderAndNonce && self.state.exists_and_has_code(&params.address)? {
-			return Err(evm::Error::OutOfGas);
+			return Err(vm::Error::OutOfGas);
 		}
 		if params.call_type == CallType::StaticCall || self.static_flag {
 			let trace_info = tracer.prepare_trace_create(&params);
-			tracer.trace_failed_create(trace_info, vec![], evm::Error::MutableCallInStaticContext.into());
+			tracer.trace_failed_create(trace_info, vec![], vm::Error::MutableCallInStaticContext.into());
-			return Err(evm::Error::MutableCallInStaticContext);
+			return Err(vm::Error::MutableCallInStaticContext);
 		}
 		// backup used in case of running out of gas
@ -496,7 +498,7 @@ impl<'a, B: 'a + StateBackend, E: Engine + ?Sized> Executive<'a, B, E> {
 		&mut self,
 		t: &SignedTransaction,
 		mut substate: Substate,
-		result: evm::Result<(U256, ReturnData)>,
+		result: vm::Result<(U256, ReturnData)>,
 		output: Bytes,
 		trace: Vec<FlatTrace>,
 		vm_trace: Option<VMTrace>
@ -538,7 +540,7 @@ impl<'a, B: 'a + StateBackend, E: Engine + ?Sized> Executive<'a, B, E> {
 		self.state.kill_garbage(&substate.touched, schedule.kill_empty, &min_balance, schedule.kill_dust == CleanDustMode::WithCodeAndStorage)?;
 		match result {
-			Err(evm::Error::Internal(msg)) => Err(ExecutionError::Internal(msg)),
+			Err(vm::Error::Internal(msg)) => Err(ExecutionError::Internal(msg)),
 			Err(exception) => {
 				Ok(Executed {
 					exception: Some(exception),
@ -572,20 +574,20 @@ impl<'a, B: 'a + StateBackend, E: Engine + ?Sized> Executive<'a, B, E> {
 		}
 	}
-	fn enact_result(&mut self, result: &evm::Result<FinalizationResult>, substate: &mut Substate, un_substate: Substate) {
+	fn enact_result(&mut self, result: &vm::Result<FinalizationResult>, substate: &mut Substate, un_substate: Substate) {
 		match *result {
-			Err(evm::Error::OutOfGas)
+			Err(vm::Error::OutOfGas)
-				| Err(evm::Error::BadJumpDestination {..})
+				| Err(vm::Error::BadJumpDestination {..})
-				| Err(evm::Error::BadInstruction {.. })
+				| Err(vm::Error::BadInstruction {.. })
-				| Err(evm::Error::StackUnderflow {..})
+				| Err(vm::Error::StackUnderflow {..})
-				| Err(evm::Error::BuiltIn {..})
+				| Err(vm::Error::BuiltIn {..})
-				| Err(evm::Error::Wasm {..})
+				| Err(vm::Error::Wasm {..})
-				| Err(evm::Error::OutOfStack {..})
+				| Err(vm::Error::OutOfStack {..})
-				| Err(evm::Error::MutableCallInStaticContext)
+				| Err(vm::Error::MutableCallInStaticContext)
 				| Ok(FinalizationResult { apply_state: false, .. }) => {
 					self.state.revert_to_checkpoint();
 			},
-			Ok(_) | Err(evm::Error::Internal(_)) => {
+			Ok(_) | Err(vm::Error::Internal(_)) => {
 				self.state.discard_checkpoint();
 				substate.accrue(un_substate);
 			}
@ -597,14 +599,14 @@ impl<'a, B: 'a + StateBackend, E: Engine + ?Sized> Executive<'a, B, E> {
 #[allow(dead_code)]
 mod tests {
 	use std::sync::Arc;
 	use std::str::FromStr;
 	use rustc_hex::FromHex;
 	use ethkey::{Generator, Random};
 	use super::*;
-	use util::{H256, U256, U512, Address, FromStr};
+	use util::{H256, U256, U512, Address};
 	use util::bytes::BytesRef;
-	use evm::action_params::{ActionParams, ActionValue};
+	use vm::{ActionParams, ActionValue, CallType, EnvInfo, CreateContractAddress};
-	use evm::env_info::EnvInfo;
+	use evm::{Factory, VMType};
 	use evm::{Factory, VMType, CreateContractAddress};
 	use error::ExecutionError;
 	use state::{Substate, CleanupMode};
 	use tests::helpers::*;
@ -613,8 +615,6 @@ mod tests {
 	use trace::{VMTrace, VMOperation, VMExecutedOperation, MemoryDiff, StorageDiff, VMTracer, NoopVMTracer, ExecutiveVMTracer};
 	use transaction::{Action, Transaction};
 	use evm::CallType;
 	#[test]
 	fn test_contract_address() {
 		let address = Address::from_str("0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6").unwrap();
--- a/ethcore/src/externalities.rs
+++ b/ethcore/src/externalities.rs
@ -15,14 +15,17 @@
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 //! Transaction Execution environment.
 use std::cmp;
 use std::sync::Arc;
 use util::*;
 use evm::action_params::{ActionParams, ActionValue};
 use state::{Backend as StateBackend, State, Substate, CleanupMode};
 use engines::Engine;
 use evm::env_info::EnvInfo;
 use executive::*;
-use evm::{self, Schedule, Ext, ContractCreateResult, MessageCallResult, CreateContractAddress, ReturnData};
+use vm::{
-use evm::CallType;
+	self, ActionParams, ActionValue, EnvInfo, CallType, Schedule,
 	Ext, ContractCreateResult, MessageCallResult, CreateContractAddress,
 	ReturnData
 };
 use transaction::UNSIGNED_SENDER;
 use trace::{Tracer, VMTracer};
@ -109,31 +112,31 @@ impl<'a, T: 'a, V: 'a, B: 'a, E: 'a> Externalities<'a, T, V, B, E>
 impl<'a, T: 'a, V: 'a, B: 'a, E: 'a> Ext for Externalities<'a, T, V, B, E>
 	where T: Tracer, V: VMTracer, B: StateBackend, E: Engine + ?Sized
 {
-	fn storage_at(&self, key: &H256) -> evm::Result<H256> {
+	fn storage_at(&self, key: &H256) -> vm::Result<H256> {
 		self.state.storage_at(&self.origin_info.address, key).map_err(Into::into)
 	}
-	fn set_storage(&mut self, key: H256, value: H256) -> evm::Result<()> {
+	fn set_storage(&mut self, key: H256, value: H256) -> vm::Result<()> {
 		if self.static_flag {
-			Err(evm::Error::MutableCallInStaticContext)
+			Err(vm::Error::MutableCallInStaticContext)
 		} else {
 			self.state.set_storage(&self.origin_info.address, key, value).map_err(Into::into)
 		}
 	}
-	fn exists(&self, address: &Address) -> evm::Result<bool> {
+	fn exists(&self, address: &Address) -> vm::Result<bool> {
 		self.state.exists(address).map_err(Into::into)
 	}
-	fn exists_and_not_null(&self, address: &Address) -> evm::Result<bool> {
+	fn exists_and_not_null(&self, address: &Address) -> vm::Result<bool> {
 		self.state.exists_and_not_null(address).map_err(Into::into)
 	}
-	fn origin_balance(&self) -> evm::Result<U256> {
+	fn origin_balance(&self) -> vm::Result<U256> {
 		self.balance(&self.origin_info.address).map_err(Into::into)
 	}
-	fn balance(&self, address: &Address) -> evm::Result<U256> {
+	fn balance(&self, address: &Address) -> vm::Result<U256> {
 		self.state.balance(address).map_err(Into::into)
 	}
@ -274,16 +277,16 @@ impl<'a, T: 'a, V: 'a, B: 'a, E: 'a> Ext for Externalities<'a, T, V, B, E>
 		}
 	}
-	fn extcode(&self, address: &Address) -> evm::Result<Arc<Bytes>> {
+	fn extcode(&self, address: &Address) -> vm::Result<Arc<Bytes>> {
 		Ok(self.state.code(address)?.unwrap_or_else(|| Arc::new(vec![])))
 	}
-	fn extcodesize(&self, address: &Address) -> evm::Result<usize> {
+	fn extcodesize(&self, address: &Address) -> vm::Result<usize> {
 		Ok(self.state.code_size(address)?.unwrap_or(0))
 	}
 	#[cfg_attr(feature="dev", allow(match_ref_pats))]
-	fn ret(mut self, gas: &U256, data: &ReturnData) -> evm::Result<U256>
+	fn ret(mut self, gas: &U256, data: &ReturnData) -> vm::Result<U256>
 		where Self: Sized {
 		let handle_copy = |to: &mut Option<&mut Bytes>| {
 			to.as_mut().map(|b| **b = data.to_vec());
@ -307,7 +310,7 @@ impl<'a, T: 'a, V: 'a, B: 'a, E: 'a> Ext for Externalities<'a, T, V, B, E>
 				let return_cost = U256::from(data.len()) * U256::from(self.schedule.create_data_gas);
 				if return_cost > *gas || data.len() > self.schedule.create_data_limit {
 					return match self.schedule.exceptional_failed_code_deposit {
-						true => Err(evm::Error::OutOfGas),
+						true => Err(vm::Error::OutOfGas),
 						false => Ok(*gas)
 					}
 				}
@ -320,11 +323,11 @@ impl<'a, T: 'a, V: 'a, B: 'a, E: 'a> Ext for Externalities<'a, T, V, B, E>
 		}
 	}
-	fn log(&mut self, topics: Vec<H256>, data: &[u8]) -> evm::Result<()> {
+	fn log(&mut self, topics: Vec<H256>, data: &[u8]) -> vm::Result<()> {
 		use log_entry::LogEntry;
 		if self.static_flag {
-			return Err(evm::Error::MutableCallInStaticContext);
+			return Err(vm::Error::MutableCallInStaticContext);
 		}
 		let address = self.origin_info.address.clone();
@ -337,9 +340,9 @@ impl<'a, T: 'a, V: 'a, B: 'a, E: 'a> Ext for Externalities<'a, T, V, B, E>
 		Ok(())
 	}
-	fn suicide(&mut self, refund_address: &Address) -> evm::Result<()> {
+	fn suicide(&mut self, refund_address: &Address) -> vm::Result<()> {
 		if self.static_flag {
-			return Err(evm::Error::MutableCallInStaticContext);
+			return Err(vm::Error::MutableCallInStaticContext);
 		}
 		let address = self.origin_info.address.clone();
@ -396,13 +399,11 @@ impl<'a, T: 'a, V: 'a, B: 'a, E: 'a> Ext for Externalities<'a, T, V, B, E>
 mod tests {
 	use util::*;
 	use engines::Engine;
-	use evm::env_info::EnvInfo;
+	use evm::{EnvInfo, Ext, CallType};
 	use evm::Ext;
 	use state::{State, Substate};
 	use tests::helpers::*;
 	use super::*;
 	use trace::{NoopTracer, NoopVMTracer};
 	use evm::CallType;
 	fn get_test_origin() -> OriginInfo {
 		OriginInfo {
@ -470,7 +471,7 @@ mod tests {
 		let mut ext = Externalities::new(state, &setup.env_info, &*setup.engine, 0, get_test_origin(), &mut setup.sub_state, OutputPolicy::InitContract(None), &mut tracer, &mut vm_tracer, false);
-		let hash = ext.blockhash(&U256::from_str("0000000000000000000000000000000000000000000000000000000000120000").unwrap());
+		let hash = ext.blockhash(&"0000000000000000000000000000000000000000000000000000000000120000".parse::<U256>().unwrap());
 		assert_eq!(hash, H256::zero());
 	}
@ -494,7 +495,7 @@ mod tests {
 		let mut ext = Externalities::new(state, &setup.env_info, &*setup.engine, 0, get_test_origin(), &mut setup.sub_state, OutputPolicy::InitContract(None), &mut tracer, &mut vm_tracer, false);
-		let hash = ext.blockhash(&U256::from_str("0000000000000000000000000000000000000000000000000000000000120000").unwrap());
+		let hash = ext.blockhash(&"0000000000000000000000000000000000000000000000000000000000120000".parse::<U256>().unwrap());
 		assert_eq!(test_hash, hash);
 	}
@ -513,10 +514,10 @@ mod tests {
 		// this should panic because we have no balance on any account
 		ext.call(
-			&U256::from_str("0000000000000000000000000000000000000000000000000000000000120000").unwrap(),
+			&"0000000000000000000000000000000000000000000000000000000000120000".parse::<U256>().unwrap(),
 			&Address::new(),
 			&Address::new(),
-			Some(U256::from_str("0000000000000000000000000000000000000000000000000000000000150000").unwrap()),
+			Some("0000000000000000000000000000000000000000000000000000000000150000".parse::<U256>().unwrap()),
 			&[],
 			&Address::new(),
 			&mut output,
--- a/ethcore/src/header.rs
+++ b/ethcore/src/header.rs
@ -16,13 +16,13 @@
 //! Block header.
 use std::cmp;
 use std::cell::RefCell;
 use util::*;
 use basic_types::{LogBloom, ZERO_LOGBLOOM};
 use time::get_time;
 use rlp::*;
 use std::cell::RefCell;
 pub use basic_types::Seal;
 pub use types::BlockNumber;
@ -175,7 +175,7 @@ impl Header {
 	/// Set the timestamp field of the header.
 	pub fn set_timestamp(&mut self, a: u64) { self.timestamp = a; self.note_dirty(); }
 	/// Set the timestamp field of the header to the current time.
-	pub fn set_timestamp_now(&mut self, but_later_than: u64) { self.timestamp = max(get_time().sec as u64, but_later_than + 1); self.note_dirty(); }
+	pub fn set_timestamp_now(&mut self, but_later_than: u64) { self.timestamp = cmp::max(get_time().sec as u64, but_later_than + 1); self.note_dirty(); }
 	/// Set the number field of the header.
 	pub fn set_number(&mut self, a: BlockNumber) { self.number = a; self.note_dirty(); }
 	/// Set the author field of the header.
@ -275,7 +275,7 @@ impl Decodable for Header {
 			number: r.val_at(8)?,
 			gas_limit: r.val_at(9)?,
 			gas_used: r.val_at(10)?,
-			timestamp: min(r.val_at::<U256>(11)?, u64::max_value().into()).as_u64(),
+			timestamp: cmp::min(r.val_at::<U256>(11)?, u64::max_value().into()).as_u64(),
 			extra_data: r.val_at(12)?,
 			seal: vec![],
 			hash: RefCell::new(Some(r.as_raw().sha3())),
--- a/ethcore/src/json_tests/chain.rs
+++ b/ethcore/src/json_tests/chain.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/>.
-use super::test_common::*;
+use std::sync::Arc;
 use client::{BlockChainClient, Client, ClientConfig};
 use block::Block;
 use ethereum;
--- a/ethcore/src/json_tests/executive.rs
+++ b/ethcore/src/json_tests/executive.rs
@ -14,16 +14,18 @@
 // 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::sync::Arc;
 use super::test_common::*;
 use evm::action_params::ActionParams;
 use state::{Backend as StateBackend, State, Substate};
 use executive::*;
 use engines::Engine;
-use evm::env_info::EnvInfo;
+use evm::{VMType, Finalize};
-use evm;
+use vm::{
-use evm::{Schedule, Ext, Finalize, VMType, ContractCreateResult, MessageCallResult, CreateContractAddress, ReturnData};
+	self, ActionParams, CallType, Schedule, Ext,
 	ContractCreateResult, EnvInfo, MessageCallResult,
 	CreateContractAddress, ReturnData,
 };
 use externalities::*;
 use evm::CallType;
 use tests::helpers::*;
 use ethjson;
 use trace::{Tracer, NoopTracer};
@ -88,27 +90,27 @@ impl<'a, T: 'a, V: 'a, B: 'a, E: 'a> TestExt<'a, T, V, B, E>
 impl<'a, T: 'a, V: 'a, B: 'a, E: 'a> Ext for TestExt<'a, T, V, B, E>
 	where T: Tracer, V: VMTracer, B: StateBackend, E: Engine + ?Sized
 {
-	fn storage_at(&self, key: &H256) -> evm::Result<H256> {
+	fn storage_at(&self, key: &H256) -> vm::Result<H256> {
 		self.ext.storage_at(key)
 	}
-	fn set_storage(&mut self, key: H256, value: H256) -> evm::Result<()> {
+	fn set_storage(&mut self, key: H256, value: H256) -> vm::Result<()> {
 		self.ext.set_storage(key, value)
 	}
-	fn exists(&self, address: &Address) -> evm::Result<bool> {
+	fn exists(&self, address: &Address) -> vm::Result<bool> {
 		self.ext.exists(address)
 	}
-	fn exists_and_not_null(&self, address: &Address) -> evm::Result<bool> {
+	fn exists_and_not_null(&self, address: &Address) -> vm::Result<bool> {
 		self.ext.exists_and_not_null(address)
 	}
-	fn balance(&self, address: &Address) -> evm::Result<U256> {
+	fn balance(&self, address: &Address) -> vm::Result<U256> {
 		self.ext.balance(address)
 	}
-	fn origin_balance(&self) -> evm::Result<U256> {
+	fn origin_balance(&self) -> vm::Result<U256> {
 		self.ext.origin_balance()
 	}
@ -146,23 +148,23 @@ impl<'a, T: 'a, V: 'a, B: 'a, E: 'a> Ext for TestExt<'a, T, V, B, E>
 		MessageCallResult::Success(*gas, ReturnData::empty())
 	}
-	fn extcode(&self, address: &Address) -> evm::Result<Arc<Bytes>>  {
+	fn extcode(&self, address: &Address) -> vm::Result<Arc<Bytes>>  {
 		self.ext.extcode(address)
 	}
-	fn extcodesize(&self, address: &Address) -> evm::Result<usize> {
+	fn extcodesize(&self, address: &Address) -> vm::Result<usize> {
 		self.ext.extcodesize(address)
 	}
-	fn log(&mut self, topics: Vec<H256>, data: &[u8]) -> evm::Result<()> {
+	fn log(&mut self, topics: Vec<H256>, data: &[u8]) -> vm::Result<()> {
 		self.ext.log(topics, data)
 	}
-	fn ret(self, gas: &U256, data: &ReturnData) -> Result<U256, evm::Error> {
+	fn ret(self, gas: &U256, data: &ReturnData) -> Result<U256, vm::Error> {
 		self.ext.ret(gas, data)
 	}
-	fn suicide(&mut self, refund_address: &Address) -> evm::Result<()> {
+	fn suicide(&mut self, refund_address: &Address) -> vm::Result<()> {
 		self.ext.suicide(refund_address)
 	}
--- a/ethcore/src/json_tests/state.rs
+++ b/ethcore/src/json_tests/state.rs
@ -22,7 +22,7 @@ use spec::Spec;
 use ethjson;
 use ethjson::state::test::ForkSpec;
 use transaction::SignedTransaction;
-use evm::env_info::EnvInfo;
+use vm::EnvInfo;
 lazy_static! {
 	pub static ref FRONTIER: Spec = ethereum::new_frontier_test();
--- a/ethcore/src/json_tests/test_common.rs
+++ b/ethcore/src/json_tests/test_common.rs
@ -15,6 +15,8 @@
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 pub use util::*;
 use std::collections::HashSet;
 use std::io::Read;
 use std::fs::{File, read_dir};
 use std::path::Path;
 use std::ffi::OsString;
--- a/ethcore/src/lib.rs
+++ b/ethcore/src/lib.rs
@ -106,6 +106,11 @@ extern crate semver;
 extern crate stats;
 extern crate time;
 extern crate transient_hashmap;
 extern crate using_queue;
 extern crate table;
 extern crate bloomable;
 extern crate vm;
 extern crate wasm;
 #[macro_use]
 extern crate log;
--- a/ethcore/src/miner/miner.rs
+++ b/ethcore/src/miner/miner.rs
@ -15,12 +15,14 @@
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 use std::time::{Instant, Duration};
 use std::collections::{BTreeMap, HashSet};
 use std::sync::Arc;
 use util::*;
-use util::using_queue::{UsingQueue, GetAction};
+use using_queue::{UsingQueue, GetAction};
 use account_provider::{AccountProvider, SignError as AccountError};
-use state::{State, CleanupMode};
+use state::State;
-use client::{MiningBlockChainClient, Executive, Executed, EnvInfo, TransactOptions, BlockId, CallAnalytics, TransactionId};
+use client::{MiningBlockChainClient, BlockId, TransactionId};
 use client::TransactionImportResult;
 use executive::contract_address;
 use block::{ClosedBlock, IsBlock, Block};
@ -37,7 +39,7 @@ use miner::local_transactions::{Status as LocalTransactionStatus};
 use miner::service_transaction_checker::ServiceTransactionChecker;
 use price_info::{Client as PriceInfoClient, PriceInfo};
 use price_info::fetch::Client as FetchClient;
-use header::BlockNumber;
+use header::{Header, BlockNumber};
 /// Different possible definitions for pending transaction set.
 #[derive(Debug, PartialEq)]
@ -329,13 +331,28 @@ impl Miner {
 	}
 	/// Get `Some` `clone()` of the current pending block's state or `None` if we're not sealing.
-	pub fn pending_state(&self) -> Option<State<::state_db::StateDB>> {
+	pub fn pending_state(&self, latest_block_number: BlockNumber) -> Option<State<::state_db::StateDB>> {
-		self.sealing_work.lock().queue.peek_last_ref().map(|b| b.block().fields().state.clone())
+		self.map_pending_block(|b| b.state().clone(), latest_block_number)
 	}
 	/// Get `Some` `clone()` of the current pending block or `None` if we're not sealing.
-	pub fn pending_block(&self) -> Option<Block> {
+	pub fn pending_block(&self, latest_block_number: BlockNumber) -> Option<Block> {
-		self.sealing_work.lock().queue.peek_last_ref().map(|b| b.to_base())
+		self.map_pending_block(|b| b.to_base(), latest_block_number)
 	}
 	/// Get `Some` `clone()` of the current pending block header or `None` if we're not sealing.
 	pub fn pending_block_header(&self, latest_block_number: BlockNumber) -> Option<Header> {
 		self.map_pending_block(|b| b.header().clone(), latest_block_number)
 	}
 	fn map_pending_block<F, T>(&self, f: F, latest_block_number: BlockNumber) -> Option<T> where
 		F: FnOnce(&ClosedBlock) -> T,
 	{
 		self.from_pending_block(
 			latest_block_number,
 			|| None,
 			|block| Some(f(block)),
 		)
 	}
 	#[cfg_attr(feature="dev", allow(match_same_arms))]
@ -677,7 +694,7 @@ impl Miner {
 	#[cfg_attr(feature="dev", allow(wrong_self_convention))]
 	#[cfg_attr(feature="dev", allow(redundant_closure))]
 	fn from_pending_block<H, F, G>(&self, latest_block_number: BlockNumber, from_chain: F, map_block: G) -> H
-		where F: Fn() -> H, G: Fn(&ClosedBlock) -> H {
+		where F: Fn() -> H, G: FnOnce(&ClosedBlock) -> H {
 		let sealing_work = self.sealing_work.lock();
 		sealing_work.queue.peek_last_ref().map_or_else(
 			|| from_chain(),
@ -715,84 +732,6 @@ impl MinerService for Miner {
 		}
 	}
 	fn call(&self, client: &MiningBlockChainClient, t: &SignedTransaction, analytics: CallAnalytics) -> Result<Executed, CallError> {
 		let sealing_work = self.sealing_work.lock();
 		match sealing_work.queue.peek_last_ref() {
 			Some(work) => {
 				let block = work.block();
 				// TODO: merge this code with client.rs's fn call somwhow.
 				let header = block.header();
 				let last_hashes = Arc::new(client.last_hashes());
 				let env_info = EnvInfo {
 					number: header.number(),
 					author: *header.author(),
 					timestamp: header.timestamp(),
 					difficulty: *header.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 = block.state().clone();
 				let original_state = if analytics.state_diffing { Some(state.clone()) } else { None };
 				let sender = t.sender();
 				let balance = state.balance(&sender).map_err(ExecutionError::from)?;
 				let needed_balance = t.value + t.gas * t.gas_price;
 				if balance < needed_balance {
 					// give the sender a sufficient balance
 					state.add_balance(&sender, &(needed_balance - balance), CleanupMode::NoEmpty)
 						.map_err(ExecutionError::from)?;
 				}
 				let options = TransactOptions { tracing: analytics.transaction_tracing, vm_tracing: analytics.vm_tracing, check_nonce: false };
 				let mut ret = Executive::new(&mut state, &env_info, &*self.engine).transact(t, options)?;
 				// TODO gav move this into Executive.
 				if let Some(original) = original_state {
 					ret.state_diff = Some(state.diff_from(original).map_err(ExecutionError::from)?);
 				}
 				Ok(ret)
 			},
 			None => client.call(t, BlockId::Latest, analytics)
 		}
 	}
 	// TODO: The `chain.latest_x` actually aren't infallible, they just panic on corruption.
 	// TODO: return trie::Result<T> here, or other.
 	fn balance(&self, chain: &MiningBlockChainClient, address: &Address) -> Option<U256> {
 		self.from_pending_block(
 			chain.chain_info().best_block_number,
 			|| Some(chain.latest_balance(address)),
 			|b| b.block().fields().state.balance(address).ok(),
 		)
 	}
 	fn storage_at(&self, chain: &MiningBlockChainClient, address: &Address, position: &H256) -> Option<H256> {
 		self.from_pending_block(
 			chain.chain_info().best_block_number,
 			|| Some(chain.latest_storage_at(address, position)),
 			|b| b.block().fields().state.storage_at(address, position).ok(),
 		)
 	}
 	fn nonce(&self, chain: &MiningBlockChainClient, address: &Address) -> Option<U256> {
 		self.from_pending_block(
 			chain.chain_info().best_block_number,
 			|| Some(chain.latest_nonce(address)),
 			|b| b.block().fields().state.nonce(address).ok(),
 		)
 	}
 	fn code(&self, chain: &MiningBlockChainClient, address: &Address) -> Option<Option<Bytes>> {
 		self.from_pending_block(
 			chain.chain_info().best_block_number,
 			|| Some(chain.latest_code(address)),
 			|b| b.block().fields().state.code(address).ok().map(|c| c.map(|c| (&*c).clone()))
 		)
 	}
 	fn set_author(&self, author: Address) {
 		if self.engine.seals_internally().is_some() {
 			let mut sealing_work = self.sealing_work.lock();
@ -1112,6 +1051,8 @@ impl MinerService for Miner {
 	/// Prepare the block and work if the Engine does not seal internally.
 	fn update_sealing(&self, chain: &MiningBlockChainClient) {
 		trace!(target: "miner", "update_sealing");
 		const NO_NEW_CHAIN_WITH_FORKS: &str = "Your chain specification contains one or more hard forks which are required to be \
 			on by default. Please remove these forks and start your chain again.";
 		if self.requires_reseal(chain.chain_info().best_block_number) {
 			// --------------------------------------------------------------------------
@ -1120,6 +1061,14 @@ impl MinerService for Miner {
 			// --------------------------------------------------------------------------
 			trace!(target: "miner", "update_sealing: preparing a block");
 			let (block, original_work_hash) = self.prepare_block(chain);
 			// refuse to seal the first block of the chain if it contains hard forks
 			// which should be on by default.
 			if block.block().fields().header.number() == 1 && self.engine.params().contains_bugfix_hard_fork() {
 				warn!("{}", NO_NEW_CHAIN_WITH_FORKS);
 				return;
 			}
 			match self.engine.seals_internally() {
 				Some(true) => {
 					trace!(target: "miner", "update_sealing: engine indicates internal sealing");
@ -1127,11 +1076,11 @@ impl MinerService for Miner {
 						trace!(target: "miner", "update_sealing: imported internally sealed block");
 					}
 				},
 				Some(false) => trace!(target: "miner", "update_sealing: engine is not keen to seal internally right now"),
 				None => {
 					trace!(target: "miner", "update_sealing: engine does not seal internally, preparing work");
 					self.prepare_work(block, original_work_hash)
 				},
 				_ => trace!(target: "miner", "update_sealing: engine is not keen to seal internally right now")
 			}
 		}
 	}
@ -1454,14 +1403,14 @@ mod tests {
 		miner.update_sealing(&*client);
 		client.flush_queue();
-		assert!(miner.pending_block().is_none());
+		assert!(miner.pending_block(0).is_none());
 		assert_eq!(client.chain_info().best_block_number, 3 as BlockNumber);
 		assert_eq!(miner.import_own_transaction(&*client, PendingTransaction::new(transaction_with_network_id(spec.network_id()).into(), None)).unwrap(), TransactionImportResult::Current);
 		miner.update_sealing(&*client);
 		client.flush_queue();
-		assert!(miner.pending_block().is_none());
+		assert!(miner.pending_block(0).is_none());
 		assert_eq!(client.chain_info().best_block_number, 4 as BlockNumber);
 	}
--- a/ethcore/src/miner/mod.rs
+++ b/ethcore/src/miner/mod.rs
@ -62,12 +62,12 @@ pub use self::stratum::{Stratum, Error as StratumError, Options as StratumOption
 use std::collections::BTreeMap;
 use util::{H256, U256, Address, Bytes};
-use client::{MiningBlockChainClient, Executed, CallAnalytics};
+use client::{MiningBlockChainClient};
 use block::ClosedBlock;
 use header::BlockNumber;
 use receipt::{RichReceipt, Receipt};
-use error::{Error, CallError};
+use error::{Error};
-use transaction::{UnverifiedTransaction, PendingTransaction, SignedTransaction};
+use transaction::{UnverifiedTransaction, PendingTransaction};
 /// Miner client API
 pub trait MinerService : Send + Sync {
@ -185,21 +185,6 @@ pub trait MinerService : Send + Sync {
 	/// Suggested gas limit.
 	fn sensible_gas_limit(&self) -> U256 { 21000.into() }
 	/// Latest account balance in pending state.
 	fn balance(&self, chain: &MiningBlockChainClient, address: &Address) -> Option<U256>;
 	/// Call into contract code using pending state.
 	fn call(&self, chain: &MiningBlockChainClient, t: &SignedTransaction, analytics: CallAnalytics) -> Result<Executed, CallError>;
 	/// Get storage value in pending state.
 	fn storage_at(&self, chain: &MiningBlockChainClient, address: &Address, position: &H256) -> Option<H256>;
 	/// Get account nonce in pending state.
 	fn nonce(&self, chain: &MiningBlockChainClient, address: &Address) -> Option<U256>;
 	/// Get contract code in pending state.
 	fn code(&self, chain: &MiningBlockChainClient, address: &Address) -> Option<Option<Bytes>>;
 }
 /// Mining status
--- a/ethcore/src/miner/transaction_queue.rs
+++ b/ethcore/src/miner/transaction_queue.rs
@ -106,7 +106,7 @@ use std::cmp;
 use std::collections::{HashSet, HashMap, BTreeSet, BTreeMap};
 use linked_hash_map::LinkedHashMap;
 use util::{Address, H256, U256, HeapSizeOf};
-use util::table::Table;
+use table::Table;
 use transaction::*;
 use error::{Error, TransactionError};
 use client::TransactionImportResult;
@ -1447,7 +1447,7 @@ fn check_if_removed(sender: &Address, nonce: &U256, dropped: Option<HashMap<Addr
 #[cfg(test)]
 pub mod test {
 	use rustc_hex::FromHex;
-	use util::table::*;
+	use table::Table;
 	use util::*;
 	use ethkey::{Random, Generator};
 	use error::{Error, TransactionError};
--- a/ethcore/src/miner/work_notify.rs
+++ b/ethcore/src/miner/work_notify.rs
@ -16,6 +16,7 @@
 extern crate hyper;
 use std::io::Write;
 use hyper::header::ContentType;
 use hyper::method::Method;
 use hyper::client::{Request, Response, Client};
--- a/ethcore/src/pod_account.rs
+++ b/ethcore/src/pod_account.rs
@ -14,6 +14,8 @@
 // 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::fmt;
 use std::collections::BTreeMap;
 use util::*;
 use state::Account;
 use ethjson;
@ -166,7 +168,7 @@ pub fn diff_pod(pre: Option<&PodAccount>, post: Option<&PodAccount>) -> Option<A
 #[cfg(test)]
 mod test {
-	use util::*;
+	use std::collections::BTreeMap;
 	use types::account_diff::*;
 	use super::{PodAccount, diff_pod};
--- a/ethcore/src/pod_state.rs
+++ b/ethcore/src/pod_state.rs
@ -16,6 +16,8 @@
 //! State of all accounts in the system expressed in Plain Old Data.
 use std::fmt;
 use std::collections::BTreeMap;
 use util::*;
 use pod_account::{self, PodAccount};
 use types::state_diff::StateDiff;
@ -77,7 +79,7 @@ pub fn diff_pod(pre: &PodState, post: &PodState) -> StateDiff {
 #[cfg(test)]
 mod test {
-	use util::*;
+	use std::collections::BTreeMap;
 	use types::state_diff::*;
 	use types::account_diff::*;
 	use pod_account::PodAccount;
--- a/ethcore/src/service.rs
+++ b/ethcore/src/service.rs
@ -16,6 +16,8 @@
 //! Creates and registers client and network services.
 use std::sync::Arc;
 use std::path::Path;
 use util::*;
 use io::*;
 use spec::Spec;
--- a/ethcore/src/snapshot/tests/test_validator_contract.json
+++ b/ethcore/src/snapshot/tests/test_validator_contract.json
@ -3,7 +3,6 @@
 	"engine": {
 		"authorityRound": {
 			"params": {
 				"gasLimitBoundDivisor": "0x0400",
 				"stepDuration": 1,
 				"startStep": 0,
 				"validators": {
@ -17,6 +16,7 @@
 		}
 	},
 	"params": {
 		"gasLimitBoundDivisor": "0x0400",
 		"accountStartNonce": "0x0",
 		"maximumExtraDataSize": "0x20",
 		"minGasLimit": "0x1388",
--- a/ethcore/src/spec/spec.rs
+++ b/ethcore/src/spec/spec.rs
@ -16,14 +16,17 @@
 //! Parameters for a block chain.
 use std::io::Read;
 use std::collections::BTreeMap;
 use std::path::Path;
 use std::sync::Arc;
 use rustc_hex::FromHex;
 use super::genesis::Genesis;
 use super::seal::Generic as GenericSeal;
 use evm::action_params::{ActionValue, ActionParams};
 use builtin::Builtin;
 use engines::{Engine, NullEngine, InstantSeal, BasicAuthority, AuthorityRound, Tendermint, DEFAULT_BLOCKHASH_CONTRACT};
-use evm::env_info::EnvInfo;
+use vm::{EnvInfo, CallType, ActionValue, ActionParams};
 use error::Error;
 use ethereum;
 use ethjson;
@ -36,10 +39,14 @@ use state_db::StateDB;
 use state::{Backend, State, Substate};
 use state::backend::Basic as BasicBackend;
 use trace::{NoopTracer, NoopVMTracer};
 use evm::CallType;
 use util::*;
-/// Parameters common to all engines.
+/// Parameters common to ethereum-like blockchains.
 /// NOTE: when adding bugfix hard-fork parameters,
 /// add to `contains_bugfix_hard_fork`
 ///
 /// we define a "bugfix" hard fork as any hard fork which
 /// you would put on-by-default in a new chain.
 #[derive(Debug, PartialEq, Default)]
 #[cfg_attr(test, derive(Clone))]
 pub struct CommonParams {
@ -59,8 +66,10 @@ pub struct CommonParams {
 	pub fork_block: Option<(BlockNumber, H256)>,
 	/// Number of first block where EIP-98 rules begin.
 	pub eip98_transition: BlockNumber,
 	/// Number of first block where EIP-155 rules begin.
 	pub eip155_transition: BlockNumber,
 	/// Validate block receipts root.
-	pub validate_receipts_transition: u64,
+	pub validate_receipts_transition: BlockNumber,
 	/// Number of first block where EIP-86 (Metropolis) rules begin.
 	pub eip86_transition: BlockNumber,
 	/// Number of first block where EIP-140 (Metropolis: REVERT opcode) rules begin.
@ -85,18 +94,24 @@ pub struct CommonParams {
 	pub remove_dust_contracts: bool,
 	/// Wasm support
 	pub wasm: bool,
 	/// Gas limit bound divisor (how much gas limit can change per block)
 	pub gas_limit_bound_divisor: U256,
 	/// Block reward in wei.
 	pub block_reward: U256,
 	/// Registrar contract address.
 	pub registrar: Address,
 }
 impl CommonParams {
 	/// Schedule for an EVM in the post-EIP-150-era of the Ethereum main net.
-	pub fn schedule(&self, block_number: u64) -> ::evm::Schedule {
+	pub fn schedule(&self, block_number: u64) -> ::vm::Schedule {
-		let mut schedule = ::evm::Schedule::new_post_eip150(usize::max_value(), true, true, true);
+		let mut schedule = ::vm::Schedule::new_post_eip150(usize::max_value(), true, true, true);
 		self.update_schedule(block_number, &mut schedule);
 		schedule
 	}
 	/// Apply common spec config parameters to the schedule.
- 	pub fn update_schedule(&self, block_number: u64, schedule: &mut ::evm::Schedule) {
+ 	pub fn update_schedule(&self, block_number: u64, schedule: &mut ::vm::Schedule) {
 		schedule.have_create2 = block_number >= self.eip86_transition;
 		schedule.have_revert = block_number >= self.eip140_transition;
 		schedule.have_static_call = block_number >= self.eip214_transition;
@ -106,11 +121,24 @@ impl CommonParams {
 		}
 		if block_number >= self.dust_protection_transition {
 			schedule.kill_dust = match self.remove_dust_contracts {
-				true => ::evm::CleanDustMode::WithCodeAndStorage,
+				true => ::vm::CleanDustMode::WithCodeAndStorage,
-				false => ::evm::CleanDustMode::BasicOnly,
+				false => ::vm::CleanDustMode::BasicOnly,
 			};
 		}
 	}
 	/// Whether these params contain any bug-fix hard forks.
 	pub fn contains_bugfix_hard_fork(&self) -> bool {
 		self.eip98_transition != 0 &&
 			self.eip155_transition != 0 &&
 			self.validate_receipts_transition != 0 &&
 			self.eip86_transition != 0 &&
 			self.eip140_transition != 0 &&
 			self.eip210_transition != 0 &&
 			self.eip211_transition != 0 &&
 			self.eip214_transition != 0 &&
 			self.dust_protection_transition != 0
 	}
 }
 impl From<ethjson::spec::Params> for CommonParams {
@ -124,6 +152,7 @@ impl From<ethjson::spec::Params> for CommonParams {
 			min_gas_limit: p.min_gas_limit.into(),
 			fork_block: if let (Some(n), Some(h)) = (p.fork_block, p.fork_hash) { Some((n.into(), h.into())) } else { None },
 			eip98_transition: p.eip98_transition.map_or(0, Into::into),
 			eip155_transition: p.eip155_transition.map_or(0, Into::into),
 			validate_receipts_transition: p.validate_receipts_transition.map_or(0, Into::into),
 			eip86_transition: p.eip86_transition.map_or(BlockNumber::max_value(), Into::into),
 			eip140_transition: p.eip140_transition.map_or(BlockNumber::max_value(), Into::into),
@ -139,6 +168,9 @@ impl From<ethjson::spec::Params> for CommonParams {
 			nonce_cap_increment: p.nonce_cap_increment.map_or(64, Into::into),
 			remove_dust_contracts: p.remove_dust_contracts.unwrap_or(false),
 			wasm: p.wasm.unwrap_or(false),
 			gas_limit_bound_divisor: p.gas_limit_bound_divisor.into(),
 			block_reward: p.block_reward.map_or_else(U256::zero, Into::into),
 			registrar: p.registrar.map_or_else(Address::new, Into::into),
 		}
 	}
 }
@ -242,7 +274,7 @@ impl Spec {
 	) -> Arc<Engine> {
 		match engine_spec {
 			ethjson::spec::Engine::Null => Arc::new(NullEngine::new(params, builtins)),
-			ethjson::spec::Engine::InstantSeal(instant) => Arc::new(InstantSeal::new(params, instant.params.registrar.map_or_else(Address::new, Into::into), builtins)),
+			ethjson::spec::Engine::InstantSeal => Arc::new(InstantSeal::new(params, builtins)),
 			ethjson::spec::Engine::Ethash(ethash) => Arc::new(ethereum::Ethash::new(cache_dir, params, From::from(ethash.params), builtins)),
 			ethjson::spec::Engine::BasicAuthority(basic_authority) => Arc::new(BasicAuthority::new(params, From::from(basic_authority.params), builtins)),
 			ethjson::spec::Engine::AuthorityRound(authority_round) => AuthorityRound::new(params, From::from(authority_round.params), builtins).expect("Failed to start AuthorityRound consensus engine."),
@ -484,6 +516,7 @@ impl Spec {
 #[cfg(test)]
 mod tests {
 	use std::str::FromStr;
 	use util::*;
 	use views::*;
 	use tests::helpers::get_temp_state_db;
@ -496,19 +529,6 @@ mod tests {
 		assert!(Spec::load(::std::env::temp_dir(), &[] as &[u8]).is_err());
 	}
 	#[test]
 	fn all_spec_files_valid() {
 		Spec::new_test();
 		Spec::new_null();
 		Spec::new_test_constructor();
 		Spec::new_instant();
 		Spec::new_test_round();
 		Spec::new_test_tendermint();
 		Spec::new_validator_safe_contract();
 		Spec::new_validator_contract();
 		Spec::new_validator_multi();
 	}
 	#[test]
 	fn test_chain() {
 		let test_spec = Spec::new_test();
--- a/ethcore/src/state/account.rs
+++ b/ethcore/src/state/account.rs
@ -16,6 +16,9 @@
 //! Single account in the system.
 use std::fmt;
 use std::sync::Arc;
 use std::collections::HashMap;
 use util::*;
 use pod_account::*;
 use rlp::*;
--- a/ethcore/src/state/mod.rs
+++ b/ethcore/src/state/mod.rs
@ -21,10 +21,13 @@
 use std::cell::{RefCell, RefMut};
 use std::collections::hash_map::Entry;
 use std::collections::{HashMap, BTreeMap, HashSet};
 use std::fmt;
 use std::sync::Arc;
 use receipt::Receipt;
 use engines::Engine;
-use evm::env_info::EnvInfo;
+use vm::EnvInfo;
 use error::Error;
 use executive::{Executive, TransactOptions};
 use factory::Factories;
@ -982,7 +985,7 @@ mod tests {
 	use ethkey::Secret;
 	use util::{U256, H256, Address, Hashable};
 	use tests::helpers::*;
-	use evm::env_info::EnvInfo;
+	use vm::EnvInfo;
 	use spec::*;
 	use transaction::*;
 	use ethcore_logger::init_log;
--- a/ethcore/src/state_db.rs
+++ b/ethcore/src/state_db.rs
@ -15,6 +15,7 @@
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 use std::collections::{VecDeque, HashSet};
 use std::sync::Arc;
 use lru_cache::LruCache;
 use util::cache::MemoryLruCache;
 use util::journaldb::JournalDB;
@ -23,7 +24,7 @@ use util::hash::{H256};
 use util::hashdb::HashDB;
 use state::{self, Account};
 use header::BlockNumber;
-use util::{Arc, Address, DBTransaction, UtilError, Mutex, Hashable};
+use util::{Address, DBTransaction, UtilError, Mutex, Hashable};
 use bloom_journal::{Bloom, BloomJournal};
 use db::COL_ACCOUNT_BLOOM;
 use byteorder::{LittleEndian, ByteOrder};
--- a/ethcore/src/tests/client.rs
+++ b/ethcore/src/tests/client.rs
@ -14,6 +14,8 @@
 // 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::str::FromStr;
 use std::sync::Arc;
 use io::IoChannel;
 use client::{BlockChainClient, MiningBlockChainClient, Client, ClientConfig, BlockId};
 use state::{self, State, CleanupMode};
--- a/Show More
+++ b/Show More