[beta] EIP150.1c (#2599 )

* EIP150.1c Conflicts: ethcore/res/ethereum/expanse.json ethcore/res/ethereum/morden.json ethcore/res/ethereum/tests ethcore/src/blockchain/blockchain.rs ethcore/src/ethereum/ethash.rs ethcore/src/evm/interpreter/mod.rs json/src/spec/ethash.rs * Update json test suite (#2574) * update json test suite * comment out the incomplete test Conflicts: ethcore/res/ethereum/tests * Updating tests * Adding state tests * Updating tests * Updating HF block * Removing flushln [ci:skip] * Commenting out suicide test * New tests. * Switch to EIP tests. * Rename some stuff, combine transition tests. * Fix U256 overflows. * Name cleanups and an effort to fix tests. * Rename back for clarity. * Fix non-EIP-150 OOG CALLs * New transition block number & additional EIP150 tests * Morden transition block set; Tests updated * Added missing test
Revert "Bloom upgrade in beta" (#2635 )
2016-10-15 15:16:26 +02:00 · 2016-10-15 13:15:45 +02:00 · 2016-10-15 12:29:27 +02:00 · 2016-10-14 17:27:47 +02:00 · 2016-10-14 17:26:35 +02:00 · 2016-10-12 20:44:25 +02:00
98 changed files with 3237 additions and 1714 deletions
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -19,9 +19,11 @@ linux-stable:
  script:
    - cargo build --release --verbose
    - strip target/release/parity
+    - md5sum target/release/parity >> parity.md5
    - aws configure set aws_access_key_id $s3_key 
    - aws configure set aws_secret_access_key $s3_secret
    - aws s3api put-object --bucket builds-parity --key $CI_BUILD_REF_NAME/x86_64-unknown-linux-gnu/parity --body target/release/parity
+    - aws s3api put-object --bucket builds-parity --key $CI_BUILD_REF_NAME/x86_64-unknown-linux-gnu/parity.md5 --body parity.md5
  tags:
    - rust
    - rust-stable
@@ -40,9 +42,11 @@ linux-stable-14.04:
  script:
    - cargo build --release --verbose
    - strip target/release/parity
+    - md5sum target/release/parity >> parity.md5
    - aws configure set aws_access_key_id $s3_key 
    - aws configure set aws_secret_access_key $s3_secret
    - aws s3api put-object --bucket builds-parity --key $CI_BUILD_REF_NAME/x86_64-unknown-ubuntu_14_04-gnu/parity --body target/release/parity
+    - aws s3api put-object --bucket builds-parity --key $CI_BUILD_REF_NAME/x86_64-unknown-ubuntu_14_04-gnu/parity.md5 --body parity.md5
  tags:
    - rust
    - rust-14.04
@@ -101,9 +105,11 @@ linux-centos:
    - export CC="gcc"
    - cargo build --release --verbose
    - strip target/release/parity
+    - md5sum target/release/parity >> parity.md5
    - aws configure set aws_access_key_id $s3_key 
    - aws configure set aws_secret_access_key $s3_secret
    - aws s3api put-object --bucket builds-parity --key $CI_BUILD_REF_NAME/x86_64-unknown-centos-gnu/parity --body target/release/parity
+    - aws s3api put-object --bucket builds-parity --key $CI_BUILD_REF_NAME/x86_64-unknown-centos-gnu/parity.md5 --body parity.md5
  tags:
    - rust
    - rust-centos
@@ -115,7 +121,6 @@ linux-armv7:
  stage: build
  image: ethcore/rust-armv7:latest
  only:
-    - master
    - beta
    - tags
    - stable
@@ -127,9 +132,11 @@ linux-armv7:
    - cat .cargo/config
    - cargo build --target armv7-unknown-linux-gnueabihf --release --verbose
    - arm-linux-gnueabihf-strip target/armv7-unknown-linux-gnueabihf/release/parity
+    - md5sum target/armv7-unknown-linux-gnueabihf/release/parity >> parity.md5
    - aws configure set aws_access_key_id $s3_key 
    - aws configure set aws_secret_access_key $s3_secret
    - aws s3api put-object --bucket builds-parity --key $CI_BUILD_REF_NAME/armv7-unknown-linux-gnueabihf/parity --body target/armv7-unknown-linux-gnueabihf/release/parity
+    - aws s3api put-object --bucket builds-parity --key $CI_BUILD_REF_NAME/armv7-unknown-linux-gnueabihf/parity.md5 --body parity.md5
  tags:
    - rust
    - rust-arm
@@ -142,7 +149,6 @@ linux-arm:
  stage: build
  image: ethcore/rust-arm:latest
  only:
-    - master
    - beta
    - tags
    - stable
@@ -154,9 +160,11 @@ linux-arm:
    - cat .cargo/config
    - cargo build --target arm-unknown-linux-gnueabihf --release --verbose
    - arm-linux-gnueabihf-strip target/arm-unknown-linux-gnueabihf/release/parity
+    - md5sum target/arm-unknown-linux-gnueabihf/release/parity >> parity.md5
    - aws configure set aws_access_key_id $s3_key 
    - aws configure set aws_secret_access_key $s3_secret
    - aws s3api put-object --bucket builds-parity --key $CI_BUILD_REF_NAME/arm-unknown-linux-gnueabihf/parity --body target/arm-unknown-linux-gnueabihf/release/parity
+    - aws s3api put-object --bucket builds-parity --key $CI_BUILD_REF_NAME/arm-unknown-linux-gnueabihf/parity.md5 --body parity.md5
  tags:
    - rust
    - rust-arm
@@ -169,7 +177,6 @@ linux-armv6:
  stage: build
  image: ethcore/rust-armv6:latest
  only:
-    - master
    - beta
    - tags
    - stable
@@ -181,9 +188,11 @@ linux-armv6:
    - cat .cargo/config
    - cargo build --target arm-unknown-linux-gnueabi --release --verbose
    - arm-linux-gnueabi-strip target/arm-unknown-linux-gnueabi/release/parity
+    - md5sum target/arm-unknown-linux-gnueabi/release/parity >> parity.md5 
    - aws configure set aws_access_key_id $s3_key 
    - aws configure set aws_secret_access_key $s3_secret
    - aws s3api put-object --bucket builds-parity --key $CI_BUILD_REF_NAME/arm-unknown-linux-gnueabi/parity --body target/arm-unknown-linux-gnueabi/release/parity
+    - aws s3api put-object --bucket builds-parity --key $CI_BUILD_REF_NAME/arm-unknown-linux-gnueabi/parity.md5 --body parity.md5
  tags:
    - rust
    - rust-arm
@@ -196,7 +205,6 @@ linux-aarch64:
  stage: build
  image: ethcore/rust-aarch64:latest
  only:
-    - master
    - beta
    - tags
    - stable
@@ -208,9 +216,11 @@ linux-aarch64:
    - cat .cargo/config
    - cargo build --target aarch64-unknown-linux-gnu --release --verbose
    - aarch64-linux-gnu-strip target/aarch64-unknown-linux-gnu/release/parity
+    - md5sum target/aarch64-unknown-linux-gnu/release/parity >> parity.md5
    - aws configure set aws_access_key_id $s3_key 
    - aws configure set aws_secret_access_key $s3_secret
    - aws s3api put-object --bucket builds-parity --key $CI_BUILD_REF_NAME/aarch64-unknown-linux-gnu/parity --body target/aarch64-unknown-linux-gnu/release/parity
+    - aws s3api put-object --bucket builds-parity --key $CI_BUILD_REF_NAME/aarch64-unknown-linux-gnu/parity.md5 --body parity.md5
  tags:
    - rust
    - rust-arm
@@ -228,9 +238,11 @@ darwin:
    - stable
  script:
    - cargo build --release --verbose
+    - md5sum target/release/parity >> parity.md5
    - aws configure set aws_access_key_id $s3_key 
    - aws configure set aws_secret_access_key $s3_secret
    - aws s3api put-object --bucket builds-parity --key $CI_BUILD_REF_NAME/x86_64-apple-darwin/parity --body target/release/parity
+    - aws s3api put-object --bucket builds-parity --key $CI_BUILD_REF_NAME/x86_64-apple-darwin/parity.md5 --body parity.md5
  tags:
    - osx
  artifacts:
@@ -248,18 +260,42 @@ windows:
    - set INCLUDE=C:\Program Files (x86)\Microsoft SDKs\Windows\v7.1A\Include;C:\vs2015\VC\include;C:\Program Files (x86)\Windows Kits\10\Include\10.0.10240.0\ucrt
    - set LIB=C:\vs2015\VC\lib;C:\Program Files (x86)\Windows Kits\10\Lib\10.0.10240.0\ucrt\x64
    - set RUST_BACKTRACE=1
+    - set RUSTFLAGS=%RUSTFLAGS% -Zorbit=off -D warnings
    - rustup default stable-x86_64-pc-windows-msvc
    - cargo build --release --verbose
+    - curl -sL --url "https://github.com/ethcore/win-build/raw/master/SimpleFC.dll" -o nsis\SimpleFC.dll
+    - curl -sL --url "https://github.com/ethcore/win-build/raw/master/vc_redist.x64.exe" -o nsis\vc_redist.x64.exe
+    - signtool sign /f %keyfile% /p %certpass% target\release\parity.exe
+    - cd nsis
+    - makensis.exe installer.nsi
+    - copy installer.exe InstallParity.exe
+    - signtool sign /f %keyfile% /p %certpass% InstallParity.exe
+    - md5sums InstallParity.exe > InstallParity.exe.md5
+    - zip win-installer.zip InstallParity.exe InstallParity.exe.md5
+    - md5sums win-installer.zip > win-installer.zip.md5
+    - cd ..\target\release\
+    - md5sums parity.exe parity.pdb > parity.md5
+    - md5sums parity.exe > parity.exe.md5
+    - zip parity.zip parity.exe parity.pdb parity.md5
+    - md5sums parity.zip > parity.zip.md5
+    - cd ..\..
    - aws configure set aws_access_key_id %s3_key%
    - aws configure set aws_secret_access_key %s3_secret%
-    - aws s3api put-object --bucket builds-parity --key %CI_BUILD_REF_NAME%/x86_64-pc-windows-msvc/parity --body target/release/parity.exe
-    - aws s3api put-object --bucket builds-parity --key %CI_BUILD_REF_NAME%/x86_64-pc-windows-msvc/parity --body target/release/parity.pdb
+    - aws s3api put-object --bucket builds-parity --key %CI_BUILD_REF_NAME%/x86_64-pc-windows-msvc/parity.exe --body target\release\parity.exe
+    - aws s3api put-object --bucket builds-parity --key %CI_BUILD_REF_NAME%/x86_64-pc-windows-msvc/parity.exe.md5 --body target\release\parity.exe.md5
+    - aws s3api put-object --bucket builds-parity --key %CI_BUILD_REF_NAME%/x86_64-pc-windows-msvc/parity.zip --body target\release\parity.zip
+    - aws s3api put-object --bucket builds-parity --key %CI_BUILD_REF_NAME%/x86_64-pc-windows-msvc/parity.zip.md5 --body target\release\parity.zip.md5
+    - aws s3api put-object --bucket builds-parity --key %CI_BUILD_REF_NAME%/x86_64-pc-windows-msvc/InstallParity.exe --body nsis\InstallParity.exe
+    - aws s3api put-object --bucket builds-parity --key %CI_BUILD_REF_NAME%/x86_64-pc-windows-msvc/InstallParity.exe.md5 --body nsis\InstallParity.exe.md5
+    - aws s3api put-object --bucket builds-parity --key %CI_BUILD_REF_NAME%/x86_64-pc-windows-msvc/win-installer.zip --body nsis\win-installer.zip
+    - aws s3api put-object --bucket builds-parity --key %CI_BUILD_REF_NAME%/x86_64-pc-windows-msvc/win-installer.zip.md5 --body nsis\win-installer.zip.md5
  tags:
   - rust-windows
  artifacts:
    paths:
    - target/release/parity.exe
    - target/release/parity.pdb
+    - nsis/InstallParity.exe
    name: "x86_64-pc-windows-msvc_parity"
 test-linux:
  stage: test
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1,12 +1,12 @@
 [root]
 name = "parity"
-version = "1.3.2"
+version = "1.3.8"
 dependencies = [
 "ansi_term 0.7.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "clippy 0.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
 "ctrlc 1.1.1 (git+https://github.com/ethcore/rust-ctrlc.git)",
- "daemonize 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
- "docopt 0.6.80 (registry+https://github.com/rust-lang/crates.io-index)",
+ "daemonize 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
+ "docopt 0.6.86 (registry+https://github.com/rust-lang/crates.io-index)",
 "env_logger 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "ethcore 1.3.0",
 "ethcore-dapps 1.3.0",
@@ -20,22 +20,22 @@ dependencies = [
 "ethcore-logger 1.3.0",
 "ethcore-rpc 1.3.0",
 "ethcore-signer 1.3.0",
- "ethcore-util 1.3.2",
+ "ethcore-util 1.3.8",
 "ethsync 1.3.0",
 "fdlimit 0.1.0",
 "hyper 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "isatty 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
- "json-ipc-server 0.2.4 (git+https://github.com/ethcore/json-ipc-server.git)",
+ "json-ipc-server 0.2.4 (git+https://github.com/ethcore/json-ipc-server.git?branch=beta)",
 "lazy_static 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 0.2.11 (registry+https://github.com/rust-lang/crates.io-index)",
- "number_prefix 0.2.5 (registry+https://github.com/rust-lang/crates.io-index)",
+ "number_prefix 0.2.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "regex 0.1.68 (registry+https://github.com/rust-lang/crates.io-index)",
- "rpassword 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rpassword 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc-serialize 0.3.19 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc_version 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "semver 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
- "syntex 0.33.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "syntex 0.36.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "time 0.1.35 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.2.6 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
@@ -192,7 +192,7 @@ dependencies = [

 [[package]]
 name = "daemonize"
-version = "0.2.2"
+version = "0.2.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
 "libc 0.2.12 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -208,12 +208,13 @@ dependencies = [

 [[package]]
 name = "docopt"
-version = "0.6.80"
+version = "0.6.86"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
+ "lazy_static 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "regex 0.1.68 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc-serialize 0.3.19 (registry+https://github.com/rust-lang/crates.io-index)",
- "strsim 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "strsim 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)",
 ]

 [[package]]
@@ -236,7 +237,7 @@ version = "0.5.4"
 source = "git+https://github.com/ethcore/rust-secp256k1#a9a0b1be1f39560ca86e8fc8e55e205a753ff25c"
 dependencies = [
 "arrayvec 0.3.16 (registry+https://github.com/rust-lang/crates.io-index)",
- "gcc 0.3.28 (registry+https://github.com/rust-lang/crates.io-index)",
+ "gcc 0.3.35 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.3.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc-serialize 0.3.19 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -269,7 +270,7 @@ dependencies = [
 "ethcore-ipc 1.3.0",
 "ethcore-ipc-codegen 1.3.0",
 "ethcore-ipc-nano 1.3.0",
- "ethcore-util 1.3.2",
+ "ethcore-util 1.3.8",
 "ethjson 0.1.0",
 "ethstore 0.1.0",
 "evmjit 1.3.0",
@@ -280,7 +281,7 @@ dependencies = [
 "lru-cache 0.0.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 0.2.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.3.14 (registry+https://github.com/rust-lang/crates.io-index)",
- "rayon 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rayon 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "rust-crypto 0.2.36 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc-serialize 0.3.19 (registry+https://github.com/rust-lang/crates.io-index)",
 "semver 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -293,7 +294,7 @@ version = "1.3.0"
 dependencies = [
 "clippy 0.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
 "ethcore-rpc 1.3.0",
- "ethcore-util 1.3.2",
+ "ethcore-util 1.3.8",
 "hyper 0.9.4 (git+https://github.com/ethcore/hyper)",
 "jsonrpc-core 2.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "jsonrpc-http-server 6.1.0 (git+https://github.com/ethcore/jsonrpc-http-server.git)",
@@ -335,7 +336,7 @@ name = "ethcore-ipc"
 version = "1.3.0"
 dependencies = [
 "ethcore-devtools 1.3.0",
- "ethcore-util 1.3.2",
+ "ethcore-util 1.3.8",
 "nanomsg 0.5.1 (git+https://github.com/ethcore/nanomsg.rs.git)",
 "semver 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
@@ -380,7 +381,7 @@ dependencies = [
 "ethcore-ipc 1.3.0",
 "ethcore-ipc-codegen 1.3.0",
 "ethcore-ipc-nano 1.3.0",
- "ethcore-util 1.3.2",
+ "ethcore-util 1.3.8",
 "log 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "nanomsg 0.5.1 (git+https://github.com/ethcore/nanomsg.rs.git)",
 "semver 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -392,7 +393,7 @@ name = "ethcore-logger"
 version = "1.3.0"
 dependencies = [
 "env_logger 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
- "ethcore-util 1.3.2",
+ "ethcore-util 1.3.8",
 "isatty 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -407,7 +408,7 @@ dependencies = [
 "ansi_term 0.7.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "ethcore-devtools 1.3.0",
 "ethcore-io 1.3.0",
- "ethcore-util 1.3.2",
+ "ethcore-util 1.3.8",
 "igd 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -431,10 +432,10 @@ dependencies = [
 "ethcore-devtools 1.3.0",
 "ethcore-io 1.3.0",
 "ethcore-ipc 1.3.0",
- "ethcore-util 1.3.2",
+ "ethcore-util 1.3.8",
 "ethjson 0.1.0",
 "ethsync 1.3.0",
- "json-ipc-server 0.2.4 (git+https://github.com/ethcore/json-ipc-server.git)",
+ "json-ipc-server 0.2.4 (git+https://github.com/ethcore/json-ipc-server.git?branch=beta)",
 "jsonrpc-core 2.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "jsonrpc-http-server 6.1.0 (git+https://github.com/ethcore/jsonrpc-http-server.git)",
 "log 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -454,7 +455,7 @@ dependencies = [
 "env_logger 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "ethcore-io 1.3.0",
 "ethcore-rpc 1.3.0",
- "ethcore-util 1.3.2",
+ "ethcore-util 1.3.8",
 "jsonrpc-core 2.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "parity-dapps-signer 1.4.0 (git+https://github.com/ethcore/parity-ui.git)",
@@ -465,7 +466,7 @@ dependencies = [

 [[package]]
 name = "ethcore-util"
-version = "1.3.2"
+version = "1.3.8"
 dependencies = [
 "ansi_term 0.7.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "arrayvec 0.3.16 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -498,7 +499,7 @@ dependencies = [
 name = "ethjson"
 version = "0.1.0"
 dependencies = [
- "ethcore-util 1.3.2",
+ "ethcore-util 1.3.8",
 "rustc-serialize 0.3.19 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 0.7.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_codegen 0.7.9 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -546,7 +547,7 @@ dependencies = [
 "ethcore-ipc-codegen 1.3.0",
 "ethcore-ipc-nano 1.3.0",
 "ethcore-network 1.3.0",
- "ethcore-util 1.3.2",
+ "ethcore-util 1.3.8",
 "heapsize 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "parking_lot 0.2.6 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -571,8 +572,11 @@ dependencies = [

 [[package]]
 name = "gcc"
-version = "0.3.28"
+version = "0.3.35"
 source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "rayon 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
+]

 [[package]]
 name = "glob"
@@ -706,7 +710,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 [[package]]
 name = "json-ipc-server"
 version = "0.2.4"
-source = "git+https://github.com/ethcore/json-ipc-server.git#56b6307130710ebc73cb9be087b6ed0b6c400bcf"
+source = "git+https://github.com/ethcore/json-ipc-server.git?branch=beta#42d0dacc9cd203757ba894d7ba3690e12ef9f934"
 dependencies = [
 "bytes 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "env_logger 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -885,7 +889,7 @@ name = "nanomsg-sys"
 version = "0.5.0"
 source = "git+https://github.com/ethcore/nanomsg.rs.git#c40fe442c9afaea5b38009a3d992ca044dcceb00"
 dependencies = [
- "gcc 0.3.28 (registry+https://github.com/rust-lang/crates.io-index)",
+ "gcc 0.3.35 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.12 (registry+https://github.com/rust-lang/crates.io-index)",
 ]

@@ -1012,7 +1016,7 @@ dependencies = [

 [[package]]
 name = "number_prefix"
-version = "0.2.5"
+version = "0.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
 "num 0.1.32 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -1193,7 +1197,7 @@ dependencies = [

 [[package]]
 name = "rayon"
-version = "0.3.1"
+version = "0.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
 "deque 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -1221,7 +1225,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 [[package]]
 name = "rocksdb"
 version = "0.4.5"
-source = "git+https://github.com/ethcore/rust-rocksdb#485dd747a2c9a9f910fc8ac696fc9edf5fa22aa3"
+source = "git+https://github.com/ethcore/rust-rocksdb#64c63ccbe1f62c2e2b39262486f9ba813793af58"
 dependencies = [
 "libc 0.2.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "rocksdb-sys 0.3.0 (git+https://github.com/ethcore/rust-rocksdb)",
@@ -1230,9 +1234,9 @@ dependencies = [
 [[package]]
 name = "rocksdb-sys"
 version = "0.3.0"
-source = "git+https://github.com/ethcore/rust-rocksdb#485dd747a2c9a9f910fc8ac696fc9edf5fa22aa3"
+source = "git+https://github.com/ethcore/rust-rocksdb#64c63ccbe1f62c2e2b39262486f9ba813793af58"
 dependencies = [
- "gcc 0.3.28 (registry+https://github.com/rust-lang/crates.io-index)",
+ "gcc 0.3.35 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.12 (registry+https://github.com/rust-lang/crates.io-index)",
 ]

@@ -1249,7 +1253,7 @@ dependencies = [

 [[package]]
 name = "rpassword"
-version = "0.2.2"
+version = "0.2.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
 "kernel32-sys 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -1263,7 +1267,7 @@ name = "rust-crypto"
 version = "0.2.36"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
- "gcc 0.3.28 (registry+https://github.com/rust-lang/crates.io-index)",
+ "gcc 0.3.35 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.3.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc-serialize 0.3.19 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -1331,7 +1335,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 name = "sha3"
 version = "0.1.0"
 dependencies = [
- "gcc 0.3.28 (registry+https://github.com/rust-lang/crates.io-index)",
+ "gcc 0.3.35 (registry+https://github.com/rust-lang/crates.io-index)",
 ]

 [[package]]
@@ -1375,7 +1379,7 @@ source = "git+https://github.com/carllerche/stable-heap?rev=3c5cd1ca47#3c5cd1ca4

 [[package]]
 name = "strsim"
-version = "0.3.0"
+version = "0.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"

 [[package]]
@@ -1386,6 +1390,14 @@ dependencies = [
 "syntex_syntax 0.33.0 (registry+https://github.com/rust-lang/crates.io-index)",
 ]

+[[package]]
+name = "syntex"
+version = "0.36.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "syntex_syntax 0.36.0 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
 [[package]]
 name = "syntex_syntax"
 version = "0.33.0"
@@ -1399,6 +1411,19 @@ dependencies = [
 "unicode-xid 0.0.3 (registry+https://github.com/rust-lang/crates.io-index)",
 ]

+[[package]]
+name = "syntex_syntax"
+version = "0.36.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "bitflags 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "libc 0.2.12 (registry+https://github.com/rust-lang/crates.io-index)",
+ "log 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rustc-serialize 0.3.19 (registry+https://github.com/rust-lang/crates.io-index)",
+ "term 0.2.14 (registry+https://github.com/rust-lang/crates.io-index)",
+ "unicode-xid 0.0.3 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
 [[package]]
 name = "table"
 version = "0.1.0"
@@ -1631,6 +1656,8 @@ dependencies = [
 "checksum bitflags 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)" = "4f67931368edf3a9a51d29886d245f1c3db2f1ef0dcc9e35ff70341b78c10d23"
 "checksum blastfig 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)" = "09640e0509d97d5cdff03a9f5daf087a8e04c735c3b113a75139634a19cfc7b2"
 "checksum bloomchain 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "3f421095d2a76fc24cd3fb3f912b90df06be7689912b1bdb423caefae59c258d"
+"checksum bloomfilter 0.0.10 (git+https://github.com/ethcore/rust-bloom-filter)" = "<none>"
+"checksum byteorder 0.5.3 (registry+https://github.com/rust-lang/crates.io-index)" = "0fc10e8cc6b2580fda3f36eb6dc5316657f812a3df879a44a66fc9f0fdbc4855"
 "checksum bytes 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "c129aff112dcc562970abb69e2508b40850dd24c274761bb50fb8a0067ba6c27"
 "checksum bytes 0.4.0-dev (git+https://github.com/carllerche/bytes)" = "<none>"
 "checksum cfg-if 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "de1e760d7b6535af4241fca8bd8adf68e2e7edacc6b29f5d399050c5e48cf88c"
@@ -1639,13 +1666,13 @@ dependencies = [
 "checksum cookie 0.2.4 (registry+https://github.com/rust-lang/crates.io-index)" = "90266f45846f14a1e986c77d1e9c2626b8c342ed806fe60241ec38cc8697b245"
 "checksum crossbeam 0.2.9 (registry+https://github.com/rust-lang/crates.io-index)" = "fb974f835e90390c5f9dfac00f05b06dc117299f5ea4e85fbc7bb443af4911cc"
 "checksum ctrlc 1.1.1 (git+https://github.com/ethcore/rust-ctrlc.git)" = "<none>"
-"checksum daemonize 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "271ec51b7e0bee92f0d04601422c73eb76ececf197026711c97ad25038a010cf"
+"checksum daemonize 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)" = "0239832c1b4ca406d5ec73728cf4c7336d25cf85dd32db9e047e9e706ee0e935"
 "checksum deque 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "1614659040e711785ed8ea24219140654da1729f3ec8a47a9719d041112fe7bf"
-"checksum docopt 0.6.80 (registry+https://github.com/rust-lang/crates.io-index)" = "4cc0acb4ce0828c6a5a11d47baa432fe885881c27428c3a4e473e454ffe57a76"
+"checksum docopt 0.6.86 (registry+https://github.com/rust-lang/crates.io-index)" = "4a7ef30445607f6fc8720f0a0a2c7442284b629cf0d049286860fae23e71c4d9"
 "checksum elastic-array 0.4.0 (git+https://github.com/ethcore/elastic-array)" = "<none>"
 "checksum env_logger 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)" = "aba65b63ffcc17ffacd6cf5aa843da7c5a25e3bd4bbe0b7def8b214e411250e5"
 "checksum eth-secp256k1 0.5.4 (git+https://github.com/ethcore/rust-secp256k1)" = "<none>"
-"checksum gcc 0.3.28 (registry+https://github.com/rust-lang/crates.io-index)" = "3da3a2cbaeb01363c8e3704fd9fd0eb2ceb17c6f27abd4c1ef040fb57d20dc79"
+"checksum gcc 0.3.35 (registry+https://github.com/rust-lang/crates.io-index)" = "91ecd03771effb0c968fd6950b37e89476a578aaf1c70297d8e92b6516ec3312"
 "checksum glob 0.2.11 (registry+https://github.com/rust-lang/crates.io-index)" = "8be18de09a56b60ed0edf84bc9df007e30040691af7acd1c41874faac5895bfb"
 "checksum hamming 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "65043da274378d68241eb9a8f8f8aa54e349136f7b8e12f63e3ef44043cc30e1"
 "checksum heapsize 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)" = "abb306abb8d398e053cfb1b3e7b72c2f580be048b85745c52652954f8ad1439c"
@@ -1658,13 +1685,14 @@ dependencies = [
 "checksum igd 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)" = "c8c12b1795b8b168f577c45fa10379b3814dcb11b7ab702406001f0d63f40484"
 "checksum isatty 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "7408a548dc0e406b7912d9f84c261cc533c1866e047644a811c133c56041ac0c"
 "checksum itertools 0.4.13 (registry+https://github.com/rust-lang/crates.io-index)" = "086e1fa5fe48840b1cfdef3a20c7e3115599f8d5c4c87ef32a794a7cdd184d76"
-"checksum json-ipc-server 0.2.4 (git+https://github.com/ethcore/json-ipc-server.git)" = "<none>"
+"checksum json-ipc-server 0.2.4 (git+https://github.com/ethcore/json-ipc-server.git?branch=beta)" = "<none>"
 "checksum jsonrpc-core 2.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "ec4477e4e8218da23caa5dd31f4eb39999aa0ea9035660617eccfb19a23bf5ad"
 "checksum jsonrpc-http-server 6.1.0 (git+https://github.com/ethcore/jsonrpc-http-server.git)" = "<none>"
 "checksum kernel32-sys 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "7507624b29483431c0ba2d82aece8ca6cdba9382bff4ddd0f7490560c056098d"
 "checksum language-tags 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "a91d884b6667cd606bb5a69aa0c99ba811a115fc68915e7056ec08a46e93199a"
 "checksum lazy_static 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "49247ec2a285bb3dcb23cbd9c35193c025e7251bfce77c1d5da97e6362dffe7f"
 "checksum libc 0.2.12 (registry+https://github.com/rust-lang/crates.io-index)" = "97def9dc7ce1d8e153e693e3a33020bc69972181adb2f871e87e888876feae49"
+"checksum linked-hash-map 0.0.9 (registry+https://github.com/rust-lang/crates.io-index)" = "83f7ff3baae999fdf921cccf54b61842bb3b26868d50d02dff48052ebec8dd79"
 "checksum log 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)" = "ab83497bf8bf4ed2a74259c1c802351fcd67a65baa86394b6ba73c36f4838054"
 "checksum lru-cache 0.0.7 (registry+https://github.com/rust-lang/crates.io-index)" = "42d50dcb5d9f145df83b1043207e1ac0c37c9c779c4e128ca4655abc3f3cbf8c"
 "checksum matches 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "15305656809ce5a4805b1ff2946892810992197ce1270ff79baded852187942e"
@@ -1690,7 +1718,7 @@ dependencies = [
 "checksum num-rational 0.1.32 (registry+https://github.com/rust-lang/crates.io-index)" = "48cdcc9ff4ae2a8296805ac15af88b3d88ce62128ded0cb74ffb63a587502a84"
 "checksum num-traits 0.1.32 (registry+https://github.com/rust-lang/crates.io-index)" = "51eab148f171aefad295f8cece636fc488b9b392ef544da31ea4b8ef6b9e9c39"
 "checksum num_cpus 0.2.11 (registry+https://github.com/rust-lang/crates.io-index)" = "51fedae97a05f7353612fe017ab705a37e6db8f4d67c5c6fe739a9e70d6eed09"
-"checksum number_prefix 0.2.5 (registry+https://github.com/rust-lang/crates.io-index)" = "084d05f4bf60621a9ac9bde941a410df548f4de9545f06e5ee9d3aef4b97cd77"
+"checksum number_prefix 0.2.6 (registry+https://github.com/rust-lang/crates.io-index)" = "b09f7c223751819881e1b95670d36fb12cdaa89848147f2222f1a2b691d5f0a3"
 "checksum odds 0.2.12 (registry+https://github.com/rust-lang/crates.io-index)" = "b28c06e81b0f789122d415d6394b5fe849bde8067469f4c2980d3cdc10c78ec1"
 "checksum parity-dapps 1.4.0 (git+https://github.com/ethcore/parity-ui.git)" = "<none>"
 "checksum parity-dapps-home 1.4.0 (git+https://github.com/ethcore/parity-ui.git)" = "<none>"
@@ -1712,13 +1740,13 @@ dependencies = [
 "checksum quick-error 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "0aad603e8d7fb67da22dbdf1f4b826ce8829e406124109e73cf1b2454b93a71c"
 "checksum quine-mc_cluskey 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "a6683b0e23d80813b1a535841f0048c1537d3f86d63c999e8373b39a9b0eb74a"
 "checksum rand 0.3.14 (registry+https://github.com/rust-lang/crates.io-index)" = "2791d88c6defac799c3f20d74f094ca33b9332612d9aef9078519c82e4fe04a5"
-"checksum rayon 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "941deb43a6254b9867fec1e0caeda38a2ad905ab18c57f7c68c396ca68998c07"
+"checksum rayon 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)" = "655df67c314c30fa3055a365eae276eb88aa4f3413a352a1ab32c1320eda41ea"
 "checksum regex 0.1.68 (registry+https://github.com/rust-lang/crates.io-index)" = "b4329b8928a284580a1c63ec9d846b12f6d3472317243ff7077aff11f23f2b29"
 "checksum regex-syntax 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "841591b1e05609a643e3b4d0045fce04f701daba7151ddcd3ad47b080693d5a9"
 "checksum rocksdb 0.4.5 (git+https://github.com/ethcore/rust-rocksdb)" = "<none>"
 "checksum rocksdb-sys 0.3.0 (git+https://github.com/ethcore/rust-rocksdb)" = "<none>"
 "checksum rotor 0.6.3 (git+https://github.com/ethcore/rotor)" = "<none>"
-"checksum rpassword 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "5d3a99497c5c544e629cc8b359ae5ede321eba5fa8e5a8078f3ced727a976c3f"
+"checksum rpassword 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)" = "320da1dfcf5c570a6c07ff60bb7cd4cdc986d2ea89caea139f2247371ab6a1df"
 "checksum rust-crypto 0.2.36 (registry+https://github.com/rust-lang/crates.io-index)" = "f76d05d3993fd5f4af9434e8e436db163a12a9d40e1a58a726f27a01dfd12a2a"
 "checksum rustc-serialize 0.3.19 (registry+https://github.com/rust-lang/crates.io-index)" = "6159e4e6e559c81bd706afe9c8fd68f547d3e851ce12e76b1de7914bab61691b"
 "checksum rustc_version 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)" = "c5f5376ea5e30ce23c03eb77cbe4962b988deead10910c372b226388b594c084"
@@ -1735,9 +1763,11 @@ dependencies = [
 "checksum solicit 0.4.4 (registry+https://github.com/rust-lang/crates.io-index)" = "172382bac9424588d7840732b250faeeef88942e37b6e35317dce98cafdd75b2"
 "checksum spmc 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "93bdab61c1a413e591c4d17388ffa859eaff2df27f1e13a5ec8b716700605adf"
 "checksum stable-heap 0.1.0 (git+https://github.com/carllerche/stable-heap?rev=3c5cd1ca47)" = "<none>"
-"checksum strsim 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "e4d73a2c36a4d095ed1a6df5cbeac159863173447f7a82b3f4757426844ab825"
+"checksum strsim 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)" = "50c069df92e4b01425a8bf3576d5d417943a6a7272fbabaf5bd80b1aaa76442e"
 "checksum syntex 0.33.0 (registry+https://github.com/rust-lang/crates.io-index)" = "393b6dd0889df2b064beeea954cfda6bc2571604ac460deeae0fed55a53988af"
+"checksum syntex 0.36.0 (registry+https://github.com/rust-lang/crates.io-index)" = "61dc0bbe1e46dcd53ec50d6600e750152c22e0e9352cadbd413e86fb847ae899"
 "checksum syntex_syntax 0.33.0 (registry+https://github.com/rust-lang/crates.io-index)" = "44bded3cabafc65c90b663b1071bd2d198a9ab7515e6ce729e4570aaf53c407e"
+"checksum syntex_syntax 0.36.0 (registry+https://github.com/rust-lang/crates.io-index)" = "2b92a8c33fad2fa99e14fe499ec17e82b6c6496a7a38a499f33b584ffa1886fa"
 "checksum target_info 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "c63f48baada5c52e65a29eef93ab4f8982681b67f9e8d29c7b05abcfec2b9ffe"
 "checksum term 0.2.14 (registry+https://github.com/rust-lang/crates.io-index)" = "f2077e54d38055cf1ca0fd7933a2e00cd3ec8f6fed352b2a377f06dcdaaf3281"
 "checksum termios 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "d5d9cf598a6d7ce700a4e6a9199da127e6819a61e64b68609683cc9a01b5683a"
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 description = "Ethcore client."
 name = "parity"
-version = "1.3.2"
+version = "1.3.8"
 license = "GPL-3.0"
 authors = ["Ethcore <admin@ethcore.io>"]
 build = "build.rs"
@@ -39,7 +39,7 @@ ethcore-ipc-nano = { path = "ipc/nano" }
 ethcore-ipc = { path = "ipc/rpc" }
 ethcore-ipc-hypervisor = { path = "ipc/hypervisor" }
 ethcore-logger = { path = "logger" }
-json-ipc-server = { git = "https://github.com/ethcore/json-ipc-server.git" }
+json-ipc-server = { git = "https://github.com/ethcore/json-ipc-server.git", branch = "beta" }
 ethcore-dapps = { path = "dapps", optional = true }
 clippy = { version = "0.0.80", optional = true}

@@ -68,6 +68,6 @@ path = "parity/main.rs"
 name = "parity"

 [profile.release]
-debug = true
+debug = false
 lto = false

--- a/appveyor.yml
+++ b/appveyor.yml
@@ -6,6 +6,7 @@ environment:
  certpass:
    secure: 0BgXJqxq9Ei34/hZ7121FQ==
  keyfile: C:\users\appveyor\Certificates.p12
+  RUSTFLAGS: -Zorbit=off

 branches:
  only:
@@ -18,10 +19,10 @@ branches:
 install:
  - git submodule update --init --recursive
  - ps: Install-Product node 6
-  - ps: Start-FileDownload "https://static.rust-lang.org/dist/rust-1.10.0-x86_64-pc-windows-msvc.exe"
+  - ps: Start-FileDownload "https://static.rust-lang.org/dist/rust-1.12.0-x86_64-pc-windows-msvc.exe"
  - ps: Start-FileDownload "https://github.com/ethcore/win-build/raw/master/SimpleFC.dll" -FileName nsis\SimpleFC.dll
  - ps: Start-FileDownload "https://github.com/ethcore/win-build/raw/master/vc_redist.x64.exe" -FileName nsis\vc_redist.x64.exe
-  - rust-1.10.0-x86_64-pc-windows-msvc.exe /VERYSILENT /NORESTART /DIR="C:\Program Files (x86)\Rust"
+  - rust-1.12.0-x86_64-pc-windows-msvc.exe /VERYSILENT /NORESTART /DIR="C:\Program Files (x86)\Rust"
  - SET PATH=%PATH%;C:\Program Files (x86)\Rust\bin;C:\Program Files (x86)\NSIS;C:\Program Files (x86)\Microsoft SDKs\Windows\v7.1A\Bin
  - rustc -V
  - cargo -V
--- a/ethcore/Cargo.toml
+++ b/ethcore/Cargo.toml
@@ -20,7 +20,7 @@ num_cpus = "0.2"
 crossbeam = "0.2.9"
 lazy_static = "0.2"
 bloomchain = "0.1"
-rayon = "0.3.1"
+rayon = "0.4"
 semver = "0.2"
 bit-set = "0.4"
 time = "0.1"
--- a/ethcore/res/ethereum/classic.json
+++ b/ethcore/res/ethereum/classic.json
@@ -10,7 +10,8 @@
 				"durationLimit": "0x0d",
 				"blockReward": "0x4563918244F40000",
 				"registrar" : "0xc6d9d2cd449a754c494264e1809c50e34d64562b",
-				"frontierCompatibilityModeLimit": "0x118c30"
+				"homesteadTransition": "0x118c30",
+				"eip150Transition": "0x7fffffffffffffff"
 			}
 		}
 	},
--- a/ethcore/res/ethereum/eip150_test.json
+++ b/ethcore/res/ethereum/eip150_test.json
@@ -0,0 +1,43 @@
+{
+	"name": "Homestead (Test)",
+	"engine": {
+		"Ethash": {
+			"params": {
+				"gasLimitBoundDivisor": "0x0400",
+				"minimumDifficulty": "0x020000",
+				"difficultyBoundDivisor": "0x0800",
+				"durationLimit": "0x0d",
+				"blockReward": "0x4563918244F40000",
+				"registrar" : "0xc6d9d2cd449a754c494264e1809c50e34d64562b",
+				"homesteadTransition": "0x0",
+				"eip150Transition": "0x0"
+			}
+		}
+	},
+	"params": {
+		"accountStartNonce": "0x00",
+		"maximumExtraDataSize": "0x20",
+		"minGasLimit": "0x1388",
+		"networkID" : "0x1"
+	},
+	"genesis": {
+		"seal": {
+			"ethereum": {
+				"nonce": "0x0000000000000042",
+				"mixHash": "0x0000000000000000000000000000000000000000000000000000000000000000"
+			}
+		},
+		"difficulty": "0x400000000",
+		"author": "0x0000000000000000000000000000000000000000",
+		"timestamp": "0x00",
+		"parentHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
+		"extraData": "0x11bbe8db4e347b4e8c937c1c8370e4b5ed33adb3db69cbdb7a38e1e50b1b82fa",
+		"gasLimit": "0x1388"
+	},
+	"accounts": {
+		"0000000000000000000000000000000000000001": { "balance": "1", "builtin": { "name": "ecrecover", "pricing": { "linear": { "base": 3000, "word": 0 } } } },
+		"0000000000000000000000000000000000000002": { "balance": "1", "builtin": { "name": "sha256", "pricing": { "linear": { "base": 60, "word": 12 } } } },
+		"0000000000000000000000000000000000000003": { "balance": "1", "builtin": { "name": "ripemd160", "pricing": { "linear": { "base": 600, "word": 120 } } } },
+		"0000000000000000000000000000000000000004": { "balance": "1", "builtin": { "name": "identity", "pricing": { "linear": { "base": 15, "word": 3 } } } }
+	}
+}
--- a/ethcore/res/ethereum/expanse.json
+++ b/ethcore/res/ethereum/expanse.json
@@ -0,0 +1,70 @@
+{
+	"name": "Expanse",
+	"forkName": "expanse",
+	"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": "0x7fffffffffffffff"				
+			}
+		}
+	},
+	"params": {
+		"accountStartNonce": "0x00",
+		"maximumExtraDataSize": "0x20",
+		"minGasLimit": "0x1388",
+		"networkID": "0x1",
+		"subprotocolName": "exp"
+	},
+	"genesis": {
+		"seal": {
+			"ethereum": {
+				"nonce": "0x214652414e4b4f21",
+				"mixHash": "0x0000000000000000000000000000000000000000000000000000000000000000"
+			}
+		},
+		"difficulty": "0x40000000",
+		"author": "0x93decab0cd745598860f782ac1e8f046cb99e898",
+		"timestamp": "0x00",
+		"parentHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
+		"extraData": "0x4672616e6b6f497346726565646f6d",
+		"gasLimit": "0x1388"
+	},
+	"nodes": [
+		"enode://7f335a047654f3e70d6f91312a7cf89c39704011f1a584e2698250db3d63817e74b88e26b7854111e16b2c9d0c7173c05419aeee2d0321850227b126d8b1be3f@46.101.156.249:42786",
+		"enode://df872f81e25f72356152b44cab662caf1f2e57c3a156ecd20e9ac9246272af68a2031b4239a0bc831f2c6ab34733a041464d46b3ea36dce88d6c11714446e06b@178.62.208.109:42786",
+		"enode://96d3919b903e7f5ad59ac2f73c43be9172d9d27e2771355db03fd194732b795829a31fe2ea6de109d0804786c39a807e155f065b4b94c6fce167becd0ac02383@45.55.22.34:42786",
+		"enode://5f6c625bf287e3c08aad568de42d868781e961cbda805c8397cfb7be97e229419bef9a5a25a75f97632787106bba8a7caf9060fab3887ad2cfbeb182ab0f433f@46.101.182.53:42786",
+		"enode://d33a8d4c2c38a08971ed975b750f21d54c927c0bf7415931e214465a8d01651ecffe4401e1db913f398383381413c78105656d665d83f385244ab302d6138414@128.199.183.48:42786",
+		"enode://df872f81e25f72356152b44cab662caf1f2e57c3a156ecd20e9ac9246272af68a2031b4239a0bc831f2c6ab34733a041464d46b3ea36dce88d6c11714446e06b@178.62.208.109:42786",
+		"enode://f6f0d6b9b7d02ec9e8e4a16e38675f3621ea5e69860c739a65c1597ca28aefb3cec7a6d84e471ac927d42a1b64c1cbdefad75e7ce8872d57548ddcece20afdd1@159.203.64.95:42786"
+	],
+	"accounts": {
+		"0000000000000000000000000000000000000001": { "builtin": { "name": "ecrecover", "pricing": { "linear": { "base": 3000, "word": 0 } } } },
+		"0000000000000000000000000000000000000002": { "builtin": { "name": "sha256", "pricing": { "linear": { "base": 60, "word": 12 } } } },
+		"0000000000000000000000000000000000000003": { "builtin": { "name": "ripemd160", "pricing": { "linear": { "base": 600, "word": 120 } } } },
+		"0000000000000000000000000000000000000004": { "builtin": { "name": "identity", "pricing": { "linear": { "base": 15, "word": 3 } } } },
+		"bb94f0ceb32257275b2a7a9c094c13e469b4563e": {
+			"balance": "10000000000000000000000000"
+		},
+		"15656715068ab0dbdf0ab00748a8a19e40f28192": {
+			"balance": "1000000000000000000000000"
+		},
+		"c075fa11f85bda3aaba67106226aaf086ac16f4e": {
+			"balance": "100000000000000000000000"
+		},
+		"93decab0cd745598860f782ac1e8f046cb99e898": {
+			"balance": "10000000000000000000000"
+		}
+	}
+}
--- a/ethcore/res/ethereum/frontier.json
+++ b/ethcore/res/ethereum/frontier.json
@@ -9,10 +9,10 @@
 				"durationLimit": "0x0d",
 				"blockReward": "0x4563918244F40000",
 				"registrar" : "0xc6d9d2cd449a754c494264e1809c50e34d64562b",
-				"frontierCompatibilityModeLimit": "0x118c30",
+				"homesteadTransition": "0x118c30",
 				"daoHardforkTransition": "0x1d4c00",
 				"daoHardforkBeneficiary": "0xbf4ed7b27f1d666546e30d74d50d173d20bca754",
-				"daoHardforkAccounts": [  
+				"daoHardforkAccounts": [
 					"0xd4fe7bc31cedb7bfb8a345f31e668033056b2728",
 					"0xb3fb0e5aba0e20e5c49d252dfd30e102b171a425",
 					"0x2c19c7f9ae8b751e37aeb2d93a699722395ae18f",
@@ -129,7 +129,8 @@
 					"0x7602b46df5390e432ef1c307d4f2c9ff6d65cc97",
 					"0xbb9bc244d798123fde783fcc1c72d3bb8c189413",
 					"0x807640a13483f8ac783c557fcdf27be11ea4ac7a"
-				]
+				],
+				"eip150Transition": "0x259518"
 			}
 		}
 	},
--- a/ethcore/res/ethereum/frontier_like_test.json
+++ b/ethcore/res/ethereum/frontier_like_test.json
@@ -9,7 +9,7 @@
 				"durationLimit": "0x0d",
 				"blockReward": "0x4563918244F40000",
 				"registrar" : "0xc6d9d2cd449a754c494264e1809c50e34d64562b",
-				"frontierCompatibilityModeLimit": "0x118c30",
+				"homesteadTransition": "0x118c30",
 				"daoHardforkTransition": "0x1d4c00",
 				"daoHardforkBeneficiary": "0xbf4ed7b27f1d666546e30d74d50d173d20bca754",
 				"daoHardforkAccounts": [  
@@ -129,7 +129,8 @@
 					"0x7602b46df5390e432ef1c307d4f2c9ff6d65cc97",
 					"0xbb9bc244d798123fde783fcc1c72d3bb8c189413",
 					"0x807640a13483f8ac783c557fcdf27be11ea4ac7a"
-				]
+				],
+				"eip150Transition": "0x7fffffffffffffff"
 			}
 		}
 	},
--- a/ethcore/res/ethereum/frontier_test.json
+++ b/ethcore/res/ethereum/frontier_test.json
@@ -9,7 +9,8 @@
 				"durationLimit": "0x0d",
 				"blockReward": "0x4563918244F40000",
 				"registrar" : "0xc6d9d2cd449a754c494264e1809c50e34d64562b",
-				"frontierCompatibilityModeLimit": "0xffffffffffffffff"
+				"homesteadTransition": "0x7fffffffffffffff",
+				"eip150Transition": "0x7fffffffffffffff"
 			}
 		}
 	},
--- a/ethcore/res/ethereum/homestead_test.json
+++ b/ethcore/res/ethereum/homestead_test.json
@@ -9,7 +9,8 @@
 				"durationLimit": "0x0d",
 				"blockReward": "0x4563918244F40000",
 				"registrar" : "0xc6d9d2cd449a754c494264e1809c50e34d64562b",
-				"frontierCompatibilityModeLimit": "0x0"
+				"homesteadTransition": "0x0",
+				"eip150Transition": "0x7fffffffffffffff"
 			}
 		}
 	},
--- a/ethcore/res/ethereum/morden.json
+++ b/ethcore/res/ethereum/morden.json
@@ -9,7 +9,8 @@
 				"durationLimit": "0x0d",
 				"blockReward": "0x4563918244F40000",
 				"registrar": "0x8e4e9b13d4b45cb0befc93c3061b1408f67316b2",
-				"frontierCompatibilityModeLimit": "0x789b0"
+				"homesteadTransition": "0x789b0",
+				"eip150Transition": "0x1b34d8"
 			}
 		}
 	},
--- a/ethcore/res/ethereum/olympic.json
+++ b/ethcore/res/ethereum/olympic.json
@@ -8,7 +8,9 @@
 				"difficultyBoundDivisor": "0x0800",
 				"durationLimit": "0x08",
 				"blockReward": "0x14D1120D7B160000",
-				"registrar": "5e70c0bbcd5636e0f9f9316e9f8633feb64d4050"
+				"registrar": "5e70c0bbcd5636e0f9f9316e9f8633feb64d4050",
+				"homesteadTransition": "0x7fffffffffffffff",
+				"eip150Transition": "0x7fffffffffffffff"
 			}
 		}
 	},
--- a/ethcore/res/ethereum/tests
+++ b/ethcore/res/ethereum/tests
--- a/ethcore/res/ethereum/daohardfork_test.json
+++ b/ethcore/res/ethereum/daohardfork_test.json
@@ -1,5 +1,5 @@
 {
-	"name": "DAO hard-fork consensus test",
+	"name": "EIP150.1b hard-fork consensus test",
 	"engine": {
 		"Ethash": {
 			"params": {
@@ -9,7 +9,7 @@
 				"durationLimit": "0x0d",
 				"blockReward": "0x4563918244F40000",
 				"registrar" : "0xc6d9d2cd449a754c494264e1809c50e34d64562b",
-				"frontierCompatibilityModeLimit": "0x5",
+				"homesteadTransition": "0x5",
 				"daoHardforkTransition": "0x8",
 				"daoHardforkBeneficiary": "0xbf4ed7b27f1d666546e30d74d50d173d20bca754",
 				"daoHardforkAccounts": [  
@@ -129,7 +129,8 @@
 					"0x7602b46df5390e432ef1c307d4f2c9ff6d65cc97",
 					"0xbb9bc244d798123fde783fcc1c72d3bb8c189413",
 					"0x807640a13483f8ac783c557fcdf27be11ea4ac7a"
-				]
+				],
+				"eip150Transition": "0xa"
 			}
 		}
 	},
--- a/ethcore/src/account.rs
+++ b/ethcore/src/account.rs
@@ -16,7 +16,6 @@

 //! Single account in the system.

-use std::collections::hash_map::Entry;
 use util::*;
 use pod_account::*;
 use account_db::*;
@@ -24,9 +23,11 @@ use lru_cache::LruCache;

 use std::cell::{RefCell, Cell};

-const STORAGE_CACHE_ITEMS: usize = 4096;
+const STORAGE_CACHE_ITEMS: usize = 8192;

 /// Single account in the system.
+/// Keeps track of changes to the code and storage.
+/// The changes are applied in `commit_storage` and `commit_code`
 pub struct Account {
 	// Balance of the account.
 	balance: U256,
@@ -40,14 +41,14 @@ pub struct Account {
 	// Modified storage. Accumulates changes to storage made in `set_storage`
 	// Takes precedence over `storage_cache`.
 	storage_changes: HashMap<H256, H256>,
-	// Code hash of the account. If None, means that it's a contract whose code has not yet been set.
-	code_hash: Option<H256>,
+	// Code hash of the account.
+	code_hash: H256,
 	// Size of the accoun code.
 	code_size: Option<u64>,
 	// Code cache of the account.
-	code_cache: Bytes,
-	// Account is new or has been modified
-	filth: Filth,
+	code_cache: Arc<Bytes>,
+	// Account code new or has been modified.
+	code_filth: Filth,
 	// Cached address hash.
 	address_hash: Cell<Option<H256>>,
 }
@@ -62,10 +63,10 @@ impl Account {
 			storage_root: SHA3_NULL_RLP,
 			storage_cache: Self::empty_storage_cache(),
 			storage_changes: storage,
-			code_hash: Some(code.sha3()),
+			code_hash: code.sha3(),
 			code_size: Some(code.len() as u64),
-			code_cache: code,
-			filth: Filth::Dirty,
+			code_cache: Arc::new(code),
+			code_filth: Filth::Dirty,
 			address_hash: Cell::new(None),
 		}
 	}
@@ -82,10 +83,10 @@ impl Account {
 			storage_root: SHA3_NULL_RLP,
 			storage_cache: Self::empty_storage_cache(),
 			storage_changes: pod.storage.into_iter().collect(),
-			code_hash: pod.code.as_ref().map(|c| c.sha3()),
+			code_hash: pod.code.as_ref().map_or(SHA3_EMPTY, |c| c.sha3()),
+			code_filth: Filth::Dirty,
 			code_size: Some(pod.code.as_ref().map_or(0, |c| c.len() as u64)),
-			code_cache: pod.code.map_or_else(|| { warn!("POD account with unknown code is being created! Assuming no code."); vec![] }, |c| c),
-			filth: Filth::Dirty,
+			code_cache: Arc::new(pod.code.map_or_else(|| { warn!("POD account with unknown code is being created! Assuming no code."); vec![] }, |c| c)),
 			address_hash: Cell::new(None),
 		}
 	}
@@ -98,10 +99,10 @@ impl Account {
 			storage_root: SHA3_NULL_RLP,
 			storage_cache: Self::empty_storage_cache(),
 			storage_changes: HashMap::new(),
-			code_hash: Some(SHA3_EMPTY),
-			code_cache: vec![],
+			code_hash: SHA3_EMPTY,
+			code_cache: Arc::new(vec![]),
 			code_size: Some(0),
-			filth: Filth::Dirty,
+			code_filth: Filth::Clean,
 			address_hash: Cell::new(None),
 		}
 	}
@@ -115,10 +116,10 @@ impl Account {
 			storage_root: r.val_at(2),
 			storage_cache: Self::empty_storage_cache(),
 			storage_changes: HashMap::new(),
-			code_hash: Some(r.val_at(3)),
-			code_cache: vec![],
+			code_hash: r.val_at(3),
+			code_cache: Arc::new(vec![]),
 			code_size: None,
-			filth: Filth::Clean,
+			code_filth: Filth::Clean,
 			address_hash: Cell::new(None),
 		}
 	}
@@ -132,10 +133,10 @@ impl Account {
 			storage_root: SHA3_NULL_RLP,
 			storage_cache: Self::empty_storage_cache(),
 			storage_changes: HashMap::new(),
-			code_hash: None,
-			code_cache: vec![],
+			code_hash: SHA3_EMPTY,
+			code_cache: Arc::new(vec![]),
 			code_size: None,
-			filth: Filth::Dirty,
+			code_filth: Filth::Clean,
 			address_hash: Cell::new(None),
 		}
 	}
@@ -143,32 +144,20 @@ impl Account {
 	/// Set this account's code to the given code.
 	/// NOTE: Account should have been created with `new_contract()`
 	pub fn init_code(&mut self, code: Bytes) {
-		assert!(self.code_hash.is_none());
-		self.code_cache = code;
+		self.code_hash = code.sha3();
+		self.code_cache = Arc::new(code);
 		self.code_size = Some(self.code_cache.len() as u64);
-		self.filth = Filth::Dirty;
+		self.code_filth = Filth::Dirty;
 	}

 	/// Reset this account's code to the given code.
 	pub fn reset_code(&mut self, code: Bytes) {
-		self.code_hash = None;
-		self.code_size = Some(0);
 		self.init_code(code);
 	}

 	/// Set (and cache) the contents of the trie's storage at `key` to `value`.
 	pub fn set_storage(&mut self, key: H256, value: H256) {
-		match self.storage_changes.entry(key) {
-			Entry::Occupied(ref mut entry) if entry.get() != &value => {
-				entry.insert(value);
-				self.filth = Filth::Dirty;
-			},
-			Entry::Vacant(entry) => {
-				entry.insert(value);
-				self.filth = Filth::Dirty;
-			},
-			_ => {},
-		}
+		self.storage_changes.insert(key, value);
 	}

 	/// Get (and cache) the contents of the trie's storage at `key`.
@@ -209,10 +198,9 @@ impl Account {
 	/// return the nonce associated with this account.
 	pub fn nonce(&self) -> &U256 { &self.nonce }

-	#[cfg(test)]
 	/// return the code hash associated with this account.
 	pub fn code_hash(&self) -> H256 {
-		self.code_hash.clone().unwrap_or(SHA3_EMPTY)
+		self.code_hash.clone()
 	}

 	/// return the code hash associated with this account.
@@ -227,13 +215,11 @@ impl Account {

 	/// returns the account's code. If `None` then the code cache isn't available -
 	/// get someone who knows to call `note_code`.
-	pub fn code(&self) -> Option<&[u8]> {
-		match self.code_hash {
-			Some(c) if c == SHA3_EMPTY && self.code_cache.is_empty() => Some(&self.code_cache),
-			Some(_) if !self.code_cache.is_empty() => Some(&self.code_cache),
-			None => Some(&self.code_cache),
-			_ => None,
+	pub fn code(&self) -> Option<Arc<Bytes>> {
+		if self.code_hash != SHA3_EMPTY && self.code_cache.is_empty() {
+			return None;
 		}
+		Some(self.code_cache.clone())
 	}

 	/// returns the account's code size. If `None` then the code cache or code size cache isn't available -
@@ -246,30 +232,18 @@ impl Account {
 	/// Provide a byte array which hashes to the `code_hash`. returns the hash as a result.
 	pub fn note_code(&mut self, code: Bytes) -> Result<(), H256> {
 		let h = code.sha3();
-		match self.code_hash {
-			Some(ref i) if h == *i => {
-				self.code_cache = code;
-				self.code_size = Some(self.code_cache.len() as u64);
-				Ok(())
-			},
-			_ => Err(h)
+		if self.code_hash == h {
+			self.code_cache = Arc::new(code);
+			self.code_size = Some(self.code_cache.len() as u64);
+			Ok(())
+		} else {
+			Err(h)
 		}
 	}

 	/// Is `code_cache` valid; such that code is going to return Some?
 	pub fn is_cached(&self) -> bool {
-		!self.code_cache.is_empty() || (self.code_cache.is_empty() && self.code_hash == Some(SHA3_EMPTY))
-	}
-
-	/// Is this a new or modified account?
-	pub fn is_dirty(&self) -> bool {
-		self.filth == Filth::Dirty || !self.storage_is_clean()
-	}
-
-	/// Mark account as clean.
-	pub fn set_clean(&mut self) {
-		assert!(self.storage_is_clean());
-		self.filth = Filth::Clean
+		!self.code_cache.is_empty() || (self.code_cache.is_empty() && self.code_hash == SHA3_EMPTY)
 	}

 	/// Provide a database to get `code_hash`. Should not be called if it is a contract without code.
@@ -277,20 +251,17 @@ impl Account {
 		// TODO: fill out self.code_cache;
 		trace!("Account::cache_code: ic={}; self.code_hash={:?}, self.code_cache={}", self.is_cached(), self.code_hash, self.code_cache.pretty());
 		self.is_cached() ||
-			match self.code_hash {
-				Some(ref h) => match db.get(h) {
-					Some(x) => {
-						self.code_cache = x.to_vec();
-						self.code_size = Some(x.len() as u64);
-						true
-					},
-					_ => {
-						warn!("Failed reverse get of {}", h);
-						false
-					},
-				},
-				_ => false,
-			}
+		match db.get(&self.code_hash) {
+			Some(x) => {
+				self.code_cache = Arc::new(x.to_vec());
+				self.code_size = Some(x.len() as u64);
+				true
+			},
+			_ => {
+				warn!("Failed reverse get of {}", self.code_hash);
+				false
+			},
+		}
 	}

 	/// Provide a database to get `code_size`. Should not be called if it is a contract without code.
@@ -298,18 +269,19 @@ impl Account {
 		// TODO: fill out self.code_cache;
 		trace!("Account::cache_code_size: ic={}; self.code_hash={:?}, self.code_cache={}", self.is_cached(), self.code_hash, self.code_cache.pretty());
 		self.code_size.is_some() ||
-			match self.code_hash {
-				Some(ref h) if h != &SHA3_EMPTY => match db.get(h) {
+			if self.code_hash != SHA3_EMPTY {
+				match db.get(&self.code_hash) {
 					Some(x) => {
 						self.code_size = Some(x.len() as u64);
 						true
 					},
 					_ => {
-						warn!("Failed reverse get of {}", h);
+						warn!("Failed reverse get of {}", self.code_hash);
 						false
 					},
-				},
-				_ => false,
+				}
+			} else {
+				false
 			}
 	}

@@ -326,25 +298,18 @@ impl Account {
 	/// Increment the nonce of the account by one.
 	pub fn inc_nonce(&mut self) {
 		self.nonce = self.nonce + U256::from(1u8);
-		self.filth = Filth::Dirty;
 	}

-	/// Increment the nonce of the account by one.
+	/// Increase account balance.
 	pub fn add_balance(&mut self, x: &U256) {
-		if !x.is_zero() {
-			self.balance = self.balance + *x;
-			self.filth = Filth::Dirty;
-		}
+		self.balance = self.balance + *x;
 	}

-	/// Increment the nonce of the account by one.
+	/// Decrease account balance.
 	/// Panics if balance is less than `x`
 	pub fn sub_balance(&mut self, x: &U256) {
-		if !x.is_zero() {
-			assert!(self.balance >= *x);
-			self.balance = self.balance - *x;
-			self.filth = Filth::Dirty;
-		}
+		assert!(self.balance >= *x);
+		self.balance = self.balance - *x;
 	}

 	/// Commit the `storage_changes` to the backing DB and update `storage_root`.
@@ -370,15 +335,16 @@ impl Account {

 	/// Commit any unsaved code. `code_hash` will always return the hash of the `code_cache` after this.
 	pub fn commit_code(&mut self, db: &mut AccountDBMut) {
-		trace!("Commiting code of {:?} - {:?}, {:?}", self, self.code_hash.is_none(), self.code_cache.is_empty());
-		match (self.code_hash.is_none(), self.code_cache.is_empty()) {
+		trace!("Commiting code of {:?} - {:?}, {:?}", self, self.code_filth == Filth::Dirty, self.code_cache.is_empty());
+		match (self.code_filth == Filth::Dirty, self.code_cache.is_empty()) {
 			(true, true) => {
-				self.code_hash = Some(SHA3_EMPTY);
 				self.code_size = Some(0);
+				self.code_filth = Filth::Clean;
 			},
 			(true, false) => {
-				self.code_hash = Some(db.insert(&self.code_cache));
+				db.emplace(self.code_hash.clone(), (*self.code_cache).clone());
 				self.code_size = Some(self.code_cache.len() as u64);
+				self.code_filth = Filth::Clean;
 			},
 			(false, _) => {},
 		}
@@ -390,7 +356,7 @@ impl Account {
 		stream.append(&self.nonce);
 		stream.append(&self.balance);
 		stream.append(&self.storage_root);
-		stream.append(self.code_hash.as_ref().unwrap_or(&SHA3_EMPTY));
+		stream.append(&self.code_hash);
 		stream.out()
 	}

@@ -404,8 +370,8 @@ impl Account {
 			storage_changes: HashMap::new(),
 			code_hash: self.code_hash.clone(),
 			code_size: self.code_size.clone(),
-			code_cache: Bytes::new(),
-			filth: self.filth,
+			code_cache: self.code_cache.clone(),
+			code_filth: self.code_filth,
 			address_hash: self.address_hash.clone(),
 		}
 	}
@@ -425,14 +391,15 @@ impl Account {
 		account
 	}

-	/// Replace self with the data from other account merging storage cache
-	pub fn merge_with(&mut self, other: Account) {
-		assert!(self.storage_is_clean());
-		assert!(other.storage_is_clean());
+	/// Replace self with the data from other account merging storage cache.
+	/// Basic account data and all modifications are overwritten
+	/// with new values.
+	pub fn overwrite_with(&mut self, other: Account) {
 		self.balance = other.balance;
 		self.nonce = other.nonce;
 		self.storage_root = other.storage_root;
 		self.code_hash = other.code_hash;
+		self.code_filth = other.code_filth;
 		self.code_cache = other.code_cache;
 		self.code_size = other.code_size;
 		self.address_hash = other.address_hash;
@@ -440,6 +407,7 @@ impl Account {
 		for (k, v) in other.storage_cache.into_inner().into_iter() {
 			cache.insert(k.clone() , v.clone()); //TODO: cloning should not be required here
 		}
+		self.storage_changes = other.storage_changes;
 	}
 }

@@ -535,7 +503,7 @@ mod tests {
 		let mut db = MemoryDB::new();
 		let mut db = AccountDBMut::new(&mut db, &Address::new());
 		a.init_code(vec![0x55, 0x44, 0xffu8]);
-		assert_eq!(a.code_hash(), SHA3_EMPTY);
+		assert_eq!(a.code_filth, Filth::Dirty);
 		assert_eq!(a.code_size(), Some(3));
 		a.commit_code(&mut db);
 		assert_eq!(a.code_hash().hex(), "af231e631776a517ca23125370d542873eca1fb4d613ed9b5d5335a46ae5b7eb");
@@ -547,11 +515,12 @@ mod tests {
 		let mut db = MemoryDB::new();
 		let mut db = AccountDBMut::new(&mut db, &Address::new());
 		a.init_code(vec![0x55, 0x44, 0xffu8]);
-		assert_eq!(a.code_hash(), SHA3_EMPTY);
+		assert_eq!(a.code_filth, Filth::Dirty);
 		a.commit_code(&mut db);
+		assert_eq!(a.code_filth, Filth::Clean);
 		assert_eq!(a.code_hash().hex(), "af231e631776a517ca23125370d542873eca1fb4d613ed9b5d5335a46ae5b7eb");
 		a.reset_code(vec![0x55]);
-		assert_eq!(a.code_hash(), SHA3_EMPTY);
+		assert_eq!(a.code_filth, Filth::Dirty);
 		a.commit_code(&mut db);
 		assert_eq!(a.code_hash().hex(), "37bf2238b11b68cdc8382cece82651b59d3c3988873b6e0f33d79694aa45f1be");
 	}
--- a/ethcore/src/action_params.rs
+++ b/ethcore/src/action_params.rs
@@ -43,6 +43,8 @@ impl ActionValue {
 pub struct ActionParams {
 	/// Address of currently executed code.
 	pub code_address: Address,
+	/// Hash of currently executed code.
+	pub code_hash: H256,
 	/// Receive address. Usually equal to code_address,
 	/// except when called using CALLCODE.
 	pub address: Address,
@@ -57,7 +59,7 @@ pub struct ActionParams {
 	/// Transaction value.
 	pub value: ActionValue,
 	/// Code being executed.
-	pub code: Option<Bytes>,
+	pub code: Option<Arc<Bytes>>,
 	/// Input data.
 	pub data: Option<Bytes>,
 	/// Type of call
@@ -70,6 +72,7 @@ impl Default for ActionParams {
 	fn default() -> ActionParams {
 		ActionParams {
 			code_address: Address::new(),
+			code_hash: SHA3_EMPTY,
 			address: Address::new(),
 			sender: Address::new(),
 			origin: Address::new(),
@@ -88,10 +91,11 @@ impl From<ethjson::vm::Transaction> for ActionParams {
 		let address: Address = t.address.into();
 		ActionParams {
 			code_address: Address::new(),
+			code_hash: (&*t.code).sha3(),
 			address: address,
 			sender: t.sender.into(),
 			origin: t.origin.into(),
-			code: Some(t.code.into()),
+			code: Some(Arc::new(t.code.into())),
 			data: Some(t.data.into()),
 			gas: t.gas.into(),
 			gas_price: t.gas_price.into(),
--- a/ethcore/src/block.rs
+++ b/ethcore/src/block.rs
@@ -395,6 +395,10 @@ impl<'x> OpenBlock<'x> {
 			uncle_bytes: uncle_bytes,
 		}
 	}
+
+	#[cfg(test)]
+	/// Return mutable block reference. To be used in tests only.
+	pub fn block_mut (&mut self) -> &mut ExecutedBlock { &mut self.block }
 }

 impl<'x> IsBlock for OpenBlock<'x> {
--- a/ethcore/src/client/client.rs
+++ b/ethcore/src/client/client.rs
@@ -17,6 +17,7 @@ use std::collections::{HashSet, HashMap, BTreeMap, VecDeque};
 use std::sync::{Arc, Weak};
 use std::path::{Path};
 use std::fmt;
+use std::cmp;
 use std::sync::atomic::{AtomicUsize, AtomicBool, Ordering as AtomicOrdering};
 use std::time::{Instant};
 use time::precise_time_ns;
@@ -73,6 +74,7 @@ pub use blockchain::CacheSize as BlockChainCacheSize;

 const MAX_TX_QUEUE_SIZE: usize = 4096;
 const MAX_QUEUE_SIZE_TO_SLEEP_ON: usize = 2;
+const MIN_HISTORY_SIZE: u64 = 8;

 impl fmt::Display for BlockChainInfo {
 	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
@@ -139,10 +141,9 @@ pub struct Client {
 	notify: RwLock<Vec<Weak<ChainNotify>>>,
 	queue_transactions: AtomicUsize,
 	last_hashes: RwLock<VecDeque<H256>>,
+	history: u64,
 }

-const HISTORY: u64 = 1200;
-
 // database columns
 /// Column for State
 pub const DB_COL_STATE: Option<u32> = Some(0);
@@ -159,13 +160,6 @@ pub const DB_COL_ACCOUNT_BLOOM: Option<u32> = Some(5);
 /// Number of columns in DB
 pub const DB_NO_OF_COLUMNS: Option<u32> = Some(6);

-/// Append a path element to the given path and return the string.
-pub fn append_path<P>(path: P, item: &str) -> String where P: AsRef<Path> {
-	let mut p = path.as_ref().to_path_buf();
-	p.push(item);
-	p.to_str().unwrap().to_owned()
-}
-
 impl Client {
 	/// Create a new client with given spec and DB path and custom verifier.
 	pub fn new(
@@ -182,7 +176,7 @@ impl Client {
 		db_config.compaction = config.db_compaction.compaction_profile();
 		db_config.wal = config.db_wal;

-		let db = Arc::new(try!(Database::open(&db_config, &path.to_str().unwrap()).map_err(ClientError::Database)));
+		let db = Arc::new(try!(Database::open(&db_config, &path.to_str().expect("DB path could not be converted to string.")).map_err(ClientError::Database)));
 		let chain = Arc::new(BlockChain::new(config.blockchain, &gb, db.clone()));
 		let tracedb = Arc::new(try!(TraceDB::new(config.tracing, db.clone(), chain.clone())));

@@ -194,6 +188,19 @@ impl Client {
 			try!(db.write(batch).map_err(ClientError::Database));
 		}

+		trace!("Cleanup journal: DB Earliest = {:?}, Latest = {:?}", state_db.journal_db().earliest_era(), state_db.journal_db().latest_era());
+		let history = cmp::max(MIN_HISTORY_SIZE, config.history);
+		if let (Some(earliest), Some(latest)) = (state_db.journal_db().earliest_era(), state_db.journal_db().latest_era()) {
+			if latest > earliest && latest - earliest > history {
+				for era in earliest..(latest - history + 1) {
+					trace!("Removing era {}", era);
+					let batch = DBTransaction::new(&db);
+					try!(state_db.journal_db_mut().commit_old(&batch, era, &chain.block_hash(era).expect("Old block not found in the database")));
+					try!(db.write(batch).map_err(ClientError::Database));
+				}
+			}
+		}
+
 		if !chain.block_header(&chain.best_block_hash()).map_or(true, |h| state_db.journal_db().contains(h.state_root())) {
 			warn!("State root not found for block #{} ({})", chain.best_block_number(), chain.best_block_hash().hex());
 		}
@@ -226,6 +233,7 @@ impl Client {
 			notify: RwLock::new(Vec::new()),
 			queue_transactions: AtomicUsize::new(0),
 			last_hashes: RwLock::new(VecDeque::new()),
+			history: history,
 		};
 		Ok(Arc::new(client))
 	}
@@ -282,7 +290,7 @@ impl Client {

 		// Check the block isn't so old we won't be able to enact it.
 		let best_block_number = self.chain.best_block_number();
-		if best_block_number >= HISTORY && header.number() <= best_block_number - HISTORY {
+		if best_block_number >= self.history && header.number() <= best_block_number - self.history {
 			warn!(target: "client", "Block import failed for #{} ({})\nBlock is ancient (current best block: #{}).", header.number(), header.hash(), best_block_number);
 			return Err(());
 		}
@@ -295,32 +303,28 @@ impl Client {
 		};

 		// Check if Parent is in chain
-		let chain_has_parent = self.chain.block_header(&header.parent_hash);
-		if let None = chain_has_parent {
-			warn!(target: "client", "Block import failed for #{} ({}): Parent not found ({}) ", header.number(), header.hash(), header.parent_hash);
-			return Err(());
-		};
+		let chain_has_parent = self.chain.block_header(header.parent_hash());
+		if let Some(parent) = chain_has_parent {
+			// Enact Verified Block
+			let last_hashes = self.build_last_hashes(header.parent_hash().clone());
+			let db = self.state_db.lock().boxed_clone_canon(&header.parent_hash());

-		// Enact Verified Block
-		let parent = chain_has_parent.unwrap();
-		let last_hashes = self.build_last_hashes(header.parent_hash.clone());
-		let is_canon = header.parent_hash == self.chain.best_block_hash();
-		let db = if is_canon { self.state_db.lock().boxed_clone_canon() } else { self.state_db.lock().boxed_clone() };
+			let enact_result = enact_verified(block, engine, self.tracedb.tracing_enabled(), db, &parent, last_hashes, &self.vm_factory, self.trie_factory.clone());
+			let locked_block = try!(enact_result.map_err(|e| {
+				warn!(target: "client", "Block import failed for #{} ({})\nError: {:?}", header.number(), header.hash(), e);
+			}));

-		let enact_result = enact_verified(block, engine, self.tracedb.tracing_enabled(), db, &parent, last_hashes, &self.vm_factory, self.trie_factory.clone());
-		if let Err(e) = enact_result {
-			warn!(target: "client", "Block import failed for #{} ({})\nError: {:?}", header.number(), header.hash(), e);
-			return Err(());
-		};
+			// Final Verification
+			if let Err(e) = self.verifier.verify_block_final(header, locked_block.block().header()) {
+				warn!(target: "client", "Stage 4 block verification failed for #{} ({})\nError: {:?}", header.number(), header.hash(), e);
+				return Err(());
+			}

-		// Final Verification
-		let locked_block = enact_result.unwrap();
-		if let Err(e) = self.verifier.verify_block_final(header, locked_block.block().header()) {
-			warn!(target: "client", "Stage 4 block verification failed for #{} ({})\nError: {:?}", header.number(), header.hash(), e);
-			return Err(());
+			Ok(locked_block)
+		} else {
+			warn!(target: "client", "Block import failed for #{} ({}): Parent not found ({}) ", header.number(), header.hash(), header.parent_hash());
+			Err(())
 		}
-
-		Ok(locked_block)
 	}

 	fn calculate_enacted_retracted(&self, import_results: &[ImportRoute]) -> (Vec<H256>, Vec<H256>) {
@@ -373,14 +377,17 @@ impl Client {
 					invalid_blocks.insert(header.hash());
 					continue;
 				}
+				let is_invalid = invalid_blocks.contains(header.parent_hash());
+				if let (false, Ok(closed_block)) = (is_invalid, self.check_and_close_block(&block)) {
+					imported_blocks.push(header.hash());

-				let closed_block = closed_block.unwrap();
-				imported_blocks.push(header.hash());
+					let route = self.commit_block(closed_block, &header.hash(), &block.bytes);
+					import_results.push(route);

-				let route = self.commit_block(closed_block, &header.hash(), &block.bytes);
-				import_results.push(route);
-
-				self.report.write().accrue_block(&block);
+					self.report.write().accrue_block(&block);
+				} else {
+					invalid_blocks.insert(header.hash());
+				}
 			}

 			let imported = imported_blocks.len();
@@ -427,9 +434,9 @@ impl Client {
 		let number = block.header().number();
 		let parent = block.header().parent_hash().clone();
 		// Are we committing an era?
-		let ancient = if number >= HISTORY {
-			let n = number - HISTORY;
-			Some((n, self.chain.block_hash(n).unwrap()))
+		let ancient = if number >= self.history {
+			let n = number - self.history;
+			Some((n, self.chain.block_hash(n).expect("only verified blocks can be commited; verified block has hash; qed")))
 		} else {
 			None
 		};
@@ -442,7 +449,6 @@ impl Client {
 			.collect();

 		//let traces = From::from(block.traces().clone().unwrap_or_else(Vec::new));
-
 		let batch = DBTransaction::new(&self.db);
 		// CHECK! I *think* this is fine, even if the state_root is equal to another
 		// already-imported block of the same number.
@@ -458,6 +464,8 @@ impl Client {
 			enacted: route.enacted.clone(),
 			retracted: route.retracted.len()
 		});
+		let is_canon = route.enacted.last().map_or(false, |h| h == hash);
+		state.sync_cache(&route.enacted, &route.retracted, is_canon);
 		// Final commit to the DB
 		self.db.write_buffered(batch).expect("DB write failed.");
 		self.chain.commit();
@@ -505,7 +513,7 @@ impl Client {
 			let db = self.state_db.lock().boxed_clone();

 			// early exit for pruned blocks
-			if db.is_pruned() && self.chain.best_block_number() >= block_number + HISTORY {
+			if db.is_pruned() && self.chain.best_block_number() >= block_number + self.history {
 				return None;
 			}

@@ -532,9 +540,11 @@ impl Client {

 	/// Get a copy of the best block's state.
 	pub fn state(&self) -> State {
+		let header = self.best_block_header();
+		let header = HeaderView::new(&header);
 		State::from_existing(
-			self.state_db.lock().boxed_clone(),
-			HeaderView::new(&self.best_block_header()).state_root(),
+			self.state_db.lock().boxed_clone_canon(&header.hash()),
+			header.state_root(),
 			self.engine.account_start_nonce(),
 			self.trie_factory.clone())
 		.expect("State root of best block header always valid.")
@@ -608,7 +618,7 @@ impl Client {
 		let best_block_number = self.chain_info().best_block_number;
 		let block_number = try!(self.block_number(at).ok_or(snapshot::Error::InvalidStartingBlock(at)));

-		if best_block_number > HISTORY + block_number && db.is_pruned() {
+		if best_block_number > self.history + block_number && db.is_pruned() {
 			return Err(snapshot::Error::OldBlockPrunedDB.into());
 		}

@@ -620,8 +630,10 @@ impl Client {
 					0
 				};

-				self.block_hash(BlockID::Number(start_num))
-					.expect("blocks within HISTORY are always stored.")
+				match self.block_hash(BlockID::Number(start_num)) {
+					Some(h) => h,
+					None => return Err(snapshot::Error::InvalidStartingBlock(at).into()),
+				}
 			}
 			_ => match self.block_hash(at) {
 				Some(hash) => hash,
@@ -808,7 +820,7 @@ impl BlockChainClient for Client {
 	}

 	fn code(&self, address: &Address, id: BlockID) -> Option<Option<Bytes>> {
-		self.state_at(id).map(|s| s.code(address))
+		self.state_at(id).map(|s| s.code(address).map(|c| (*c).clone()))
 	}

 	fn balance(&self, address: &Address, id: BlockID) -> Option<U256> {
@@ -833,8 +845,9 @@ impl BlockChainClient for Client {
 			let t = self.chain.block_body(&address.block_hash)
 				.and_then(|block| BodyView::new(&block).localized_transaction_at(&address.block_hash, block_number, address.index));

-			match (t, self.chain.transaction_receipt(&address)) {
-				(Some(tx), Some(receipt)) => {
+			let tx_and_sender = t.and_then(|tx| tx.sender().ok().map(|sender| (tx, sender)));
+			match (tx_and_sender, self.chain.transaction_receipt(&address)) {
+				(Some((tx, sender)), Some(receipt)) => {
 					let block_hash = tx.block_hash.clone();
 					let block_number = tx.block_number.clone();
 					let transaction_hash = tx.hash();
@@ -856,7 +869,7 @@ impl BlockChainClient for Client {
 						gas_used: receipt.gas_used - prior_gas_used,
 						contract_address: match tx.action {
 							Action::Call(_) => None,
-							Action::Create => Some(contract_address(&tx.sender().unwrap(), &tx.nonce))
+							Action::Create => Some(contract_address(&sender, &tx.nonce))
 						},
 						logs: receipt.logs.into_iter().enumerate().map(|(i, log)| LocalizedLogEntry {
 							entry: log,
@@ -979,17 +992,18 @@ impl BlockChainClient for Client {
 		let start = self.block_number(filter.range.start);
 		let end = self.block_number(filter.range.end);

-		if start.is_some() && end.is_some() {
-			let filter = trace::Filter {
-				range: start.unwrap() as usize..end.unwrap() as usize,
-				from_address: From::from(filter.from_address),
-				to_address: From::from(filter.to_address),
-			};
+		match (start, end) {
+			(Some(s), Some(e)) => {
+				let filter = trace::Filter {
+					range: s as usize..e as usize,
+					from_address: From::from(filter.from_address),
+					to_address: From::from(filter.to_address),
+				};

-			let traces = self.tracedb.filter(&filter);
-			Some(traces)
-		} else {
-			None
+				let traces = self.tracedb.filter(&filter);
+				Some(traces)
+			},
+			_ => None,
 		}
 	}

@@ -1036,7 +1050,7 @@ impl BlockChainClient for Client {
 	}

 	fn pending_transactions(&self) -> Vec<SignedTransaction> {
-		self.miner.pending_transactions()
+		self.miner.pending_transactions(self.chain.best_block_number())
 	}
 }

@@ -1050,7 +1064,7 @@ impl MiningBlockChainClient for Client {
 			&self.vm_factory,
 			self.trie_factory.clone(),
 			false,	// TODO: this will need to be parameterised once we want to do immediate mining insertion.
-			self.state_db.lock().boxed_clone(),
+			self.state_db.lock().boxed_clone_canon(&h),
 			&self.chain.block_header(&h).expect("h is best block hash: so its header must exist: qed"),
 			self.build_last_hashes(h.clone()),
 			author,
@@ -1061,11 +1075,15 @@ impl MiningBlockChainClient for Client {
 		// Add uncles
 		self.chain
 			.find_uncle_headers(&h, engine.maximum_uncle_age())
-			.unwrap()
+			.unwrap_or_else(Vec::new)
 			.into_iter()
 			.take(engine.maximum_uncle_count())
 			.foreach(|h| {
-				open_block.push_uncle(h).unwrap();
+				open_block.push_uncle(h).expect("pushing maximum_uncle_count;
+												open_block was just created;
+												push_uncle is not ok only if more than maximum_uncle_count is pushed;
+												so all push_uncle are Ok;
+												qed");
 			});

 		open_block
@@ -1085,9 +1103,9 @@ impl MiningBlockChainClient for Client {

 		let block_data = block.rlp_bytes();
 		// Clear canonical state cache
-		self.state_db.lock().clear_cache();
 		let route = self.commit_block(block, &h, &block_data);
 		trace!(target: "client", "Imported sealed block #{} ({})", number, h);
+		self.state_db.lock().sync_cache(&route.enacted, &route.retracted, false);

 		let (enacted, retracted) = self.calculate_enacted_retracted(&[route]);
 		self.miner.chain_new_blocks(self, &[h.clone()], &[], &enacted, &retracted);
--- a/ethcore/src/client/config.rs
+++ b/ethcore/src/client/config.rs
@@ -107,6 +107,8 @@ pub struct ClientConfig {
 	pub mode: Mode,
 	/// Type of block verifier used by client.
 	pub verifier_type: VerifierType,
+	/// State pruning history size.
+	pub history: u64,
 }

 #[cfg(test)]
--- a/ethcore/src/client/test_client.rs
+++ b/ethcore/src/client/test_client.rs
@@ -53,6 +53,8 @@ pub struct TestBlockChainClient {
 	pub genesis_hash: H256,
 	/// Last block hash.
 	pub last_hash: RwLock<H256>,
+	/// Extra data do set for each block
+	pub extra_data: Bytes,
 	/// Difficulty.
 	pub difficulty: RwLock<U256>,
 	/// Balances.
@@ -99,11 +101,17 @@ impl Default for TestBlockChainClient {
 impl TestBlockChainClient {
 	/// Creates new test client.
 	pub fn new() -> Self {
+		Self::new_with_extra_data(Bytes::new())
+	}
+
+	/// Creates new test client with specified extra data for each block
+	pub fn new_with_extra_data(extra_data: Bytes) -> Self {
 		let spec = Spec::new_test();
 		let mut client = TestBlockChainClient {
 			blocks: RwLock::new(HashMap::new()),
 			numbers: RwLock::new(HashMap::new()),
 			genesis_hash: H256::new(),
+			extra_data: extra_data,
 			last_hash: RwLock::new(H256::new()),
 			difficulty: RwLock::new(From::from(0)),
 			balances: RwLock::new(HashMap::new()),
@@ -121,7 +129,7 @@ impl TestBlockChainClient {
 		client.genesis_hash = client.last_hash.read().clone();
 		client
 	}
-
+	
 	/// Set the transaction receipt result
 	pub fn set_transaction_receipt(&self, id: TransactionID, receipt: LocalizedReceipt) {
 		self.receipts.write().insert(id, receipt);
@@ -166,6 +174,7 @@ impl TestBlockChainClient {
 			header.parent_hash = self.last_hash.read().clone();
 			header.number = n as BlockNumber;
 			header.gas_limit = U256::from(1_000_000);
+			header.extra_data = self.extra_data.clone();
 			let uncles = match with {
 				EachBlockWith::Uncle | EachBlockWith::UncleAndTransaction => {
 					let mut uncles = RlpStream::new_list(1);
@@ -558,6 +567,6 @@ impl BlockChainClient for TestBlockChainClient {
 	}

 	fn pending_transactions(&self) -> Vec<SignedTransaction> {
-		self.miner.pending_transactions()
+		self.miner.pending_transactions(self.chain_info().best_block_number)
 	}
 }
--- a/ethcore/src/ethereum/ethash.rs
+++ b/ethcore/src/ethereum/ethash.rs
@@ -38,13 +38,21 @@ pub struct EthashParams {
 	/// Namereg contract address.
 	pub registrar: Address,
 	/// Homestead transition block number.
-	pub frontier_compatibility_mode_limit: u64,
+	pub homestead_transition: u64,
 	/// DAO hard-fork transition block (X).
 	pub dao_hardfork_transition: u64,
 	/// DAO hard-fork refund contract address (C).
 	pub dao_hardfork_beneficiary: Address,
 	/// DAO hard-fork DAO accounts list (L)
 	pub dao_hardfork_accounts: Vec<Address>,
+	/// Transition block for a change of difficulty params (currently just bound_divisor).
+	pub difficulty_hardfork_transition: u64,
+	/// Difficulty param after the difficulty transition.
+	pub difficulty_hardfork_bound_divisor: U256,
+	/// Block on which there is no additional difficulty from the exponential bomb.
+	pub bomb_defuse_transition: u64,
+	/// Bad gas transition block number.
+	pub eip150_transition: u64,
 }

 impl From<ethjson::spec::EthashParams> for EthashParams {
@@ -56,10 +64,14 @@ impl From<ethjson::spec::EthashParams> for EthashParams {
 			duration_limit: p.duration_limit.into(),
 			block_reward: p.block_reward.into(),
 			registrar: p.registrar.map_or_else(Address::new, Into::into),
-			frontier_compatibility_mode_limit: p.frontier_compatibility_mode_limit.map_or(0, Into::into),
+			homestead_transition: p.homestead_transition.map_or(0, Into::into),
 			dao_hardfork_transition: p.dao_hardfork_transition.map_or(0x7fffffffffffffff, Into::into),
 			dao_hardfork_beneficiary: p.dao_hardfork_beneficiary.map_or_else(Address::new, Into::into),
 			dao_hardfork_accounts: p.dao_hardfork_accounts.unwrap_or_else(Vec::new).into_iter().map(Into::into).collect(),
+			difficulty_hardfork_transition: p.difficulty_hardfork_transition.map_or(0x7fffffffffffffff, Into::into),
+			difficulty_hardfork_bound_divisor: p.difficulty_hardfork_bound_divisor.map_or(p.difficulty_bound_divisor.into(), Into::into),
+			bomb_defuse_transition: p.bomb_defuse_transition.map_or(0x7fffffffffffffff, Into::into),
+			eip150_transition: p.eip150_transition.map_or(0, Into::into),
 		}
 	}
 }
@@ -104,12 +116,14 @@ impl Engine for Ethash {
 	}

 	fn schedule(&self, env_info: &EnvInfo) -> Schedule {
-		trace!(target: "client", "Creating schedule. fCML={}", self.ethash_params.frontier_compatibility_mode_limit);
+		trace!(target: "client", "Creating schedule. fCML={}, bGCML={}", self.ethash_params.homestead_transition, self.ethash_params.eip150_transition);

-		if env_info.number < self.ethash_params.frontier_compatibility_mode_limit {
+		if env_info.number < self.ethash_params.homestead_transition {
 			Schedule::new_frontier()
-		} else {
+		} else if env_info.number < self.ethash_params.eip150_transition {
 			Schedule::new_homestead()
+		} else {
+			Schedule::new_homestead_gas_fix()
 		}
 	}

@@ -246,7 +260,7 @@ impl Engine for Ethash {
 	}

 	fn verify_transaction_basic(&self, t: &SignedTransaction, header: &Header) -> result::Result<(), Error> {
-		if header.number() >= self.ethash_params.frontier_compatibility_mode_limit {
+		if header.number() >= self.ethash_params.homestead_transition {
 			try!(t.check_low_s());
 		}
 		Ok(())
@@ -268,7 +282,7 @@ impl Ethash {
 		let min_difficulty = self.ethash_params.minimum_difficulty;
 		let difficulty_bound_divisor = self.ethash_params.difficulty_bound_divisor;
 		let duration_limit = self.ethash_params.duration_limit;
-		let frontier_limit = self.ethash_params.frontier_compatibility_mode_limit;
+		let frontier_limit = self.ethash_params.homestead_transition;

 		let mut target = if header.number < frontier_limit {
 			if header.timestamp >= parent.timestamp + duration_limit {
--- a/ethcore/src/ethereum/mod.rs
+++ b/ethcore/src/ethereum/mod.rs
@@ -44,8 +44,11 @@ pub fn new_frontier_test() -> Spec { Spec::load(include_bytes!("../../res/ethere
 /// Create a new Homestead chain spec as though it never changed from Frontier.
 pub fn new_homestead_test() -> Spec { Spec::load(include_bytes!("../../res/ethereum/homestead_test.json")) }

+/// Create a new Homestead-EIP150 chain spec as though it never changed from Homestead/Frontier.
+pub fn new_eip150_test() -> Spec { Spec::load(include_bytes!("../../res/ethereum/eip150_test.json")) }
+
 /// Create a new Frontier/Homestead/DAO chain spec with transition points at #5 and #8.
-pub fn new_daohardfork_test() -> Spec { Spec::load(include_bytes!("../../res/ethereum/daohardfork_test.json")) }
+pub fn new_transition_test() -> Spec { Spec::load(include_bytes!("../../res/ethereum/transition_test.json")) }

 /// Create a new Frontier main net chain spec without genesis accounts.
 pub fn new_mainnet_like() -> Spec { Spec::load(include_bytes!("../../res/ethereum/frontier_like_test.json")) }
--- a/ethcore/src/evm/ext.rs
+++ b/ethcore/src/evm/ext.rs
@@ -81,7 +81,7 @@ pub trait Ext {
 	) -> MessageCallResult;

 	/// Returns code at given address
-	fn extcode(&self, address: &Address) -> Bytes;
+	fn extcode(&self, address: &Address) -> Arc<Bytes>;

 	/// Returns code length in bytes at given address
 	fn extcode_len(&self, address: &Address) -> u64;
--- a/ethcore/src/evm/factory.rs
+++ b/ethcore/src/evm/factory.rs
@@ -18,8 +18,10 @@
 //!
 //! TODO: consider spliting it into two separate files.
 use std::fmt;
+use std::sync::Arc;
 use evm::Evm;
 use util::{U256, Uint};
+use super::interpreter::SharedCache;

 #[derive(Debug, PartialEq, Clone)]
 /// Type of EVM to use.
@@ -81,7 +83,8 @@ impl VMType {

 /// Evm factory. Creates appropriate Evm.
 pub struct Factory {
-	evm: VMType
+	evm: VMType,
+	evm_cache: Arc<SharedCache>,
 }

 impl Factory {
@@ -94,9 +97,9 @@ impl Factory {
 				Box::new(super::jit::JitEvm::default())
 			},
 			VMType::Interpreter => if Self::can_fit_in_usize(gas) {
-				Box::new(super::interpreter::Interpreter::<usize>::default())
+				Box::new(super::interpreter::Interpreter::<usize>::new(self.evm_cache.clone()))
 			} else {
-				Box::new(super::interpreter::Interpreter::<U256>::default())
+				Box::new(super::interpreter::Interpreter::<U256>::new(self.evm_cache.clone()))
 			}
 		}
 	}
@@ -107,9 +110,9 @@ impl Factory {
 	pub fn create(&self, gas: U256) -> Box<Evm> {
 		match self.evm {
 			VMType::Interpreter => if Self::can_fit_in_usize(gas) {
-				Box::new(super::interpreter::Interpreter::<usize>::default())
+				Box::new(super::interpreter::Interpreter::<usize>::new(self.evm_cache.clone()))
 			} else {
-				Box::new(super::interpreter::Interpreter::<U256>::default())
+				Box::new(super::interpreter::Interpreter::<U256>::new(self.evm_cache.clone()))
 			}
 		}
 	}
@@ -117,7 +120,8 @@ impl Factory {
 	/// Create new instance of specific `VMType` factory
 	pub fn new(evm: VMType) -> Self {
 		Factory {
-			evm: evm
+			evm: evm,
+			evm_cache: Arc::new(SharedCache::default()),
 		}
 	}

@@ -131,7 +135,8 @@ impl Default for Factory {
 	#[cfg(feature = "jit")]
 	fn default() -> Factory {
 		Factory {
-			evm: VMType::Jit
+			evm: VMType::Jit,
+			evm_cache: Arc::new(SharedCache::default()),
 		}
 	}

@@ -139,7 +144,8 @@ impl Default for Factory {
 	#[cfg(not(feature = "jit"))]
 	fn default() -> Factory {
 		Factory {
-			evm: VMType::Interpreter
+			evm: VMType::Interpreter,
+			evm_cache: Arc::new(SharedCache::default()),
 		}
 	}
 }
--- a/ethcore/src/evm/interpreter/gasometer.rs
+++ b/ethcore/src/evm/interpreter/gasometer.rs
@@ -19,6 +19,7 @@ use super::u256_to_address;
 use evm::{self, CostType};
 use evm::instructions::{self, Instruction, InstructionInfo};
 use evm::interpreter::stack::Stack;
+use evm::schedule::Schedule;

 macro_rules! overflowing {
 	($x: expr) => {{
@@ -31,7 +32,7 @@ macro_rules! overflowing {
 #[cfg_attr(feature="dev", allow(enum_variant_names))]
 enum InstructionCost<Cost: CostType> {
 	Gas(Cost),
-	GasMem(Cost, Cost),
+	GasMem(Cost, Cost, Option<Cost>),
 	GasMemCopy(Cost, Cost, Cost)
 }

@@ -56,7 +57,37 @@ impl<Gas: CostType> Gasometer<Gas> {
 		}
 	}

+	/// 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<evm::Result<Gas>>) -> evm::Result<Gas> {
+		match schedule.sub_gas_cap_divisor {
+			Some(cap_divisor) if self.current_gas >= needed => {
+				let gas_remaining = self.current_gas - needed;
+				let max_gas_provided = gas_remaining - gas_remaining / Gas::from(cap_divisor);
+				if let Some(Ok(r)) = requested { 
+					Ok(min(r, max_gas_provided))
+				} else {
+					Ok(max_gas_provided)
+				}
+			},
+			_ => {
+				if let Some(r) = requested { 
+					r
+				} else if self.current_gas >= needed {
+					Ok(self.current_gas - needed)
+				} else {
+					Ok(0.into())
+				}
+			}
+		}
+	}
+
 	#[cfg_attr(feature="dev", allow(cyclomatic_complexity))]
+	/// Determine how much gas is used by the given instruction, given the machine's state.
+	/// 
+	/// We guarantee that the final element of the returned tuple (`provided`) will be `Some`
+	/// iff the `instruction` is one of `CREATE`, or any of the `CALL` variants. In this case,
+	/// it will be the amount of gas that the current context provides to the child context. 
 	pub fn get_gas_cost_mem(
 		&mut self,
 		ext: &evm::Ext,
@@ -64,7 +95,7 @@ impl<Gas: CostType> Gasometer<Gas> {
 		info: &InstructionInfo,
 		stack: &Stack<U256>,
 		current_mem_size: usize,
-	) -> evm::Result<(Gas, Gas, usize)> {
+	) -> evm::Result<(Gas, Gas, usize, Option<Gas>)> {
 		let schedule = ext.schedule();
 		let tier = instructions::get_tier_idx(info.tier);
 		let default_gas = Gas::from(schedule.tier_step_gas[tier]);
@@ -90,26 +121,42 @@ impl<Gas: CostType> Gasometer<Gas> {
 			instructions::SLOAD => {
 				InstructionCost::Gas(Gas::from(schedule.sload_gas))
 			},
+			instructions::BALANCE => {
+				InstructionCost::Gas(Gas::from(schedule.balance_gas))
+			},
+			instructions::EXTCODESIZE => {
+				InstructionCost::Gas(Gas::from(schedule.extcodesize_gas))
+			},
+			instructions::SUICIDE => {
+				let mut gas = Gas::from(schedule.suicide_gas);
+
+				let address = u256_to_address(stack.peek(0));
+				if !ext.exists(&address) {
+					gas = overflowing!(gas.overflow_add(schedule.suicide_to_new_account_cost.into()));
+				}
+
+				InstructionCost::Gas(gas)
+			},
 			instructions::MSTORE | instructions::MLOAD => {
-				InstructionCost::GasMem(default_gas, try!(mem_needed_const(stack.peek(0), 32)))
+				InstructionCost::GasMem(default_gas, try!(mem_needed_const(stack.peek(0), 32)), None)
 			},
 			instructions::MSTORE8 => {
-				InstructionCost::GasMem(default_gas, try!(mem_needed_const(stack.peek(0), 1)))
+				InstructionCost::GasMem(default_gas, try!(mem_needed_const(stack.peek(0), 1)), None)
 			},
 			instructions::RETURN => {
-				InstructionCost::GasMem(default_gas, try!(mem_needed(stack.peek(0), stack.peek(1))))
+				InstructionCost::GasMem(default_gas, try!(mem_needed(stack.peek(0), stack.peek(1))), None)
 			},
 			instructions::SHA3 => {
 				let w = overflowing!(add_gas_usize(try!(Gas::from_u256(*stack.peek(1))), 31));
 				let words = w >> 5;
 				let gas = Gas::from(schedule.sha3_gas) + (Gas::from(schedule.sha3_word_gas) * words);
-				InstructionCost::GasMem(gas, try!(mem_needed(stack.peek(0), stack.peek(1))))
+				InstructionCost::GasMem(gas, try!(mem_needed(stack.peek(0), stack.peek(1))), None)
 			},
 			instructions::CALLDATACOPY | instructions::CODECOPY => {
 				InstructionCost::GasMemCopy(default_gas, try!(mem_needed(stack.peek(0), stack.peek(2))), try!(Gas::from_u256(*stack.peek(2))))
 			},
 			instructions::EXTCODECOPY => {
-				InstructionCost::GasMemCopy(default_gas, try!(mem_needed(stack.peek(1), stack.peek(3))), try!(Gas::from_u256(*stack.peek(3))))
+				InstructionCost::GasMemCopy(schedule.extcodecopy_base_gas.into(), try!(mem_needed(stack.peek(1), stack.peek(3))), try!(Gas::from_u256(*stack.peek(3))))
 			},
 			instructions::LOG0...instructions::LOG4 => {
 				let no_of_topics = instructions::get_log_topics(instruction);
@@ -117,10 +164,10 @@ impl<Gas: CostType> Gasometer<Gas> {

 				let data_gas = overflowing!(try!(Gas::from_u256(*stack.peek(1))).overflow_mul(Gas::from(schedule.log_data_gas)));
 				let gas = overflowing!(data_gas.overflow_add(Gas::from(log_gas)));
-				InstructionCost::GasMem(gas, try!(mem_needed(stack.peek(0), stack.peek(1))))
+				InstructionCost::GasMem(gas, try!(mem_needed(stack.peek(0), stack.peek(1))), None)
 			},
 			instructions::CALL | instructions::CALLCODE => {
-				let mut gas  = overflowing!(add_gas_usize(try!(Gas::from_u256(*stack.peek(0))), schedule.call_gas));
+				let mut gas = Gas::from(schedule.call_gas);
 				let mem = cmp::max(
 					try!(mem_needed(stack.peek(5), stack.peek(6))),
 					try!(mem_needed(stack.peek(3), stack.peek(4)))
@@ -129,27 +176,49 @@ impl<Gas: CostType> Gasometer<Gas> {
 				let address = u256_to_address(stack.peek(1));

 				if instruction == instructions::CALL && !ext.exists(&address) {
-					gas = overflowing!(gas.overflow_add(Gas::from(schedule.call_new_account_gas)));
+					gas = overflowing!(gas.overflow_add(schedule.call_new_account_gas.into()));
 				};

 				if !stack.peek(2).is_zero() {
-					gas = overflowing!(gas.overflow_add(Gas::from(schedule.call_value_transfer_gas)));
+					gas = overflowing!(gas.overflow_add(schedule.call_value_transfer_gas.into()));
 				};

-				InstructionCost::GasMem(gas,mem)
+				// TODO: refactor to avoid duplicate calculation here and later on. 
+				let (mem_gas_cost, _, _) = try!(self.mem_gas_cost(schedule, current_mem_size, &mem));
+				let cost_so_far = overflowing!(gas.overflow_add(mem_gas_cost.into()));
+				let requested = Gas::from_u256(*stack.peek(0));
+				let provided = try!(self.gas_provided(schedule, cost_so_far, Some(requested)));
+				gas = overflowing!(gas.overflow_add(provided));
+
+				InstructionCost::GasMem(gas, mem, Some(provided))
 			},
 			instructions::DELEGATECALL => {
-				let gas = overflowing!(add_gas_usize(try!(Gas::from_u256(*stack.peek(0))), schedule.call_gas));
+				let mut gas = Gas::from(schedule.call_gas);
 				let mem = cmp::max(
 					try!(mem_needed(stack.peek(4), stack.peek(5))),
 					try!(mem_needed(stack.peek(2), stack.peek(3)))
 				);
-				InstructionCost::GasMem(gas, mem)
+
+				// TODO: refactor to avoid duplicate calculation here and later on. 
+				let (mem_gas_cost, _, _) = try!(self.mem_gas_cost(schedule, current_mem_size, &mem));
+				let cost_so_far = overflowing!(gas.overflow_add(mem_gas_cost.into()));
+				let requested = Gas::from_u256(*stack.peek(0));
+				let provided = try!(self.gas_provided(schedule, cost_so_far, Some(requested)));
+				gas = overflowing!(gas.overflow_add(provided));
+
+				InstructionCost::GasMem(gas, mem, Some(provided))
 			},
 			instructions::CREATE => {
-				let gas = Gas::from(schedule.create_gas);
+				let mut gas = Gas::from(schedule.create_gas);
 				let mem = try!(mem_needed(stack.peek(1), stack.peek(2)));
-				InstructionCost::GasMem(gas, mem)
+
+				// TODO: refactor to avoid duplicate calculation here and later on. 
+				let (mem_gas_cost, _, _) = try!(self.mem_gas_cost(schedule, current_mem_size, &mem));
+				let cost_so_far = overflowing!(gas.overflow_add(mem_gas_cost.into())); 
+				let provided = try!(self.gas_provided(schedule, cost_so_far, None));
+				gas = overflowing!(gas.overflow_add(provided));
+
+				InstructionCost::GasMem(gas, mem, Some(provided))
 			},
 			instructions::EXP => {
 				let expon = stack.peek(1);
@@ -157,17 +226,17 @@ impl<Gas: CostType> Gasometer<Gas> {
 				let gas = Gas::from(schedule.exp_gas + schedule.exp_byte_gas * bytes);
 				InstructionCost::Gas(gas)
 			},
-			_ => InstructionCost::Gas(default_gas)
+			_ => InstructionCost::Gas(default_gas),
 		};

 		match cost {
 			InstructionCost::Gas(gas) => {
-				Ok((gas, self.current_mem_gas, 0))
+				Ok((gas, self.current_mem_gas, 0, None))
 			},
-			InstructionCost::GasMem(gas, mem_size) => {
+			InstructionCost::GasMem(gas, mem_size, provided) => {
 				let (mem_gas_cost, new_mem_gas, new_mem_size) = try!(self.mem_gas_cost(schedule, current_mem_size, &mem_size));
 				let gas = overflowing!(gas.overflow_add(mem_gas_cost));
-				Ok((gas, new_mem_gas, new_mem_size))
+				Ok((gas, new_mem_gas, new_mem_size, provided))
 			},
 			InstructionCost::GasMemCopy(gas, mem_size, copy) => {
 				let (mem_gas_cost, new_mem_gas, new_mem_size) = try!(self.mem_gas_cost(schedule, current_mem_size, &mem_size));
@@ -175,7 +244,7 @@ impl<Gas: CostType> Gasometer<Gas> {
 				let copy_gas = Gas::from(schedule.copy_gas) * copy;
 				let gas = overflowing!(gas.overflow_add(copy_gas));
 				let gas = overflowing!(gas.overflow_add(mem_gas_cost));
-				Ok((gas, new_mem_gas, new_mem_size))
+				Ok((gas, new_mem_gas, new_mem_size, None))
 			}
 		}
 	}
--- a/ethcore/src/evm/interpreter/mod.rs
+++ b/ethcore/src/evm/interpreter/mod.rs
@@ -31,10 +31,12 @@ macro_rules! evm_debug {
 mod gasometer;
 mod stack;
 mod memory;
+mod shared_cache;

 use self::gasometer::Gasometer;
 use self::stack::{Stack, VecStack};
 use self::memory::Memory;
+pub use self::shared_cache::SharedCache;

 use std::marker::PhantomData;
 use common::*;
@@ -87,8 +89,6 @@ impl<'a> CodeReader<'a> {

 enum InstructionResult<Gas> {
 	Ok,
-	UseAllGas,
-	GasLeft(Gas),
 	UnusedGas(Gas),
 	JumpToPosition(U256),
 	// gas left, init_orf, init_size
@@ -98,9 +98,9 @@ enum InstructionResult<Gas> {


 /// Intepreter EVM implementation
-#[derive(Default)]
 pub struct Interpreter<Cost: CostType> {
 	mem: Vec<u8>,
+	cache: Arc<SharedCache>,
 	_type: PhantomData<Cost>,
 }

@@ -109,7 +109,7 @@ impl<Cost: CostType> evm::Evm for Interpreter<Cost> {
 		self.mem.clear();

 		let code = &params.code.as_ref().unwrap();
-		let valid_jump_destinations = self.find_jump_destinations(code);
+		let valid_jump_destinations = self.cache.jump_destinations(&params.code_hash, code);

 		let mut gasometer = Gasometer::<Cost>::new(try!(Cost::from_u256(params.gas)));
 		let mut stack = VecStack::with_capacity(ext.schedule().stack_limit, U256::zero());
@@ -127,7 +127,7 @@ impl<Cost: CostType> evm::Evm for Interpreter<Cost> {
 			try!(self.verify_instruction(ext, instruction, &info, &stack));

 			// Calculate gas cost
-			let (gas_cost, mem_gas, mem_size) = try!(gasometer.get_gas_cost_mem(ext, instruction, &info, &stack, self.mem.size()));
+			let (gas_cost, mem_gas, mem_size, provided) = try!(gasometer.get_gas_cost_mem(ext, instruction, &info, &stack, self.mem.size()));
 			// TODO: make compile-time removable if too much of a performance hit.
 			let trace_executed = ext.trace_prepare_execute(reader.position - 1, instruction, &gas_cost.as_u256());

@@ -153,25 +153,19 @@ impl<Cost: CostType> evm::Evm for Interpreter<Cost> {

 			// Execute instruction
 			let result = try!(self.exec_instruction(
-				gasometer.current_gas, &params, ext, instruction, &mut reader, &mut stack
+				gasometer.current_gas, &params, ext, instruction, &mut reader, &mut stack, provided
 			));

+			if let InstructionResult::UnusedGas(ref gas) = result {
+				gasometer.current_gas = gasometer.current_gas + *gas;
+			}
+
 			if trace_executed {
 				ext.trace_executed(gasometer.current_gas.as_u256(), stack.peek_top(info.ret), mem_written.map(|(o, s)| (o, &(self.mem[o..(o + s)]))), store_written);
 			}

 			// Advance
 			match result {
-				InstructionResult::Ok => {},
-				InstructionResult::UnusedGas(gas) => {
-					gasometer.current_gas = gasometer.current_gas + gas;
-				},
-				InstructionResult::UseAllGas => {
-					gasometer.current_gas = Cost::from(0);
-				},
-				InstructionResult::GasLeft(gas_left) => {
-					gasometer.current_gas = gas_left;
-				},
 				InstructionResult::JumpToPosition(position) => {
 					let pos = try!(self.verify_jump(position, &valid_jump_destinations));
 					reader.position = pos;
@@ -180,6 +174,7 @@ impl<Cost: CostType> evm::Evm for Interpreter<Cost> {
 					return Ok(GasLeft::NeedsReturn(gas.as_u256(), self.mem.read_slice(off, size)));
 				},
 				InstructionResult::StopExecution => break,
+				_ => {},
 			}
 		}

@@ -188,6 +183,14 @@ impl<Cost: CostType> evm::Evm for Interpreter<Cost> {
 }

 impl<Cost: CostType> Interpreter<Cost> {
+	/// Create a new `Interpreter` instance with shared cache.
+	pub fn new(cache: Arc<SharedCache>) -> Interpreter<Cost> {
+		Interpreter {
+			mem: Vec::new(),
+			cache: cache,
+			_type: PhantomData::default(),
+		}
+	}

 	fn verify_instruction(&self, ext: &evm::Ext, instruction: Instruction, info: &InstructionInfo, stack: &Stack<U256>) -> evm::Result<()> {
 		let schedule = ext.schedule();
@@ -254,7 +257,8 @@ impl<Cost: CostType> Interpreter<Cost> {
 		ext: &mut evm::Ext,
 		instruction: Instruction,
 		code: &mut CodeReader,
-		stack: &mut Stack<U256>
+		stack: &mut Stack<U256>,
+		provided: Option<Cost>
 	) -> evm::Result<InstructionResult<Cost>> {
 		match instruction {
 			instructions::JUMP => {
@@ -279,31 +283,32 @@ impl<Cost: CostType> Interpreter<Cost> {
 				let endowment = stack.pop_back();
 				let init_off = stack.pop_back();
 				let init_size = stack.pop_back();
+				let create_gas = provided.expect("`provided` comes through Self::exec from `Gasometer::get_gas_cost_mem`; `gas_gas_mem_cost` guarantees `Some` when instruction is `CALL`/`CALLCODE`/`DELEGATECALL`/`CREATE`; this is `CREATE`; qed");

 				let contract_code = self.mem.read_slice(init_off, init_size);
 				let can_create = ext.balance(&params.address) >= endowment && ext.depth() < ext.schedule().max_depth;

 				if !can_create {
 					stack.push(U256::zero());
-					return Ok(InstructionResult::Ok);
+					return Ok(InstructionResult::UnusedGas(create_gas));
 				}

-				let create_result = ext.create(&gas.as_u256(), &endowment, contract_code);
+				let create_result = ext.create(&create_gas.as_u256(), &endowment, contract_code);
 				return match create_result {
 					ContractCreateResult::Created(address, gas_left) => {
 						stack.push(address_to_u256(address));
-						Ok(InstructionResult::GasLeft(Cost::from_u256(gas_left).expect("Gas left cannot be greater.")))
+						Ok(InstructionResult::UnusedGas(Cost::from_u256(gas_left).expect("Gas left cannot be greater.")))
 					},
 					ContractCreateResult::Failed => {
 						stack.push(U256::zero());
-						// TODO [todr] Should we just StopExecution here?
-						Ok(InstructionResult::UseAllGas)
+						Ok(InstructionResult::Ok)
 					}
 				};
 			},
 			instructions::CALL | instructions::CALLCODE | instructions::DELEGATECALL => {
 				assert!(ext.schedule().call_value_transfer_gas > ext.schedule().call_stipend, "overflow possible");
-				let call_gas = Cost::from_u256(stack.pop_back()).expect("Gas is already validated.");
+				stack.pop_back();
+				let call_gas = provided.expect("`provided` comes through Self::exec from `Gasometer::get_gas_cost_mem`; `gas_gas_mem_cost` guarantees `Some` when instruction is `CALL`/`CALLCODE`/`DELEGATECALL`/`CREATE`; this is one of `CALL`/`CALLCODE`/`DELEGATECALL`; qed");
 				let code_address = stack.pop_back();
 				let code_address = u256_to_address(&code_address);

@@ -321,7 +326,7 @@ impl<Cost: CostType> Interpreter<Cost> {
 				// Add stipend (only CALL|CALLCODE when value > 0)
 				let call_gas = call_gas + value.map_or_else(|| Cost::from(0), |val| match val.is_zero() {
 					false => Cost::from(ext.schedule().call_stipend),
-					true => Cost::from(0)
+					true => Cost::from(0),
 				});

 				// Get sender & receive addresses, check if we have balance
@@ -486,10 +491,10 @@ impl<Cost: CostType> Interpreter<Cost> {
 				stack.push(U256::from(len));
 			},
 			instructions::CALLDATACOPY => {
-				self.copy_data_to_memory(stack, &params.data.clone().unwrap_or_else(|| vec![]));
+				self.copy_data_to_memory(stack, params.data.as_ref().map_or_else(|| &[] as &[u8], |d| &*d as &[u8]));
 			},
 			instructions::CODECOPY => {
-				self.copy_data_to_memory(stack, &params.code.clone().unwrap_or_else(|| vec![]));
+				self.copy_data_to_memory(stack, params.code.as_ref().map_or_else(|| &[] as &[u8], |c| &**c as &[u8]));
 			},
 			instructions::EXTCODECOPY => {
 				let address = u256_to_address(&stack.pop_back());
@@ -790,23 +795,6 @@ impl<Cost: CostType> Interpreter<Cost> {
 		Ok(())
 	}

-	fn find_jump_destinations(&self, code: &[u8]) -> BitSet {
-		let mut jump_dests = BitSet::with_capacity(code.len());
-		let mut position = 0;
-
-		while position < code.len() {
-			let instruction = code[position];
-
-			if instruction == instructions::JUMPDEST {
-				jump_dests.insert(position);
-			} else if instructions::is_push(instruction) {
-				position += instructions::get_push_bytes(instruction);
-			}
-			position += 1;
-		}
-
-		jump_dests
-	}
 }

 fn get_and_reset_sign(value: U256) -> (U256, bool) {
@@ -833,15 +821,3 @@ fn address_to_u256(value: Address) -> U256 {
 	U256::from(H256::from(value).as_slice())
 }

-#[test]
-fn test_find_jump_destinations() {
-	// given
-	let interpreter = Interpreter::<U256>::default();
-	let code = "7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff5b01600055".from_hex().unwrap();
-
-	// when
-	let valid_jump_destinations = interpreter.find_jump_destinations(&code);
-
-	// then
-	assert!(valid_jump_destinations.contains(66));
-}
--- a/ethcore/src/evm/interpreter/shared_cache.rs
+++ b/ethcore/src/evm/interpreter/shared_cache.rs
@@ -0,0 +1,84 @@
+// Copyright 2015, 2016 Ethcore (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+use std::sync::Arc;
+use lru_cache::LruCache;
+use util::{H256, Mutex};
+use util::sha3::*;
+use bit_set::BitSet;
+use super::super::instructions;
+
+const CACHE_CODE_ITEMS: usize = 65536;
+
+/// GLobal cache for EVM interpreter
+pub struct SharedCache {
+	jump_destinations: Mutex<LruCache<H256, Arc<BitSet>>>
+}
+
+impl SharedCache {
+	/// Get jump destincations bitmap for a contract.
+	pub fn jump_destinations(&self, code_hash: &H256, code: &[u8]) -> Arc<BitSet> {
+		if code_hash == &SHA3_EMPTY {
+			return Self::find_jump_destinations(code);
+		}
+		if let Some(d) = self.jump_destinations.lock().get_mut(code_hash) {
+			return d.clone();
+		}
+
+		let d = Self::find_jump_destinations(code);
+		self.jump_destinations.lock().insert(code_hash.clone(), d.clone());
+		d
+	}
+
+	fn find_jump_destinations(code: &[u8]) -> Arc<BitSet> {
+		let mut jump_dests = BitSet::with_capacity(code.len());
+		let mut position = 0;
+
+		while position < code.len() {
+			let instruction = code[position];
+
+			if instruction == instructions::JUMPDEST {
+				jump_dests.insert(position);
+			} else if instructions::is_push(instruction) {
+				position += instructions::get_push_bytes(instruction);
+			}
+			position += 1;
+		}
+		Arc::new(jump_dests)
+	}
+}
+
+impl Default for SharedCache {
+	fn default() -> SharedCache {
+		SharedCache {
+			jump_destinations: Mutex::new(LruCache::new(CACHE_CODE_ITEMS)),
+		}
+	}
+}
+
+
+#[test]
+fn test_find_jump_destinations() {
+	use util::FromHex;
+	// given
+	let code = "7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff5b01600055".from_hex().unwrap();
+
+	// when
+	let valid_jump_destinations = SharedCache::find_jump_destinations(&code);
+
+	// then
+	assert!(valid_jump_destinations.contains(66));
+}
--- a/ethcore/src/evm/schedule.rs
+++ b/ethcore/src/evm/schedule.rs
@@ -80,6 +80,19 @@ pub struct Schedule {
 	pub tx_data_non_zero_gas: usize,
 	/// Gas price for copying memory
 	pub copy_gas: usize,
+	/// Price of EXTCODESIZE
+	pub extcodesize_gas: usize,
+	/// Base price of EXTCODECOPY
+	pub extcodecopy_base_gas: usize,
+	/// Price of BALANCE
+	pub balance_gas: usize,
+	/// Price of SUICIDE
+	pub suicide_gas: usize,
+	/// Amount of additional gas to pay when SUICIDE credits a non-existant account
+	pub suicide_to_new_account_cost: usize,
+	/// If Some(x): let limit = GAS * (x - 1) / x; let CALL's gas = min(requested, limit). let CREATE's gas = limit.
+	/// If None: let CALL's gas = (requested > GAS ? [OOG] : GAS). let CREATE's gas = GAS
+	pub sub_gas_cap_divisor: Option<usize>,
 }

 impl Schedule {
@@ -93,6 +106,49 @@ impl Schedule {
 		Self::new(true, true, 53000)
 	}

+	/// Schedule for the Homestead-era of the Ethereum main net.
+	pub fn new_homestead_gas_fix() -> Schedule {
+		Schedule{
+			exceptional_failed_code_deposit: true,
+			have_delegate_call: true,
+			stack_limit: 1024,
+			max_depth: 1024,
+			tier_step_gas: [0, 2, 3, 5, 8, 10, 20, 0],
+			exp_gas: 10,
+			exp_byte_gas: 10,
+			sha3_gas: 30,
+			sha3_word_gas: 6,
+			sload_gas: 200,
+			sstore_set_gas: 20000,
+			sstore_reset_gas: 5000,
+			sstore_refund_gas: 15000,
+			jumpdest_gas: 1,
+			log_gas: 375,
+			log_data_gas: 8,
+			log_topic_gas: 375,
+			create_gas: 32000,
+			call_gas: 700,
+			call_stipend: 2300,
+			call_value_transfer_gas: 9000,
+			call_new_account_gas: 25000,
+			suicide_refund_gas: 24000,
+			memory_gas: 3,
+			quad_coeff_div: 512,
+			create_data_gas: 200,
+			tx_gas: 21000,
+			tx_create_gas: 53000,
+			tx_data_zero_gas: 4,
+			tx_data_non_zero_gas: 68,
+			copy_gas: 3,
+			extcodesize_gas: 700,
+			extcodecopy_base_gas: 700,
+			balance_gas: 400,
+			suicide_gas: 5000,
+			suicide_to_new_account_cost: 25000,
+			sub_gas_cap_divisor: Some(64),
+		}
+	}
+
 	fn new(efcd: bool, hdc: bool, tcg: usize) -> Schedule {
 		Schedule{
 			exceptional_failed_code_deposit: efcd,
@@ -126,6 +182,12 @@ impl Schedule {
 			tx_data_zero_gas: 4,
 			tx_data_non_zero_gas: 68,
 			copy_gas: 3,
+			extcodesize_gas: 20,
+			extcodecopy_base_gas: 20,
+			balance_gas: 20,
+			suicide_gas: 0,
+			suicide_to_new_account_cost: 0,
+			sub_gas_cap_divisor: None,
 		}
 	}
 }
--- a/ethcore/src/evm/tests.rs
+++ b/ethcore/src/evm/tests.rs
@@ -49,7 +49,7 @@ pub struct FakeExt {
 	depth: usize,
 	store: HashMap<H256, H256>,
 	blockhashes: HashMap<U256, H256>,
-	codes: HashMap<Address, Bytes>,
+	codes: HashMap<Address, Arc<Bytes>>,
 	logs: Vec<FakeLogEntry>,
 	_suicides: HashSet<Address>,
 	info: EnvInfo,
@@ -136,8 +136,8 @@ impl Ext for FakeExt {
 		MessageCallResult::Success(*gas)
 	}

-	fn extcode(&self, address: &Address) -> Bytes {
-		self.codes.get(address).unwrap_or(&Bytes::new()).clone()
+	fn extcode(&self, address: &Address) -> Arc<Bytes> {
+		self.codes.get(address).unwrap_or(&Arc::new(Bytes::new())).clone()
 	}

 	fn extcode_len(&self, address: &Address) -> u64 {
@@ -184,11 +184,11 @@ fn test_stack_underflow() {
 	let mut params = ActionParams::default();
 	params.address = address.clone();
 	params.gas = U256::from(100_000);
-	params.code = Some(code);
+	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>::default());
+		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()
 	};

@@ -211,7 +211,7 @@ fn test_add(factory: super::Factory) {
 	let mut params = ActionParams::default();
 	params.address = address.clone();
 	params.gas = U256::from(100_000);
-	params.code = Some(code);
+	params.code = Some(Arc::new(code));
 	let mut ext = FakeExt::new();

 	let gas_left = {
@@ -231,7 +231,7 @@ fn test_sha3(factory: super::Factory) {
 	let mut params = ActionParams::default();
 	params.address = address.clone();
 	params.gas = U256::from(100_000);
-	params.code = Some(code);
+	params.code = Some(Arc::new(code));
 	let mut ext = FakeExt::new();

 	let gas_left = {
@@ -251,7 +251,7 @@ fn test_address(factory: super::Factory) {
 	let mut params = ActionParams::default();
 	params.address = address.clone();
 	params.gas = U256::from(100_000);
-	params.code = Some(code);
+	params.code = Some(Arc::new(code));
 	let mut ext = FakeExt::new();

 	let gas_left = {
@@ -273,7 +273,7 @@ fn test_origin(factory: super::Factory) {
 	params.address = address.clone();
 	params.origin = origin.clone();
 	params.gas = U256::from(100_000);
-	params.code = Some(code);
+	params.code = Some(Arc::new(code));
 	let mut ext = FakeExt::new();

 	let gas_left = {
@@ -295,7 +295,7 @@ fn test_sender(factory: super::Factory) {
 	params.address = address.clone();
 	params.sender = sender.clone();
 	params.gas = U256::from(100_000);
-	params.code = Some(code);
+	params.code = Some(Arc::new(code));
 	let mut ext = FakeExt::new();

 	let gas_left = {
@@ -329,9 +329,9 @@ fn test_extcodecopy(factory: super::Factory) {
 	params.address = address.clone();
 	params.sender = sender.clone();
 	params.gas = U256::from(100_000);
-	params.code = Some(code);
+	params.code = Some(Arc::new(code));
 	let mut ext = FakeExt::new();
-	ext.codes.insert(sender, sender_code);
+	ext.codes.insert(sender, Arc::new(sender_code));

 	let gas_left = {
 		let mut vm = factory.create(params.gas);
@@ -350,7 +350,7 @@ fn test_log_empty(factory: super::Factory) {
 	let mut params = ActionParams::default();
 	params.address = address.clone();
 	params.gas = U256::from(100_000);
-	params.code = Some(code);
+	params.code = Some(Arc::new(code));
 	let mut ext = FakeExt::new();

 	let gas_left = {
@@ -382,7 +382,7 @@ fn test_log_sender(factory: super::Factory) {
 	params.address = address.clone();
 	params.sender = sender.clone();
 	params.gas = U256::from(100_000);
-	params.code = Some(code);
+	params.code = Some(Arc::new(code));
 	let mut ext = FakeExt::new();

 	let gas_left = {
@@ -406,7 +406,7 @@ fn test_blockhash(factory: super::Factory) {
 	let mut params = ActionParams::default();
 	params.address = address.clone();
 	params.gas = U256::from(100_000);
-	params.code = Some(code);
+	params.code = Some(Arc::new(code));
 	let mut ext = FakeExt::new();
 	ext.blockhashes.insert(U256::zero(), blockhash.clone());

@@ -428,7 +428,7 @@ fn test_calldataload(factory: super::Factory) {
 	let mut params = ActionParams::default();
 	params.address = address.clone();
 	params.gas = U256::from(100_000);
-	params.code = Some(code);
+	params.code = Some(Arc::new(code));
 	params.data = Some(data);
 	let mut ext = FakeExt::new();

@@ -449,7 +449,7 @@ fn test_author(factory: super::Factory) {

 	let mut params = ActionParams::default();
 	params.gas = U256::from(100_000);
-	params.code = Some(code);
+	params.code = Some(Arc::new(code));
 	let mut ext = FakeExt::new();
 	ext.info.author = author;

@@ -469,7 +469,7 @@ fn test_timestamp(factory: super::Factory) {

 	let mut params = ActionParams::default();
 	params.gas = U256::from(100_000);
-	params.code = Some(code);
+	params.code = Some(Arc::new(code));
 	let mut ext = FakeExt::new();
 	ext.info.timestamp = timestamp;

@@ -489,7 +489,7 @@ fn test_number(factory: super::Factory) {

 	let mut params = ActionParams::default();
 	params.gas = U256::from(100_000);
-	params.code = Some(code);
+	params.code = Some(Arc::new(code));
 	let mut ext = FakeExt::new();
 	ext.info.number = number;

@@ -509,7 +509,7 @@ fn test_difficulty(factory: super::Factory) {

 	let mut params = ActionParams::default();
 	params.gas = U256::from(100_000);
-	params.code = Some(code);
+	params.code = Some(Arc::new(code));
 	let mut ext = FakeExt::new();
 	ext.info.difficulty = difficulty;

@@ -529,7 +529,7 @@ fn test_gas_limit(factory: super::Factory) {

 	let mut params = ActionParams::default();
 	params.gas = U256::from(100_000);
-	params.code = Some(code);
+	params.code = Some(Arc::new(code));
 	let mut ext = FakeExt::new();
 	ext.info.gas_limit = gas_limit;

@@ -548,7 +548,7 @@ fn test_mul(factory: super::Factory) {

 	let mut params = ActionParams::default();
 	params.gas = U256::from(100_000);
-	params.code = Some(code);
+	params.code = Some(Arc::new(code));
 	let mut ext = FakeExt::new();

 	let gas_left = {
@@ -566,7 +566,7 @@ fn test_sub(factory: super::Factory) {

 	let mut params = ActionParams::default();
 	params.gas = U256::from(100_000);
-	params.code = Some(code);
+	params.code = Some(Arc::new(code));
 	let mut ext = FakeExt::new();

 	let gas_left = {
@@ -584,7 +584,7 @@ fn test_div(factory: super::Factory) {

 	let mut params = ActionParams::default();
 	params.gas = U256::from(100_000);
-	params.code = Some(code);
+	params.code = Some(Arc::new(code));
 	let mut ext = FakeExt::new();

 	let gas_left = {
@@ -602,7 +602,7 @@ fn test_div_zero(factory: super::Factory) {

 	let mut params = ActionParams::default();
 	params.gas = U256::from(100_000);
-	params.code = Some(code);
+	params.code = Some(Arc::new(code));
 	let mut ext = FakeExt::new();

 	let gas_left = {
@@ -620,7 +620,7 @@ fn test_mod(factory: super::Factory) {

 	let mut params = ActionParams::default();
 	params.gas = U256::from(100_000);
-	params.code = Some(code);
+	params.code = Some(Arc::new(code));
 	let mut ext = FakeExt::new();

 	let gas_left = {
@@ -639,7 +639,7 @@ fn test_smod(factory: super::Factory) {

 	let mut params = ActionParams::default();
 	params.gas = U256::from(100_000);
-	params.code = Some(code);
+	params.code = Some(Arc::new(code));
 	let mut ext = FakeExt::new();

 	let gas_left = {
@@ -658,7 +658,7 @@ fn test_sdiv(factory: super::Factory) {

 	let mut params = ActionParams::default();
 	params.gas = U256::from(100_000);
-	params.code = Some(code);
+	params.code = Some(Arc::new(code));
 	let mut ext = FakeExt::new();

 	let gas_left = {
@@ -677,7 +677,7 @@ fn test_exp(factory: super::Factory) {

 	let mut params = ActionParams::default();
 	params.gas = U256::from(100_000);
-	params.code = Some(code);
+	params.code = Some(Arc::new(code));
 	let mut ext = FakeExt::new();

 	let gas_left = {
@@ -697,7 +697,7 @@ fn test_comparison(factory: super::Factory) {

 	let mut params = ActionParams::default();
 	params.gas = U256::from(100_000);
-	params.code = Some(code);
+	params.code = Some(Arc::new(code));
 	let mut ext = FakeExt::new();

 	let gas_left = {
@@ -718,7 +718,7 @@ fn test_signed_comparison(factory: super::Factory) {

 	let mut params = ActionParams::default();
 	params.gas = U256::from(100_000);
-	params.code = Some(code);
+	params.code = Some(Arc::new(code));
 	let mut ext = FakeExt::new();

 	let gas_left = {
@@ -739,7 +739,7 @@ fn test_bitops(factory: super::Factory) {

 	let mut params = ActionParams::default();
 	params.gas = U256::from(150_000);
-	params.code = Some(code);
+	params.code = Some(Arc::new(code));
 	let mut ext = FakeExt::new();

 	let gas_left = {
@@ -762,7 +762,7 @@ fn test_addmod_mulmod(factory: super::Factory) {

 	let mut params = ActionParams::default();
 	params.gas = U256::from(100_000);
-	params.code = Some(code);
+	params.code = Some(Arc::new(code));
 	let mut ext = FakeExt::new();

 	let gas_left = {
@@ -783,7 +783,7 @@ fn test_byte(factory: super::Factory) {

 	let mut params = ActionParams::default();
 	params.gas = U256::from(100_000);
-	params.code = Some(code);
+	params.code = Some(Arc::new(code));
 	let mut ext = FakeExt::new();

 	let gas_left = {
@@ -802,7 +802,7 @@ fn test_signextend(factory: super::Factory) {

 	let mut params = ActionParams::default();
 	params.gas = U256::from(100_000);
-	params.code = Some(code);
+	params.code = Some(Arc::new(code));
 	let mut ext = FakeExt::new();

 	let gas_left = {
@@ -822,7 +822,7 @@ fn test_badinstruction_int() {

 	let mut params = ActionParams::default();
 	params.gas = U256::from(100_000);
-	params.code = Some(code);
+	params.code = Some(Arc::new(code));
 	let mut ext = FakeExt::new();

 	let err = {
@@ -842,7 +842,7 @@ fn test_pop(factory: super::Factory) {

 	let mut params = ActionParams::default();
 	params.gas = U256::from(100_000);
-	params.code = Some(code);
+	params.code = Some(Arc::new(code));
 	let mut ext = FakeExt::new();

 	let gas_left = {
@@ -862,7 +862,7 @@ fn test_extops(factory: super::Factory) {
 	params.gas = U256::from(150_000);
 	params.gas_price = U256::from(0x32);
 	params.value = ActionValue::Transfer(U256::from(0x99));
-	params.code = Some(code);
+	params.code = Some(Arc::new(code));
 	let mut ext = FakeExt::new();

 	let gas_left = {
@@ -885,7 +885,7 @@ fn test_jumps(factory: super::Factory) {

 	let mut params = ActionParams::default();
 	params.gas = U256::from(150_000);
-	params.code = Some(code);
+	params.code = Some(Arc::new(code));
 	let mut ext = FakeExt::new();

 	let gas_left = {
@@ -908,7 +908,7 @@ fn test_calls(factory: super::Factory) {
 	let code_address = Address::from(0x998);
 	let mut params = ActionParams::default();
 	params.gas = U256::from(150_000);
-	params.code = Some(code);
+	params.code = Some(Arc::new(code));
 	params.address = address.clone();
 	let mut ext = FakeExt::new();
 	ext.balances = {
--- a/ethcore/src/executive.rs
+++ b/ethcore/src/executive.rs
@@ -26,10 +26,10 @@ use trace::{FlatTrace, Tracer, NoopTracer, ExecutiveTracer, VMTrace, VMTracer, E
 use crossbeam;
 pub use types::executed::{Executed, ExecutionResult};

-/// Max depth to avoid stack overflow (when it's reached we start a new thread with VM)
+/// Roughly estimate what stack size each level of evm depth will use
 /// TODO [todr] We probably need some more sophisticated calculations here (limit on my machine 132)
 /// Maybe something like here: `https://github.com/ethereum/libethereum/blob/4db169b8504f2b87f7d5a481819cfb959fc65f6c/libethereum/ExtVM.cpp`
-const MAX_VM_DEPTH_FOR_THREAD: usize = 64;
+const STACK_SIZE_PER_DEPTH: usize = 24*1024;

 /// Returns new address created from address and given nonce.
 pub fn contract_address(address: &Address, nonce: &U256) -> Address {
@@ -148,12 +148,13 @@ impl<'a> Executive<'a> {

 		// TODO: we might need bigints here, or at least check overflows.
 		let balance = self.state.balance(&sender);
-		let gas_cost = U512::from(t.gas) * U512::from(t.gas_price);
+		let gas_cost = t.gas.full_mul(t.gas_price);
 		let total_cost = U512::from(t.value) + gas_cost;

 		// avoid unaffordable transactions
-		if U512::from(balance) < total_cost {
-			return Err(From::from(ExecutionError::NotEnoughCash { required: total_cost, got: U512::from(balance) }));
+		let balance512 = U512::from(balance);
+		if balance512 < total_cost {
+			return Err(From::from(ExecutionError::NotEnoughCash { required: total_cost, got: balance512 }));
 		}

 		// NOTE: there can be no invalid transactions from this point.
@@ -167,13 +168,14 @@ impl<'a> Executive<'a> {
 				let new_address = contract_address(&sender, &nonce);
 				let params = ActionParams {
 					code_address: new_address.clone(),
+					code_hash: t.data.sha3(),
 					address: new_address,
 					sender: sender.clone(),
 					origin: sender.clone(),
 					gas: init_gas,
 					gas_price: t.gas_price,
 					value: ActionValue::Transfer(t.value),
-					code: Some(t.data.clone()),
+					code: Some(Arc::new(t.data.clone())),
 					data: None,
 					call_type: CallType::None,
 				};
@@ -189,6 +191,7 @@ impl<'a> Executive<'a> {
 					gas_price: t.gas_price,
 					value: ActionValue::Transfer(t.value),
 					code: self.state.code(address),
+					code_hash: self.state.code_hash(address),
 					data: Some(t.data.clone()),
 					call_type: CallType::Call,
 				};
@@ -210,8 +213,11 @@ impl<'a> Executive<'a> {
 		tracer: &mut T,
 		vm_tracer: &mut V
 	) -> evm::Result<U256> where T: Tracer, V: VMTracer {
+
+		let depth_threshold = ::io::LOCAL_STACK_SIZE.with(|sz| sz.get() / STACK_SIZE_PER_DEPTH);
+
 		// Ordinary execution - keep VM in same thread
-		if (self.depth + 1) % MAX_VM_DEPTH_FOR_THREAD != 0 {
+		if (self.depth + 1) % depth_threshold != 0 {
 			let vm_factory = self.vm_factory;
 			let mut ext = self.as_externalities(OriginInfo::from(&params), unconfirmed_substate, output_policy, tracer, vm_tracer);
 			trace!(target: "executive", "ext.schedule.have_delegate_call: {}", ext.schedule().have_delegate_call);
@@ -263,7 +269,7 @@ impl<'a> Executive<'a> {
 			let cost = self.engine.cost_of_builtin(&params.code_address, data);
 			if cost <= params.gas {
 				self.engine.execute_builtin(&params.code_address, data, &mut output);
-				self.state.clear_snapshot();
+				self.state.discard_snapshot();

 				// trace only top level calls to builtins to avoid DDoS attacks
 				if self.depth == 0 {
@@ -283,7 +289,7 @@ impl<'a> Executive<'a> {
 				Ok(params.gas - cost)
 			} else {
 				// just drain the whole gas
-				self.state.revert_snapshot();
+				self.state.revert_to_snapshot();

 				tracer.trace_failed_call(trace_info, vec![]);

@@ -329,7 +335,7 @@ impl<'a> Executive<'a> {
 				res
 			} else {
 				// otherwise it's just a basic transaction, only do tracing, if necessary.
-				self.state.clear_snapshot();
+				self.state.discard_snapshot();

 				tracer.trace_call(trace_info, U256::zero(), trace_output, vec![]);
 				Ok(params.gas)
@@ -411,7 +417,7 @@ impl<'a> Executive<'a> {

 		// real ammount to refund
 		let gas_left_prerefund = match result { Ok(x) => x, _ => 0.into() };
-		let refunded = cmp::min(refunds_bound, (t.gas - gas_left_prerefund) / U256::from(2));
+		let refunded = cmp::min(refunds_bound, (t.gas - gas_left_prerefund) >> 1);
 		let gas_left = gas_left_prerefund + refunded;

 		let gas_used = t.gas - gas_left;
@@ -471,10 +477,10 @@ impl<'a> Executive<'a> {
 				| Err(evm::Error::BadInstruction {.. })
 				| Err(evm::Error::StackUnderflow {..})
 				| Err(evm::Error::OutOfStack {..}) => {
-					self.state.revert_snapshot();
+					self.state.revert_to_snapshot();
 			},
 			Ok(_) | Err(evm::Error::Internal) => {
-				self.state.clear_snapshot();
+				self.state.discard_snapshot();
 				substate.accrue(un_substate);
 			}
 		}
@@ -510,7 +516,7 @@ mod tests {
 		params.address = address.clone();
 		params.sender = sender.clone();
 		params.gas = U256::from(100_000);
-		params.code = Some("3331600055".from_hex().unwrap());
+		params.code = Some(Arc::new("3331600055".from_hex().unwrap()));
 		params.value = ActionValue::Transfer(U256::from(0x7));
 		let mut state_result = get_temp_state();
 		let mut state = state_result.reference_mut();
@@ -569,7 +575,7 @@ mod tests {
 		params.sender = sender.clone();
 		params.origin = sender.clone();
 		params.gas = U256::from(100_000);
-		params.code = Some(code.clone());
+		params.code = Some(Arc::new(code));
 		params.value = ActionValue::Transfer(U256::from(100));
 		let mut state_result = get_temp_state();
 		let mut state = state_result.reference_mut();
@@ -624,7 +630,7 @@ mod tests {
 		params.sender = sender.clone();
 		params.origin = sender.clone();
 		params.gas = U256::from(100_000);
-		params.code = Some(code.clone());
+		params.code = Some(Arc::new(code));
 		params.value = ActionValue::Transfer(U256::from(100));
 		params.call_type = CallType::Call;
 		let mut state_result = get_temp_state();
@@ -687,7 +693,7 @@ mod tests {
 				VMOperation { pc: 33, instruction: 96, gas_cost: 3.into(), executed: Some(VMExecutedOperation { gas_used: 99985.into(), stack_push: vec_into![29], mem_diff: None, store_diff: None }) },
 				VMOperation { pc: 35, instruction: 96, gas_cost: 3.into(), executed: Some(VMExecutedOperation { gas_used: 99982.into(), stack_push: vec_into![3], mem_diff: None, store_diff: None }) },
 				VMOperation { pc: 37, instruction: 96, gas_cost: 3.into(), executed: Some(VMExecutedOperation { gas_used: 99979.into(), stack_push: vec_into![23], mem_diff: None, store_diff: None }) },
-				VMOperation { pc: 39, instruction: 240, gas_cost: 32000.into(), executed: Some(VMExecutedOperation { gas_used: 67979.into(), stack_push: vec_into![U256::from_dec_str("1135198453258042933984631383966629874710669425204").unwrap()], mem_diff: None, store_diff: None }) },
+				VMOperation { pc: 39, instruction: 240, gas_cost: 99979.into(), executed: Some(VMExecutedOperation { gas_used: 64755.into(), stack_push: vec_into![U256::from_dec_str("1135198453258042933984631383966629874710669425204").unwrap()], mem_diff: None, store_diff: None }) },
 				VMOperation { pc: 40, instruction: 96, gas_cost: 3.into(), executed: Some(VMExecutedOperation { gas_used: 64752.into(), stack_push: vec_into![0], mem_diff: None, store_diff: None }) },
 				VMOperation { pc: 42, instruction: 85, gas_cost: 20000.into(), executed: Some(VMExecutedOperation { gas_used: 44752.into(), stack_push: vec_into![], mem_diff: None, store_diff: Some(StorageDiff { location: 0.into(), value: U256::from_dec_str("1135198453258042933984631383966629874710669425204").unwrap() }) }) }
 			],
@@ -734,7 +740,7 @@ mod tests {
 		params.sender = sender.clone();
 		params.origin = sender.clone();
 		params.gas = U256::from(100_000);
-		params.code = Some(code.clone());
+		params.code = Some(Arc::new(code));
 		params.value = ActionValue::Transfer(100.into());
 		let mut state_result = get_temp_state();
 		let mut state = state_result.reference_mut();
@@ -822,7 +828,7 @@ mod tests {
 		params.sender = sender.clone();
 		params.origin = sender.clone();
 		params.gas = U256::from(100_000);
-		params.code = Some(code.clone());
+		params.code = Some(Arc::new(code));
 		params.value = ActionValue::Transfer(U256::from(100));
 		let mut state_result = get_temp_state();
 		let mut state = state_result.reference_mut();
@@ -874,7 +880,7 @@ mod tests {
 		params.sender = sender.clone();
 		params.origin = sender.clone();
 		params.gas = U256::from(100_000);
-		params.code = Some(code.clone());
+		params.code = Some(Arc::new(code));
 		params.value = ActionValue::Transfer(U256::from(100));
 		let mut state_result = get_temp_state();
 		let mut state = state_result.reference_mut();
@@ -931,7 +937,7 @@ mod tests {
 		params.address = address_a.clone();
 		params.sender = sender.clone();
 		params.gas = U256::from(100_000);
-		params.code = Some(code_a.clone());
+		params.code = Some(Arc::new(code_a.clone()));
 		params.value = ActionValue::Transfer(U256::from(100_000));

 		let mut state_result = get_temp_state();
@@ -981,10 +987,10 @@ mod tests {
 		let mut params = ActionParams::default();
 		params.address = address.clone();
 		params.gas = U256::from(100_000);
-		params.code = Some(code.clone());
+		params.code = Some(Arc::new(code.clone()));
 		let mut state_result = get_temp_state();
 		let mut state = state_result.reference_mut();
-		state.init_code(&address, code.clone());
+		state.init_code(&address, code);
 		let info = EnvInfo::default();
 		let engine = TestEngine::new(0);
 		let mut substate = Substate::new();
@@ -1182,7 +1188,7 @@ mod tests {
 		params.sender = sender.clone();
 		params.origin = sender.clone();
 		params.gas = U256::from(0x0186a0);
-		params.code = Some(code.clone());
+		params.code = Some(Arc::new(code));
 		params.value = ActionValue::Transfer(U256::from_str("0de0b6b3a7640000").unwrap());
 		let mut state_result = get_temp_state();
 		let mut state = state_result.reference_mut();
--- a/ethcore/src/externalities.rs
+++ b/ethcore/src/externalities.rs
@@ -147,7 +147,8 @@ impl<'a, T, V> Ext for Externalities<'a, T, V> where T: 'a + Tracer, V: 'a + VMT
 			gas: *gas,
 			gas_price: self.origin_info.gas_price,
 			value: ActionValue::Transfer(*value),
-			code: Some(code.to_vec()),
+			code: Some(Arc::new(code.to_vec())),
+			code_hash: code.sha3(),
 			data: None,
 			call_type: CallType::None,
 		};
@@ -186,6 +187,7 @@ impl<'a, T, V> Ext for Externalities<'a, T, V> where T: 'a + Tracer, V: 'a + VMT
 			gas: *gas,
 			gas_price: self.origin_info.gas_price,
 			code: self.state.code(code_address),
+			code_hash: self.state.code_hash(code_address),
 			data: Some(data.to_vec()),
 			call_type: call_type,
 		};
@@ -202,8 +204,8 @@ impl<'a, T, V> Ext for Externalities<'a, T, V> where T: 'a + Tracer, V: 'a + VMT
 		}
 	}

-	fn extcode(&self, address: &Address) -> Bytes {
-		self.state.code(address).unwrap_or_else(|| vec![])
+	fn extcode(&self, address: &Address) -> Arc<Bytes> {
+		self.state.code(address).unwrap_or_else(|| Arc::new(vec![]))
 	}

 	fn extcode_len(&self, address: &Address) -> u64 {
--- a/ethcore/src/json_tests/chain.rs
+++ b/ethcore/src/json_tests/chain.rs
@@ -48,7 +48,8 @@ pub fn json_chain_test(json_data: &[u8], era: ChainEra) -> Vec<String> {
 				let mut spec = match era {
 					ChainEra::Frontier => ethereum::new_frontier_test(),
 					ChainEra::Homestead => ethereum::new_homestead_test(),
-					ChainEra::DaoHardfork => ethereum::new_daohardfork_test(),
+					ChainEra::Eip150 => ethereum::new_eip150_test(),
+					ChainEra::TransitionTest => ethereum::new_transition_test(),
 				};
 				spec.set_genesis_state(state);
 				spec.overwrite_genesis_params(genesis);
@@ -114,14 +115,38 @@ mod frontier_era_tests {
 	declare_test!{BlockchainTests_RandomTests_bl201507071825GO, "BlockchainTests/RandomTests/bl201507071825GO"}
 }

-mod daohardfork_tests {
+mod transition_tests {
 	use tests::helpers::*;
 	use super::json_chain_test;

 	fn do_json_test(json_data: &[u8]) -> Vec<String> {
-		json_chain_test(json_data, ChainEra::DaoHardfork)
+		json_chain_test(json_data, ChainEra::TransitionTest)
 	}

 	declare_test!{BlockchainTests_TestNetwork_bcSimpleTransitionTest, "BlockchainTests/TestNetwork/bcSimpleTransitionTest"}
 	declare_test!{BlockchainTests_TestNetwork_bcTheDaoTest, "BlockchainTests/TestNetwork/bcTheDaoTest"}
+	declare_test!{BlockchainTests_TestNetwork_bcEIP150Test, "BlockchainTests/TestNetwork/bcEIP150Test"}
+}
+
+mod eip150_blockchain_tests {
+	use tests::helpers::*;
+	use super::json_chain_test;
+
+	fn do_json_test(json_data: &[u8]) -> Vec<String> {
+		json_chain_test(json_data, ChainEra::Eip150)
+	}
+
+	declare_test!{BlockchainTests_EIP150_bcBlockGasLimitTest, "BlockchainTests/EIP150/bcBlockGasLimitTest"}
+	declare_test!{BlockchainTests_EIP150_bcForkStressTest, "BlockchainTests/EIP150/bcForkStressTest"}
+	declare_test!{BlockchainTests_EIP150_bcGasPricerTest, "BlockchainTests/EIP150/bcGasPricerTest"}
+	declare_test!{BlockchainTests_EIP150_bcInvalidHeaderTest, "BlockchainTests/EIP150/bcInvalidHeaderTest"}
+	declare_test!{BlockchainTests_EIP150_bcInvalidRLPTest, "BlockchainTests/EIP150/bcInvalidRLPTest"}
+	declare_test!{BlockchainTests_EIP150_bcMultiChainTest, "BlockchainTests/EIP150/bcMultiChainTest"}
+	declare_test!{BlockchainTests_EIP150_bcRPC_API_Test, "BlockchainTests/EIP150/bcRPC_API_Test"}
+	declare_test!{BlockchainTests_EIP150_bcStateTest, "BlockchainTests/EIP150/bcStateTest"}
+	declare_test!{BlockchainTests_EIP150_bcTotalDifficultyTest, "BlockchainTests/EIP150/bcTotalDifficultyTest"}
+	declare_test!{BlockchainTests_EIP150_bcUncleHeaderValiditiy, "BlockchainTests/EIP150/bcUncleHeaderValiditiy"}
+	declare_test!{BlockchainTests_EIP150_bcUncleTest, "BlockchainTests/EIP150/bcUncleTest"}
+	declare_test!{BlockchainTests_EIP150_bcValidBlockTest, "BlockchainTests/EIP150/bcValidBlockTest"}
+	declare_test!{BlockchainTests_EIP150_bcWalletTest, "BlockchainTests/EIP150/bcWalletTest"}
 }
--- a/ethcore/src/json_tests/eip150_state.rs
+++ b/ethcore/src/json_tests/eip150_state.rs
@@ -0,0 +1,43 @@
+// Copyright 2015, 2016 Ethcore (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+use super::test_common::*;
+use tests::helpers::*;
+use super::state::json_chain_test;
+
+fn do_json_test(json_data: &[u8]) -> Vec<String> {
+	json_chain_test(json_data, ChainEra::Eip150)
+}
+
+declare_test!{StateTests_EIP150_stEIPSpecificTest, "StateTests/EIP150/stEIPSpecificTest"}
+declare_test!{StateTests_EIP150_stEIPsingleCodeGasPrices, "StateTests/EIP150/stEIPsingleCodeGasPrices"}
+declare_test!{StateTests_EIP150_stMemExpandingEIPCalls, "StateTests/EIP150/stMemExpandingEIPCalls"}
+
+declare_test!{StateTests_EIP150_stCallCodes, "StateTests/EIP150/Homestead/stCallCodes"}
+declare_test!{StateTests_EIP150_stCallCreateCallCodeTest, "StateTests/EIP150/Homestead/stCallCreateCallCodeTest"}
+declare_test!{StateTests_EIP150_stDelegatecallTest, "StateTests/EIP150/Homestead/stDelegatecallTest"}
+declare_test!{StateTests_EIP150_stInitCodeTest, "StateTests/EIP150/Homestead/stInitCodeTest"}
+declare_test!{StateTests_EIP150_stLogTests, "StateTests/EIP150/Homestead/stLogTests"}
+declare_test!{heavy => StateTests_EIP150_stMemoryStressTest, "StateTests/EIP150/Homestead/stMemoryStressTest"}
+declare_test!{heavy => StateTests_EIP150_stMemoryTest, "StateTests/EIP150/Homestead/stMemoryTest"}
+declare_test!{StateTests_EIP150_stPreCompiledContracts, "StateTests/EIP150/Homestead/stPreCompiledContracts"}
+declare_test!{heavy => StateTests_EIP150_stQuadraticComplexityTest, "StateTests/EIP150/Homestead/stQuadraticComplexityTest"}
+declare_test!{StateTests_EIP150_stRecursiveCreate, "StateTests/EIP150/Homestead/stRecursiveCreate"}
+declare_test!{StateTests_EIP150_stRefundTest, "StateTests/EIP150/Homestead/stRefundTest"}
+declare_test!{StateTests_EIP150_stSpecialTest, "StateTests/EIP150/Homestead/stSpecialTest"}
+declare_test!{StateTests_EIP150_stSystemOperationsTest, "StateTests/EIP150/Homestead/stSystemOperationsTest"}
+declare_test!{StateTests_EIP150_stTransactionTest, "StateTests/EIP150/Homestead/stTransactionTest"}
+declare_test!{StateTests_EIP150_stWalletTest, "StateTests/EIP150/Homestead/stWalletTest"}
--- a/ethcore/src/json_tests/executive.rs
+++ b/ethcore/src/json_tests/executive.rs
@@ -128,7 +128,7 @@ impl<'a, T, V> Ext for TestExt<'a, T, V> where T: Tracer, V: VMTracer {
 		MessageCallResult::Success(*gas)
 	}

-	fn extcode(&self, address: &Address) -> Bytes  {
+	fn extcode(&self, address: &Address) -> Arc<Bytes>  {
 		self.ext.extcode(address)
 	}

@@ -233,7 +233,7 @@ fn do_json_test_for(vm_type: &VMType, json_data: &[u8]) -> Vec<String> {
 				for (address, account) in vm.post_state.unwrap().into_iter() {
 					let address = address.into();
 					let code: Vec<u8> = account.code.into();
-					fail_unless(state.code(&address).unwrap_or_else(Vec::new) == code, "code is incorrect");
+					fail_unless(state.code(&address).as_ref().map_or_else(|| code.is_empty(), |c| &**c == &code), "code is incorrect");
 					fail_unless(state.balance(&address) == account.balance.into(), "balance is incorrect");
 					fail_unless(state.nonce(&address) == account.nonce.into(), "nonce is incorrect");
 					account.storage.into_iter().foreach(|(k, v)| {
--- a/ethcore/src/json_tests/homestead_chain.rs
+++ b/ethcore/src/json_tests/homestead_chain.rs
@@ -36,3 +36,6 @@ declare_test!{BlockchainTests_Homestead_bcUncleHeaderValiditiy, "BlockchainTests
 declare_test!{BlockchainTests_Homestead_bcUncleTest, "BlockchainTests/Homestead/bcUncleTest"}
 declare_test!{BlockchainTests_Homestead_bcValidBlockTest, "BlockchainTests/Homestead/bcValidBlockTest"}
 declare_test!{BlockchainTests_Homestead_bcWalletTest, "BlockchainTests/Homestead/bcWalletTest"}
+declare_test!{BlockchainTests_Homestead_bcShanghaiLove, "BlockchainTests/Homestead/bcShanghaiLove"}
+// declare_test!{BlockchainTests_Homestead_bcSuicideIssue, "BlockchainTests/Homestead/bcSuicideIssue"}
+declare_test!{BlockchainTests_Homestead_bcExploitTest, "BlockchainTests/Homestead/bcExploitTest"}
--- a/ethcore/src/json_tests/mod.rs
+++ b/ethcore/src/json_tests/mod.rs
@@ -23,4 +23,5 @@ mod state;
 mod chain;
 mod homestead_state;
 mod homestead_chain;
+mod eip150_state;
 mod trie;
--- a/ethcore/src/json_tests/state.rs
+++ b/ethcore/src/json_tests/state.rs
--- a/ethcore/src/miner/miner.rs
+++ b/ethcore/src/miner/miner.rs
@@ -25,12 +25,13 @@ use state::State;
 use client::{MiningBlockChainClient, Executive, Executed, EnvInfo, TransactOptions, BlockID, CallAnalytics};
 use executive::contract_address;
 use block::{ClosedBlock, IsBlock, Block};
+use header::BlockNumber;
 use error::*;
 use transaction::{Action, SignedTransaction};
 use receipt::{Receipt, RichReceipt};
 use spec::Spec;
 use engines::Engine;
-use miner::{MinerService, MinerStatus, TransactionQueue, AccountDetails, TransactionOrigin};
+use miner::{MinerService, MinerStatus, TransactionQueue, PrioritizationStrategy, AccountDetails, TransactionOrigin};
 use miner::work_notify::WorkPoster;
 use client::TransactionImportResult;
 use miner::price_info::PriceInfo;
@@ -47,6 +48,17 @@ pub enum PendingSet {
 	SealingOrElseQueue,
 }

+/// Type of the gas limit to apply to the transaction queue.
+#[derive(Debug, PartialEq)]
+pub enum GasLimit {
+	/// Depends on the block gas limit and is updated with every block.
+	Auto,
+	/// No limit.
+	None,
+	/// Set to a fixed gas value.
+	Fixed(U256),
+}
+
 /// Configures the behaviour of the miner.
 #[derive(Debug, PartialEq)]
 pub struct MinerOptions {
@@ -64,12 +76,16 @@ pub struct MinerOptions {
 	pub tx_gas_limit: U256,
 	/// Maximum size of the transaction queue.
 	pub tx_queue_size: usize,
+	/// Strategy to use for prioritizing transactions in the queue.
+	pub tx_queue_strategy: PrioritizationStrategy,
 	/// Whether we should fallback to providing all the queue's transactions or just pending.
 	pub pending_set: PendingSet,
 	/// How many historical work packages can we store before running out?
 	pub work_queue_size: usize,
 	/// Can we submit two different solutions for the same block and expect both to result in an import?
 	pub enable_resubmission: bool,
+	/// Global gas limit for all transaction in the queue except for local and retracted.
+	pub tx_queue_gas_limit: GasLimit,
 }

 impl Default for MinerOptions {
@@ -80,11 +96,13 @@ impl Default for MinerOptions {
 			reseal_on_external_tx: false,
 			reseal_on_own_tx: true,
 			tx_gas_limit: !U256::zero(),
-			tx_queue_size: 1024,
+			tx_queue_size: 2048,
+			tx_queue_strategy: PrioritizationStrategy::GasFactorAndGasPrice,
 			pending_set: PendingSet::AlwaysQueue,
 			reseal_min_period: Duration::from_secs(2),
-			work_queue_size: 20,
+			work_queue_size: 5,
 			enable_resubmission: true,
+			tx_queue_gas_limit: GasLimit::Auto,
 		}
 	}
 }
@@ -188,7 +206,7 @@ impl Miner {
 	/// Creates new instance of miner without accounts, but with given spec.
 	pub fn with_spec(spec: &Spec) -> Miner {
 		Miner {
-			transaction_queue: Arc::new(Mutex::new(TransactionQueue::new())),
+			transaction_queue: Arc::new(Mutex::new(TransactionQueue::default())),
 			options: Default::default(),
 			next_allowed_reseal: Mutex::new(Instant::now()),
 			sealing_block_last_request: Mutex::new(0),
@@ -206,7 +224,13 @@ impl Miner {
 	/// Creates new instance of miner
 	pub fn new(options: MinerOptions, gas_pricer: GasPricer, spec: &Spec, accounts: Option<Arc<AccountProvider>>) -> Arc<Miner> {
 		let work_poster = if !options.new_work_notify.is_empty() { Some(WorkPoster::new(&options.new_work_notify)) } else { None };
-		let txq = Arc::new(Mutex::new(TransactionQueue::with_limits(options.tx_queue_size, options.tx_gas_limit)));
+		let gas_limit = match options.tx_queue_gas_limit {
+			GasLimit::Fixed(ref limit) => *limit,
+			_ => !U256::zero(),
+		};
+		let txq = Arc::new(Mutex::new(TransactionQueue::with_limits(
+			options.tx_queue_strategy, options.tx_queue_size, gas_limit, options.tx_gas_limit
+		)));
 		Arc::new(Miner {
 			transaction_queue: txq,
 			next_allowed_reseal: Mutex::new(Instant::now()),
@@ -243,6 +267,7 @@ impl Miner {
 	fn prepare_sealing(&self, chain: &MiningBlockChainClient) {
 		trace!(target: "miner", "prepare_sealing: entering");

+		let _timer = PerfTimer::new("prepare_sealing");
 		{
 			trace!(target: "miner", "recalibrating...");
 			let txq = self.transaction_queue.clone();
@@ -395,6 +420,10 @@ impl Miner {
 		let gas_limit = HeaderView::new(&chain.best_block_header()).gas_limit();
 		let mut queue = self.transaction_queue.lock();
 		queue.set_gas_limit(gas_limit);
+		if let GasLimit::Auto = self.options.tx_queue_gas_limit {
+			// Set total tx queue gas limit to be 20x the block gas limit.
+			queue.set_total_gas_limit(gas_limit * 20.into());
+		}
 	}

 	/// Returns true if we had to prepare new pending block
@@ -444,6 +473,21 @@ impl Miner {

 	/// Are we allowed to do a non-mandatory reseal?
 	fn tx_reseal_allowed(&self) -> bool { Instant::now() > *self.next_allowed_reseal.lock() }
+
+	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 {
+		let sealing_work = self.sealing_work.lock();
+		sealing_work.queue.peek_last_ref().map_or_else(
+			|| from_chain(),
+			|b| {
+				if b.block().header().number() > latest_block_number {
+					map_block(b)
+				} else {
+					from_chain()
+				}
+			}
+		)
+	}
 }

 const SEALING_TIMEOUT_IN_BLOCKS : u64 = 5;
@@ -516,29 +560,35 @@ impl MinerService for Miner {
 	}

 	fn balance(&self, chain: &MiningBlockChainClient, address: &Address) -> U256 {
-		let sealing_work = self.sealing_work.lock();
-		sealing_work.queue.peek_last_ref().map_or_else(
+		self.from_pending_block(
+			chain.chain_info().best_block_number,
 			|| chain.latest_balance(address),
 			|b| b.block().fields().state.balance(address)
 		)
 	}

 	fn storage_at(&self, chain: &MiningBlockChainClient, address: &Address, position: &H256) -> H256 {
-		let sealing_work = self.sealing_work.lock();
-		sealing_work.queue.peek_last_ref().map_or_else(
+		self.from_pending_block(
+			chain.chain_info().best_block_number,
 			|| chain.latest_storage_at(address, position),
 			|b| b.block().fields().state.storage_at(address, position)
 		)
 	}

 	fn nonce(&self, chain: &MiningBlockChainClient, address: &Address) -> U256 {
-		let sealing_work = self.sealing_work.lock();
-		sealing_work.queue.peek_last_ref().map_or_else(|| chain.latest_nonce(address), |b| b.block().fields().state.nonce(address))
+		self.from_pending_block(
+			chain.chain_info().best_block_number,
+			|| chain.latest_nonce(address),
+			|b| b.block().fields().state.nonce(address)
+		)
 	}

 	fn code(&self, chain: &MiningBlockChainClient, address: &Address) -> Option<Bytes> {
-		let sealing_work = self.sealing_work.lock();
-		sealing_work.queue.peek_last_ref().map_or_else(|| chain.latest_code(address), |b| b.block().fields().state.code(address))
+		self.from_pending_block(
+			chain.chain_info().best_block_number,
+			|| chain.latest_code(address),
+			|b| b.block().fields().state.code(address).map(|c| (*c).clone())
+		)
 	}

 	fn set_author(&self, author: Address) {
@@ -683,50 +733,74 @@ impl MinerService for Miner {
 		queue.top_transactions()
 	}

-	fn pending_transactions(&self) -> Vec<SignedTransaction> {
+	fn pending_transactions(&self, best_block: BlockNumber) -> Vec<SignedTransaction> {
 		let queue = self.transaction_queue.lock();
-		let sw = self.sealing_work.lock();
-		// TODO: should only use the sealing_work when it's current (it could be an old block)
-		let sealing_set = match sw.enabled {
-			true => sw.queue.peek_last_ref(),
-			false => None,
-		};
-		match (&self.options.pending_set, sealing_set) {
-			(&PendingSet::AlwaysQueue, _) | (&PendingSet::SealingOrElseQueue, None) => queue.top_transactions(),
-			(_, sealing) => sealing.map_or_else(Vec::new, |s| s.transactions().to_owned()),
+		match self.options.pending_set {
+			PendingSet::AlwaysQueue => queue.top_transactions(),
+			PendingSet::SealingOrElseQueue => {
+				self.from_pending_block(
+					best_block,
+					|| queue.top_transactions(),
+					|sealing| sealing.transactions().to_owned()
+				)
+			},
+			PendingSet::AlwaysSealing => {
+				self.from_pending_block(
+					best_block,
+					|| vec![],
+					|sealing| sealing.transactions().to_owned()
+				)
+			},
 		}
 	}

-	fn pending_transactions_hashes(&self) -> Vec<H256> {
+	fn pending_transactions_hashes(&self, best_block: BlockNumber) -> Vec<H256> {
 		let queue = self.transaction_queue.lock();
-		let sw = self.sealing_work.lock();
-		let sealing_set = match sw.enabled {
-			true => sw.queue.peek_last_ref(),
-			false => None,
-		};
-		match (&self.options.pending_set, sealing_set) {
-			(&PendingSet::AlwaysQueue, _) | (&PendingSet::SealingOrElseQueue, None) => queue.pending_hashes(),
-			(_, sealing) => sealing.map_or_else(Vec::new, |s| s.transactions().iter().map(|t| t.hash()).collect()),
+		match self.options.pending_set {
+			PendingSet::AlwaysQueue => queue.pending_hashes(),
+			PendingSet::SealingOrElseQueue => {
+				self.from_pending_block(
+					best_block,
+					|| queue.pending_hashes(),
+					|sealing| sealing.transactions().iter().map(|t| t.hash()).collect()
+				)
+			},
+			PendingSet::AlwaysSealing => {
+				self.from_pending_block(
+					best_block,
+					|| vec![],
+					|sealing| sealing.transactions().iter().map(|t| t.hash()).collect()
+				)
+			},
 		}
 	}

-	fn transaction(&self, hash: &H256) -> Option<SignedTransaction> {
+	fn transaction(&self, best_block: BlockNumber, hash: &H256) -> Option<SignedTransaction> {
 		let queue = self.transaction_queue.lock();
-		let sw = self.sealing_work.lock();
-		let sealing_set = match sw.enabled {
-			true => sw.queue.peek_last_ref(),
-			false => None,
-		};
-		match (&self.options.pending_set, sealing_set) {
-			(&PendingSet::AlwaysQueue, _) | (&PendingSet::SealingOrElseQueue, None) => queue.find(hash),
-			(_, sealing) => sealing.and_then(|s| s.transactions().iter().find(|t| &t.hash() == hash).cloned()),
+		match self.options.pending_set {
+			PendingSet::AlwaysQueue => queue.find(hash),
+			PendingSet::SealingOrElseQueue => {
+				self.from_pending_block(
+					best_block,
+					|| queue.find(hash),
+					|sealing| sealing.transactions().iter().find(|t| &t.hash() == hash).cloned()
+				)
+			},
+			PendingSet::AlwaysSealing => {
+				self.from_pending_block(
+					best_block,
+					|| None,
+					|sealing| sealing.transactions().iter().find(|t| &t.hash() == hash).cloned()
+				)
+			},
 		}
 	}

-	fn pending_receipt(&self, hash: &H256) -> Option<RichReceipt> {
-		let sealing_work = self.sealing_work.lock();
-		match (sealing_work.enabled, sealing_work.queue.peek_last_ref()) {
-			(true, Some(pending)) => {
+	fn pending_receipt(&self, best_block: BlockNumber, hash: &H256) -> Option<RichReceipt> {
+		self.from_pending_block(
+			best_block,
+			|| None,
+			|pending| {
 				let txs = pending.transactions();
 				txs.iter()
 					.map(|t| t.hash())
@@ -747,15 +821,15 @@ impl MinerService for Miner {
 							logs: receipt.logs.clone(),
 						}
 					})
-			},
-			_ => None
-		}
+			}
+		)
 	}

-	fn pending_receipts(&self) -> BTreeMap<H256, Receipt> {
-		let sealing_work = self.sealing_work.lock();
-		match (sealing_work.enabled, sealing_work.queue.peek_last_ref()) {
-			(true, Some(pending)) => {
+	fn pending_receipts(&self, best_block: BlockNumber) -> BTreeMap<H256, Receipt> {
+		self.from_pending_block(
+			best_block,
+			|| BTreeMap::new(),
+			|pending| {
 				let hashes = pending.transactions()
 					.iter()
 					.map(|t| t.hash());
@@ -763,9 +837,8 @@ impl MinerService for Miner {
 				let receipts = pending.receipts().iter().cloned();

 				hashes.zip(receipts).collect()
-			},
-			_ => BTreeMap::new()
-		}
+			}
+		)
 	}

 	fn last_nonce(&self, address: &Address) -> Option<U256> {
@@ -918,7 +991,7 @@ impl MinerService for Miner {
 mod tests {

 	use std::time::Duration;
-	use super::super::MinerService;
+	use super::super::{MinerService, PrioritizationStrategy};
 	use super::*;
 	use util::*;
 	use client::{TestBlockChainClient, EachBlockWith};
@@ -969,6 +1042,8 @@ mod tests {
 				reseal_min_period: Duration::from_secs(5),
 				tx_gas_limit: !U256::zero(),
 				tx_queue_size: 1024,
+				tx_queue_strategy: PrioritizationStrategy::GasFactorAndGasPrice,
+				tx_queue_gas_limit: GasLimit::None,
 				pending_set: PendingSet::AlwaysSealing,
 				work_queue_size: 5,
 				enable_resubmission: true,
@@ -995,20 +1070,48 @@ mod tests {
 				nonce: U256::zero(),
 			}.sign(keypair.secret())
 		};
-
+		let best_block = 0;
 		// when
 		let res = miner.import_own_transaction(&client, transaction);

 		// then
 		assert_eq!(res.unwrap(), TransactionImportResult::Current);
 		assert_eq!(miner.all_transactions().len(), 1);
-		assert_eq!(miner.pending_transactions().len(), 1);
-		assert_eq!(miner.pending_transactions_hashes().len(), 1);
-		assert_eq!(miner.pending_receipts().len(), 1);
+		assert_eq!(miner.pending_transactions(best_block).len(), 1);
+		assert_eq!(miner.pending_transactions_hashes(best_block).len(), 1);
+		assert_eq!(miner.pending_receipts(best_block).len(), 1);
 		// This method will let us know if pending block was created (before calling that method)
 		assert_eq!(miner.enable_and_prepare_sealing(&client), false);
 	}

+	#[test]
+	fn should_not_use_pending_block_if_best_block_is_higher() {
+		// given
+		let client = TestBlockChainClient::default();
+		let miner = miner();
+		let transaction = {
+			let keypair = KeyPair::create().unwrap();
+			Transaction {
+				action: Action::Create,
+				value: U256::zero(),
+				data: "3331600055".from_hex().unwrap(),
+				gas: U256::from(100_000),
+				gas_price: U256::zero(),
+				nonce: U256::zero(),
+			}.sign(keypair.secret())
+		};
+		let best_block = 10;
+		// when
+		let res = miner.import_own_transaction(&client, transaction);
+
+		// then
+		assert_eq!(res.unwrap(), TransactionImportResult::Current);
+		assert_eq!(miner.all_transactions().len(), 1);
+		assert_eq!(miner.pending_transactions(best_block).len(), 0);
+		assert_eq!(miner.pending_transactions_hashes(best_block).len(), 0);
+		assert_eq!(miner.pending_receipts(best_block).len(), 0);
+	}
+
 	#[test]
 	fn should_import_external_transaction() {
 		// given
@@ -1025,16 +1128,16 @@ mod tests {
 				nonce: U256::zero(),
 			}.sign(keypair.secret())
 		};
-
+		let best_block = 0;
 		// when
 		let res = miner.import_external_transactions(&client, vec![transaction]).pop().unwrap();

 		// then
 		assert_eq!(res.unwrap(), TransactionImportResult::Current);
 		assert_eq!(miner.all_transactions().len(), 1);
-		assert_eq!(miner.pending_transactions_hashes().len(), 0);
-		assert_eq!(miner.pending_transactions().len(), 0);
-		assert_eq!(miner.pending_receipts().len(), 0);
+		assert_eq!(miner.pending_transactions_hashes(best_block).len(), 0);
+		assert_eq!(miner.pending_transactions(best_block).len(), 0);
+		assert_eq!(miner.pending_receipts(best_block).len(), 0);
 		// This method will let us know if pending block was created (before calling that method)
 		assert_eq!(miner.enable_and_prepare_sealing(&client), true);
 	}
--- a/ethcore/src/miner/mod.rs
+++ b/ethcore/src/miner/mod.rs
@@ -47,8 +47,8 @@ mod transaction_queue;
 mod work_notify;
 mod price_info;

-pub use self::transaction_queue::{TransactionQueue, AccountDetails, TransactionOrigin};
-pub use self::miner::{Miner, MinerOptions, PendingSet, GasPricer, GasPriceCalibratorOptions};
+pub use self::transaction_queue::{TransactionQueue, PrioritizationStrategy, AccountDetails, TransactionOrigin};
+pub use self::miner::{Miner, MinerOptions, PendingSet, GasPricer, GasPriceCalibratorOptions, GasLimit};
 pub use self::external::{ExternalMiner, ExternalMinerService};
 pub use client::TransactionImportResult;

@@ -56,6 +56,7 @@ use std::collections::BTreeMap;
 use util::{H256, U256, Address, Bytes};
 use client::{MiningBlockChainClient, Executed, CallAnalytics};
 use block::ClosedBlock;
+use header::BlockNumber;
 use receipt::{RichReceipt, Receipt};
 use error::{Error, CallError};
 use transaction::SignedTransaction;
@@ -115,7 +116,7 @@ pub trait MinerService : Send + Sync {
 		Result<TransactionImportResult, Error>;

 	/// Returns hashes of transactions currently in pending
-	fn pending_transactions_hashes(&self) -> Vec<H256>;
+	fn pending_transactions_hashes(&self, best_block: BlockNumber) -> Vec<H256>;

 	/// Removes all transactions from the queue and restart mining operation.
 	fn clear_and_reset(&self, chain: &MiningBlockChainClient);
@@ -135,19 +136,19 @@ pub trait MinerService : Send + Sync {
 		where F: FnOnce(&ClosedBlock) -> T, Self: Sized;

 	/// Query pending transactions for hash.
-	fn transaction(&self, hash: &H256) -> Option<SignedTransaction>;
+	fn transaction(&self, best_block: BlockNumber, hash: &H256) -> Option<SignedTransaction>;

 	/// Get a list of all transactions.
 	fn all_transactions(&self) -> Vec<SignedTransaction>;

 	/// Get a list of all pending transactions.
-	fn pending_transactions(&self) -> Vec<SignedTransaction>;
+	fn pending_transactions(&self, best_block: BlockNumber) -> Vec<SignedTransaction>;

 	/// Get a list of all pending receipts.
-	fn pending_receipts(&self) -> BTreeMap<H256, Receipt>;
+	fn pending_receipts(&self, best_block: BlockNumber) -> BTreeMap<H256, Receipt>;

 	/// Get a particular reciept.
-	fn pending_receipt(&self, hash: &H256) -> Option<RichReceipt>;
+	fn pending_receipt(&self, best_block: BlockNumber, hash: &H256) -> Option<RichReceipt>;

 	/// Returns highest transaction nonce for given address.
 	fn last_nonce(&self, address: &Address) -> Option<U256>;
--- a/ethcore/src/miner/transaction_queue.rs
+++ b/ethcore/src/miner/transaction_queue.rs
@@ -49,7 +49,7 @@
 //!			balance: U256::from(1_000_000),
 //!		};
 //!
-//!		let mut txq = TransactionQueue::new();
+//!		let mut txq = TransactionQueue::default();
 //!		txq.add(st2.clone(), &default_nonce, TransactionOrigin::External).unwrap();
 //!		txq.add(st1.clone(), &default_nonce, TransactionOrigin::External).unwrap();
 //!
@@ -134,9 +134,17 @@ struct TransactionOrder {
 	/// Gas Price of the transaction.
 	/// Low gas price = Low priority (processed later)
 	gas_price: U256,
-	/// Gas (limit) of the transaction.
+	/// Gas usage priority factor. Usage depends on strategy.
+	/// Represents the linear increment in required gas price for heavy transactions.
+	///
+	/// High gas limit + Low gas price = Low priority
+	/// High gas limit + High gas price = High priority
+	gas_factor: U256,
+	/// Gas (limit) of the transaction. Usage depends on strategy.
 	/// Low gas limit = High priority (processed earlier)
 	gas: U256,
+	/// Transaction ordering strategy
+	strategy: PrioritizationStrategy,
 	/// Hash to identify associated transaction
 	hash: H256,
 	/// Origin of the transaction
@@ -147,11 +155,15 @@ struct TransactionOrder {


 impl TransactionOrder {
-	fn for_transaction(tx: &VerifiedTransaction, base_nonce: U256) -> Self {
+
+	fn for_transaction(tx: &VerifiedTransaction, base_nonce: U256, min_gas_price: U256, strategy: PrioritizationStrategy) -> Self {
+		let factor = (tx.transaction.gas >> 15) * min_gas_price;
 		TransactionOrder {
 			nonce_height: tx.nonce() - base_nonce,
 			gas_price: tx.transaction.gas_price,
 			gas: tx.transaction.gas,
+			gas_factor: factor,
+			strategy: strategy,
 			hash: tx.hash(),
 			origin: tx.origin,
 			penalties: 0,
@@ -199,18 +211,28 @@ impl Ord for TransactionOrder {
 			return self.origin.cmp(&b.origin);
 		}

-		// Then compare gas usage
-		let a_gas = self.gas;
-		let b_gas = b.gas;
-		if a_gas != b_gas {
-			return a_gas.cmp(&b_gas);
+		match self.strategy {
+			PrioritizationStrategy::GasAndGasPrice => {
+				if self.gas != b.gas {
+					return self.gas.cmp(&b.gas);
+				}
+			},
+			PrioritizationStrategy::GasFactorAndGasPrice => {
+				// avoiding overflows
+				// (gp1 - g1) > (gp2 - g2) <=>
+				// (gp1 + g2) > (gp2 + g1)
+				let f_a = self.gas_price + b.gas_factor;
+				let f_b = b.gas_price + self.gas_factor;
+				if f_a != f_b {
+					return f_b.cmp(&f_a);
+				}
+			},
+			PrioritizationStrategy::GasPriceOnly => {},
 		}

 		// Then compare gas_prices
-		let a_gas_price = self.gas_price;
-		let b_gas_price = b.gas_price;
-		if a_gas_price != b_gas_price {
-			return b_gas_price.cmp(&a_gas_price);
+		if self.gas_price != b.gas_price {
+			return b.gas_price.cmp(&self.gas_price);
 		}

 		// Compare hashes
@@ -257,6 +279,7 @@ struct TransactionSet {
 	by_priority: BTreeSet<TransactionOrder>,
 	by_address: Table<Address, U256, TransactionOrder>,
 	limit: usize,
+	gas_limit: U256,
 }

 impl TransactionSet {
@@ -277,14 +300,20 @@ impl TransactionSet {
 	/// It drops transactions from this set but also removes associated `VerifiedTransaction`.
 	/// Returns addresses and lowest nonces of transactions removed because of limit.
 	fn enforce_limit(&mut self, by_hash: &mut HashMap<H256, VerifiedTransaction>) -> Option<HashMap<Address, U256>> {
-		let len = self.by_priority.len();
-		if len <= self.limit {
-			return None;
-		}
+		let mut count = 0;
+		let mut gas: U256 = 0.into();
 		let to_drop : Vec<(Address, U256)> = {
 			self.by_priority
 				.iter()
-				.skip(self.limit)
+				.filter(|order| {
+					count = count + 1;
+					let r = gas.overflowing_add(order.gas);
+					if r.1 { return false }
+					gas = r.0;
+					// Own and retracted transactions are allowed to go above all limits.
+					order.origin != TransactionOrigin::Local && order.origin != TransactionOrigin::RetractedBlock &&
+					(gas > self.gas_limit || count > self.limit)
+				})
 				.map(|order| by_hash.get(&order.hash)
 					.expect("All transactions in `self.by_priority` and `self.by_address` are kept in sync with `by_hash`."))
 				.map(|tx| (tx.sender(), tx.nonce()))
@@ -295,6 +324,7 @@ impl TransactionSet {
 			.fold(HashMap::new(), |mut removed, (sender, nonce)| {
 				let order = self.drop(&sender, &nonce)
 					.expect("Transaction has just been found in `by_priority`; so it is in `by_address` also.");
+				trace!(target: "txqueue", "Dropped out of limit transaction: {:?}", order.hash);

 				by_hash.remove(&order.hash)
 					.expect("Hash found in `by_priorty` matches the one dropped; so it is included in `by_hash`");
@@ -350,8 +380,32 @@ pub struct AccountDetails {
 /// Transactions with `gas > (gas_limit + gas_limit * Factor(in percents))` are not imported to the queue.
 const GAS_LIMIT_HYSTERESIS: usize = 10; // (100/GAS_LIMIT_HYSTERESIS) %

+/// Describes the strategy used to prioritize transactions in the queue.
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub enum PrioritizationStrategy {
+	/// Use only gas price. Disregards the actual computation cost of the transaction.
+	/// i.e. Higher gas price = Higher priority
+	GasPriceOnly,
+	/// Use gas limit and then gas price.
+	/// i.e. Higher gas limit = Lower priority
+	GasAndGasPrice,
+	/// Calculate and use priority based on gas and gas price.
+	/// PRIORITY = GAS_PRICE - GAS/2^15 * MIN_GAS_PRICE
+	///
+	/// Rationale:
+	/// Heavy transactions are paying linear cost (GAS * GAS_PRICE)
+	/// while the computation might be more expensive.
+	///
+	/// i.e.
+	/// 1M gas tx with `gas_price=30*min` has the same priority
+	/// as 32k gas tx with `gas_price=min`
+	GasFactorAndGasPrice,
+}
+
 /// `TransactionQueue` implementation
 pub struct TransactionQueue {
+	/// Prioritization strategy for this queue
+	strategy: PrioritizationStrategy,
 	/// Gas Price threshold for transactions that can be imported to this queue (defaults to 0)
 	minimal_gas_price: U256,
 	/// The maximum amount of gas any individual transaction may use.
@@ -370,31 +424,34 @@ pub struct TransactionQueue {

 impl Default for TransactionQueue {
 	fn default() -> Self {
-		TransactionQueue::new()
+		TransactionQueue::new(PrioritizationStrategy::GasPriceOnly)
 	}
 }

 impl TransactionQueue {
 	/// Creates new instance of this Queue
-	pub fn new() -> Self {
-		Self::with_limits(1024, !U256::zero())
+	pub fn new(strategy: PrioritizationStrategy) -> Self {
+		Self::with_limits(strategy, 1024, !U256::zero(), !U256::zero())
 	}

 	/// Create new instance of this Queue with specified limits
-	pub fn with_limits(limit: usize, tx_gas_limit: U256) -> Self {
+	pub fn with_limits(strategy: PrioritizationStrategy, limit: usize, gas_limit: U256, tx_gas_limit: U256) -> Self {
 		let current = TransactionSet {
 			by_priority: BTreeSet::new(),
 			by_address: Table::new(),
 			limit: limit,
+			gas_limit: gas_limit,
 		};

 		let future = TransactionSet {
 			by_priority: BTreeSet::new(),
 			by_address: Table::new(),
 			limit: limit,
+			gas_limit: gas_limit,
 		};

 		TransactionQueue {
+			strategy: strategy,
 			minimal_gas_price: U256::zero(),
 			tx_gas_limit: tx_gas_limit,
 			gas_limit: !U256::zero(),
@@ -441,6 +498,13 @@ impl TransactionQueue {
 		};
 	}

+	/// Sets new total gas limit.
+	pub fn set_total_gas_limit(&mut self, gas_limit: U256) {
+		self.future.gas_limit = gas_limit;
+		self.current.gas_limit = gas_limit;
+		self.future.enforce_limit(&mut self.by_hash);
+	}
+
 	/// Set the new limit for the amount of gas any individual transaction may have.
 	/// Any transaction already imported to the queue is not affected.
 	pub fn set_tx_gas_limit(&mut self, limit: U256) {
@@ -560,7 +624,7 @@ impl TransactionQueue {
 		};
 		for k in nonces_from_sender {
 			let order = self.future.drop(&sender, &k).unwrap();
-			self.current.insert(sender, k, order.penalize());
+			self.future.insert(sender, k, order.penalize());
 		}
 	}

@@ -584,6 +648,8 @@ impl TransactionQueue {
 		let nonce = transaction.nonce();
 		let current_nonce = fetch_account(&sender).nonce;

+		trace!(target: "txqueue", "Removing invalid transaction: {:?}", transaction.hash());
+
 		// Remove from future
 		let order = self.future.drop(&sender, &nonce);
 		if order.is_some() {
@@ -658,6 +724,15 @@ impl TransactionQueue {
 			.collect()
 	}

+	#[cfg(test)]
+	fn future_transactions(&self) -> Vec<SignedTransaction> {
+		self.future.by_priority
+			.iter()
+			.map(|t| self.by_hash.get(&t.hash).expect("All transactions in `current` and `future` are always included in `by_hash`"))
+			.map(|t| t.transaction.clone())
+			.collect()
+	}
+
 	/// Returns hashes of all transactions from current, ordered by priority.
 	pub fn pending_hashes(&self) -> Vec<H256> {
 		self.current.by_priority
@@ -736,10 +811,21 @@ impl TransactionQueue {
 			return Err(TransactionError::AlreadyImported);
 		}

+		let min_gas_price = (self.minimal_gas_price, self.strategy);
 		let address = tx.sender();
 		let nonce = tx.nonce();
 		let hash = tx.hash();

+		{
+			// Rough size sanity check
+			let gas = &tx.transaction.gas;
+			if U256::from(tx.transaction.data.len()) > *gas {
+				// Droping transaction
+				trace!(target: "txqueue", "Dropping oversized transaction: {:?} (gas: {} < size {})", hash, gas, tx.transaction.data.len());
+				return Err(TransactionError::LimitReached);
+			}
+		}
+
 		// The transaction might be old, let's check that.
 		// This has to be the first test, otherwise calculating
 		// nonce height would result in overflow.
@@ -763,7 +849,7 @@ impl TransactionQueue {
 		if nonce > next_nonce {
 			// We have a gap - put to future.
 			// Insert transaction (or replace old one with lower gas price)
-			try!(check_too_cheap(Self::replace_transaction(tx, state_nonce, &mut self.future, &mut self.by_hash)));
+			try!(check_too_cheap(Self::replace_transaction(tx, state_nonce, min_gas_price, &mut self.future, &mut self.by_hash)));
 			// Enforce limit in Future
 			let removed = self.future.enforce_limit(&mut self.by_hash);
 			// Return an error if this transaction was not imported because of limit.
@@ -779,7 +865,7 @@ impl TransactionQueue {
 		self.move_matching_future_to_current(address, nonce + U256::one(), state_nonce);

 		// Replace transaction if any
-		try!(check_too_cheap(Self::replace_transaction(tx, state_nonce, &mut self.current, &mut self.by_hash)));
+		try!(check_too_cheap(Self::replace_transaction(tx, state_nonce, min_gas_price, &mut self.current, &mut self.by_hash)));
 		// Keep track of highest nonce stored in current
 		let new_max = self.last_nonces.get(&address).map_or(nonce, |n| cmp::max(nonce, *n));
 		self.last_nonces.insert(address, new_max);
@@ -815,8 +901,8 @@ impl TransactionQueue {
 	///
 	/// Returns `true` if transaction actually got to the queue (`false` if there was already a transaction with higher
 	/// gas_price)
-	fn replace_transaction(tx: VerifiedTransaction, base_nonce: U256, set: &mut TransactionSet, by_hash: &mut HashMap<H256, VerifiedTransaction>) -> bool {
-		let order = TransactionOrder::for_transaction(&tx, base_nonce);
+	fn replace_transaction(tx: VerifiedTransaction, base_nonce: U256, min_gas_price: (U256, PrioritizationStrategy), set: &mut TransactionSet, by_hash: &mut HashMap<H256, VerifiedTransaction>) -> bool {
+		let order = TransactionOrder::for_transaction(&tx, base_nonce, min_gas_price.0, min_gas_price.1);
 		let hash = tx.hash();
 		let address = tx.sender();
 		let nonce = tx.nonce();
@@ -837,12 +923,14 @@ impl TransactionQueue {
 		let old_fee = old.gas_price;
 		let new_fee = order.gas_price;
 		if old_fee.cmp(&new_fee) == Ordering::Greater {
+			trace!(target: "txqueue", "Didn't insert transaction because gas price was too low: {:?} ({:?} stays in the queue)", order.hash, old.hash);
 			// Put back old transaction since it has greater priority (higher gas_price)
 			set.insert(address, nonce, old);
 			// and remove new one
 			by_hash.remove(&order.hash).expect("The hash has been just inserted and no other line is altering `by_hash`.");
 			false
 		} else {
+			trace!(target: "txqueue", "Replaced transaction: {:?} with transaction with higher gas price: {:?}", old.hash, order.hash);
 			// Make sure we remove old transaction entirely
 			by_hash.remove(&old.hash).expect("The hash is coming from `future` so it has to be in `by_hash`.");
 			true
@@ -982,13 +1070,18 @@ mod test {
 		assert_eq!(TransactionOrigin::External.cmp(&TransactionOrigin::RetractedBlock), Ordering::Greater);
 	}

+	fn transaction_order(tx: &VerifiedTransaction, nonce: U256) -> TransactionOrder {
+		TransactionOrder::for_transaction(tx, nonce, 0.into(), PrioritizationStrategy::GasPriceOnly)
+	}
+
 	#[test]
 	fn should_create_transaction_set() {
 		// given
 		let mut set = TransactionSet {
 			by_priority: BTreeSet::new(),
 			by_address: Table::new(),
-			limit: 1
+			limit: 1,
+			gas_limit: !U256::zero(),
 		};
 		let (tx1, tx2) = new_txs(U256::from(1));
 		let tx1 = VerifiedTransaction::new(tx1, TransactionOrigin::External).unwrap();
@@ -1002,9 +1095,9 @@ mod test {
 			x
 		};
 		// Insert both transactions
-		let order1 = TransactionOrder::for_transaction(&tx1, U256::zero());
+		let order1 = transaction_order(&tx1, U256::zero());
 		set.insert(tx1.sender(), tx1.nonce(), order1.clone());
-		let order2 = TransactionOrder::for_transaction(&tx2, U256::zero());
+		let order2 = transaction_order(&tx2, U256::zero());
 		set.insert(tx2.sender(), tx2.nonce(), order2.clone());
 		assert_eq!(set.by_priority.len(), 2);
 		assert_eq!(set.by_address.len(), 2);
@@ -1027,7 +1120,8 @@ mod test {
 		let mut set = TransactionSet {
 			by_priority: BTreeSet::new(),
 			by_address: Table::new(),
-			limit: 1
+			limit: 1,
+			gas_limit: !U256::zero(),
 		};
 		// Create two transactions with same nonce
 		// (same hash)
@@ -1043,12 +1137,12 @@ mod test {
 			x
 		};
 		// Insert both transactions
-		let order1 = TransactionOrder::for_transaction(&tx1, U256::zero());
+		let order1 = transaction_order(&tx1, U256::zero());
 		set.insert(tx1.sender(), tx1.nonce(), order1.clone());
 		assert_eq!(set.by_priority.len(), 1);
 		assert_eq!(set.by_address.len(), 1);
 		// Two different orders (imagine nonce changed in the meantime)
-		let order2 = TransactionOrder::for_transaction(&tx2, U256::one());
+		let order2 = transaction_order(&tx2, U256::one());
 		set.insert(tx2.sender(), tx2.nonce(), order2.clone());
 		assert_eq!(set.by_priority.len(), 1);
 		assert_eq!(set.by_address.len(), 1);
@@ -1063,7 +1157,7 @@ mod test {
 	#[test]
 	fn should_handle_same_transaction_imported_twice_with_different_state_nonces() {
 		// given
-		let mut txq = TransactionQueue::new();
+		let mut txq = TransactionQueue::default();
 		let (tx, tx2) = new_similar_txs();
 		let prev_nonce = |a: &Address| AccountDetails{ nonce: default_nonce(a).nonce - U256::one(), balance:
 			!U256::zero() };
@@ -1088,7 +1182,7 @@ mod test {
 	#[test]
 	fn should_move_all_transactions_from_future() {
 		// given
-		let mut txq = TransactionQueue::new();
+		let mut txq = TransactionQueue::default();
 		let (tx, tx2) = new_txs_with_gas_price_diff(1.into(), 1.into());
 		let prev_nonce = |a: &Address| AccountDetails{ nonce: default_nonce(a).nonce - U256::one(), balance:
 			!U256::zero() };
@@ -1114,7 +1208,7 @@ mod test {
 	#[test]
 	fn should_import_tx() {
 		// given
-		let mut txq = TransactionQueue::new();
+		let mut txq = TransactionQueue::default();
 		let tx = new_tx();

 		// when
@@ -1129,7 +1223,7 @@ mod test {
 	#[test]
 	fn should_order_by_gas() {
 		// given
-		let mut txq = TransactionQueue::new();
+		let mut txq = TransactionQueue::new(PrioritizationStrategy::GasAndGasPrice);
 		let tx1 = new_tx_with_gas(50000.into(), 40.into());
 		let tx2 = new_tx_with_gas(40000.into(), 30.into());
 		let tx3 = new_tx_with_gas(30000.into(), 10.into());
@@ -1159,10 +1253,45 @@ mod test {
 		assert_eq!(txq.top_transactions()[2].gas_price, 20.into());
 	}

+	#[test]
+	fn should_order_by_gas_factor() {
+		// given
+		let mut txq = TransactionQueue::new(PrioritizationStrategy::GasFactorAndGasPrice);
+
+		let tx1 = new_tx_with_gas(150_000.into(), 40.into());
+		let tx2 = new_tx_with_gas(40_000.into(), 16.into());
+		let tx3 = new_tx_with_gas(30_000.into(), 15.into());
+		let tx4 = new_tx_with_gas(150_000.into(), 62.into());
+		txq.set_minimal_gas_price(15.into());
+
+		// when
+		let res1 = txq.add(tx1, &default_nonce, TransactionOrigin::External);
+		let res2 = txq.add(tx2, &default_nonce, TransactionOrigin::External);
+		let res3 = txq.add(tx3, &default_nonce, TransactionOrigin::External);
+		let res4 = txq.add(tx4, &default_nonce, TransactionOrigin::External);
+
+		// then
+		assert_eq!(res1.unwrap(), TransactionImportResult::Current);
+		assert_eq!(res2.unwrap(), TransactionImportResult::Current);
+		assert_eq!(res3.unwrap(), TransactionImportResult::Current);
+		assert_eq!(res4.unwrap(), TransactionImportResult::Current);
+		let stats = txq.status();
+		assert_eq!(stats.pending, 4);
+		println!("{:?}", txq.top_transactions());
+		assert_eq!(txq.top_transactions()[0].gas, 30_000.into());
+		assert_eq!(txq.top_transactions()[1].gas, 150_000.into());
+		assert_eq!(txq.top_transactions()[2].gas, 40_000.into());
+		assert_eq!(txq.top_transactions()[3].gas, 150_000.into());
+		assert_eq!(txq.top_transactions()[0].gas_price, 15.into());
+		assert_eq!(txq.top_transactions()[1].gas_price, 62.into());
+		assert_eq!(txq.top_transactions()[2].gas_price, 16.into());
+		assert_eq!(txq.top_transactions()[3].gas_price, 40.into());
+	}
+
 	#[test]
 	fn gas_limit_should_never_overflow() {
 		// given
-		let mut txq = TransactionQueue::new();
+		let mut txq = TransactionQueue::default();
 		txq.set_gas_limit(U256::zero());
 		assert_eq!(txq.gas_limit, U256::zero());

@@ -1176,7 +1305,7 @@ mod test {
 	#[test]
 	fn should_not_import_transaction_above_gas_limit() {
 		// given
-		let mut txq = TransactionQueue::new();
+		let mut txq = TransactionQueue::default();
 		let tx = new_tx();
 		let gas = tx.gas;
 		let limit = gas / U256::from(2);
@@ -1198,7 +1327,7 @@ mod test {
 	#[test]
 	fn should_drop_transactions_from_senders_without_balance() {
 		// given
-		let mut txq = TransactionQueue::new();
+		let mut txq = TransactionQueue::default();
 		let tx = new_tx();
 		let account = |a: &Address| AccountDetails {
 			nonce: default_nonce(a).nonce,
@@ -1221,7 +1350,7 @@ mod test {
 	#[test]
 	fn should_not_import_transaction_below_min_gas_price_threshold_if_external() {
 		// given
-		let mut txq = TransactionQueue::new();
+		let mut txq = TransactionQueue::default();
 		let tx = new_tx();
 		txq.set_minimal_gas_price(tx.gas_price + U256::one());

@@ -1241,7 +1370,7 @@ mod test {
 	#[test]
 	fn should_import_transaction_below_min_gas_price_threshold_if_local() {
 		// given
-		let mut txq = TransactionQueue::new();
+		let mut txq = TransactionQueue::default();
 		let tx = new_tx();
 		txq.set_minimal_gas_price(tx.gas_price + U256::one());

@@ -1258,7 +1387,7 @@ mod test {
 	#[test]
 	fn should_reject_incorrectly_signed_transaction() {
 		// given
-		let mut txq = TransactionQueue::new();
+		let mut txq = TransactionQueue::default();
 		let tx = new_unsigned_tx(U256::from(123));
 		let stx = {
 			let mut s = RlpStream::new_list(9);
@@ -1283,7 +1412,7 @@ mod test {
 	#[test]
 	fn should_import_txs_from_same_sender() {
 		// given
-		let mut txq = TransactionQueue::new();
+		let mut txq = TransactionQueue::default();

 		let (tx, tx2) = new_txs(U256::from(1));

@@ -1301,7 +1430,7 @@ mod test {
 	#[test]
 	fn should_prioritize_local_transactions_within_same_nonce_height() {
 		// given
-		let mut txq = TransactionQueue::new();
+		let mut txq = TransactionQueue::default();
 		let tx = new_tx();
 		// the second one has same nonce but higher `gas_price`
 		let (_, tx2) = new_similar_txs();
@@ -1322,7 +1451,7 @@ mod test {
 	#[test]
 	fn should_prioritize_reimported_transactions_within_same_nonce_height() {
 		// given
-		let mut txq = TransactionQueue::new();
+		let mut txq = TransactionQueue::default();
 		let tx = new_tx();
 		// the second one has same nonce but higher `gas_price`
 		let (_, tx2) = new_similar_txs();
@@ -1343,7 +1472,7 @@ mod test {
 	#[test]
 	fn should_not_prioritize_local_transactions_with_different_nonce_height() {
 		// given
-		let mut txq = TransactionQueue::new();
+		let mut txq = TransactionQueue::default();
 		let (tx, tx2) = new_txs(U256::from(1));

 		// when
@@ -1357,10 +1486,40 @@ mod test {
 		assert_eq!(top.len(), 2);
 	}

+	#[test]
+	fn should_penalize_transactions_from_sender_in_future() {
+		// given
+		let prev_nonce = |a: &Address| AccountDetails{ nonce: default_nonce(a).nonce - U256::one(), balance: !U256::zero() };
+		let mut txq = TransactionQueue::default();
+		// txa, txb - slightly bigger gas price to have consistent ordering
+		let (txa, txb) = new_txs(U256::from(1));
+		let (tx1, tx2) = new_txs_with_higher_gas_price(U256::from(3));
+
+		// insert everything
+		txq.add(txa.clone(), &prev_nonce, TransactionOrigin::External).unwrap();
+		txq.add(txb.clone(), &prev_nonce, TransactionOrigin::External).unwrap();
+		txq.add(tx1.clone(), &prev_nonce, TransactionOrigin::External).unwrap();
+		txq.add(tx2.clone(), &prev_nonce, TransactionOrigin::External).unwrap();
+
+		assert_eq!(txq.status().future, 4);
+
+		// when
+		txq.penalize(&tx1.hash());
+
+		// then
+		let top = txq.future_transactions();
+		assert_eq!(top[0], txa);
+		assert_eq!(top[1], txb);
+		assert_eq!(top[2], tx1);
+		assert_eq!(top[3], tx2);
+		assert_eq!(top.len(), 4);
+	}
+
+
 	#[test]
 	fn should_penalize_transactions_from_sender() {
 		// given
-		let mut txq = TransactionQueue::new();
+		let mut txq = TransactionQueue::default();
 		// txa, txb - slightly bigger gas price to have consistent ordering
 		let (txa, txb) = new_txs(U256::from(1));
 		let (tx1, tx2) = new_txs_with_higher_gas_price(U256::from(3));
@@ -1393,7 +1552,7 @@ mod test {
 	#[test]
 	fn should_return_pending_hashes() {
 			// given
-		let mut txq = TransactionQueue::new();
+		let mut txq = TransactionQueue::default();

 		let (tx, tx2) = new_txs(U256::from(1));

@@ -1411,7 +1570,7 @@ mod test {
 	#[test]
 	fn should_put_transaction_to_futures_if_gap_detected() {
 		// given
-		let mut txq = TransactionQueue::new();
+		let mut txq = TransactionQueue::default();

 		let (tx, tx2) = new_txs(U256::from(2));

@@ -1437,7 +1596,7 @@ mod test {
 			!U256::zero() };
 		let next2_nonce = default_nonce_val() + U256::from(3);

-		let mut txq = TransactionQueue::new();
+		let mut txq = TransactionQueue::default();

 		let (tx, tx2) = new_txs(U256::from(1));
 		txq.add(tx.clone(), &prev_nonce, TransactionOrigin::External).unwrap();
@@ -1456,7 +1615,7 @@ mod test {
 	#[test]
 	fn should_move_transactions_if_gap_filled() {
 		// given
-		let mut txq = TransactionQueue::new();
+		let mut txq = TransactionQueue::default();
 		let kp = KeyPair::create().unwrap();
 		let secret = kp.secret();
 		let tx = new_unsigned_tx(U256::from(123)).sign(secret);
@@ -1480,7 +1639,7 @@ mod test {
 	#[test]
 	fn should_remove_transaction() {
 		// given
-		let mut txq2 = TransactionQueue::new();
+		let mut txq2 = TransactionQueue::default();
 		let (tx, tx2) = new_txs(U256::from(3));
 		txq2.add(tx.clone(), &default_nonce, TransactionOrigin::External).unwrap();
 		txq2.add(tx2.clone(), &default_nonce, TransactionOrigin::External).unwrap();
@@ -1501,7 +1660,7 @@ mod test {
 	#[test]
 	fn should_move_transactions_to_future_if_gap_introduced() {
 		// given
-		let mut txq = TransactionQueue::new();
+		let mut txq = TransactionQueue::default();
 		let (tx, tx2) = new_txs(U256::from(1));
 		let tx3 = new_tx();
 		txq.add(tx2.clone(), &default_nonce, TransactionOrigin::External).unwrap();
@@ -1522,7 +1681,7 @@ mod test {
 	#[test]
 	fn should_clear_queue() {
 		// given
-		let mut txq = TransactionQueue::new();
+		let mut txq = TransactionQueue::default();
 		let (tx, tx2) = new_txs(U256::one());

 		// add
@@ -1542,7 +1701,7 @@ mod test {
 	#[test]
 	fn should_drop_old_transactions_when_hitting_the_limit() {
 		// given
-		let mut txq = TransactionQueue::with_limits(1, !U256::zero());
+		let mut txq = TransactionQueue::with_limits(PrioritizationStrategy::GasPriceOnly, 1, !U256::zero(), !U256::zero());
 		let (tx, tx2) = new_txs(U256::one());
 		let sender = tx.sender().unwrap();
 		let nonce = tx.nonce;
@@ -1564,7 +1723,7 @@ mod test {
 	#[test]
 	fn should_return_correct_nonces_when_dropped_because_of_limit() {
 		// given
-		let mut txq = TransactionQueue::with_limits(2, !U256::zero());
+		let mut txq = TransactionQueue::with_limits(PrioritizationStrategy::GasPriceOnly, 2, !U256::zero(), !U256::zero());
 		let tx = new_tx();
 		let (tx1, tx2) = new_txs(U256::one());
 		let sender = tx1.sender().unwrap();
@@ -1585,7 +1744,7 @@ mod test {

 	#[test]
 	fn should_limit_future_transactions() {
-		let mut txq = TransactionQueue::with_limits(1, !U256::zero());
+		let mut txq = TransactionQueue::with_limits(PrioritizationStrategy::GasPriceOnly, 1, !U256::zero(), !U256::zero());
 		txq.current.set_limit(10);
 		let (tx1, tx2) = new_txs_with_gas_price_diff(U256::from(4), U256::from(1));
 		let (tx3, tx4) = new_txs_with_gas_price_diff(U256::from(4), U256::from(2));
@@ -1602,9 +1761,37 @@ mod test {
 		assert_eq!(txq.status().future, 1);
 	}

+	#[test]
+	fn should_limit_by_gas() {
+		let mut txq = TransactionQueue::with_limits(PrioritizationStrategy::GasPriceOnly, 100, default_gas_val() * U256::from(2), !U256::zero());
+		let (tx1, tx2) = new_txs_with_gas_price_diff(U256::from(1), U256::from(1));
+		let (tx3, tx4) = new_txs_with_gas_price_diff(U256::from(1), U256::from(2));
+		txq.add(tx1.clone(), &default_nonce, TransactionOrigin::External).ok();
+		txq.add(tx2.clone(), &default_nonce, TransactionOrigin::External).ok();
+		txq.add(tx3.clone(), &default_nonce, TransactionOrigin::External).ok();
+		txq.add(tx4.clone(), &default_nonce, TransactionOrigin::External).ok();
+		assert_eq!(txq.status().pending, 2);
+	}
+
+	#[test]
+	fn should_keep_own_transactions_above_gas_limit() {
+		let mut txq = TransactionQueue::with_limits(PrioritizationStrategy::GasPriceOnly, 100, default_gas_val() * U256::from(2), !U256::zero());
+		let (tx1, tx2) = new_txs_with_gas_price_diff(U256::from(1), U256::from(1));
+		let (tx3, tx4) = new_txs_with_gas_price_diff(U256::from(1), U256::from(2));
+		let (tx5, tx6) = new_txs_with_gas_price_diff(U256::from(1), U256::from(2));
+		txq.add(tx1.clone(), &default_nonce, TransactionOrigin::Local).unwrap();
+		txq.add(tx2.clone(), &default_nonce, TransactionOrigin::Local).unwrap();
+		txq.add(tx5.clone(), &default_nonce, TransactionOrigin::External).unwrap();
+		// Not accepted because of limit
+		txq.add(tx6.clone(), &default_nonce, TransactionOrigin::External).unwrap_err();
+		txq.add(tx3.clone(), &default_nonce, TransactionOrigin::Local).unwrap();
+		txq.add(tx4.clone(), &default_nonce, TransactionOrigin::Local).unwrap();
+		assert_eq!(txq.status().pending, 4);
+	}
+
 	#[test]
 	fn should_drop_transactions_with_old_nonces() {
-		let mut txq = TransactionQueue::new();
+		let mut txq = TransactionQueue::default();
 		let tx = new_tx();
 		let last_nonce = tx.nonce + U256::one();
 		let fetch_last_nonce = |_a: &Address| AccountDetails{ nonce: last_nonce, balance: !U256::zero() };
@@ -1624,7 +1811,7 @@ mod test {
 		// given
 		let nonce = |a: &Address| AccountDetails { nonce: default_nonce(a).nonce + U256::one(),
 			balance: !U256::zero() };
-		let mut txq = TransactionQueue::new();
+		let mut txq = TransactionQueue::default();
 		let (_tx1, tx2) = new_txs(U256::from(1));
 		txq.add(tx2.clone(), &default_nonce, TransactionOrigin::External).unwrap();
 		assert_eq!(txq.status().future, 1);
@@ -1643,7 +1830,7 @@ mod test {
 	#[test]
 	fn should_accept_same_transaction_twice_if_removed() {
 		// given
-		let mut txq = TransactionQueue::new();
+		let mut txq = TransactionQueue::default();
 		let (tx1, tx2) = new_txs(U256::from(1));
 		txq.add(tx1.clone(), &default_nonce, TransactionOrigin::External).unwrap();
 		txq.add(tx2.clone(), &default_nonce, TransactionOrigin::External).unwrap();
@@ -1664,7 +1851,7 @@ mod test {
 	#[test]
 	fn should_not_move_to_future_if_state_nonce_is_higher() {
 		// given
-		let mut txq = TransactionQueue::new();
+		let mut txq = TransactionQueue::default();
 		let (tx, tx2) = new_txs(U256::from(1));
 		let tx3 = new_tx();
 		txq.add(tx2.clone(), &default_nonce, TransactionOrigin::External).unwrap();
@@ -1687,7 +1874,7 @@ mod test {
 	fn should_replace_same_transaction_when_has_higher_fee() {
 		init_log();
 		// given
-		let mut txq = TransactionQueue::new();
+		let mut txq = TransactionQueue::default();
 		let keypair = KeyPair::create().unwrap();
 		let tx = new_unsigned_tx(U256::from(123)).sign(keypair.secret());
 		let tx2 = {
@@ -1710,7 +1897,7 @@ mod test {
 	#[test]
 	fn should_replace_same_transaction_when_importing_to_futures() {
 		// given
-		let mut txq = TransactionQueue::new();
+		let mut txq = TransactionQueue::default();
 		let keypair = KeyPair::create().unwrap();
 		let tx0 = new_unsigned_tx(U256::from(123)).sign(keypair.secret());
 		let tx1 = {
@@ -1744,7 +1931,7 @@ mod test {
 			!U256::zero() };
 		let next_nonce = |a: &Address| AccountDetails{ nonce: default_nonce(a).nonce + U256::one(), balance:
 			!U256::zero() };
-		let mut txq = TransactionQueue::new();
+		let mut txq = TransactionQueue::default();
 		let (tx1, tx2) = new_txs(U256::one());
 		txq.add(tx1.clone(), &previous_nonce, TransactionOrigin::External).unwrap();
 		txq.add(tx2, &previous_nonce, TransactionOrigin::External).unwrap();
@@ -1762,7 +1949,7 @@ mod test {
 	#[test]
 	fn should_return_none_when_transaction_from_given_address_does_not_exist() {
 		// given
-		let txq = TransactionQueue::new();
+		let txq = TransactionQueue::default();

 		// then
 		assert_eq!(txq.last_nonce(&Address::default()), None);
@@ -1771,7 +1958,7 @@ mod test {
 	#[test]
 	fn should_return_correct_nonce_when_transactions_from_given_address_exist() {
 		// given
-		let mut txq = TransactionQueue::new();
+		let mut txq = TransactionQueue::default();
 		let tx = new_tx();
 		let from = tx.sender().unwrap();
 		let nonce = tx.nonce;
@@ -1787,7 +1974,7 @@ mod test {
 	#[test]
 	fn should_remove_old_transaction_even_if_newer_transaction_was_not_known() {
 		// given
-		let mut txq = TransactionQueue::new();
+		let mut txq = TransactionQueue::default();
 		let (tx1, tx2) = new_txs(U256::one());
 		let (nonce1, nonce2) = (tx1.nonce, tx2.nonce);
 		let details1 = |_a: &Address| AccountDetails { nonce: nonce1, balance: !U256::zero() };
@@ -1805,7 +1992,7 @@ mod test {
 	#[test]
 	fn should_return_valid_last_nonce_after_remove_all() {
 		// given
-		let mut txq = TransactionQueue::new();
+		let mut txq = TransactionQueue::default();
 		let (tx1, tx2) = new_txs(U256::from(4));
 		let sender = tx1.sender().unwrap();
 		let (nonce1, nonce2) = (tx1.nonce, tx2.nonce);
@@ -1829,7 +2016,7 @@ mod test {
 	#[test]
 	fn should_return_true_if_there_is_local_transaction_pending() {
 		// given
-		let mut txq = TransactionQueue::new();
+		let mut txq = TransactionQueue::default();
 		let (tx1, tx2) = new_txs(U256::from(1));
 		assert_eq!(txq.has_local_pending_transactions(), false);

@@ -1845,7 +2032,7 @@ mod test {
 	#[test]
 	fn should_keep_right_order_in_future() {
 		// given
-		let mut txq = TransactionQueue::with_limits(1, !U256::zero());
+		let mut txq = TransactionQueue::with_limits(PrioritizationStrategy::GasPriceOnly, 1, !U256::zero(), !U256::zero());
 		let (tx1, tx2) = new_txs(U256::from(1));
 		let prev_nonce = |a: &Address| AccountDetails { nonce: default_nonce(a).nonce - U256::one(), balance:
 			default_nonce(a).balance };
@@ -1862,7 +2049,7 @@ mod test {
 	#[test]
 	fn should_return_correct_last_nonce() {
 		// given
-		let mut txq = TransactionQueue::new();
+		let mut txq = TransactionQueue::default();
 		let (tx1, tx2, tx2_2, tx3) = {
 			let keypair = KeyPair::create().unwrap();
 			let secret = &keypair.secret();
--- a/ethcore/src/state.rs
+++ b/ethcore/src/state.rs
@@ -15,7 +15,7 @@
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.

 use std::cell::{RefCell, RefMut};
-
+use std::collections::hash_map::Entry;
 use common::*;
 use engines::Engine;
 use executive::{Executive, TransactOptions};
@@ -38,42 +38,93 @@ pub struct ApplyOutcome {
 /// Result type for the execution ("application") of a transaction.
 pub type ApplyResult = Result<ApplyOutcome, Error>;

-#[derive(Debug)]
-enum AccountEntry {
-	/// Contains account data.
-	Cached(Account),
-	/// Account has been deleted.
-	Killed,
-	/// Account does not exist.
-	Missing,
+#[derive(Eq, PartialEq, Clone, Copy, Debug)]
+/// Account modification state. Used to check if the account was
+/// Modified in between commits and overall.
+enum AccountState {
+	/// Account was loaded from disk and never modified in this state object.
+	CleanFresh,
+	/// Account was loaded from the global cache and never modified.
+	CleanCached,
+	/// Account has been modified and is not committed to the trie yet.
+	/// This is set if any of the account data is changed, including
+	/// storage and code.
+	Dirty,
+	/// Account was modified and committed to the trie.
+	Committed,
 }

+#[derive(Debug)]
+/// In-memory copy of the account data. Holds the optional account
+/// and the modification status.
+/// Account entry can contain existing (`Some`) or non-existing
+/// account (`None`)
+struct AccountEntry {
+	account: Option<Account>,
+	state: AccountState,
+}
+
+// Account cache item. Contains account data and
+// modification state
 impl AccountEntry {
 	fn is_dirty(&self) -> bool {
-		match *self {
-			AccountEntry::Cached(ref a) => a.is_dirty(),
-			AccountEntry::Killed => true,
-			AccountEntry::Missing => false,
-		}
+		self.state == AccountState::Dirty
 	}

-	/// Clone dirty data into new `AccountEntry`.
+	/// Clone dirty data into new `AccountEntry`. This includes
+	/// basic account data and modified storage keys.
 	/// Returns None if clean.
-	fn clone_dirty(&self) -> Option<AccountEntry> {
-		match *self {
-			AccountEntry::Cached(ref acc) if acc.is_dirty() => Some(AccountEntry::Cached(acc.clone_dirty())),
-			AccountEntry::Killed => Some(AccountEntry::Killed),
-			_ => None,
+	fn clone_if_dirty(&self) -> Option<AccountEntry> {
+		match self.is_dirty() {
+			true => Some(self.clone_dirty()),
+			false => None,
 		}
 	}

-	/// Clone account entry data that needs to be saved in the snapshot.
-	/// This includes basic account information and all locally cached storage keys
-	fn clone_for_snapshot(&self) -> AccountEntry {
-		match *self {
-			AccountEntry::Cached(ref acc) => AccountEntry::Cached(acc.clone_all()),
-			AccountEntry::Killed => AccountEntry::Killed,
-			AccountEntry::Missing => AccountEntry::Missing,
+	/// Clone dirty data into new `AccountEntry`. This includes
+	/// basic account data and modified storage keys.
+	fn clone_dirty(&self) -> AccountEntry {
+		AccountEntry {
+			account: self.account.as_ref().map(Account::clone_dirty),
+			state: self.state,
+		}
+	}
+
+	// Create a new account entry and mark it as dirty.
+	fn new_dirty(account: Option<Account>) -> AccountEntry {
+		AccountEntry {
+			account: account,
+			state: AccountState::Dirty,
+		}
+	}
+
+	// Create a new account entry and mark it as clean.
+	fn new_clean(account: Option<Account>) -> AccountEntry {
+		AccountEntry {
+			account: account,
+			state: AccountState::CleanFresh,
+		}
+	}
+
+	// Create a new account entry and mark it as clean and cached.
+	fn new_clean_cached(account: Option<Account>) -> AccountEntry {
+		AccountEntry {
+			account: account,
+			state: AccountState::CleanCached,
+		}
+	}
+
+	// Replace data with another entry but preserve storage cache.
+	fn overwrite_with(&mut self, other: AccountEntry) {
+		self.state = other.state;
+		match other.account {
+			Some(acc) => match self.account {
+				Some(ref mut ours) => {
+					ours.overwrite_with(acc);
+				},
+				None => {},
+			},
+			None => self.account = None,
 		}
 	}
 }
@@ -86,6 +137,9 @@ impl AccountEntry {
 /// locally from previous commits. Global cache reflects the database
 /// state and never contains any changes.
 ///
+/// Cache items contains account data, or the flag that account does not exist
+/// and modification state (see `AccountState`)
+///
 /// Account data can be in the following cache states:
 /// * In global but not local - something that was queried from the database,
 /// but never modified
@@ -99,12 +153,32 @@ impl AccountEntry {
 /// then global state cache. If data is not found in any of the caches
 /// it is loaded from the DB to the local cache.
 ///
+/// **** IMPORTANT *************************************************************
+/// All the modifications to the account data must set the `Dirty` state in the
+/// `AccountEntry`. This is done in `require` and `require_or_from`. So just
+/// use that.
+/// ****************************************************************************
+///
 /// Upon destruction all the local cache data merged into the global cache.
 /// The merge might be rejected if current state is non-canonical.
+///
+/// State snapshotting.
+///
+/// A new snapshot can be created with `snapshot()`. Snapshots can be
+/// created in a hierarchy.
+/// When a snapshot is active all changes are applied directly into
+/// `cache` and the original value is copied into an active snapshot.
+/// Reverting a snapshot with `revert_to_snapshot` involves copying
+/// original values from the latest snapshot back into `cache`. The code
+/// takes care not to overwrite cached storage while doing that.
+/// Snapshot can be discateded with `discard_snapshot`. All of the orignal
+/// backed-up values are moved into a parent snapshot (if any).
+///
 pub struct State {
 	db: StateDB,
 	root: H256,
 	cache: RefCell<HashMap<Address, AccountEntry>>,
+	// The original account is preserved in
 	snapshots: RefCell<Vec<HashMap<Address, Option<AccountEntry>>>>,
 	account_start_nonce: U256,
 	trie_factory: TrieFactory,
@@ -158,35 +232,48 @@ impl State {
 		Ok(state)
 	}

-	/// Create a recoverable snaphot of this state
+	/// Create a recoverable snaphot of this state.
 	pub fn snapshot(&mut self) {
-		self.snapshots.borrow_mut().push(HashMap::new());
+		self.snapshots.get_mut().push(HashMap::new());
 	}

-	/// Merge last snapshot with previous
-	pub fn clear_snapshot(&mut self) {
+	/// Merge last snapshot with previous.
+	pub fn discard_snapshot(&mut self) {
 		// merge with previous snapshot
-		let last = self.snapshots.borrow_mut().pop();
+		let last = self.snapshots.get_mut().pop();
 		if let Some(mut snapshot) = last {
-			if let Some(ref mut prev) = self.snapshots.borrow_mut().last_mut() {
-				for (k, v) in snapshot.drain() {
-					prev.entry(k).or_insert(v);
+			if let Some(ref mut prev) = self.snapshots.get_mut().last_mut() {
+				if prev.is_empty() {
+					**prev = snapshot;
+				} else {
+					for (k, v) in snapshot.drain() {
+						prev.entry(k).or_insert(v);
+					}
 				}
 			}
 		}
 	}

-	/// Revert to snapshot
-	pub fn revert_snapshot(&mut self) {
-		if let Some(mut snapshot) = self.snapshots.borrow_mut().pop() {
+	/// Revert to the last snapshot and discard it.
+	pub fn revert_to_snapshot(&mut self) {
+		if let Some(mut snapshot) = self.snapshots.get_mut().pop() {
 			for (k, v) in snapshot.drain() {
 				match v {
 					Some(v) => {
-						self.cache.borrow_mut().insert(k, v);
+						match self.cache.get_mut().entry(k) {
+							Entry::Occupied(mut e) => {
+								// Merge snapshotted changes back into the main account
+								// storage preserving the cache.
+								e.get_mut().overwrite_with(v);
+							},
+							Entry::Vacant(e) => {
+								e.insert(v);
+							}
+						}
 					},
 					None => {
-						match self.cache.borrow_mut().entry(k) {
-							::std::collections::hash_map::Entry::Occupied(e) => {
+						match self.cache.get_mut().entry(k) {
+							Entry::Occupied(e) => {
 								if e.get().is_dirty() {
 									e.remove();
 								}
@@ -200,10 +287,17 @@ impl State {
 	}

 	fn insert_cache(&self, address: &Address, account: AccountEntry) {
-		if let Some(ref mut snapshot) = self.snapshots.borrow_mut().last_mut() {
-			if !snapshot.contains_key(address) {
-				snapshot.insert(address.clone(), self.cache.borrow_mut().insert(address.clone(), account));
-				return;
+		// Dirty account which is not in the cache means this is a new account.
+		// It goes directly into the snapshot as there's nothing to rever to.
+		//
+		// In all other cases account is read as clean first, and after that made
+		// dirty in and added to the snapshot with `note_cache`.
+		if account.is_dirty() {
+			if let Some(ref mut snapshot) = self.snapshots.borrow_mut().last_mut() {
+				if !snapshot.contains_key(address) {
+					snapshot.insert(address.clone(), self.cache.borrow_mut().insert(address.clone(), account));
+					return;
+				}
 			}
 		}
 		self.cache.borrow_mut().insert(address.clone(), account);
@@ -212,14 +306,14 @@ impl State {
 	fn note_cache(&self, address: &Address) {
 		if let Some(ref mut snapshot) = self.snapshots.borrow_mut().last_mut() {
 			if !snapshot.contains_key(address) {
-				snapshot.insert(address.clone(), self.cache.borrow().get(address).map(AccountEntry::clone_for_snapshot));
+				snapshot.insert(address.clone(), self.cache.borrow().get(address).map(AccountEntry::clone_dirty));
 			}
 		}
 	}

 	/// Destroy the current object and return root and database.
 	pub fn drop(mut self) -> (H256, StateDB) {
-		self.commit_cache();
+		self.update_shared_cache();
 		(self.root, self.db)
 	}

@@ -231,12 +325,12 @@ impl State {
 	/// Create a new contract at address `contract`. If there is already an account at the address
 	/// it will have its code reset, ready for `init_code()`.
 	pub fn new_contract(&mut self, contract: &Address, balance: U256) {
-		self.insert_cache(contract, AccountEntry::Cached(Account::new_contract(balance, self.account_start_nonce)));
+		self.insert_cache(contract, AccountEntry::new_dirty(Some(Account::new_contract(balance, self.account_start_nonce))));
 	}

 	/// Remove an existing account.
 	pub fn kill_account(&mut self, account: &Address) {
-		self.insert_cache(account, AccountEntry::Killed);
+		self.insert_cache(account, AccountEntry::new_dirty(None));
 	}

 	/// Determine whether an account exists.
@@ -271,8 +365,8 @@ impl State {
 			let local_cache = self.cache.borrow_mut();
 			let mut local_account = None;
 			if let Some(maybe_acc) = local_cache.get(address) {
-				match *maybe_acc {
-					AccountEntry::Cached(ref account) => {
+				match maybe_acc.account {
+					Some(ref account) => {
 						if let Some(value) = account.cached_storage_at(key) {
 							return value;
 						} else {
@@ -288,7 +382,7 @@ impl State {
 				return result;
 			}
 			if let Some(ref mut acc) = local_account {
-				if let AccountEntry::Cached(ref account) = **acc {
+				if let Some(ref account) = acc.account {
 					return account.storage_at(&AccountDB::from_hash(self.db.as_hashdb(), account.address_hash(address)), key)
 				} else {
 					return H256::new()
@@ -303,17 +397,19 @@ impl State {
 			Err(e) => panic!("Potential DB corruption encountered: {}", e),
 		};
 		let r = maybe_acc.as_ref().map_or(H256::new(), |a| a.storage_at(&AccountDB::from_hash(self.db.as_hashdb(), a.address_hash(address)), key));
-		match maybe_acc {
-			Some(account) => self.insert_cache(address, AccountEntry::Cached(account)),
-			None => self.insert_cache(address, AccountEntry::Missing),
-		}
+		self.insert_cache(address, AccountEntry::new_clean(maybe_acc));
 		r
 	}

 	/// Get accounts' code.
-	pub fn code(&self, a: &Address) -> Option<Bytes> {
+	pub fn code(&self, a: &Address) -> Option<Arc<Bytes>> {
 		self.ensure_cached(a, RequireCache::Code,
-			|a| a.as_ref().map_or(None, |a| a.code().map(|x|x.to_vec())))
+			|a| a.as_ref().map_or(None, |a| a.code().clone()))
+	}
+
+	pub fn code_hash(&self, a: &Address) -> H256 {
+		self.ensure_cached(a, RequireCache::None,
+			|a| a.as_ref().map_or(SHA3_EMPTY, |a| a.code_hash()))
 	}

 	/// Get accounts' code size.
@@ -325,13 +421,17 @@ impl State {
 	/// Add `incr` to the balance of account `a`.
 	pub fn add_balance(&mut self, a: &Address, incr: &U256) {
 		trace!(target: "state", "add_balance({}, {}): {}", a, incr, self.balance(a));
-		self.require(a, false).add_balance(incr);
+		if !incr.is_zero() || !self.exists(a) {
+			self.require(a, false).add_balance(incr);
+		}
 	}

 	/// Subtract `decr` from the balance of account `a`.
 	pub fn sub_balance(&mut self, a: &Address, decr: &U256) {
 		trace!(target: "state", "sub_balance({}, {}): {}", a, decr, self.balance(a));
-		self.require(a, false).sub_balance(decr);
+		if !decr.is_zero() || !self.exists(a) {
+			self.require(a, false).sub_balance(decr);
+		}
 	}

 	/// Subtracts `by` from the balance of `from` and adds it to that of `to`.
@@ -347,7 +447,9 @@ impl State {

 	/// Mutate storage of account `a` so that it is `value` for `key`.
 	pub fn set_storage(&mut self, a: &Address, key: H256, value: H256) {
-		self.require(a, false).set_storage(key, value)
+		if self.storage_at(a, &key) != value {
+			self.require(a, false).set_storage(key, value)
+		}
 	}

 	/// Initialise the code of account `a` so that it is `code`.
@@ -387,10 +489,9 @@ impl State {
 		accounts: &mut HashMap<Address, AccountEntry>
 	) -> Result<(), Error> {
 		// first, commit the sub trees.
-		// TODO: is this necessary or can we dispense with the `ref mut a` for just `a`?
-		for (address, ref mut a) in accounts.iter_mut() {
-			match a {
-				&mut&mut AccountEntry::Cached(ref mut account) if account.is_dirty() => {
+		for (address, ref mut a) in accounts.iter_mut().filter(|&(_, ref a)| a.is_dirty()) {
+			match a.account {
+				Some(ref mut account) => {
 					db.note_account_bloom(&address);
 					let mut account_db = AccountDBMut::from_hash(db.as_hashdb_mut(), account.address_hash(address));
 					account.commit_storage(trie_factory, &mut account_db);
@@ -402,17 +503,15 @@ impl State {

 		{
 			let mut trie = trie_factory.from_existing(db.as_hashdb_mut(), root).unwrap();
-			for (address, ref mut a) in accounts.iter_mut() {
-				match **a {
-					AccountEntry::Cached(ref mut account) if account.is_dirty() => {
-						account.set_clean();
+			for (address, ref mut a) in accounts.iter_mut().filter(|&(_, ref a)| a.is_dirty()) {
+				a.state = AccountState::Committed;
+				match a.account {
+					Some(ref mut account) => {
 						try!(trie.insert(address, &account.rlp()));
 					},
-					AccountEntry::Killed => {
+					None => {
 						try!(trie.remove(address));
-						**a = AccountEntry::Missing;
 					},
-					_ => {},
 				}
 			}
 		}
@@ -420,20 +519,12 @@ impl State {
 		Ok(())
 	}

-	fn commit_cache(&mut self) {
+	/// Merge local cache into shared canonical state cache.
+	fn update_shared_cache(&mut self) {
 		let mut addresses = self.cache.borrow_mut();
-		for (address, a) in addresses.drain() {
-			match a {
-				AccountEntry::Cached(account) => {
-					if !account.is_dirty() {
-						self.db.cache_account(address, Some(account));
-					}
-				},
-				AccountEntry::Missing => {
-					self.db.cache_account(address, None);
-				},
-				_ => {},
-			}
+		trace!("Committing cache {:?} entries", addresses.len());
+		for (address, a) in addresses.drain().filter(|&(_, ref a)| a.state == AccountState::Committed || a.state == AccountState::CleanFresh) {
+			self.db.add_to_account_cache(address, a.account, a.state == AccountState::Committed);
 		}
 	}

@@ -455,7 +546,7 @@ impl State {
 		assert!(self.snapshots.borrow().is_empty());
 		for (add, acc) in accounts.drain().into_iter() {
 			self.db.note_account_bloom(&add);
-			self.cache.borrow_mut().insert(add, AccountEntry::Cached(Account::from_pod(acc)));
+			self.cache.borrow_mut().insert(add, AccountEntry::new_dirty(Some(Account::from_pod(acc))));
 		}
 	}

@@ -465,7 +556,7 @@ impl State {
 		// TODO: handle database rather than just the cache.
 		// will need fat db.
 		PodState::from(self.cache.borrow().iter().fold(BTreeMap::new(), |mut m, (add, opt)| {
-			if let AccountEntry::Cached(ref acc) = *opt {
+			if let Some(ref acc) = opt.account {
 				m.insert(add.clone(), PodAccount::from_account(acc));
 			}
 			m
@@ -473,14 +564,14 @@ impl State {
 	}

 	fn query_pod(&mut self, query: &PodState) {
-		for (ref address, ref pod_account) in query.get() {
-			self.ensure_cached(address, RequireCache::Code, |a| {
-				if a.is_some() {
-					for key in pod_account.storage.keys() {
-						self.storage_at(address, key);
-					}
-				}
-			});
+		for (address, pod_account) in query.get().into_iter()
+			.filter(|&(ref a, _)| self.ensure_cached(a, RequireCache::Code, |a| a.is_some()))
+		{
+			// needs to be split into two parts for the refcell code here
+			// to work.
+			for key in pod_account.storage.keys() {
+				self.storage_at(address, key);
+			}
 		}
 	}

@@ -514,7 +605,7 @@ impl State {
 		where F: Fn(Option<&Account>) -> U {
 		// check local cache first
 		if let Some(ref mut maybe_acc) = self.cache.borrow_mut().get_mut(a) {
-			if let AccountEntry::Cached(ref mut account) = **maybe_acc {
+			if let Some(ref mut account) = maybe_acc.account {
 				Self::update_account_cache(require, account, a, self.db.as_hashdb());
 				return f(Some(account));
 			}
@@ -541,10 +632,7 @@ impl State {
 					Self::update_account_cache(require, account, a, self.db.as_hashdb());
 				}
 				let r = f(maybe_acc.as_ref());
-				match maybe_acc {
-					Some(account) => self.insert_cache(a, AccountEntry::Cached(account)),
-					None => self.insert_cache(a, AccountEntry::Missing),
-				}
+				self.insert_cache(a, AccountEntry::new_clean(maybe_acc));
 				r
 			}
 		}
@@ -563,36 +651,38 @@ impl State {
 		let contains_key = self.cache.borrow().contains_key(a);
 		if !contains_key {
 			match self.db.get_cached_account(a) {
-				Some(Some(acc)) => self.insert_cache(a, AccountEntry::Cached(acc)),
-				Some(None) => self.insert_cache(a, AccountEntry::Missing),
+				Some(acc) => self.insert_cache(a, AccountEntry::new_clean_cached(acc)),
 				None => {
 					let maybe_acc = if self.db.check_account_bloom(a) {
 						let db = self.trie_factory.readonly(self.db.as_hashdb(), &self.root).expect(SEC_TRIE_DB_UNWRAP_STR);
 						let maybe_acc = match db.get(a) {
-							Ok(Some(acc)) => AccountEntry::Cached(Account::from_rlp(acc)),
-							Ok(None) => AccountEntry::Missing,
+							Ok(Some(acc)) => AccountEntry::new_clean(Some(Account::from_rlp(acc))),
+							Ok(None) => AccountEntry::new_clean(None),
 							Err(e) => panic!("Potential DB corruption encountered: {}", e),
 						};
 						maybe_acc
 					}
 					else {
-						AccountEntry::Missing
+						AccountEntry::new_clean(None)
 					};
 					self.insert_cache(a, maybe_acc);
 				}
 			}
-		} else {
-			self.note_cache(a);
-		}
-
-		match self.cache.borrow_mut().get_mut(a).unwrap() {
-			&mut AccountEntry::Cached(ref mut acc) => not_default(acc),
-			slot => *slot = AccountEntry::Cached(default()),
+		}
+		self.note_cache(a);
+
+		match &mut self.cache.borrow_mut().get_mut(a).unwrap().account {
+			&mut Some(ref mut acc) => not_default(acc),
+			slot => *slot = Some(default()),
 		}

+		// at this point the account is guaranteed to be in the cache.
 		RefMut::map(self.cache.borrow_mut(), |c| {
-			match c.get_mut(a).unwrap() {
-				&mut AccountEntry::Cached(ref mut account) => {
+			let mut entry = c.get_mut(a).unwrap();
+			// set the dirty flag after changing account data.
+			entry.state = AccountState::Dirty;
+			match entry.account {
+				Some(ref mut account) => {
 					if require_code {
 						let addr_hash = account.address_hash(a);
 						account.cache_code(&AccountDB::from_hash(self.db.as_hashdb(), addr_hash));
@@ -616,7 +706,7 @@ impl Clone for State {
 		let cache = {
 			let mut cache: HashMap<Address, AccountEntry> = HashMap::new();
 			for (key, val) in self.cache.borrow().iter() {
-				if let Some(entry) = val.clone_dirty() {
+				if let Some(entry) = val.clone_if_dirty() {
 					cache.insert(key.clone(), entry);
 				}
 			}
@@ -1517,14 +1607,14 @@ fn code_from_database() {
 		let mut state = get_temp_state_in(temp.as_path());
 		state.require_or_from(&a, false, ||Account::new_contract(42.into(), 0.into()), |_|{});
 		state.init_code(&a, vec![1, 2, 3]);
-		assert_eq!(state.code(&a), Some([1u8, 2, 3].to_vec()));
+		assert_eq!(state.code(&a), Some(Arc::new([1u8, 2, 3].to_vec())));
 		state.commit().unwrap();
-		assert_eq!(state.code(&a), Some([1u8, 2, 3].to_vec()));
+		assert_eq!(state.code(&a), Some(Arc::new([1u8, 2, 3].to_vec())));
 		state.drop()
 	};

 	let state = State::from_existing(db, root, U256::from(0u8), Default::default()).unwrap();
-	assert_eq!(state.code(&a), Some([1u8, 2, 3].to_vec()));
+	assert_eq!(state.code(&a), Some(Arc::new([1u8, 2, 3].to_vec())));
 }

 #[test]
@@ -1672,12 +1762,12 @@ fn snapshot_basic() {
 	state.snapshot();
 	state.add_balance(&a, &U256::from(69u64));
 	assert_eq!(state.balance(&a), U256::from(69u64));
-	state.clear_snapshot();
+	state.discard_snapshot();
 	assert_eq!(state.balance(&a), U256::from(69u64));
 	state.snapshot();
 	state.add_balance(&a, &U256::from(1u64));
 	assert_eq!(state.balance(&a), U256::from(70u64));
-	state.revert_snapshot();
+	state.revert_to_snapshot();
 	assert_eq!(state.balance(&a), U256::from(69u64));
 }

@@ -1690,9 +1780,9 @@ fn snapshot_nested() {
 	state.snapshot();
 	state.add_balance(&a, &U256::from(69u64));
 	assert_eq!(state.balance(&a), U256::from(69u64));
-	state.clear_snapshot();
+	state.discard_snapshot();
 	assert_eq!(state.balance(&a), U256::from(69u64));
-	state.revert_snapshot();
+	state.revert_to_snapshot();
 	assert_eq!(state.balance(&a), U256::from(0));
 }

@@ -1704,4 +1794,20 @@ fn create_empty() {
 	assert_eq!(state.root().hex(), "56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421");
 }

+#[test]
+fn should_not_panic_on_state_diff_with_storage() {
+	let state = get_temp_state();
+	let mut state = state.reference().clone();
+
+	let a: Address = 0xa.into();
+	state.init_code(&a, b"abcdefg".to_vec());
+	state.add_balance(&a, &256.into());
+	state.set_storage(&a, 0xb.into(), 0xc.into());
+
+	let mut new_state = state.clone();
+	new_state.set_storage(&a, 0xb.into(), 0xd.into());
+
+	new_state.diff_from(state);
+}
+
 }
--- a/ethcore/src/state_db.rs
+++ b/ethcore/src/state_db.rs
@@ -14,22 +14,53 @@
 // 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::{VecDeque, HashSet};
 use lru_cache::LruCache;
 use util::journaldb::JournalDB;
 use util::hash::{H256};
 use util::hashdb::HashDB;
-use util::{Arc, Address, DBTransaction, UtilError, Mutex, Hashable, BytesConvertable};
 use account::Account;
+use header::BlockNumber;
+use util::{Arc, Address, Database, DBTransaction, UtilError, Mutex, Hashable, BytesConvertable};
 use bloomfilter::{Bloom, BloomJournal};
-use util::Database;
 use client::DB_COL_ACCOUNT_BLOOM;
 use byteorder::{LittleEndian, ByteOrder};

-const STATE_CACHE_ITEMS: usize = 65536;
+const STATE_CACHE_ITEMS: usize = 256000;
+const STATE_CACHE_BLOCKS: usize = 12;

+/// Shared canonical state cache.
 struct AccountCache {
 	/// DB Account cache. `None` indicates that account is known to be missing.
 	accounts: LruCache<Address, Option<Account>>,
+	/// Accounts changed in recently committed blocks. Ordered by block number.
+	modifications: VecDeque<BlockChanges>,
+}
+
+/// Buffered account cache item.
+struct CacheQueueItem {
+	/// Account address.
+	address: Address,
+	/// Acccount data or `None` if account does not exist.
+	account: Option<Account>,
+	/// Indicates that the account was modified before being
+	/// added to the cache.
+	modified: bool,
+}
+
+#[derive(Debug)]
+/// Accumulates a list of accounts changed in a block.
+struct BlockChanges {
+	/// Block number.
+	number: BlockNumber,
+	/// Block hash.
+	hash: H256,
+	/// Parent block hash.
+	parent: H256,
+	/// A set of modified account addresses.
+	accounts: HashSet<Address>,
+	/// Block is part of the canonical chain.
+	is_canon: bool,
 }

 /// State database abstraction.
@@ -39,11 +70,21 @@ struct AccountCache {
 /// on commit.
 /// For non-canonical clones cache is cleared on commit.
 pub struct StateDB {
+	/// Backing database.
 	db: Box<JournalDB>,
+	/// Shared canonical state cache.
 	account_cache: Arc<Mutex<AccountCache>>,
-	cache_overlay: Vec<(Address, Option<Account>)>,
-	is_canon: bool,
+	/// Local cache buffer.
+	cache_buffer: Vec<CacheQueueItem>,
+	/// Shared account bloom. Does not handle chain reorganizations.
 	account_bloom: Arc<Mutex<Bloom>>,
+	/// Hash of the block on top of which this instance was created or
+	/// `None` if cache is disabled
+	parent_hash: Option<H256>,
+	/// Hash of the committing block or `None` if not committed yet.
+	commit_hash: Option<H256>,
+	/// Number of the committing block or `None` if not committed yet.
+	commit_number: Option<BlockNumber>,
 }

 pub const ACCOUNT_BLOOM_SPACE: usize = 1048576;
@@ -52,6 +93,8 @@ pub const DEFAULT_ACCOUNT_PRESET: usize = 1000000;
 pub const ACCOUNT_BLOOM_HASHCOUNT_KEY: &'static [u8] = b"account_hash_count";

 impl StateDB {
+	/// Loads accounts bloom from the database
+	/// This bloom is used to handle request for the non-existant account fast
 	pub fn load_bloom(db: &Database) -> Bloom {
 		let hash_count_entry = db.get(DB_COL_ACCOUNT_BLOOM, ACCOUNT_BLOOM_HASHCOUNT_KEY)
 			.expect("Low-level database error");
@@ -82,10 +125,15 @@ impl StateDB {
 		let bloom = Self::load_bloom(db.backing());
 		StateDB {
 			db: db,
-			account_cache: Arc::new(Mutex::new(AccountCache { accounts: LruCache::new(STATE_CACHE_ITEMS) })),
-			cache_overlay: Vec::new(),
-			is_canon: false,
+			account_cache: Arc::new(Mutex::new(AccountCache {
+				accounts: LruCache::new(STATE_CACHE_ITEMS),
+				modifications: VecDeque::new(),
+			})),
+			cache_buffer: Vec::new(),
 			account_bloom: Arc::new(Mutex::new(bloom)),
+			parent_hash: None,
+			commit_hash: None,
+			commit_number: None,
 		}
 	}

@@ -124,14 +172,106 @@ impl StateDB {
 		}

 		let records = try!(self.db.commit(batch, now, id, end));
-		if self.is_canon {
-			self.commit_cache();
-		} else {
-			self.clear_cache();
-		}
+		self.commit_hash = Some(id.clone());
+		self.commit_number = Some(now);
 		Ok(records)
 	}

+	/// Apply buffered cache changes and synchronize canonical
+	/// state cache with the best block state.
+	/// This function updates the cache by removing entries that are
+	/// invalidated by chain reorganization. `update_cache` should be
+	/// called after the block has been commited and the blockchain
+	/// route has ben calculated.
+	pub fn sync_cache(&mut self, enacted: &[H256], retracted: &[H256], is_best: bool) {
+		trace!("sync_cache id = (#{:?}, {:?}), parent={:?}, best={}", self.commit_number, self.commit_hash, self.parent_hash, is_best);
+		let mut cache = self.account_cache.lock();
+		let mut cache = &mut *cache;
+
+		// Clean changes from re-enacted and retracted blocks
+		let mut clear = false;
+		for block in enacted.iter().filter(|h| self.commit_hash.as_ref().map_or(true, |p| *h != p)) {
+			clear = clear || {
+				if let Some(ref mut m) = cache.modifications.iter_mut().find(|ref m| &m.hash == block) {
+					trace!("Reverting enacted block {:?}", block);
+					m.is_canon = true;
+					for a in &m.accounts {
+						trace!("Reverting enacted address {:?}", a);
+						cache.accounts.remove(a);
+					}
+					false
+				} else {
+					true
+				}
+			};
+		}
+
+		for block in retracted {
+			clear = clear || {
+				if let Some(ref mut m) = cache.modifications.iter_mut().find(|ref m| &m.hash == block) {
+					trace!("Retracting block {:?}", block);
+					m.is_canon = false;
+					for a in &m.accounts {
+						trace!("Retracted address {:?}", a);
+						cache.accounts.remove(a);
+					}
+					false
+				} else {
+					true
+				}
+			};
+		}
+		if clear {
+			// We don't know anything about the block; clear everything
+			trace!("Wiping cache");
+			cache.accounts.clear();
+			cache.modifications.clear();
+		}
+
+		// Apply cache changes only if committing on top of the latest canonical state
+		// blocks are ordered by number and only one block with a given number is marked as canonical
+		// (contributed to canonical state cache)
+		if let (Some(ref number), Some(ref hash), Some(ref parent)) = (self.commit_number, self.commit_hash, self.parent_hash) {
+			if cache.modifications.len() == STATE_CACHE_BLOCKS {
+				cache.modifications.pop_back();
+			}
+			let mut modifications = HashSet::new();
+			trace!("committing {} cache entries", self.cache_buffer.len());
+			for account in self.cache_buffer.drain(..) {
+				if account.modified {
+					modifications.insert(account.address.clone());
+				}
+				if is_best {
+					if let Some(&mut Some(ref mut existing)) = cache.accounts.get_mut(&account.address) {
+						if let Some(new) = account.account {
+							if account.modified {
+								existing.overwrite_with(new);
+							}
+							continue;
+						}
+					}
+					cache.accounts.insert(account.address, account.account);
+				}
+			}
+
+			// Save modified accounts. These are ordered by the block number.
+			let block_changes = BlockChanges {
+				accounts: modifications,
+				number: *number,
+				hash: hash.clone(),
+				is_canon: is_best,
+				parent: parent.clone(),
+			};
+			let insert_at = cache.modifications.iter().enumerate().find(|&(_, ref m)| m.number < *number).map(|(i, _)| i);
+			trace!("inserting modifications at {:?}", insert_at);
+			if let Some(insert_at) = insert_at {
+				cache.modifications.insert(insert_at, block_changes);
+			} else {
+				cache.modifications.push_back(block_changes);
+			}
+		}
+	}
+
 	/// Returns an interface to HashDB.
 	pub fn as_hashdb(&self) -> &HashDB {
 		self.db.as_hashdb()
@@ -147,20 +287,24 @@ impl StateDB {
 		StateDB {
 			db: self.db.boxed_clone(),
 			account_cache: self.account_cache.clone(),
-			cache_overlay: Vec::new(),
-			is_canon: false,
+			cache_buffer: Vec::new(),
 			account_bloom: self.account_bloom.clone(),
+			parent_hash: None,
+			commit_hash: None,
+			commit_number: None,
 		}
 	}

 	/// Clone the database for a canonical state.
-	pub fn boxed_clone_canon(&self) -> StateDB {
+	pub fn boxed_clone_canon(&self, parent: &H256) -> StateDB {
 		StateDB {
 			db: self.db.boxed_clone(),
 			account_cache: self.account_cache.clone(),
-			cache_overlay: Vec::new(),
-			is_canon: true,
+			cache_buffer: Vec::new(),
 			account_bloom: self.account_bloom.clone(),
+			parent_hash: Some(parent.clone()),
+			commit_hash: None,
+			commit_number: None,
 		}
 	}

@@ -179,53 +323,152 @@ impl StateDB {
 		&*self.db
 	}

-	/// Enqueue cache change.
-	pub fn cache_account(&mut self, addr: Address, data: Option<Account>) {
-		self.cache_overlay.push((addr, data));
+	/// Returns underlying `JournalDB`.
+	pub fn journal_db_mut(&mut self) -> &mut JournalDB {
+		&mut *self.db
 	}

-	/// Apply pending cache changes.
-	fn commit_cache(&mut self) {
-		let mut cache = self.account_cache.lock();
-		for (address, account) in self.cache_overlay.drain(..) {
-			if let Some(&mut Some(ref mut existing)) = cache.accounts.get_mut(&address) {
-				if let Some(new) = account {
-					existing.merge_with(new);
-					continue;
-				}
-			}
-			cache.accounts.insert(address, account);
-		}
-	}
-
-	/// Clear the cache.
-	pub fn clear_cache(&mut self) {
-		self.cache_overlay.clear();
-		let mut cache = self.account_cache.lock();
-		cache.accounts.clear();
+	/// Add pending cache change.
+	/// The change is queued to be applied in `commit`.
+	pub fn add_to_account_cache(&mut self, addr: Address, data: Option<Account>, modified: bool) {
+		self.cache_buffer.push(CacheQueueItem {
+			address: addr,
+			account: data,
+			modified: modified,
+		})
 	}

 	/// Get basic copy of the cached account. Does not include storage.
-	/// Returns 'None' if the state is non-canonical and cache is disabled
-	/// or if the account is not cached.
+	/// Returns 'None' if cache is disabled or if the account is not cached.
 	pub fn get_cached_account(&self, addr: &Address) -> Option<Option<Account>> {
-		if !self.is_canon {
+		let mut cache = self.account_cache.lock();
+		if !Self::is_allowed(addr, &self.parent_hash, &cache.modifications) {
 			return None;
 		}
-		let mut cache = self.account_cache.lock();
 		cache.accounts.get_mut(&addr).map(|a| a.as_ref().map(|a| a.clone_basic()))
 	}

 	/// Get value from a cached account.
-	/// Returns 'None' if the state is non-canonical and cache is disabled
-	/// or if the account is not cached.
+	/// Returns 'None' if cache is disabled or if the account is not cached.
 	pub fn get_cached<F, U>(&self, a: &Address, f: F) -> Option<U>
 		where F: FnOnce(Option<&mut Account>) -> U {
-		if !self.is_canon {
+		let mut cache = self.account_cache.lock();
+		if !Self::is_allowed(a, &self.parent_hash, &cache.modifications) {
 			return None;
 		}
-		let mut cache = self.account_cache.lock();
 		cache.accounts.get_mut(a).map(|c| f(c.as_mut()))
 	}
+
+	/// Check if the account can be returned from cache by matching current block parent hash against canonical
+	/// state and filtering out account modified in later blocks.
+	fn is_allowed(addr: &Address, parent_hash: &Option<H256>, modifications: &VecDeque<BlockChanges>) -> bool {
+		let mut parent = match *parent_hash {
+			None => {
+				trace!("Cache lookup skipped for {:?}: no parent hash", addr);
+				return false;
+			}
+			Some(ref parent) => parent,
+		};
+		if modifications.is_empty() {
+			return true;
+		}
+		// Ignore all accounts modified in later blocks
+		// Modifications contains block ordered by the number
+		// We search for our parent in that list first and then for
+		// all its parent until we hit the canonical block,
+		// checking against all the intermediate modifications.
+		let mut iter = modifications.iter();
+		while let Some(ref m) = iter.next() {
+			if &m.hash == parent {
+				if m.is_canon {
+					return true;
+				}
+				parent = &m.parent;
+			}
+			if m.accounts.contains(addr) {
+				trace!("Cache lookup skipped for {:?}: modified in a later block", addr);
+				return false;
+			}
+		}
+		trace!("Cache lookup skipped for {:?}: parent hash is unknown", addr);
+		return false;
+	}
+}
+
+#[cfg(test)]
+mod tests {
+
+use util::{U256, H256, FixedHash, Address, DBTransaction};
+use tests::helpers::*;
+use account::Account;
+use util::log::init_log;
+
+#[test]
+fn state_db_smoke() {
+	init_log();
+
+	let mut state_db_result = get_temp_state_db();
+	let state_db = state_db_result.take();
+	let root_parent = H256::random();
+	let address = Address::random();
+	let h0 = H256::random();
+	let h1a = H256::random();
+	let h1b = H256::random();
+	let h2a = H256::random();
+	let h2b = H256::random();
+	let h3a = H256::random();
+	let h3b = H256::random();
+	let mut batch = DBTransaction::new(state_db.journal_db().backing());
+
+	// blocks  [ 3a(c) 2a(c) 2b 1b 1a(c) 0 ]
+    // balance [ 5     5     4  3  2     2 ]
+	let mut s = state_db.boxed_clone_canon(&root_parent);
+	s.add_to_account_cache(address, Some(Account::new_basic(2.into(), 0.into())), false);
+	s.commit(&mut batch, 0, &h0, None).unwrap();
+	s.sync_cache(&[], &[], true);
+
+	let mut s = state_db.boxed_clone_canon(&h0);
+	s.commit(&mut batch, 1, &h1a, None).unwrap();
+	s.sync_cache(&[], &[], true);
+
+	let mut s = state_db.boxed_clone_canon(&h0);
+	s.add_to_account_cache(address, Some(Account::new_basic(3.into(), 0.into())), true);
+	s.commit(&mut batch, 1, &h1b, None).unwrap();
+	s.sync_cache(&[], &[], false);
+
+	let mut s = state_db.boxed_clone_canon(&h1b);
+	s.add_to_account_cache(address, Some(Account::new_basic(4.into(), 0.into())), true);
+	s.commit(&mut batch, 2, &h2b, None).unwrap();
+	s.sync_cache(&[], &[], false);
+
+	let mut s = state_db.boxed_clone_canon(&h1a);
+	s.add_to_account_cache(address, Some(Account::new_basic(5.into(), 0.into())), true);
+	s.commit(&mut batch, 2, &h2a, None).unwrap();
+	s.sync_cache(&[], &[], true);
+
+	let mut s = state_db.boxed_clone_canon(&h2a);
+	s.commit(&mut batch, 3, &h3a, None).unwrap();
+	s.sync_cache(&[], &[], true);
+
+	let s = state_db.boxed_clone_canon(&h3a);
+	assert_eq!(s.get_cached_account(&address).unwrap().unwrap().balance(), &U256::from(5));
+
+	let s = state_db.boxed_clone_canon(&h1a);
+	assert!(s.get_cached_account(&address).is_none());
+
+	let s = state_db.boxed_clone_canon(&h2b);
+	assert!(s.get_cached_account(&address).is_none());
+
+	let s = state_db.boxed_clone_canon(&h1b);
+	assert!(s.get_cached_account(&address).is_none());
+
+	// reorg to 3b
+	// blocks  [ 3b(c) 3a 2a 2b(c) 1b 1a 0 ]
+	let mut s = state_db.boxed_clone_canon(&h2b);
+	s.commit(&mut batch, 3, &h3b, None).unwrap();
+	s.sync_cache(&[h1b.clone(), h2b.clone(), h3b.clone()], &[h1a.clone(), h2a.clone(), h3a.clone()], true);
+	let s = state_db.boxed_clone_canon(&h3a);
+	assert!(s.get_cached_account(&address).is_none());
+}
 }

--- a/ethcore/src/tests/client.rs
+++ b/ethcore/src/tests/client.rs
@@ -22,6 +22,7 @@ use tests::helpers::*;
 use common::*;
 use devtools::*;
 use miner::Miner;
+use spec::Spec;

 #[test]
 fn imports_from_empty() {
@@ -167,3 +168,26 @@ fn can_mine() {

 	assert_eq!(*b.block().header().parent_hash(), BlockView::new(&dummy_blocks[0]).header_view().sha3());
 }
+
+#[test]
+fn change_history_size() {
+	let dir = RandomTempPath::new();
+	let test_spec = Spec::new_null();
+	let mut config = ClientConfig::default();
+	config.history = 2;
+	let address = Address::random();
+	{
+		let client = Client::new(ClientConfig::default(), &test_spec, dir.as_path(), Arc::new(Miner::with_spec(&test_spec)), IoChannel::disconnected()).unwrap();
+		for _ in 0..20 {
+			let mut b = client.prepare_open_block(Address::default(), (3141562.into(), 31415620.into()), vec![]);
+			b.block_mut().fields_mut().state.add_balance(&address, &5.into());
+			b.block_mut().fields_mut().state.commit().unwrap();
+			let b = b.close_and_lock().seal(&*test_spec.engine, vec![]).unwrap();
+			client.import_sealed_block(b).unwrap(); // account change is in the journal overlay
+		}
+	}
+	let mut config = ClientConfig::default();
+	config.history = 10;
+	let client = Client::new(config, &test_spec, dir.as_path(), Arc::new(Miner::with_spec(&test_spec)), IoChannel::disconnected()).unwrap();
+	assert_eq!(client.state().balance(&address), 100.into());
+}
--- a/ethcore/src/tests/helpers.rs
+++ b/ethcore/src/tests/helpers.rs
@@ -32,19 +32,20 @@ use miner::Miner;
 pub enum ChainEra {
 	Frontier,
 	Homestead,
-	DaoHardfork,
+	Eip150,
+	TransitionTest,
 }

 pub struct TestEngine {
 	engine: Arc<Engine>,
-	max_depth: usize
+	max_depth: usize,
 }

 impl TestEngine {
 	pub fn new(max_depth: usize) -> TestEngine {
 		TestEngine {
 			engine: ethereum::new_frontier_test().engine,
-			max_depth: max_depth
+			max_depth: max_depth,
 		}
 	}
 }
--- a/ethcore/src/trace/db.rs
+++ b/ethcore/src/trace/db.rs
@@ -268,16 +268,6 @@ impl<T> TraceDatabase for TraceDB<T> where T: DatabaseExtras {
 			return;
 		}

-		// at first, let's insert new block traces
-		{
-			let mut traces = self.traces.write();
-			// it's important to use overwrite here,
-			// cause this value might be queried by hash later
-			batch.write_with_cache(DB_COL_TRACE, &mut *traces, request.block_hash, request.traces, CacheUpdatePolicy::Overwrite);
-			// note_used must be called after locking traces to avoid cache/traces deadlock on garbage collection
-			self.note_used(CacheID::Trace(request.block_hash.clone()));
-		}
-
 		// now let's rebuild the blooms
 		{
 			let range_start = request.block_number as Number + 1 - request.enacted.len();
@@ -288,12 +278,25 @@ impl<T> TraceDatabase for TraceDB<T> where T: DatabaseExtras {
 				// all traces are expected to be found here. That's why `expect` has been used
 				// instead of `filter_map`. If some traces haven't been found, it meens that
 				// traces database is corrupted or incomplete.
-				.map(|block_hash| self.traces(block_hash).expect("Traces database is incomplete."))
-				.map(|block_traces| block_traces.bloom())
+				.map(|block_hash| if block_hash == &request.block_hash {
+					request.traces.bloom()
+				} else {
+					self.traces(block_hash).expect("Traces database is incomplete.").bloom()
+				})
 				.map(blooms::Bloom::from)
 				.map(Into::into)
 				.collect();

+			// insert new block traces into the cache and the database
+			{
+				let mut traces = self.traces.write();
+				// it's important to use overwrite here,
+				// cause this value might be queried by hash later
+				batch.write_with_cache(DB_COL_TRACE, &mut *traces, request.block_hash, request.traces, CacheUpdatePolicy::Overwrite);
+				// note_used must be called after locking traces to avoid cache/traces deadlock on garbage collection
+				self.note_used(CacheID::Trace(request.block_hash.clone()));
+			}
+
 			let chain = BloomGroupChain::new(self.bloom_config, self);
 			let trace_blooms = chain.replace(&replaced_range, enacted_blooms);
 			let blooms_to_insert = trace_blooms.into_iter()
--- a/ethcore/src/types/filter.rs
+++ b/ethcore/src/types/filter.rs
@@ -25,7 +25,7 @@ use std::mem;
 use std::collections::VecDeque;

 /// Blockchain Filter.
-#[derive(Binary)]
+#[derive(Binary, Debug, PartialEq)]
 pub struct Filter {
 	/// Blockchain will be searched from this block.
 	pub from_block: BlockID,
--- a/ethcore/src/types/trace_types/trace.rs
+++ b/ethcore/src/types/trace_types/trace.rs
@@ -181,7 +181,7 @@ impl From<ActionParams> for Create {
 			from: p.sender,
 			value: p.value.value(),
 			gas: p.gas,
-			init: p.code.unwrap_or_else(Vec::new),
+			init: p.code.map_or_else(Vec::new, |c| (*c).clone()),
 		}
 	}
 }
--- a/ethkey/src/primitive.rs
+++ b/ethkey/src/primitive.rs
@@ -24,7 +24,6 @@ macro_rules! impl_primitive {
 	($name: ident, $size: expr, $err: expr) => {

 		#[repr(C)]
-		#[derive(Eq)]
 		pub struct $name([u8; $size]);

 		impl fmt::Debug for $name {
@@ -62,6 +61,8 @@ macro_rules! impl_primitive {
 			}
 		}

+		impl Eq for $name { }
+
 		impl PartialOrd for $name {
 			fn partial_cmp(&self, other: &Self) -> Option<cmp::Ordering> {
 				let self_ref: &[u8] = &self.0;
--- a/ethkey/src/signature.rs
+++ b/ethkey/src/signature.rs
@@ -23,7 +23,6 @@ use rustc_serialize::hex::{ToHex, FromHex};
 use {Secret, Public, SECP256K1, Error, Message, public_to_address, Address};

 #[repr(C)]
-#[derive(Eq)]
 pub struct Signature([u8; 65]);

 impl Signature {
@@ -51,6 +50,9 @@ impl ::std::cmp::PartialEq for Signature {
 	}
 }

+// manual implementation required in Rust 1.13+, see `std::cmp::AssertParamIsEq`.
+impl Eq for Signature { }
+
 // also manual for the same reason, but the pretty printing might be useful.
 impl fmt::Debug for Signature {
 	fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
--- a/ethstore/src/account/safe_account.rs
+++ b/ethstore/src/account/safe_account.rs
@@ -23,7 +23,7 @@ use account::{Version, Cipher, Kdf, Aes128Ctr, Pbkdf2, Prf};
 #[derive(Debug, PartialEq, Clone)]
 pub struct Crypto {
 	pub cipher: Cipher,
-	pub ciphertext: [u8; 32],
+	pub ciphertext: Vec<u8>,
 	pub kdf: Kdf,
 	pub mac: [u8; 32],
 }
@@ -95,7 +95,7 @@ impl Crypto {
 			cipher: Cipher::Aes128Ctr(Aes128Ctr {
 				iv: iv,
 			}),
-			ciphertext: ciphertext,
+			ciphertext: ciphertext.to_vec(),
 			kdf: Kdf::Pbkdf2(Pbkdf2 {
 				dklen: crypto::KEY_LENGTH as u32,
 				salt: salt,
@@ -107,6 +107,10 @@ impl Crypto {
 	}

 	pub fn secret(&self, password: &str) -> Result<Secret, Error> {
+		if self.ciphertext.len() > 32 {
+			return Err(Error::InvalidSecret);
+		}
+
 		let (derived_left_bits, derived_right_bits) = match self.kdf {
 			Kdf::Pbkdf2(ref params) => crypto::derive_key_iterations(password, &params.salt, params.c),
 			Kdf::Scrypt(ref params) => crypto::derive_key_scrypt(password, &params.salt, params.n, params.p, params.r),
@@ -122,7 +126,8 @@ impl Crypto {

 		match self.cipher {
 			Cipher::Aes128Ctr(ref params) => {
-				crypto::aes::decrypt(&derived_left_bits, &params.iv, &self.ciphertext, &mut *secret)
+				let from = 32 - self.ciphertext.len();
+				crypto::aes::decrypt(&derived_left_bits, &params.iv, &self.ciphertext, &mut (&mut *secret)[from..])
 			},
 		}

--- a/ethstore/src/dir/disk.rs
+++ b/ethstore/src/dir/disk.rs
@@ -76,15 +76,14 @@ impl DiskDirectory {
 			.map(|entry| entry.path())
 			.collect::<Vec<PathBuf>>();

-		let files: Result<Vec<_>, _> = paths.iter()
-			.map(fs::File::open)
-			.collect();
-
-		let files = try!(files);
-
-		files.into_iter()
-			.map(json::KeyFile::load)
-			.zip(paths.into_iter())
+		paths
+			.iter()
+			.map(|p| (
+				fs::File::open(p)
+					.map_err(Error::from)
+					.and_then(|r| json::KeyFile::load(r).map_err(|e| Error::Custom(format!("{:?}", e)))),
+				p
+			))
 			.map(|(file, path)| match file {
 				Ok(file) => Ok((path.clone(), SafeAccount::from_file(
 					file, path.file_name().and_then(|n| n.to_str()).expect("Keys have valid UTF8 names only.").to_owned()
--- a/ethstore/src/json/bytes.rs
+++ b/ethstore/src/json/bytes.rs
@@ -0,0 +1,58 @@
+use std::{ops, str};
+use serde::{Deserialize, Deserializer, Error, Serialize, Serializer};
+use rustc_serialize::hex::{ToHex, FromHex, FromHexError};
+
+#[derive(Debug, PartialEq)]
+pub struct Bytes(Vec<u8>);
+
+impl ops::Deref for Bytes {
+	type Target = [u8];
+
+	fn deref(&self) -> &Self::Target {
+		&self.0
+	}
+}
+
+impl Deserialize for Bytes {
+	fn deserialize<D>(deserializer: &mut D) -> Result<Self, D::Error>
+		where D: Deserializer
+	{
+		let s = try!(String::deserialize(deserializer));
+		let data = try!(s.from_hex().map_err(|e| Error::custom(format!("Invalid hex value {}", e))));
+		Ok(Bytes(data))
+	}
+}
+
+impl Serialize for Bytes {
+	fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+	where S: Serializer {
+		serializer.serialize_str(&self.0.to_hex())
+	}
+}
+
+impl str::FromStr for Bytes {
+	type Err = FromHexError;
+
+	fn from_str(s: &str) -> Result<Self, Self::Err> {
+		s.from_hex().map(Bytes)
+	}
+}
+
+impl From<&'static str> for Bytes {
+	fn from(s: &'static str) -> Self {
+		s.parse().expect(&format!("invalid string literal for {}: '{}'", stringify!(Self), s))
+	}
+}
+
+impl From<Vec<u8>> for Bytes {
+	fn from(v: Vec<u8>) -> Self {
+		Bytes(v)
+	}
+}
+
+impl From<Bytes> for Vec<u8> {
+	fn from(b: Bytes) -> Self {
+		b.0
+	}
+}
+
--- a/ethstore/src/json/crypto.rs
+++ b/ethstore/src/json/crypto.rs
@@ -17,12 +17,14 @@
 use serde::{Deserialize, Deserializer, Serialize, Serializer, Error};
 use serde::de::{Visitor, MapVisitor};
 use serde::ser;
-use super::{Cipher, CipherSer, CipherSerParams, Kdf, KdfSer, KdfSerParams, H256};
+use super::{Cipher, CipherSer, CipherSerParams, Kdf, KdfSer, KdfSerParams, H256, Bytes};
+
+pub type CipherText = Bytes;

 #[derive(Debug, PartialEq)]
 pub struct Crypto {
 	pub cipher: Cipher,
-	pub ciphertext: H256,
+	pub ciphertext: CipherText,
 	pub kdf: Kdf,
 	pub mac: H256,
 }
--- a/ethstore/src/json/hash.rs
+++ b/ethstore/src/json/hash.rs
@@ -14,9 +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 std::fmt;
-use std::ops;
-use std::str::FromStr;
+use std::{ops, fmt, str};
 use rustc_serialize::hex::{FromHex, ToHex};
 use serde::{Serialize, Serializer, Deserialize, Deserializer, Error as SerdeError};
 use serde::de::Visitor;
@@ -65,7 +63,7 @@ macro_rules! impl_hash {
 					type Value = $name;

 					fn visit_str<E>(&mut self, value: &str) -> Result<Self::Value, E> where E: SerdeError {
-						FromStr::from_str(value).map_err(SerdeError::custom)
+						value.parse().map_err(SerdeError::custom)
 					}

 					fn visit_string<E>(&mut self, value: String) -> Result<Self::Value, E> where E: SerdeError {
@@ -77,7 +75,7 @@ macro_rules! impl_hash {
 			}
 		}

-		impl FromStr for $name {
+		impl str::FromStr for $name {
 			type Err = Error;

 			fn from_str(value: &str) -> Result<Self, Self::Err> {
@@ -92,6 +90,12 @@ macro_rules! impl_hash {
 			}
 		}

+		impl From<&'static str> for $name {
+			fn from(s: &'static str) -> Self {
+				s.parse().expect(&format!("invalid string literal for {}: '{}'", stringify!(Self), s))
+			}
+		}
+
 		impl From<[u8; $size]> for $name {
 			fn from(bytes: [u8; $size]) -> Self {
 				$name(bytes)
--- a/ethstore/src/json/id.rs
+++ b/ethstore/src/json/id.rs
@@ -15,8 +15,7 @@
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.

 //! Universaly unique identifier.
-use std::str::FromStr;
-use std::fmt;
+use std::{fmt, str};
 use rustc_serialize::hex::{ToHex, FromHex};
 use serde::{Deserialize, Serialize, Deserializer, Serializer, Error as SerdeError};
 use serde::de::Visitor;
@@ -73,7 +72,7 @@ fn copy_into(from: &str, into: &mut [u8]) -> Result<(), Error> {
 	Ok(())
 }

-impl FromStr for UUID {
+impl str::FromStr for UUID {
 	type Err = Error;

 	fn from_str(s: &str) -> Result<Self, Self::Err> {
@@ -95,6 +94,12 @@ impl FromStr for UUID {
 	}
 }

+impl From<&'static str> for UUID {
+	fn from(s: &'static str) -> Self {
+		s.parse().expect(&format!("invalid string literal for {}: '{}'", stringify!(Self), s))
+	}
+}
+
 impl Serialize for UUID {
 	fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
 	where S: Serializer {
@@ -116,7 +121,7 @@ impl Visitor for UUIDVisitor {
 	type Value = UUID;

 	fn visit_str<E>(&mut self, value: &str) -> Result<Self::Value, E> where E: SerdeError {
-		UUID::from_str(value).map_err(SerdeError::custom)
+		value.parse().map_err(SerdeError::custom)
 	}

 	fn visit_string<E>(&mut self, value: String) -> Result<Self::Value, E> where E: SerdeError {
@@ -126,19 +131,18 @@ impl Visitor for UUIDVisitor {

 #[cfg(test)]
 mod tests {
-	use std::str::FromStr;
 	use super::UUID;

 	#[test]
 	fn uuid_from_str() {
-		let uuid = UUID::from_str("3198bc9c-6672-5ab3-d995-4942343ae5b6").unwrap();
+		let uuid: UUID = "3198bc9c-6672-5ab3-d995-4942343ae5b6".into();
 		assert_eq!(uuid, UUID::from([0x31, 0x98, 0xbc, 0x9c, 0x66, 0x72, 0x5a, 0xb3, 0xd9, 0x95, 0x49, 0x42, 0x34, 0x3a, 0xe5, 0xb6]));
 	}

 	#[test]
 	fn uuid_from_and_to_str() {
 		let from = "3198bc9c-6672-5ab3-d995-4942343ae5b6";
-		let uuid = UUID::from_str(from).unwrap();
+		let uuid: UUID = from.into();
 		let to: String = uuid.into();
 		assert_eq!(from, &to);
 	}
--- a/ethstore/src/json/key_file.rs
+++ b/ethstore/src/json/key_file.rs
@@ -98,7 +98,7 @@ impl Visitor for KeyFileVisitor {
 				Some(KeyFileField::Version) => { version = Some(try!(visitor.visit_value())); }
 				Some(KeyFileField::Crypto) => { crypto = Some(try!(visitor.visit_value())); }
 				Some(KeyFileField::Address) => { address = Some(try!(visitor.visit_value())); }
-				Some(KeyFileField::Name) => { name = visitor.visit_value().ok(); }	// ignore anyhing that is not a string to be permissive. 
+				Some(KeyFileField::Name) => { name = visitor.visit_value().ok(); }	// ignore anyhing that is not a string to be permissive.
 				Some(KeyFileField::Meta) => { meta = visitor.visit_value().ok(); }	// ignore anyhing that is not a string to be permissive.
 				None => { break; }
 			}
@@ -153,7 +153,7 @@ impl KeyFile {
 mod tests {
 	use std::str::FromStr;
 	use serde_json;
-	use json::{KeyFile, UUID, Version, Crypto, Cipher, Aes128Ctr, Kdf, Scrypt, H128, H160, H256};
+	use json::{KeyFile, UUID, Version, Crypto, Cipher, Aes128Ctr, Kdf, Scrypt};

 	#[test]
 	fn basic_keyfile() {
@@ -185,20 +185,20 @@ mod tests {
 		let expected = KeyFile {
 			id: UUID::from_str("8777d9f6-7860-4b9b-88b7-0b57ee6b3a73").unwrap(),
 			version: Version::V3,
-			address: H160::from_str("6edddfc6349aff20bc6467ccf276c5b52487f7a8").unwrap(),
+			address: "6edddfc6349aff20bc6467ccf276c5b52487f7a8".into(),
 			crypto: Crypto {
 				cipher: Cipher::Aes128Ctr(Aes128Ctr {
-					iv: H128::from_str("b5a7ec855ec9e2c405371356855fec83").unwrap(),
+					iv: "b5a7ec855ec9e2c405371356855fec83".into(),
 				}),
-				ciphertext: H256::from_str("7203da0676d141b138cd7f8e1a4365f59cc1aa6978dc5443f364ca943d7cb4bc").unwrap(),
+				ciphertext: "7203da0676d141b138cd7f8e1a4365f59cc1aa6978dc5443f364ca943d7cb4bc".into(),
 				kdf: Kdf::Scrypt(Scrypt {
 					n: 262144,
 					dklen: 32,
 					p: 1,
 					r: 8,
-					salt: H256::from_str("1e8642fdf1f87172492c1412fc62f8db75d796cdfa9c53c3f2b11e44a2a1b209").unwrap(),
+					salt: "1e8642fdf1f87172492c1412fc62f8db75d796cdfa9c53c3f2b11e44a2a1b209".into(),
 				}),
-				mac: H256::from_str("46325c5d4e8c991ad2683d525c7854da387138b6ca45068985aa4959fa2b8c8f").unwrap(),
+				mac: "46325c5d4e8c991ad2683d525c7854da387138b6ca45068985aa4959fa2b8c8f".into(),
 			},
 			name: Some("Test".to_owned()),
 			meta: Some("{}".to_owned()),
@@ -234,22 +234,22 @@ mod tests {
 		}"#;

 		let expected = KeyFile {
-			id: UUID::from_str("8777d9f6-7860-4b9b-88b7-0b57ee6b3a73").unwrap(),
+			id: "8777d9f6-7860-4b9b-88b7-0b57ee6b3a73".into(),
 			version: Version::V3,
-			address: H160::from_str("6edddfc6349aff20bc6467ccf276c5b52487f7a8").unwrap(),
+			address: "6edddfc6349aff20bc6467ccf276c5b52487f7a8".into(),
 			crypto: Crypto {
 				cipher: Cipher::Aes128Ctr(Aes128Ctr {
-					iv: H128::from_str("b5a7ec855ec9e2c405371356855fec83").unwrap(),
+					iv: "b5a7ec855ec9e2c405371356855fec83".into(),
 				}),
-				ciphertext: H256::from_str("7203da0676d141b138cd7f8e1a4365f59cc1aa6978dc5443f364ca943d7cb4bc").unwrap(),
+				ciphertext: "7203da0676d141b138cd7f8e1a4365f59cc1aa6978dc5443f364ca943d7cb4bc".into(),
 				kdf: Kdf::Scrypt(Scrypt {
 					n: 262144,
 					dklen: 32,
 					p: 1,
 					r: 8,
-					salt: H256::from_str("1e8642fdf1f87172492c1412fc62f8db75d796cdfa9c53c3f2b11e44a2a1b209").unwrap(),
+					salt: "1e8642fdf1f87172492c1412fc62f8db75d796cdfa9c53c3f2b11e44a2a1b209".into(),
 				}),
-				mac: H256::from_str("46325c5d4e8c991ad2683d525c7854da387138b6ca45068985aa4959fa2b8c8f").unwrap(),
+				mac: "46325c5d4e8c991ad2683d525c7854da387138b6ca45068985aa4959fa2b8c8f".into(),
 			},
 			name: None,
 			meta: None,
@@ -262,22 +262,22 @@ mod tests {
 	#[test]
 	fn to_and_from_json() {
 		let file = KeyFile {
-			id: UUID::from_str("8777d9f6-7860-4b9b-88b7-0b57ee6b3a73").unwrap(),
+			id: "8777d9f6-7860-4b9b-88b7-0b57ee6b3a73".into(),
 			version: Version::V3,
-			address: H160::from_str("6edddfc6349aff20bc6467ccf276c5b52487f7a8").unwrap(),
+			address: "6edddfc6349aff20bc6467ccf276c5b52487f7a8".into(),
 			crypto: Crypto {
 				cipher: Cipher::Aes128Ctr(Aes128Ctr {
-					iv: H128::from_str("b5a7ec855ec9e2c405371356855fec83").unwrap(),
+					iv: "b5a7ec855ec9e2c405371356855fec83".into(),
 				}),
-				ciphertext: H256::from_str("7203da0676d141b138cd7f8e1a4365f59cc1aa6978dc5443f364ca943d7cb4bc").unwrap(),
+				ciphertext: "7203da0676d141b138cd7f8e1a4365f59cc1aa6978dc5443f364ca943d7cb4bc".into(),
 				kdf: Kdf::Scrypt(Scrypt {
 					n: 262144,
 					dklen: 32,
 					p: 1,
 					r: 8,
-					salt: H256::from_str("1e8642fdf1f87172492c1412fc62f8db75d796cdfa9c53c3f2b11e44a2a1b209").unwrap(),
+					salt: "1e8642fdf1f87172492c1412fc62f8db75d796cdfa9c53c3f2b11e44a2a1b209".into(),
 				}),
-				mac: H256::from_str("46325c5d4e8c991ad2683d525c7854da387138b6ca45068985aa4959fa2b8c8f").unwrap(),
+				mac: "46325c5d4e8c991ad2683d525c7854da387138b6ca45068985aa4959fa2b8c8f".into(),
 			},
 			name: Some("Test".to_owned()),
 			meta: None,
--- a/ethstore/src/json/mod.rs.in
+++ b/ethstore/src/json/mod.rs.in
@@ -1,3 +1,4 @@
+mod bytes;
 mod cipher;
 mod crypto;
 mod error;
@@ -8,8 +9,9 @@ mod key_file;
 mod presale;
 mod version;

+pub use self::bytes::Bytes;
 pub use self::cipher::{Cipher, CipherSer, CipherSerParams, Aes128Ctr};
-pub use self::crypto::Crypto;
+pub use self::crypto::{Crypto, CipherText};
 pub use self::error::Error;
 pub use self::hash::{H128, H160, H256};
 pub use self::id::UUID;
--- a/ethstore/src/json/presale.rs
+++ b/ethstore/src/json/presale.rs
@@ -1,30 +1,8 @@
 use std::io::Read;
-use std::ops::Deref;
 use serde_json;
-use serde::{Deserialize, Deserializer, Error};
-use rustc_serialize::hex::FromHex;
-use super::{H160};
+use super::{H160, Bytes};

-#[derive(Debug, PartialEq)]
-pub struct Encseed(Vec<u8>);
-
-impl Deref for Encseed {
-	type Target = [u8];
-
-	fn deref(&self) -> &Self::Target {
-		&self.0
-	}
-}
-
-impl Deserialize for Encseed {
-	fn deserialize<D>(deserializer: &mut D) -> Result<Self, D::Error>
-		where D: Deserializer
-	{
-		let s = try!(String::deserialize(deserializer));
-		let data = try!(s.from_hex().map_err(|e| Error::custom(format!("Invalid hex value {}", e))));
-		Ok(Encseed(data))
-	}
-}
+pub type Encseed = Bytes;

 #[derive(Debug, PartialEq, Deserialize)]
 pub struct PresaleWallet {
@@ -43,8 +21,7 @@ impl PresaleWallet {
 mod tests {
 	use std::str::FromStr;
 	use serde_json;
-	use rustc_serialize::hex::FromHex;
-	use json::{PresaleWallet, H160, Encseed};
+	use json::{PresaleWallet, H160};

 	#[test]
 	fn presale_wallet() {
@@ -57,7 +34,7 @@ mod tests {
 		} "#;

 		let expected = PresaleWallet {
-			encseed: Encseed("137103c28caeebbcea5d7f95edb97a289ded151b72159137cb7b2671f394f54cff8c121589dcb373e267225547b3c71cbdb54f6e48ec85cd549f96cf0dedb3bc0a9ac6c79b9c426c5878ca2c9d06ff42a23cb648312fc32ba83649de0928e066".from_hex().unwrap()),
+			encseed: "137103c28caeebbcea5d7f95edb97a289ded151b72159137cb7b2671f394f54cff8c121589dcb373e267225547b3c71cbdb54f6e48ec85cd549f96cf0dedb3bc0a9ac6c79b9c426c5878ca2c9d06ff42a23cb648312fc32ba83649de0928e066".into(),
 			address: H160::from_str("ede84640d1a1d3e06902048e67aa7db8d52c2ce1").unwrap(),
 		};

@@ -77,7 +54,7 @@ mod tests {
 		} "#;

 		let expected = PresaleWallet {
-			encseed: Encseed("137103c28caeebbcea5d7f95edb97a289ded151b72159137cb7b2671f394f54cff8c121589dcb373e267225547b3c71cbdb54f6e48ec85cd549f96cf0dedb3bc0a9ac6c79b9c426c5878ca2c9d06ff42a23cb648312fc32ba83649de0928e066137103c28caeebbcea5d7f95edb97a289ded151b72159137cb7b2671f394f54cff8c121589dcb373e267225547b3c71cbdb54f6e48ec85cd549f96cf0dedb3bc0a9ac6c79b9c426c5878ca2c9d06ff42a23cb648312fc32ba83649de0928e066137103c28caeebbcea5d7f95edb97a289ded151b72159137cb7b2671f394f54cff8c121589dcb373e267225547b3c71cbdb54f6e48ec85cd549f96cf0dedb3bc0a9ac6c79b9c426c5878ca2c9d06ff42a23cb648312fc32ba83649de0928e066137103c28caeebbcea5d7f95edb97a289ded151b72159137cb7b2671f394f54cff8c121589dcb373e267225547b3c71cbdb54f6e48ec85cd549f96cf0dedb3bc0a9ac6c79b9c426c5878ca2c9d06ff42a23cb648312fc32ba83649de0928e066137103c28caeebbcea5d7f95edb97a289ded151b72159137cb7b2671f394f54cff8c121589dcb373e267225547b3c71cbdb54f6e48ec85cd549f96cf0dedb3bc0a9ac6c79b9c426c5878ca2c9d06ff42a23cb648312fc32ba83649de0928e066137103c28caeebbcea5d7f95edb97a289ded151b72159137cb7b2671f394f54cff8c121589dcb373e267225547b3c71cbdb54f6e48ec85cd549f96cf0dcf0dcf0dcf0dcf0dcf0dcf0dcf0dcf0dcf0dcf0dcf0dcf0dcf0dcf0dcf0dcf0dcf0dcf0dcf0dcf0dcf0dcf0dcf0dcf0dcf0dcf0dcf0dcf0dcf0dcf0dcf0dcf0dcf0dcf0dcf0dcf0dcf0dcf0dcf0dcf0dcf0dcf0d".from_hex().unwrap()),
+			encseed: "137103c28caeebbcea5d7f95edb97a289ded151b72159137cb7b2671f394f54cff8c121589dcb373e267225547b3c71cbdb54f6e48ec85cd549f96cf0dedb3bc0a9ac6c79b9c426c5878ca2c9d06ff42a23cb648312fc32ba83649de0928e066137103c28caeebbcea5d7f95edb97a289ded151b72159137cb7b2671f394f54cff8c121589dcb373e267225547b3c71cbdb54f6e48ec85cd549f96cf0dedb3bc0a9ac6c79b9c426c5878ca2c9d06ff42a23cb648312fc32ba83649de0928e066137103c28caeebbcea5d7f95edb97a289ded151b72159137cb7b2671f394f54cff8c121589dcb373e267225547b3c71cbdb54f6e48ec85cd549f96cf0dedb3bc0a9ac6c79b9c426c5878ca2c9d06ff42a23cb648312fc32ba83649de0928e066137103c28caeebbcea5d7f95edb97a289ded151b72159137cb7b2671f394f54cff8c121589dcb373e267225547b3c71cbdb54f6e48ec85cd549f96cf0dedb3bc0a9ac6c79b9c426c5878ca2c9d06ff42a23cb648312fc32ba83649de0928e066137103c28caeebbcea5d7f95edb97a289ded151b72159137cb7b2671f394f54cff8c121589dcb373e267225547b3c71cbdb54f6e48ec85cd549f96cf0dedb3bc0a9ac6c79b9c426c5878ca2c9d06ff42a23cb648312fc32ba83649de0928e066137103c28caeebbcea5d7f95edb97a289ded151b72159137cb7b2671f394f54cff8c121589dcb373e267225547b3c71cbdb54f6e48ec85cd549f96cf0dcf0dcf0dcf0dcf0dcf0dcf0dcf0dcf0dcf0dcf0dcf0dcf0dcf0dcf0dcf0dcf0dcf0dcf0dcf0dcf0dcf0dcf0dcf0dcf0dcf0dcf0dcf0dcf0dcf0dcf0dcf0dcf0dcf0dcf0dcf0dcf0dcf0dcf0dcf0dcf0dcf0dcf0d".into(),
 			address: H160::from_str("ede84640d1a1d3e06902048e67aa7db8d52c2ce1").unwrap(),
 		};

--- a/ethstore/tests/api.rs
+++ b/ethstore/tests/api.rs
@@ -19,9 +19,8 @@ extern crate ethstore;

 mod util;

-use std::str::FromStr;
 use ethstore::{SecretStore, EthStore};
-use ethstore::ethkey::{Random, Generator, Secret, Address};
+use ethstore::ethkey::{Random, Generator, Secret, KeyPair, verify_address};
 use ethstore::dir::DiskDirectory;
 use util::TransientDir;

@@ -103,14 +102,21 @@ fn pat_path() -> &'static str {
 	}
 }

+fn ciphertext_path() -> &'static str {
+	match ::std::fs::metadata("ethstore") {
+		Ok(_) => "ethstore/tests/res/ciphertext",
+		Err(_) => "tests/res/ciphertext",
+	}
+}
+
 #[test]
 fn secret_store_laod_geth_files() {
 	let dir = DiskDirectory::at(test_path());
 	let store = EthStore::open(Box::new(dir)).unwrap();
 	assert_eq!(store.accounts().unwrap(), vec![
-		Address::from_str("3f49624084b67849c7b4e805c5988c21a430f9d9").unwrap(),
-		Address::from_str("5ba4dcf897e97c2bdf8315b9ef26c13c085988cf").unwrap(),
-		Address::from_str("63121b431a52f8043c16fcf0d1df9cb7b5f66649").unwrap(),
+		"3f49624084b67849c7b4e805c5988c21a430f9d9".parse().unwrap(),
+		"5ba4dcf897e97c2bdf8315b9ef26c13c085988cf".parse().unwrap(),
+		"63121b431a52f8043c16fcf0d1df9cb7b5f66649".parse().unwrap(),
 	]);
 }

@@ -119,9 +125,30 @@ fn secret_store_load_pat_files() {
 	let dir = DiskDirectory::at(pat_path());
 	let store = EthStore::open(Box::new(dir)).unwrap();
 	assert_eq!(store.accounts().unwrap(), vec![
-		Address::from_str("3f49624084b67849c7b4e805c5988c21a430f9d9").unwrap(),
-		Address::from_str("5ba4dcf897e97c2bdf8315b9ef26c13c085988cf").unwrap(),
+		"3f49624084b67849c7b4e805c5988c21a430f9d9".parse().unwrap(),
+		"5ba4dcf897e97c2bdf8315b9ef26c13c085988cf".parse().unwrap(),
 	]);
 }

+#[test]
+fn test_decrypting_files_with_short_ciphertext() {
+	// 31e9d1e6d844bd3a536800ef8d8be6a9975db509, 30
+	let kp1 = KeyPair::from_secret("000081c29e8142bb6a81bef5a92bda7a8328a5c85bb2f9542e76f9b0f94fc018".parse().unwrap()).unwrap();
+	// d1e64e5480bfaf733ba7d48712decb8227797a4e , 31
+	let kp2 = KeyPair::from_secret("00fa7b3db73dc7dfdf8c5fbdb796d741e4488628c41fc4febd9160a866ba0f35".parse().unwrap()).unwrap();
+	let dir = DiskDirectory::at(ciphertext_path());
+	let store = EthStore::open(Box::new(dir)).unwrap();
+	let accounts = store.accounts().unwrap();
+	assert_eq!(accounts, vec![
+		"31e9d1e6d844bd3a536800ef8d8be6a9975db509".parse().unwrap(),
+		"d1e64e5480bfaf733ba7d48712decb8227797a4e".parse().unwrap(),
+	]);

+	let message = Default::default();
+
+	let s1 = store.sign(&accounts[0], "foo", &message).unwrap();
+	let s2 = store.sign(&accounts[1], "foo", &message).unwrap();
+	assert!(verify_address(&accounts[0], &s1, &message).unwrap());
+	assert!(verify_address(&kp1.address(), &s1, &message).unwrap());
+	assert!(verify_address(&kp2.address(), &s2, &message).unwrap());
+}
--- a/ethstore/tests/res/ciphertext/30.json
+++ b/ethstore/tests/res/ciphertext/30.json
@@ -0,0 +1,21 @@
+{
+	"address" : "31e9d1e6d844bd3a536800ef8d8be6a9975db509",
+	"crypto" : {
+		"cipher" : "aes-128-ctr",
+		"cipherparams" : {
+			"iv" : "3ca92af36ad7c2cd92454c59cea5ef00"
+		},
+		"ciphertext" : "108b7d34f3442fc26ab1ab90ca91476ba6bfa8c00975a49ef9051dc675aa",
+		"kdf" : "scrypt",
+		"kdfparams" : {
+			"dklen" : 32,
+			"n" : 2,
+			"r" : 8,
+			"p" : 1,
+			"salt" : "d0769e608fb86cda848065642a9c6fa046845c928175662b8e356c77f914cd3b"
+		},
+		"mac" : "75d0e6759f7b3cefa319c3be41680ab6beea7d8328653474bd06706d4cc67420"
+	},
+	"id" : "a37e1559-5955-450d-8075-7b8931b392b2",
+	"version" : 3
+}
--- a/ethstore/tests/res/ciphertext/31.json
+++ b/ethstore/tests/res/ciphertext/31.json
@@ -0,0 +1,21 @@
+{
+	"address" : "d1e64e5480bfaf733ba7d48712decb8227797a4e",
+	"crypto" : {
+		"cipher" : "aes-128-ctr",
+		"cipherparams" : {
+			"iv" : "e0c41130a323adc1446fc82f724bca2f"
+		},
+		"ciphertext" : "9517cd5bdbe69076f9bf5057248c6c050141e970efa36ce53692d5d59a3984",
+		"kdf" : "scrypt",
+		"kdfparams" : {
+			"dklen" : 32,
+			"n" : 2,
+			"r" : 8,
+			"p" : 1,
+			"salt" : "711f816911c92d649fb4c84b047915679933555030b3552c1212609b38208c63"
+		},
+		"mac" : "d5e116151c6aa71470e67a7d42c9620c75c4d23229847dcc127794f0732b0db5"
+	},
+	"id" : "fecfc4ce-e956-48fd-953b-30f8b52ed66c",
+	"version" : 3
+}
--- a/json/src/spec/engine.rs
+++ b/json/src/spec/engine.rs
@@ -63,7 +63,7 @@ mod tests {
 					"durationLimit": "0x0d",
 					"blockReward": "0x4563918244F40000",
 					"registrar" : "0xc6d9d2cd449a754c494264e1809c50e34d64562b",
-					"frontierCompatibilityModeLimit" : "0x",
+					"homesteadTransition" : "0x",
 					"daoHardforkTransition": "0xffffffffffffffff",
 					"daoHardforkBeneficiary": "0x0000000000000000000000000000000000000000",
 					"daoHardforkAccounts": []
--- a/json/src/spec/ethash.rs
+++ b/json/src/spec/ethash.rs
@@ -40,8 +40,8 @@ pub struct EthashParams {
 	/// See main EthashParams docs.
 	pub registrar: Option<Address>,
 	/// See main EthashParams docs.
-	#[serde(rename="frontierCompatibilityModeLimit")]
-	pub frontier_compatibility_mode_limit: Option<Uint>,
+	#[serde(rename="homesteadTransition")]
+	pub homestead_transition: Option<Uint>,
 	/// See main EthashParams docs.
 	#[serde(rename="daoHardforkTransition")]
 	pub dao_hardfork_transition: Option<Uint>,
@@ -51,6 +51,18 @@ pub struct EthashParams {
 	/// See main EthashParams docs.
 	#[serde(rename="daoHardforkAccounts")]
 	pub dao_hardfork_accounts: Option<Vec<Address>>,
+	/// See main EthashParams docs.
+	#[serde(rename="difficultyHardforkTransition")]
+	pub difficulty_hardfork_transition: Option<Uint>,
+	/// See main EthashParams docs.
+	#[serde(rename="difficultyHardforkBoundDivisor")]
+	pub difficulty_hardfork_bound_divisor: Option<Uint>,
+	/// See main EthashParams docs.
+	#[serde(rename="bombDefuseTransition")]
+	pub bomb_defuse_transition: Option<Uint>,
+	/// See main EthashParams docs.
+	#[serde(rename="eip150Transition")]
+	pub eip150_transition: Option<Uint>,
 }

 /// Ethash engine deserialization.
@@ -75,7 +87,7 @@ mod tests {
 				"durationLimit": "0x0d",
 				"blockReward": "0x4563918244F40000",
 				"registrar": "0xc6d9d2cd449a754c494264e1809c50e34d64562b",
-				"frontierCompatibilityModeLimit": "0x42",
+				"homesteadTransition": "0x42",
 				"daoHardforkTransition": "0x08",
 				"daoHardforkBeneficiary": "0xabcabcabcabcabcabcabcabcabcabcabcabcabca",
 				"daoHardforkAccounts": [
@@ -99,7 +111,11 @@ mod tests {
 					"0x7602b46df5390e432ef1c307d4f2c9ff6d65cc97",
 					"0xbb9bc244d798123fde783fcc1c72d3bb8c189413",
 					"0x807640a13483f8ac783c557fcdf27be11ea4ac7a"
-				]
+				],
+				"difficultyHardforkTransition": "0x59d9",
+				"difficultyHardforkBoundDivisor": "0x0200",
+				"bombDefuseTransition": "0x42",
+				"eip150Transition": "0x42"
 			}
 		}"#;

--- a/json/src/spec/params.rs
+++ b/json/src/spec/params.rs
@@ -50,7 +50,7 @@ mod tests {
 	#[test]
 	fn params_deserialization() {
 		let s = r#"{
-			"frontierCompatibilityModeLimit": "0x118c30",
+			"homesteadTransition": "0x118c30",
 			"maximumExtraDataSize": "0x20",
 			"networkID" : "0x1",
 			"minGasLimit": "0x1388",
--- a/json/src/spec/spec.rs
+++ b/json/src/spec/spec.rs
@@ -66,7 +66,7 @@ mod tests {
 				"durationLimit": "0x0d",
 				"blockReward": "0x4563918244F40000",
 				"registrar" : "0xc6d9d2cd449a754c494264e1809c50e34d64562b",
-				"frontierCompatibilityModeLimit" : "0x",
+				"homesteadTransition" : "0x",
 				"daoHardforkTransition": "0xffffffffffffffff",
 				"daoHardforkBeneficiary": "0x0000000000000000000000000000000000000000",
 				"daoHardforkAccounts": []
@@ -75,7 +75,7 @@ mod tests {
 	},
 	"params": {
 		"accountStartNonce": "0x0100000",
-		"frontierCompatibilityModeLimit": "0x789b0",
+		"homesteadTransition": "0x789b0",
 		"maximumExtraDataSize": "0x20",
 		"minGasLimit": "0x1388",
 		"networkID" : "0x2",
--- a/nsis/installer.nsi
+++ b/nsis/installer.nsi
@@ -4,7 +4,7 @@
 !define DESCRIPTION "Fast, light, robust Ethereum implementation"
 !define VERSIONMAJOR 1
 !define VERSIONMINOR 3
-!define VERSIONBUILD 2
+!define VERSIONBUILD 8

 !addplugindir .\

--- a/parity/blockchain.rs
+++ b/parity/blockchain.rs
@@ -75,6 +75,7 @@ pub struct ImportBlockchain {
 	pub file_path: Option<String>,
 	pub format: Option<DataFormat>,
 	pub pruning: Pruning,
+	pub pruning_history: u64,
 	pub compaction: DatabaseCompactionProfile,
 	pub wal: bool,
 	pub mode: Mode,
@@ -91,6 +92,7 @@ pub struct ExportBlockchain {
 	pub file_path: Option<String>,
 	pub format: Option<DataFormat>,
 	pub pruning: Pruning,
+	pub pruning_history: u64,
 	pub compaction: DatabaseCompactionProfile,
 	pub wal: bool,
 	pub mode: Mode,
@@ -131,7 +133,7 @@ fn execute_import(cmd: ImportBlockchain) -> Result<String, String> {
 	try!(execute_upgrades(&cmd.dirs, genesis_hash, spec.fork_name.as_ref(), algorithm, cmd.compaction.compaction_profile()));

 	// prepare client config
-	let client_config = to_client_config(&cmd.cache_config, &cmd.dirs, genesis_hash, cmd.mode, cmd.tracing, cmd.pruning, cmd.compaction, cmd.wal, cmd.vm_type, "".into(), spec.fork_name.as_ref());
+	let client_config = to_client_config(&cmd.cache_config, &cmd.dirs, genesis_hash, cmd.mode, cmd.tracing, cmd.pruning, cmd.pruning_history, cmd.compaction, cmd.wal, cmd.vm_type, "".into(), spec.fork_name.as_ref());

 	// build client
 	let service = try!(ClientService::start(
@@ -242,7 +244,7 @@ fn execute_export(cmd: ExportBlockchain) -> Result<String, String> {
 	try!(execute_upgrades(&cmd.dirs, genesis_hash, spec.fork_name.as_ref(), algorithm, cmd.compaction.compaction_profile()));

 	// prepare client config
-	let client_config = to_client_config(&cmd.cache_config, &cmd.dirs, genesis_hash, cmd.mode, cmd.tracing, cmd.pruning, cmd.compaction, cmd.wal, VMType::default(), "".into(), spec.fork_name.as_ref());
+	let client_config = to_client_config(&cmd.cache_config, &cmd.dirs, genesis_hash, cmd.mode, cmd.tracing, cmd.pruning, cmd.pruning_history, cmd.compaction, cmd.wal, VMType::default(), "".into(), spec.fork_name.as_ref());

 	let service = try!(ClientService::start(
 		client_config,
--- a/parity/cli.rs
+++ b/parity/cli.rs
@@ -164,7 +164,7 @@ Sealing/Mining Options:
  --work-queue-size ITEMS  Specify the number of historical work packages
                           which are kept cached lest a solution is found for
                           them later. High values take more memory but result
-                           in fewer unusable solutions [default: 20].
+                           in fewer unusable solutions [default: 5].
  --tx-gas-limit GAS       Apply a limit of GAS as the maximum amount of gas
                           a single transaction may have for it to be mined.
  --relay-set SET          Set of transactions to relay. SET may be:
@@ -193,7 +193,17 @@ Sealing/Mining Options:
  --extra-data STRING      Specify a custom extra-data for authored blocks, no
                           more than 32 characters.
  --tx-queue-size LIMIT    Maximum amount of transactions in the queue (waiting
-                           to be included in next block) [default: 1024].
+                           to be included in next block) [default: 2048].
+  --tx-queue-strategy S    Prioritization strategy used to order transactions
+                           in the queue. S may be:
+                           gas - Prioritize txs with low gas limit;
+                           gas_price - Prioritize txs with high gas price;
+                           gas_factor - Prioritize txs using gas price
+                           and gas limit ratio [default: gas_factor].
+  --tx-queue-gas LIMIT     Maximum amount of total gas for external transactions in
+                           the queue. LIMIT can be either an amount of gas or
+                           'auto' or 'off'. 'auto' sets the limit to be 20x
+                           the current block gas limit. [default: auto].
  --remove-solved          Move solved blocks from the work package queue
                           instead of cloning them. This gives a slightly
                           faster import speed, but means that extra solutions
@@ -213,6 +223,8 @@ Footprint Options:
                           fast - maintain journal overlay. Fast but 50MB used.
                           auto - use the method most recently synced or
                           default to fast if none synced [default: auto].
+  --pruning-history NUM    Set a number of recent states to keep when pruning
+                           is active. [default: 64].
  --cache-size-db MB       Override database cache size [default: 64].
  --cache-size-blocks MB   Specify the prefered size of the blockchain cache in
                           megabytes [default: 8].
@@ -319,6 +331,7 @@ pub struct Args {
 	pub flag_bootnodes: Option<String>,
 	pub flag_network_id: Option<String>,
 	pub flag_pruning: String,
+	pub flag_pruning_history: u64,
 	pub flag_tracing: String,
 	pub flag_port: u16,
 	pub flag_min_peers: u16,
@@ -372,12 +385,14 @@ pub struct Args {
 	pub flag_gas_cap: String,
 	pub flag_extra_data: Option<String>,
 	pub flag_tx_queue_size: usize,
+	pub flag_tx_queue_strategy: String,
+	pub flag_tx_queue_gas: String,
 	pub flag_notify_work: Option<String>,
 	pub flag_logging: Option<String>,
 	pub flag_version: bool,
 	pub flag_from: String,
 	pub flag_to: String,
-  pub flag_at: String,
+	pub flag_at: String,
 	pub flag_format: Option<String>,
 	pub flag_jitvm: bool,
 	pub flag_log_file: Option<String>,
--- a/parity/configuration.rs
+++ b/parity/configuration.rs
@@ -25,13 +25,13 @@ use util::{Hashable, U256, Uint, Bytes, version_data, Secret, Address};
 use util::log::Colour;
 use ethsync::{NetworkConfiguration, is_valid_node_url};
 use ethcore::client::{VMType, Mode};
-use ethcore::miner::MinerOptions;
+use ethcore::miner::{MinerOptions, PrioritizationStrategy};

 use rpc::{IpcConfiguration, HttpConfiguration};
 use ethcore_rpc::NetworkSettings;
 use cache::CacheConfig;
 use helpers::{to_duration, to_mode, to_block_id, to_u256, to_pending_set, to_price, replace_home,
-geth_ipc_path, parity_ipc_path, to_bootnodes, to_addresses, to_address};
+geth_ipc_path, parity_ipc_path, to_bootnodes, to_addresses, to_address, to_gas_limit};
 use params::{ResealPolicy, AccountsConfig, GasPricerConfig, MinerExtras};
 use ethcore_logger::Config as LogConfig;
 use dir::Directories;
@@ -73,6 +73,7 @@ impl Configuration {
 	pub fn into_command(self) -> Result<Cmd, String> {
 		let dirs = self.directories();
 		let pruning = try!(self.args.flag_pruning.parse());
+		let pruning_history = self.args.flag_pruning_history;
 		let vm_type = try!(self.vm_type());
 		let mode = try!(to_mode(&self.args.flag_mode, self.args.flag_mode_timeout, self.args.flag_mode_alarm));
 		let miner_options = try!(self.miner_options());
@@ -134,6 +135,7 @@ impl Configuration {
 				file_path: self.args.arg_file.clone(),
 				format: format,
 				pruning: pruning,
+				pruning_history: pruning_history,
 				compaction: compaction,
 				wal: wal,
 				mode: mode,
@@ -150,6 +152,7 @@ impl Configuration {
 				file_path: self.args.arg_file.clone(),
 				format: format,
 				pruning: pruning,
+				pruning_history: pruning_history,
 				compaction: compaction,
 				wal: wal,
 				mode: mode,
@@ -164,6 +167,7 @@ impl Configuration {
 				dirs: dirs,
 				spec: spec,
 				pruning: pruning,
+				pruning_history: pruning_history,
 				logger_config: logger_config,
 				mode: mode,
 				tracing: tracing,
@@ -180,6 +184,7 @@ impl Configuration {
 				dirs: dirs,
 				spec: spec,
 				pruning: pruning,
+				pruning_history: pruning_history,
 				logger_config: logger_config,
 				mode: mode,
 				tracing: tracing,
@@ -202,6 +207,7 @@ impl Configuration {
 				dirs: dirs,
 				spec: spec,
 				pruning: pruning,
+				pruning_history: pruning_history,
 				daemon: daemon,
 				logger_config: logger_config,
 				miner_options: miner_options,
@@ -319,6 +325,15 @@ impl Configuration {
 		Ok(cfg)
 	}

+	fn transaction_queue_strategy(&self) -> Result<PrioritizationStrategy, String> {
+		match self.args.flag_tx_queue_strategy.as_str() {
+			"gas" => Ok(PrioritizationStrategy::GasAndGasPrice),
+			"gas_price" => Ok(PrioritizationStrategy::GasPriceOnly),
+			"gas_factor" => Ok(PrioritizationStrategy::GasFactorAndGasPrice),
+			_ => Err(format!("Invalid queue strategy: {}", self.args.flag_tx_queue_strategy)),
+		}
+	}
+
 	fn miner_options(&self) -> Result<MinerOptions, String> {
 		let reseal = try!(self.args.flag_reseal_on_txs.parse::<ResealPolicy>());

@@ -332,6 +347,8 @@ impl Configuration {
 				None => U256::max_value(),
 			},
 			tx_queue_size: self.args.flag_tx_queue_size,
+			tx_queue_strategy: try!(self.transaction_queue_strategy()),
+			tx_queue_gas_limit: try!(to_gas_limit(&self.args.flag_tx_queue_gas)),
 			pending_set: try!(to_pending_set(&self.args.flag_relay_set)),
 			reseal_min_period: Duration::from_millis(self.args.flag_reseal_min_period),
 			work_queue_size: self.args.flag_work_queue_size,
@@ -604,6 +621,7 @@ mod tests {
 	use docopt::Docopt;
 	use ethcore_rpc::NetworkSettings;
 	use ethcore::client::{VMType, BlockID};
+	use ethcore::miner::{MinerOptions, PrioritizationStrategy};
 	use helpers::{replace_home, default_network_config};
 	use run::RunCmd;
 	use blockchain::{BlockchainCmd, ImportBlockchain, ExportBlockchain, DataFormat};
@@ -683,6 +701,7 @@ mod tests {
 			file_path: Some("blockchain.json".into()),
 			format: Default::default(),
 			pruning: Default::default(),
+			pruning_history: 64,
 			compaction: Default::default(),
 			wal: true,
 			mode: Default::default(),
@@ -702,6 +721,7 @@ mod tests {
 			dirs: Default::default(),
 			file_path: Some("blockchain.json".into()),
 			pruning: Default::default(),
+			pruning_history: 64,
 			format: Default::default(),
 			compaction: Default::default(),
 			wal: true,
@@ -723,6 +743,7 @@ mod tests {
 			dirs: Default::default(),
 			file_path: Some("blockchain.json".into()),
 			pruning: Default::default(),
+			pruning_history: 64,
 			format: Some(DataFormat::Hex),
 			compaction: Default::default(),
 			wal: true,
@@ -750,6 +771,7 @@ mod tests {
 			dirs: Default::default(),
 			spec: Default::default(),
 			pruning: Default::default(),
+			pruning_history: 64,
 			daemon: None,
 			logger_config: Default::default(),
 			miner_options: Default::default(),
@@ -777,6 +799,27 @@ mod tests {
 		}));
 	}

+	#[test]
+	fn should_parse_mining_options() {
+		// given
+		let mut mining_options = MinerOptions::default();
+
+		// when
+		let conf0 = parse(&["parity"]);
+		let conf1 = parse(&["parity", "--tx-queue-strategy", "gas_factor"]);
+		let conf2 = parse(&["parity", "--tx-queue-strategy", "gas_price"]);
+		let conf3 = parse(&["parity", "--tx-queue-strategy", "gas"]);
+
+		// then
+		assert_eq!(conf0.miner_options().unwrap(), mining_options);
+		mining_options.tx_queue_strategy = PrioritizationStrategy::GasFactorAndGasPrice;
+		assert_eq!(conf1.miner_options().unwrap(), mining_options);
+		mining_options.tx_queue_strategy = PrioritizationStrategy::GasPriceOnly;
+		assert_eq!(conf2.miner_options().unwrap(), mining_options);
+		mining_options.tx_queue_strategy = PrioritizationStrategy::GasAndGasPrice;
+		assert_eq!(conf3.miner_options().unwrap(), mining_options);
+	}
+
 	#[test]
 	fn should_parse_network_settings() {
 		// given
--- a/parity/helpers.rs
+++ b/parity/helpers.rs
@@ -22,7 +22,7 @@ use std::fs::File;
 use util::{clean_0x, U256, Uint, Address, path, H256, CompactionProfile};
 use util::journaldb::Algorithm;
 use ethcore::client::{Mode, BlockID, Switch, VMType, DatabaseCompactionProfile, ClientConfig};
-use ethcore::miner::PendingSet;
+use ethcore::miner::{PendingSet, GasLimit};
 use cache::CacheConfig;
 use dir::Directories;
 use params::Pruning;
@@ -94,6 +94,14 @@ pub fn to_pending_set(s: &str) -> Result<PendingSet, String> {
 	}
 }

+pub fn to_gas_limit(s: &str) -> Result<GasLimit, String> {
+	match s {
+		"auto" => Ok(GasLimit::Auto),
+		"off" => Ok(GasLimit::None),
+		other => Ok(GasLimit::Fixed(try!(to_u256(other)))),
+	}
+}
+
 pub fn to_address(s: Option<String>) -> Result<Address, String> {
 	match s {
 		Some(ref a) => clean_0x(a).parse().map_err(|_| format!("Invalid address: {:?}", a)),
@@ -194,6 +202,7 @@ pub fn to_client_config(
 		mode: Mode,
 		tracing: Switch,
 		pruning: Pruning,
+		pruning_history: u64,
 		compaction: DatabaseCompactionProfile,
 		wal: bool,
 		vm_type: VMType,
@@ -221,6 +230,7 @@ pub fn to_client_config(
 	client_config.mode = mode;
 	client_config.tracing.enabled = tracing;
 	client_config.pruning = pruning.to_algorithm(dirs, genesis_hash, fork_name);
+	client_config.history = pruning_history;
 	client_config.db_compaction = compaction;
 	client_config.db_wal = wal;
 	client_config.vm_type = vm_type;
--- a/parity/main.rs
+++ b/parity/main.rs
@@ -117,6 +117,8 @@ fn start() -> Result<String, String> {
 }

 fn main() {
+	// Always print backtrace on panic.
+	::std::env::set_var("RUST_BACKTRACE", "1");
 	// just redirect to the sync::main()
 	if std::env::args().nth(1).map_or(false, |arg| arg == "sync") {
 		sync::main();
--- a/parity/migration.rs
+++ b/parity/migration.rs
@@ -270,10 +270,13 @@ pub fn migrate(path: &Path, pruning: Algorithm, compaction_profile: CompactionPr
 		println!("Migration finished");
 	}

+	// update version file.
+	try!(update_version(path));
+
+	// run any inplace migrations for the fully upgraded database
 	try!(run_inplace_upgrades(consolidated_database_path(path).as_path()));

-	// update version file.
-	update_version(path)
+	Ok(())
 }

 /// Old migrations utilities
--- a/parity/params.rs
+++ b/parity/params.rs
@@ -215,7 +215,7 @@ impl Default for MinerExtras {
 			extra_data: version_data(),
 			gas_floor_target: U256::from(4_700_000),
 			gas_ceil_target: U256::from(6_283_184),
-			transactions_limit: 1024,
+			transactions_limit: 2048,
 		}
 	}
 }
--- a/parity/run.rs
+++ b/parity/run.rs
@@ -52,6 +52,7 @@ pub struct RunCmd {
 	pub dirs: Directories,
 	pub spec: SpecType,
 	pub pruning: Pruning,
+	pub pruning_history: u64,
 	/// Some if execution should be daemonized. Contains pid_file path.
 	pub daemon: Option<String>,
 	pub logger_config: LogConfig,
@@ -149,6 +150,7 @@ pub fn execute(cmd: RunCmd) -> Result<(), String> {
 		cmd.mode,
 		cmd.tracing,
 		cmd.pruning,
+		cmd.pruning_history,
 		cmd.compaction,
 		cmd.wal,
 		cmd.vm_type,
--- a/parity/snapshot.rs
+++ b/parity/snapshot.rs
@@ -52,6 +52,7 @@ pub struct SnapshotCommand {
 	pub dirs: Directories,
 	pub spec: SpecType,
 	pub pruning: Pruning,
+	pub pruning_history: u64,
 	pub logger_config: LogConfig,
 	pub mode: Mode,
 	pub tracing: Switch,
@@ -89,7 +90,7 @@ impl SnapshotCommand {
 		try!(execute_upgrades(&self.dirs, genesis_hash, spec.fork_name.as_ref(), algorithm, self.compaction.compaction_profile()));

 		// prepare client config
-		let client_config = to_client_config(&self.cache_config, &self.dirs, genesis_hash, self.mode, self.tracing, self.pruning, self.compaction, self.wal, VMType::default(), "".into(), spec.fork_name.as_ref());
+		let client_config = to_client_config(&self.cache_config, &self.dirs, genesis_hash, self.mode, self.tracing, self.pruning, self.pruning_history, self.compaction, self.wal, VMType::default(), "".into(), spec.fork_name.as_ref());

 		let service = try!(ClientService::start(
 			client_config,
--- a/rpc/Cargo.toml
+++ b/rpc/Cargo.toml
@@ -25,7 +25,7 @@ rustc-serialize = "0.3"
 transient-hashmap = "0.1"
 serde_macros = { version = "0.7.0", optional = true }
 clippy = { version = "0.0.80", optional = true}
-json-ipc-server = { git = "https://github.com/ethcore/json-ipc-server.git" }
+json-ipc-server = { git = "https://github.com/ethcore/json-ipc-server.git", branch = "beta" }
 ethcore-ipc = { path = "../ipc/rpc" }

 [build-dependencies]
--- a/rpc/src/v1/impls/eth.rs
+++ b/rpc/src/v1/impls/eth.rs
@@ -32,7 +32,7 @@ use util::rlp::{encode, decode, UntrustedRlp, View};
 use util::{FromHex, Mutex};
 use ethcore::account_provider::AccountProvider;
 use ethcore::client::{MiningBlockChainClient, BlockID, TransactionID, UncleID};
-use ethcore::header::Header as BlockHeader;
+use ethcore::header::{Header as BlockHeader, BlockNumber as EthBlockNumber};
 use ethcore::block::IsBlock;
 use ethcore::views::*;
 use ethcore::ethereum::Ethash;
@@ -193,8 +193,8 @@ impl<C, S: ?Sized, M, EM> EthClient<C, S, M, EM> where
 	}
 }

-pub fn pending_logs<M>(miner: &M, filter: &EthcoreFilter) -> Vec<Log> where M: MinerService {
-	let receipts = miner.pending_receipts();
+pub fn pending_logs<M>(miner: &M, best_block: EthBlockNumber, filter: &EthcoreFilter) -> Vec<Log> where M: MinerService {
+	let receipts = miner.pending_receipts(best_block);

 	let pending_logs = receipts.into_iter()
 		.flat_map(|(hash, r)| r.logs.into_iter().map(|l| (hash.clone(), l)).collect::<Vec<(H256, LogEntry)>>())
@@ -437,7 +437,7 @@ impl<C, S: ?Sized, M, EM> Eth for EthClient<C, S, M, EM> where
 				let miner = take_weak!(self.miner);
 				let client = take_weak!(self.client);
 				let maybe_tx = client.transaction(TransactionID::Hash(hash)).map(Transaction::from)
-					.or_else(|| miner.transaction(&hash).map(Transaction::from));
+					.or_else(|| miner.transaction(client.chain_info().best_block_number, &hash).map(Transaction::from));
 				match maybe_tx {
 					Some(t) => to_value(&t),
 					None => Ok(Value::Null),
@@ -462,8 +462,9 @@ impl<C, S: ?Sized, M, EM> Eth for EthClient<C, S, M, EM> where
 		from_params::<(RpcH256,)>(params)
 			.and_then(|(hash,)| {
 				let miner = take_weak!(self.miner);
+				let best_block = take_weak!(self.client).chain_info().best_block_number;
 				let hash: H256 = hash.into();
-				match (miner.pending_receipt(&hash), self.options.allow_pending_receipt_query) {
+				match (miner.pending_receipt(best_block, &hash), self.options.allow_pending_receipt_query) {
 					(Some(receipt), true) => to_value(&Receipt::from(receipt)),
 					_ => {
 						let client = take_weak!(self.client);
@@ -509,7 +510,8 @@ impl<C, S: ?Sized, M, EM> Eth for EthClient<C, S, M, EM> where
 					.collect::<Vec<Log>>();

 				if include_pending {
-					let pending = pending_logs(&*take_weak!(self.miner), &filter);
+					let best_block = take_weak!(self.client).chain_info().best_block_number;
+					let pending = pending_logs(&*take_weak!(self.miner), best_block, &filter);
 					logs.extend(pending);
 				}

--- a/rpc/src/v1/impls/eth_filter.rs
+++ b/rpc/src/v1/impls/eth_filter.rs
@@ -88,7 +88,8 @@ impl<C, M> EthFilter for EthFilterClient<C, M> where
 		try!(expect_no_params(params));

 		let mut polls = self.polls.lock();
-		let pending_transactions = take_weak!(self.miner).pending_transactions_hashes();
+		let best_block = take_weak!(self.client).chain_info().best_block_number;
+		let pending_transactions = take_weak!(self.miner).pending_transactions_hashes(best_block);
 		let id = polls.create_poll(PollFilter::PendingTransaction(pending_transactions));

 		to_value(&RpcU256::from(id))
@@ -118,7 +119,8 @@ impl<C, M> EthFilter for EthFilterClient<C, M> where
 						},
 						PollFilter::PendingTransaction(ref mut previous_hashes) => {
 							// get hashes of pending transactions
-							let current_hashes = take_weak!(self.miner).pending_transactions_hashes();
+							let current_number = client.chain_info().best_block_number;
+							let current_hashes = take_weak!(self.miner).pending_transactions_hashes(current_number);

 							let new_hashes =
 							{
@@ -159,7 +161,7 @@ impl<C, M> EthFilter for EthFilterClient<C, M> where

 							// additionally retrieve pending logs
 							if include_pending {
-								let pending_logs = pending_logs(&*take_weak!(self.miner), &filter);
+								let pending_logs = pending_logs(&*take_weak!(self.miner), current_number, &filter);

 								// remove logs about which client was already notified about
 								let new_pending_logs: Vec<_> = pending_logs.iter()
@@ -177,7 +179,6 @@ impl<C, M> EthFilter for EthFilterClient<C, M> where
 							// save the number of the next block as a first block from which
 							// we want to get logs
 							*block_number = current_number + 1;
-
 							to_value(&logs)
 						}
 					}
@@ -200,7 +201,8 @@ impl<C, M> EthFilter for EthFilterClient<C, M> where
 							.collect::<Vec<Log>>();

 						if include_pending {
-							logs.extend(pending_logs(&*take_weak!(self.miner), &filter));
+							let best_block = take_weak!(self.client).chain_info().best_block_number;
+							logs.extend(pending_logs(&*take_weak!(self.miner), best_block, &filter));
 						}

 						to_value(&logs)
--- a/rpc/src/v1/tests/eth.rs
+++ b/rpc/src/v1/tests/eth.rs
@@ -25,7 +25,7 @@ use ethcore::spec::{Genesis, Spec};
 use ethcore::block::Block;
 use ethcore::views::BlockView;
 use ethcore::ethereum;
-use ethcore::miner::{MinerOptions, GasPricer, MinerService, ExternalMiner, Miner, PendingSet};
+use ethcore::miner::{MinerOptions, GasPricer, MinerService, ExternalMiner, Miner, PendingSet, PrioritizationStrategy, GasLimit};
 use ethcore::account_provider::AccountProvider;
 use devtools::RandomTempPath;
 use util::Hashable;
@@ -59,6 +59,8 @@ fn miner_service(spec: &Spec, accounts: Arc<AccountProvider>) -> Arc<Miner> {
 			reseal_on_own_tx: true,
 			tx_queue_size: 1024,
 			tx_gas_limit: !U256::zero(),
+			tx_queue_strategy: PrioritizationStrategy::GasPriceOnly,
+			tx_queue_gas_limit: GasLimit::None,
 			pending_set: PendingSet::SealingOrElseQueue,
 			reseal_min_period: Duration::from_secs(0),
 			work_queue_size: 50,
@@ -199,7 +201,7 @@ const TRANSACTION_COUNT_SPEC: &'static [u8] = br#"{
 				"durationLimit": "0x0d",
 				"blockReward": "0x4563918244F40000",
 				"registrar" : "0xc6d9d2cd449a754c494264e1809c50e34d64562b",
-				"frontierCompatibilityModeLimit": "0xffffffffffffffff",
+				"homesteadTransition": "0xffffffffffffffff",
 				"daoHardforkTransition": "0xffffffffffffffff",
 				"daoHardforkBeneficiary": "0x0000000000000000000000000000000000000000",
 				"daoHardforkAccounts": []
@@ -247,7 +249,7 @@ const POSITIVE_NONCE_SPEC: &'static [u8] = br#"{
 				"durationLimit": "0x0d",
 				"blockReward": "0x4563918244F40000",
 				"registrar" : "0xc6d9d2cd449a754c494264e1809c50e34d64562b",
-				"frontierCompatibilityModeLimit": "0xffffffffffffffff",
+				"homesteadTransition": "0xffffffffffffffff",
 				"daoHardforkTransition": "0xffffffffffffffff",
 				"daoHardforkBeneficiary": "0x0000000000000000000000000000000000000000",
 				"daoHardforkAccounts": []
--- a/rpc/src/v1/tests/helpers/miner_service.rs
+++ b/rpc/src/v1/tests/helpers/miner_service.rs
@@ -21,6 +21,7 @@ use util::standard::*;
 use ethcore::error::{Error, CallError};
 use ethcore::client::{MiningBlockChainClient, Executed, CallAnalytics};
 use ethcore::block::{ClosedBlock, IsBlock};
+use ethcore::header::BlockNumber;
 use ethcore::transaction::SignedTransaction;
 use ethcore::receipt::{Receipt, RichReceipt};
 use ethcore::miner::{MinerService, MinerStatus, TransactionImportResult};
@@ -162,7 +163,7 @@ impl MinerService for TestMinerService {
 	}

 	/// Returns hashes of transactions currently in pending
-	fn pending_transactions_hashes(&self) -> Vec<H256> {
+	fn pending_transactions_hashes(&self, _best_block: BlockNumber) -> Vec<H256> {
 		vec![]
 	}

@@ -186,7 +187,7 @@ impl MinerService for TestMinerService {
 		Some(f(&open_block.close()))
 	}

-	fn transaction(&self, hash: &H256) -> Option<SignedTransaction> {
+	fn transaction(&self, _best_block: BlockNumber, hash: &H256) -> Option<SignedTransaction> {
 		self.pending_transactions.lock().get(hash).cloned()
 	}

@@ -194,13 +195,13 @@ impl MinerService for TestMinerService {
 		self.pending_transactions.lock().values().cloned().collect()
 	}

-	fn pending_transactions(&self) -> Vec<SignedTransaction> {
+	fn pending_transactions(&self, _best_block: BlockNumber) -> Vec<SignedTransaction> {
 		self.pending_transactions.lock().values().cloned().collect()
 	}

-	fn pending_receipt(&self, hash: &H256) -> Option<RichReceipt> {
+	fn pending_receipt(&self, _best_block: BlockNumber, hash: &H256) -> Option<RichReceipt> {
 		// Not much point implementing this since the logic is complex and the only thing it relies on is pending_receipts, which is already tested.
-		self.pending_receipts().get(hash).map(|r|
+		self.pending_receipts(0).get(hash).map(|r|
 			RichReceipt {
 				transaction_hash: Default::default(),
 				transaction_index: Default::default(),
@@ -212,7 +213,7 @@ impl MinerService for TestMinerService {
 		)
 	}

-	fn pending_receipts(&self) -> BTreeMap<H256, Receipt> {
+	fn pending_receipts(&self, _best_block: BlockNumber) -> BTreeMap<H256, Receipt> {
 		self.pending_receipts.lock().clone()
 	}

@@ -249,7 +250,7 @@ impl MinerService for TestMinerService {
 	}

 	fn code(&self, _chain: &MiningBlockChainClient, address: &Address) -> Option<Bytes> {
-		self.latest_closed_block.lock().as_ref().map_or(None, |b| b.block().fields().state.code(address).clone())
+		self.latest_closed_block.lock().as_ref().map_or(None, |b| b.block().fields().state.code(address).map(|c| (*c).clone()))
 	}

 }
--- a/rpc/src/v1/types/filter.rs
+++ b/rpc/src/v1/types/filter.rs
@@ -83,9 +83,15 @@ impl Into<EthFilter> for Filter {
 					VariadicValue::Null => None,
 					VariadicValue::Single(t) => Some(vec![t.into()]),
 					VariadicValue::Multiple(t) => Some(t.into_iter().map(Into::into).collect())
-				}).filter_map(|m| m).collect()).into_iter();
-				vec![iter.next(), iter.next(), iter.next(), iter.next()]
-			}
+				}).collect()).into_iter();
+
+				vec![
+					iter.next().unwrap_or(None),
+					iter.next().unwrap_or(None),
+					iter.next().unwrap_or(None),
+					iter.next().unwrap_or(None)
+				]
+			},
 		}
 	}
 }
@@ -97,6 +103,8 @@ mod tests {
 	use util::hash::*;
 	use super::*;
 	use v1::types::BlockNumber;
+	use ethcore::filter::Filter as EthFilter;
+	use ethcore::client::BlockID;

 	#[test]
 	fn topic_deserialization() {
@@ -123,4 +131,31 @@ mod tests {
 			topics: None
 		});
 	}
+
+	#[test]
+	fn filter_conversion() {
+		let filter = Filter {
+			from_block: Some(BlockNumber::Earliest),
+			to_block: Some(BlockNumber::Latest),
+			address: Some(VariadicValue::Multiple(vec![])),
+			topics: Some(vec![
+				VariadicValue::Null,
+				VariadicValue::Single("000000000000000000000000a94f5374fce5edbc8e2a8697c15331677e6ebf0b".into()),
+				VariadicValue::Null,
+			]),
+		};
+
+		let eth_filter: EthFilter = filter.into();
+		assert_eq!(eth_filter, EthFilter {
+			from_block: BlockID::Earliest,
+			to_block: BlockID::Latest,
+			address: Some(vec![]),
+			topics: vec![
+				None,
+				Some(vec!["000000000000000000000000a94f5374fce5edbc8e2a8697c15331677e6ebf0b".into()]),
+				None,
+				None,
+			],
+		});
+	}
 }
--- a/rpc/src/v1/types/hash.rs
+++ b/rpc/src/v1/types/hash.rs
@@ -25,9 +25,10 @@ use util::{H64 as Eth64, H256 as EthH256, H520 as EthH520, H2048 as Eth2048, Add
 macro_rules! impl_hash {
 	($name: ident, $other: ident, $size: expr) => {
 		/// Hash serialization
-		#[derive(Eq)]
 		pub struct $name([u8; $size]);

+		impl Eq for $name { }
+
 		impl Default for $name {
 			fn default() -> Self {
 				$name([0; $size])
--- a/rpc/src/v1/types/uint.rs
+++ b/rpc/src/v1/types/uint.rs
@@ -23,9 +23,11 @@ use util::{U256 as EthU256, Uint};
 macro_rules! impl_uint {
 	($name: ident, $other: ident, $size: expr) => {
 		/// Uint serialization.
-		#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, Hash)]
+		#[derive(Debug, Default, Clone, Copy, PartialEq, Hash)]
 		pub struct $name($other);

+		impl Eq for $name { }
+
 		impl<T> From<T> for $name where $other: From<T> {
 			fn from(o: T) -> Self {
 				$name($other::from(o))
--- a/sync/src/blocks.rs
+++ b/sync/src/blocks.rs
@@ -183,8 +183,8 @@ impl BlockCollection {
 		{
 			let mut blocks = Vec::new();
 			let mut head = self.head;
-			while head.is_some() {
-				head = self.parents.get(&head.unwrap()).cloned();
+			while let Some(h) = head {
+				head = self.parents.get(&h).cloned();
 				if let Some(head) = head {
 					match self.blocks.get(&head) {
 						Some(block) if block.body.is_some() => {
@@ -200,7 +200,7 @@ impl BlockCollection {
 			for block in blocks.drain(..) {
 				let mut block_rlp = RlpStream::new_list(3);
 				block_rlp.append_raw(&block.header, 1);
-				let body = Rlp::new(block.body.as_ref().unwrap()); // incomplete blocks are filtered out in the loop above
+				let body = Rlp::new(block.body.as_ref().expect("blocks contains only full blocks; qed"));
 				block_rlp.append_raw(body.at(0).as_raw(), 1);
 				block_rlp.append_raw(body.at(1).as_raw(), 1);
 				drained.push(block_rlp.out());
--- a/sync/src/chain.rs
+++ b/sync/src/chain.rs
@@ -89,7 +89,6 @@

 use util::*;
 use network::*;
-use std::mem::{replace};
 use ethcore::views::{HeaderView, BlockView};
 use ethcore::header::{BlockNumber, Header as BlockHeader};
 use ethcore::client::{BlockChainClient, BlockStatus, BlockID, BlockChainInfo, BlockImportError};
@@ -121,6 +120,7 @@ const MAX_ROUND_PARENTS: usize = 32;
 const MAX_NEW_HASHES: usize = 64;
 const MAX_TX_TO_IMPORT: usize = 512;
 const MAX_NEW_BLOCK_AGE: BlockNumber = 20;
+const MAX_TRANSACTION_SIZE: usize = 300*1024;

 const STATUS_PACKET: u8 = 0x00;
 const NEW_BLOCK_HASHES_PACKET: u8 = 0x01;
@@ -137,7 +137,7 @@ const GET_RECEIPTS_PACKET: u8 = 0x0f;
 const RECEIPTS_PACKET: u8 = 0x10;

 const HEADERS_TIMEOUT_SEC: f64 = 15f64;
-const BODIES_TIMEOUT_SEC: f64 = 5f64;
+const BODIES_TIMEOUT_SEC: f64 = 10f64;
 const FORK_HEADER_TIMEOUT_SEC: f64 = 3f64;

 #[derive(Copy, Clone, Eq, PartialEq, Debug)]
@@ -229,8 +229,6 @@ struct PeerInfo {
 	network_id: U256,
 	/// Peer best block hash
 	latest_hash: H256,
-	/// Peer best block number if known
-	latest_number: Option<BlockNumber>,
 	/// Peer total difficulty if known
 	difficulty: Option<U256>,
 	/// Type of data currenty being requested from peer.
@@ -359,6 +357,8 @@ impl ChainSync {
 		}
 		self.syncing_difficulty = From::from(0u64);
 		self.state = SyncState::Idle;
+		// Reactivate peers only if some progress has been made
+		// since the last sync round of if starting fresh.
 		self.active_peers = self.peers.keys().cloned().collect();
 	}

@@ -370,7 +370,8 @@ impl ChainSync {
 		self.continue_sync(io);
 	}

-	/// Remove peer from active peer set
+	/// Remove peer from active peer set. Peer will be reactivated on the next sync
+	/// round.
 	fn deactivate_peer(&mut self, io: &mut SyncIo, peer_id: PeerId) {
 		trace!(target: "sync", "Deactivating peer {}", peer_id);
 		self.active_peers.remove(&peer_id);
@@ -400,7 +401,6 @@ impl ChainSync {
 			network_id: try!(r.val_at(1)),
 			difficulty: Some(try!(r.val_at(2))),
 			latest_hash: try!(r.val_at(3)),
-			latest_number: None,
 			genesis: try!(r.val_at(4)),
 			asking: PeerAsking::Nothing,
 			asking_blocks: Vec::new(),
@@ -433,7 +433,11 @@ impl ChainSync {
 		}

 		self.peers.insert(peer_id.clone(), peer);
-		self.active_peers.insert(peer_id.clone());
+		// Don't activate peer immediatelly when searching for common block.
+		// Let the current sync round complete first.
+		if self.state != SyncState::ChainHead {
+			self.active_peers.insert(peer_id.clone());
+		}
 		debug!(target: "sync", "Connected {}:{}", peer_id, io.peer_info(peer_id));
 		if let Some((fork_block, _)) = self.fork_block {
 			self.request_headers_by_number(io, peer_id, fork_block, 1, 0, false, PeerAsking::ForkHeader);
@@ -520,7 +524,7 @@ impl ChainSync {
 				continue;
 			}

-			if self.highest_block == None || number > self.highest_block.unwrap() {
+			if self.highest_block.as_ref().map_or(true,  |n| number > *n) {
 				self.highest_block = Some(number);
 			}
 			let hash = info.hash();
@@ -552,18 +556,13 @@ impl ChainSync {
 		}

 		if headers.is_empty() {
-			// Peer does not have any new subchain heads, deactivate it nd try with another
+			// Peer does not have any new subchain heads, deactivate it and try with another.
 			trace!(target: "sync", "{} Disabled for no data", peer_id);
-			io.disable_peer(peer_id);
+			self.deactivate_peer(io, peer_id);
 		}
 		match self.state {
 			SyncState::ChainHead => {
-				if headers.is_empty() {
-					// peer is not on our chain
-					// track back and try again
-					self.imported_this_round = Some(0);
-					self.start_sync_round(io);
-				} else {
+				if !headers.is_empty() {
 					// TODO: validate heads better. E.g. check that there is enough distance between blocks.
 					trace!(target: "sync", "Received {} subchain heads, proceeding to download", headers.len());
 					self.blocks.reset_to(hashes);
@@ -633,9 +632,9 @@ impl ChainSync {
 		}
 		let mut unknown = false;
 		{
-			let peer = self.peers.get_mut(&peer_id).unwrap();
-			peer.latest_hash = header.hash();
-			peer.latest_number = Some(header.number());
+			if let Some(ref mut peer) = self.peers.get_mut(&peer_id) {
+				peer.latest_hash = header.hash();
+			}
 		}
 		if self.last_imported_block > header.number() && self.last_imported_block - header.number() > MAX_NEW_BLOCK_AGE {
 			trace!(target: "sync", "Ignored ancient new block {:?}", h);
@@ -728,9 +727,9 @@ impl ChainSync {
 					new_hashes.push(hash.clone());
 					if number > max_height {
 						trace!(target: "sync", "New unknown block hash {:?}", hash);
-						let peer = self.peers.get_mut(&peer_id).unwrap();
-						peer.latest_hash = hash.clone();
-						peer.latest_number = Some(number);
+						if let Some(ref mut peer) = self.peers.get_mut(&peer_id) {
+							peer.latest_hash = hash.clone();
+						}
 						max_height = number;
 					}
 				},
@@ -807,15 +806,18 @@ impl ChainSync {
 			return;
 		}
 		let (peer_latest, peer_difficulty) = {
-			let peer = self.peers.get_mut(&peer_id).unwrap();
-			if peer.asking != PeerAsking::Nothing || !peer.can_sync() {
+			if let Some(ref mut peer) = self.peers.get_mut(&peer_id) {
+				if peer.asking != PeerAsking::Nothing || !peer.can_sync() {
+					return;
+				}
+				if self.state == SyncState::Waiting {
+					trace!(target: "sync", "Waiting for the block queue");
+					return;
+				}
+				(peer.latest_hash.clone(), peer.difficulty.clone())
+			} else {
 				return;
 			}
-			if self.state == SyncState::Waiting {
-				trace!(target: "sync", "Waiting for the block queue");
-				return;
-			}
-			(peer.latest_hash.clone(), peer.difficulty.clone())
 		};
 		let chain_info = io.chain().chain_info();
 		let td = chain_info.pending_total_difficulty;
@@ -892,35 +894,40 @@ impl ChainSync {
 		// check to see if we need to download any block bodies first
 		let needed_bodies = self.blocks.needed_bodies(MAX_BODIES_TO_REQUEST, ignore_others);
 		if !needed_bodies.is_empty() {
-			replace(&mut self.peers.get_mut(&peer_id).unwrap().asking_blocks, needed_bodies.clone());
+			if let Some(ref mut peer) = self.peers.get_mut(&peer_id) {
+				peer.asking_blocks = needed_bodies.clone();
+			}
 			self.request_bodies(io, peer_id, needed_bodies);
 			return;
 		}

 		// find subchain to download
 		if let Some((h, count)) = self.blocks.needed_headers(MAX_HEADERS_TO_REQUEST, ignore_others) {
-			replace(&mut self.peers.get_mut(&peer_id).unwrap().asking_blocks, vec![h.clone()]);
+			if let Some(ref mut peer) = self.peers.get_mut(&peer_id) {
+				peer.asking_blocks = vec![h.clone()];
+			}
 			self.request_headers_by_hash(io, peer_id, &h, count, 0, false, PeerAsking::BlockHeaders);
 		}
 	}

 	/// Clear all blocks/headers marked as being downloaded by a peer.
 	fn clear_peer_download(&mut self, peer_id: PeerId) {
-		let peer = self.peers.get_mut(&peer_id).unwrap();
-		match peer.asking {
-			PeerAsking::BlockHeaders | PeerAsking::Heads => {
-				for b in &peer.asking_blocks {
-					self.blocks.clear_header_download(b);
-				}
-			},
-			PeerAsking::BlockBodies => {
-				for b in &peer.asking_blocks {
-					self.blocks.clear_body_download(b);
-				}
-			},
-			_ => (),
+		if let Some(ref mut peer) = self.peers.get_mut(&peer_id) {
+			match peer.asking {
+				PeerAsking::BlockHeaders | PeerAsking::Heads => {
+					for b in &peer.asking_blocks {
+						self.blocks.clear_header_download(b);
+					}
+				},
+				PeerAsking::BlockBodies => {
+					for b in &peer.asking_blocks {
+						self.blocks.clear_body_download(b);
+					}
+				},
+				_ => (),
+			}
+			peer.asking_blocks.clear();
 		}
-		peer.asking_blocks.clear();
 	}

 	fn block_imported(&mut self, hash: &H256, number: BlockNumber, parent: &H256) {
@@ -1029,30 +1036,34 @@ impl ChainSync {

 	/// Reset peer status after request is complete.
 	fn reset_peer_asking(&mut self, peer_id: PeerId, asking: PeerAsking) -> bool {
-		let peer = self.peers.get_mut(&peer_id).unwrap();
-		peer.expired = false;
-		if peer.asking != asking {
-			trace!(target:"sync", "Asking {:?} while expected {:?}", peer.asking, asking);
-			peer.asking = PeerAsking::Nothing;
+		if let Some(ref mut peer) = self.peers.get_mut(&peer_id) {
+			peer.expired = false;
+			if peer.asking != asking {
+				trace!(target:"sync", "Asking {:?} while expected {:?}", peer.asking, asking);
+				peer.asking = PeerAsking::Nothing;
+				false
+			}
+			else {
+				peer.asking = PeerAsking::Nothing;
+				true
+			}
+		} else {
 			false
 		}
-		else {
-			peer.asking = PeerAsking::Nothing;
-			true
-		}
 	}

 	/// Generic request sender
 	fn send_request(&mut self, sync: &mut SyncIo, peer_id: PeerId, asking: PeerAsking,  packet_id: PacketId, packet: Bytes) {
-		let peer = self.peers.get_mut(&peer_id).unwrap();
-		if peer.asking != PeerAsking::Nothing {
-			warn!(target:"sync", "Asking {:?} while requesting {:?}", peer.asking, asking);
-		}
-		peer.asking = asking;
-		peer.ask_time = time::precise_time_s();
-		if let Err(e) = sync.send(peer_id, packet_id, packet) {
-			debug!(target:"sync", "Error sending request: {:?}", e);
-			sync.disable_peer(peer_id);
+		if let Some(ref mut peer) = self.peers.get_mut(&peer_id) {
+			if peer.asking != PeerAsking::Nothing {
+				warn!(target:"sync", "Asking {:?} while requesting {:?}", peer.asking, asking);
+			}
+			peer.asking = asking;
+			peer.ask_time = time::precise_time_s();
+			if let Err(e) = sync.send(peer_id, packet_id, packet) {
+				debug!(target:"sync", "Error sending request: {:?}", e);
+				sync.disable_peer(peer_id);
+			}
 		}
 	}

@@ -1079,7 +1090,12 @@ impl ChainSync {
 		item_count = min(item_count, MAX_TX_TO_IMPORT);
 		let mut transactions = Vec::with_capacity(item_count);
 		for i in 0 .. item_count {
-			let tx = try!(r.at(i)).as_raw().to_vec();
+			let rlp = try!(r.at(i));
+			if rlp.as_raw().len() > MAX_TRANSACTION_SIZE {
+				debug!("Skipped oversized transaction of {} bytes", rlp.as_raw().len());
+				continue;
+			}
+			let tx = rlp.as_raw().to_vec();
 			transactions.push(tx);
 		}
 		io.chain().queue_transactions(transactions);
@@ -1365,7 +1381,7 @@ impl ChainSync {
 	/// creates latest block rlp for the given client
 	fn create_latest_block_rlp(chain: &BlockChainClient) -> Bytes {
 		let mut rlp_stream = RlpStream::new_list(2);
-		rlp_stream.append_raw(&chain.block(BlockID::Hash(chain.chain_info().best_block_hash)).unwrap(), 1);
+		rlp_stream.append_raw(&chain.block(BlockID::Hash(chain.chain_info().best_block_hash)).expect("Best block always exists"), 1);
 		rlp_stream.append(&chain.chain_info().total_difficulty);
 		rlp_stream.out()
 	}
@@ -1379,25 +1395,23 @@ impl ChainSync {
 	}

 	/// returns peer ids that have less blocks than our chain
-	fn get_lagging_peers(&mut self, chain_info: &BlockChainInfo, io: &SyncIo) -> Vec<(PeerId, BlockNumber)> {
+	fn get_lagging_peers(&mut self, chain_info: &BlockChainInfo, io: &SyncIo) -> Vec<PeerId> {
 		let latest_hash = chain_info.best_block_hash;
-		let latest_number = chain_info.best_block_number;
 		self.peers.iter_mut().filter_map(|(&id, ref mut peer_info)|
 			match io.chain().block_status(BlockID::Hash(peer_info.latest_hash.clone())) {
 				BlockStatus::InChain => {
-					if peer_info.latest_number.is_none() {
-						peer_info.latest_number = Some(HeaderView::new(&io.chain().block_header(BlockID::Hash(peer_info.latest_hash.clone())).unwrap()).number());
+					if peer_info.latest_hash != latest_hash {
+						Some(id)
+					} else {
+						None
 					}
-					if peer_info.latest_hash != latest_hash && latest_number > peer_info.latest_number.unwrap() {
-						Some((id, peer_info.latest_number.unwrap()))
-					} else { None }
 				},
 				_ => None
 			})
 			.collect::<Vec<_>>()
 	}

-	fn select_random_lagging_peers(&mut self, peers: &[(PeerId, BlockNumber)]) -> Vec<(PeerId, BlockNumber)> {
+	fn select_random_lagging_peers(&mut self, peers: &[PeerId]) -> Vec<PeerId> {
 		use rand::Rng;
 		// take sqrt(x) peers
 		let mut peers = peers.to_vec();
@@ -1410,46 +1424,42 @@ impl ChainSync {
 	}

 	/// propagates latest block to lagging peers
-	fn propagate_blocks(&mut self, chain_info: &BlockChainInfo, io: &mut SyncIo, sealed: &[H256], peers: &[(PeerId, BlockNumber)]) -> usize {
+	fn propagate_blocks(&mut self, chain_info: &BlockChainInfo, io: &mut SyncIo, sealed: &[H256], peers: &[PeerId]) -> usize {
 		trace!(target: "sync", "Sending NewBlocks to {:?}", peers);
 		let mut sent = 0;
-		for &(peer_id, _) in peers {
+		for peer_id in peers {
 			if sealed.is_empty() {
 				let rlp =  ChainSync::create_latest_block_rlp(io.chain());
-				self.send_packet(io, peer_id, NEW_BLOCK_PACKET, rlp);
+				self.send_packet(io, *peer_id, NEW_BLOCK_PACKET, rlp);
 			} else {
 				for h in sealed {
 					let rlp =  ChainSync::create_new_block_rlp(io.chain(), h);
-					self.send_packet(io, peer_id, NEW_BLOCK_PACKET, rlp);
+					self.send_packet(io, *peer_id, NEW_BLOCK_PACKET, rlp);
 				}
 			}
-			self.peers.get_mut(&peer_id).unwrap().latest_hash = chain_info.best_block_hash.clone();
-			self.peers.get_mut(&peer_id).unwrap().latest_number = Some(chain_info.best_block_number);
+			if let Some(ref mut peer) = self.peers.get_mut(&peer_id) {
+				peer.latest_hash = chain_info.best_block_hash.clone();
+			}
 			sent += 1;
 		}
 		sent
 	}

 	/// propagates new known hashes to all peers
-	fn propagate_new_hashes(&mut self, chain_info: &BlockChainInfo, io: &mut SyncIo, peers: &[(PeerId, BlockNumber)]) -> usize {
+	fn propagate_new_hashes(&mut self, chain_info: &BlockChainInfo, io: &mut SyncIo, peers: &[PeerId]) -> usize {
 		trace!(target: "sync", "Sending NewHashes to {:?}", peers);
 		let mut sent = 0;
-		let last_parent = HeaderView::new(&io.chain().block_header(BlockID::Hash(chain_info.best_block_hash.clone())).unwrap()).parent_hash();
-		for &(peer_id, peer_number) in peers {
-			let peer_best = if chain_info.best_block_number - peer_number > MAX_PEER_LAG_PROPAGATION as BlockNumber {
-				// If we think peer is too far behind just send one latest hash
-				last_parent.clone()
-			} else {
-				self.peers.get(&peer_id).unwrap().latest_hash.clone()
-			};
-			sent += match ChainSync::create_new_hashes_rlp(io.chain(), &peer_best, &chain_info.best_block_hash) {
+		let last_parent = HeaderView::new(&io.chain().block_header(BlockID::Hash(chain_info.best_block_hash.clone()))
+			.expect("Best block always exists")).parent_hash();
+		for peer_id in peers {
+			sent += match ChainSync::create_new_hashes_rlp(io.chain(), &last_parent, &chain_info.best_block_hash) {
 				Some(rlp) => {
 					{
-						let peer = self.peers.get_mut(&peer_id).unwrap();
-						peer.latest_hash = chain_info.best_block_hash.clone();
-						peer.latest_number = Some(chain_info.best_block_number);
+						if let Some(ref mut peer) = self.peers.get_mut(&peer_id) {
+							peer.latest_hash = chain_info.best_block_hash.clone();
+						}
 					}
-					self.send_packet(io, peer_id, NEW_BLOCK_HASHES_PACKET, rlp);
+					self.send_packet(io, *peer_id, NEW_BLOCK_HASHES_PACKET, rlp);
 					1
 				},
 				None => 0
@@ -1729,7 +1739,6 @@ mod tests {
 				genesis: H256::zero(),
 				network_id: U256::zero(),
 				latest_hash: peer_latest_hash,
-				latest_number: None,
 				difficulty: None,
 				asking: PeerAsking::Nothing,
 				asking_blocks: Vec::new(),
--- a/sync/src/tests/chain.rs
+++ b/sync/src/tests/chain.rs
@@ -95,6 +95,27 @@ fn forked() {
 	assert_eq!(&*net.peer(2).chain.numbers.read(), &peer1_chain);
 }

+#[test]
+fn forked_with_misbehaving_peer() {
+	::env_logger::init().ok();
+	let mut net = TestNet::new(3);
+	// peer 0 is on a totally different chain with higher total difficulty
+	net.peer_mut(0).chain = TestBlockChainClient::new_with_extra_data(b"fork".to_vec());
+	net.peer_mut(0).chain.add_blocks(500, EachBlockWith::Nothing);
+	net.peer_mut(1).chain.add_blocks(100, EachBlockWith::Nothing);
+	net.peer_mut(2).chain.add_blocks(100, EachBlockWith::Nothing);
+
+	net.peer_mut(1).chain.add_blocks(100, EachBlockWith::Nothing);
+	net.peer_mut(2).chain.add_blocks(200, EachBlockWith::Uncle);
+	// peer 1 should sync to peer 2, others should not change
+	let peer0_chain = net.peer(0).chain.numbers.read().clone();
+	let peer2_chain = net.peer(2).chain.numbers.read().clone();
+	net.sync();
+	assert_eq!(&*net.peer(0).chain.numbers.read(), &peer0_chain);
+	assert_eq!(&*net.peer(1).chain.numbers.read(), &peer2_chain);
+	assert_eq!(&*net.peer(2).chain.numbers.read(), &peer2_chain);
+}
+
 #[test]
 fn net_hard_fork() {
 	::env_logger::init().ok();
@@ -116,11 +137,12 @@ fn net_hard_fork() {

 #[test]
 fn restart() {
+	::env_logger::init().ok();
 	let mut net = TestNet::new(3);
 	net.peer_mut(1).chain.add_blocks(1000, EachBlockWith::Uncle);
 	net.peer_mut(2).chain.add_blocks(1000, EachBlockWith::Uncle);

-	net.sync_steps(8);
+	net.sync();

 	// make sure that sync has actually happened
 	assert!(net.peer(0).chain.chain_info().best_block_number > 100);
--- a/sync/src/tests/helpers.rs
+++ b/sync/src/tests/helpers.rs
@@ -26,6 +26,7 @@ pub struct TestIo<'p> {
 	pub chain: &'p mut TestBlockChainClient,
 	pub queue: &'p mut VecDeque<TestPacket>,
 	pub sender: Option<PeerId>,
+	pub to_disconnect: HashSet<PeerId>,
 	overlay: RwLock<HashMap<BlockNumber, Bytes>>,
 }

@@ -35,16 +36,19 @@ impl<'p> TestIo<'p> {
 			chain: chain,
 			queue: queue,
 			sender: sender,
+			to_disconnect: HashSet::new(),
 			overlay: RwLock::new(HashMap::new()),
 		}
 	}
 }

 impl<'p> SyncIo for TestIo<'p> {
-	fn disable_peer(&mut self, _peer_id: PeerId) {
+	fn disable_peer(&mut self, peer_id: PeerId) {
+		self.disconnect_peer(peer_id);
 	}

-	fn disconnect_peer(&mut self, _peer_id: PeerId) {
+	fn disconnect_peer(&mut self, peer_id: PeerId) {
+		self.to_disconnect.insert(peer_id);
 	}

 	fn is_expired(&self) -> bool {
@@ -141,13 +145,30 @@ impl TestNet {
 	pub fn sync_step(&mut self) {
 		for peer in 0..self.peers.len() {
 			if let Some(packet) = self.peers[peer].queue.pop_front() {
-				let mut p = self.peers.get_mut(packet.recipient).unwrap();
-				trace!("--- {} -> {} ---", peer, packet.recipient);
-				ChainSync::dispatch_packet(&p.sync, &mut TestIo::new(&mut p.chain, &mut p.queue, Some(peer as PeerId)), peer as PeerId, packet.packet_id, &packet.data);
-				trace!("----------------");
+				let disconnecting = {
+					let mut p = self.peers.get_mut(packet.recipient).unwrap();
+					trace!("--- {} -> {} ---", peer, packet.recipient);
+					let to_disconnect = {
+						let mut io = TestIo::new(&mut p.chain, &mut p.queue, Some(peer as PeerId));
+						ChainSync::dispatch_packet(&p.sync, &mut io, peer as PeerId, packet.packet_id, &packet.data);
+						io.to_disconnect
+					};
+					for d in &to_disconnect {
+						// notify this that disconnecting peers are disconnecting
+						let mut io = TestIo::new(&mut p.chain, &mut p.queue, Some(*d));
+						p.sync.write().on_peer_aborting(&mut io, *d);
+					}
+					to_disconnect
+				};
+				for d in &disconnecting {
+					// notify other peers that this peer is disconnecting
+					let mut p = self.peers.get_mut(*d).unwrap();
+					let mut io = TestIo::new(&mut p.chain, &mut p.queue, Some(peer as PeerId));
+					p.sync.write().on_peer_aborting(&mut io, peer as PeerId);
+				}
 			}
-			let mut p = self.peers.get_mut(peer).unwrap();
-			p.sync.write().maintain_sync(&mut TestIo::new(&mut p.chain, &mut p.queue, None));
+
+			self.sync_step_peer(peer);
 		}
 	}

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

--- a/util/io/src/lib.rs
+++ b/util/io/src/lib.rs
@@ -68,6 +68,8 @@ mod panics;
 use mio::{EventLoop, Token};
 use std::fmt;

+pub use worker::LOCAL_STACK_SIZE;
+
 #[derive(Debug)]
 /// IO Error
 pub enum IoError {
--- a/util/io/src/worker.rs
+++ b/util/io/src/worker.rs
@@ -22,9 +22,19 @@ use crossbeam::sync::chase_lev;
 use service::{HandlerId, IoChannel, IoContext};
 use IoHandler;
 use panics::*;
+use std::cell::Cell;

 use std::sync::{Condvar as SCondvar, Mutex as SMutex};

+const STACK_SIZE: usize = 16*1024*1024;
+
+thread_local! {
+	/// Stack size
+	/// Should be modified if it is changed in Rust since it is no way
+	/// to know or get it
+	pub static LOCAL_STACK_SIZE: Cell<usize> = Cell::new(::std::env::var("RUST_MIN_STACK").ok().and_then(|s| s.parse().ok()).unwrap_or(2 * 1024 * 1024));
+}
+
 pub enum WorkType<Message> {
 	Readable,
 	Writable,
@@ -66,8 +76,9 @@ impl Worker {
 			deleting: deleting.clone(),
 			wait_mutex: wait_mutex.clone(),
 		};
-		worker.thread = Some(thread::Builder::new().name(format!("IO Worker #{}", index)).spawn(
+		worker.thread = Some(thread::Builder::new().stack_size(STACK_SIZE).name(format!("IO Worker #{}", index)).spawn(
 			move || {
+				LOCAL_STACK_SIZE.with(|val| val.set(STACK_SIZE));
 				panic_handler.catch_panic(move || {
 					Worker::work_loop(stealer, channel.clone(), wait, wait_mutex.clone(), deleting)
 				}).unwrap()
--- a/util/network/src/host.rs
+++ b/util/network/src/host.rs
@@ -580,7 +580,8 @@ impl Host {
 	}

 	fn handshake_count(&self) -> usize {
-		self.sessions.read().count() - self.session_count()
+		// session_count < total_count is possible because of the data race.
+		self.sessions.read().count().saturating_sub(self.session_count())
 	}

 	fn keep_alive(&self, io: &IoContext<NetworkIoMessage>) {
--- a/util/src/journaldb/overlayrecentdb.rs
+++ b/util/src/journaldb/overlayrecentdb.rs
@@ -70,6 +70,7 @@ struct JournalOverlay {
 	pending_overlay: H256FastMap<Bytes>, // Nodes being transfered from backing_overlay to backing db
 	journal: HashMap<u64, Vec<JournalEntry>>,
 	latest_era: Option<u64>,
+	earliest_era: Option<u64>,
 }

 #[derive(PartialEq)]
@@ -123,7 +124,10 @@ impl OverlayRecentDB {
 	fn can_reconstruct_refs(&self) -> bool {
 		let reconstructed = Self::read_overlay(&self.backing, self.column);
 		let journal_overlay = self.journal_overlay.read();
-		*journal_overlay == reconstructed
+		journal_overlay.backing_overlay == reconstructed.backing_overlay &&
+		journal_overlay.pending_overlay == reconstructed.pending_overlay &&
+		journal_overlay.journal == reconstructed.journal &&
+		journal_overlay.latest_era == reconstructed.latest_era
 	}

 	fn payload(&self, key: &H256) -> Option<Bytes> {
@@ -135,6 +139,7 @@ impl OverlayRecentDB {
 		let mut overlay = MemoryDB::new();
 		let mut count = 0;
 		let mut latest_era = None;
+		let mut earliest_era = None;
 		if let Some(val) = db.get(col, &LATEST_ERA_KEY).expect("Low-level database error.") {
 			let mut era = decode::<u64>(&val);
 			latest_era = Some(era);
@@ -166,6 +171,7 @@ impl OverlayRecentDB {
 						deletions: deletions,
 					});
 					index += 1;
+					earliest_era = Some(era);
 				};
 				if index == 0 || era == 0 {
 					break;
@@ -178,9 +184,62 @@ impl OverlayRecentDB {
 			backing_overlay: overlay,
 			pending_overlay: HashMap::default(),
 			journal: journal,
-			latest_era: latest_era }
+			latest_era: latest_era,
+			earliest_era: earliest_era,
+		}
 	}

+	fn apply_old_commit(batch: &DBTransaction, journal_overlay: &mut JournalOverlay, column: Option<u32>, end_era: u64, canon_id: &H256) -> Result<(), UtilError> {
+		// apply old commits' details
+		if let Some(ref mut records) = journal_overlay.journal.get_mut(&end_era) {
+			let mut canon_insertions: Vec<(H256, Bytes)> = Vec::new();
+			let mut canon_deletions: Vec<H256> = Vec::new();
+			let mut overlay_deletions: Vec<H256> = Vec::new();
+			let mut index = 0usize;
+			for mut journal in records.drain(..) {
+				//delete the record from the db
+				let mut r = RlpStream::new_list(3);
+				r.append(&end_era);
+				r.append(&index);
+				r.append(&&PADDING[..]);
+				try!(batch.delete(column, &r.drain()));
+				trace!("commit: Delete journal for time #{}.{}: {}, (canon was {}): +{} -{} entries", end_era, index, journal.id, canon_id, journal.insertions.len(), journal.deletions.len());
+				{
+					if canon_id == &journal.id {
+						for h in &journal.insertions {
+							if let Some((d, rc)) = journal_overlay.backing_overlay.raw(&to_short_key(h)) {
+								if rc > 0 {
+									canon_insertions.push((h.clone(), d.to_owned())); //TODO: optimize this to avoid data copy
+								}
+							}
+						}
+						canon_deletions = journal.deletions;
+					}
+					overlay_deletions.append(&mut journal.insertions);
+				}
+				index += 1;
+			}
+			// apply canon inserts first
+			for (k, v) in canon_insertions {
+				try!(batch.put(column, &k, &v));
+				journal_overlay.pending_overlay.insert(to_short_key(&k), v);
+			}
+			// update the overlay
+			for k in overlay_deletions {
+				journal_overlay.backing_overlay.remove_and_purge(&to_short_key(&k));
+			}
+			// apply canon deletions
+			for k in canon_deletions {
+				if !journal_overlay.backing_overlay.contains(&to_short_key(&k)) {
+					try!(batch.delete(column, &k));
+				}
+			}
+		}
+		journal_overlay.journal.remove(&end_era);
+		Ok(())
+	}
+
+
 }

 #[inline]
@@ -214,6 +273,8 @@ impl JournalDB for OverlayRecentDB {

 	fn latest_era(&self) -> Option<u64> { self.journal_overlay.read().latest_era }

+	fn earliest_era(&self) -> Option<u64> { self.journal_overlay.read().earliest_era }
+
 	fn state(&self, key: &H256) -> Option<Bytes> {
 		let journal_overlay = self.journal_overlay.read();
 		let key = to_short_key(key);
@@ -257,57 +318,16 @@ impl JournalDB for OverlayRecentDB {
 			}
 			journal_overlay.journal.entry(now).or_insert_with(Vec::new).push(JournalEntry { id: id.clone(), insertions: inserted_keys, deletions: removed_keys });
 		}
-
-		let journal_overlay = &mut *journal_overlay;
-		// apply old commits' details
 		if let Some((end_era, canon_id)) = end {
-			if let Some(ref mut records) = journal_overlay.journal.get_mut(&end_era) {
-				let mut canon_insertions: Vec<(H256, Bytes)> = Vec::new();
-				let mut canon_deletions: Vec<H256> = Vec::new();
-				let mut overlay_deletions: Vec<H256> = Vec::new();
-				let mut index = 0usize;
-				for mut journal in records.drain(..) {
-					//delete the record from the db
-					let mut r = RlpStream::new_list(3);
-					r.append(&end_era);
-					r.append(&index);
-					r.append(&&PADDING[..]);
-					try!(batch.delete(self.column, &r.drain()));
-					trace!("commit: Delete journal for time #{}.{}: {}, (canon was {}): +{} -{} entries", end_era, index, journal.id, canon_id, journal.insertions.len(), journal.deletions.len());
-					{
-						if canon_id == journal.id {
-							for h in &journal.insertions {
-								if let Some((d, rc)) = journal_overlay.backing_overlay.raw(&to_short_key(h)) {
-									if rc > 0 {
-										canon_insertions.push((h.clone(), d.to_owned())); //TODO: optimize this to avoid data copy
-									}
-								}
-							}
-							canon_deletions = journal.deletions;
-						}
-						overlay_deletions.append(&mut journal.insertions);
-					}
-					index += 1;
-				}
-				// apply canon inserts first
-				for (k, v) in canon_insertions {
-					try!(batch.put(self.column, &k, &v));
-					journal_overlay.pending_overlay.insert(to_short_key(&k), v);
-				}
-				// update the overlay
-				for k in overlay_deletions {
-					journal_overlay.backing_overlay.remove_and_purge(&to_short_key(&k));
-				}
-				// apply canon deletions
-				for k in canon_deletions {
-					if !journal_overlay.backing_overlay.contains(&to_short_key(&k)) {
-						try!(batch.delete(self.column, &k));
-					}
-				}
-			}
-			journal_overlay.journal.remove(&end_era);
+			try!(Self::apply_old_commit(batch, &mut journal_overlay, self.column, end_era, &canon_id));
 		}
-		Ok(0)
+		Ok((0))
+
+	}
+
+	fn commit_old(&mut self, batch: &DBTransaction, end_era: u64, end_id: &H256) -> Result<(), UtilError> {
+		let mut journal_overlay = self.journal_overlay.write();
+		Self::apply_old_commit(batch, &mut journal_overlay, self.column, end_era, end_id)
 	}

 	fn flush(&self) {
--- a/util/src/journaldb/traits.rs
+++ b/util/src/journaldb/traits.rs
@@ -35,10 +35,19 @@ pub trait JournalDB: HashDB {
 	/// Get the latest era in the DB. None if there isn't yet any data in there.
 	fn latest_era(&self) -> Option<u64>;

+	/// Get the earliest era in the DB. None if there isn't yet any data in there.
+	fn earliest_era(&self) -> Option<u64> { None }
+
 	/// Commit all recent insert operations and canonical historical commits' removals from the
 	/// old era to the backing database, reverting any non-canonical historical commit's inserts.
 	fn commit(&mut self, batch: &DBTransaction, now: u64, id: &H256, end: Option<(u64, H256)>) -> Result<u32, UtilError>;

+	/// Commit canonical historical commits' removals from the
+	/// old era to the backing database, reverting any non-canonical historical commit's inserts.
+	fn commit_old(&mut self, _batch: &DBTransaction, _end_era: u64, _end_id: &H256) -> Result<(), UtilError> {
+		Ok(())
+	}
+
 	/// Commit all queued insert and delete operations without affecting any journalling -- this requires that all insertions
 	/// and deletions are indeed canonical and will likely lead to an invalid database if that assumption is violated.
 	///
--- a/util/src/kvdb.rs
+++ b/util/src/kvdb.rs
@@ -21,7 +21,7 @@ use elastic_array::*;
 use std::default::Default;
 use rlp::{UntrustedRlp, RlpType, View, Compressible};
 use rocksdb::{DB, Writable, WriteBatch, WriteOptions, IteratorMode, DBIterator,
-	Options, DBCompactionStyle, BlockBasedOptions, Direction, Cache, Column};
+	Options, DBCompactionStyle, BlockBasedOptions, Direction, Cache, Column, ReadOptions};

 const DB_BACKGROUND_FLUSHES: i32 = 2;
 const DB_BACKGROUND_COMPACTIONS: i32 = 2;
@@ -198,6 +198,7 @@ pub struct Database {
 	db: DB,
 	write_opts: WriteOptions,
 	cfs: Vec<Column>,
+	read_opts: ReadOptions,
 	overlay: RwLock<Vec<HashMap<ElasticArray32<u8>, KeyState>>>,
 }

@@ -214,6 +215,7 @@ impl Database {
 			try!(opts.set_parsed_options(&format!("rate_limiter_bytes_per_sec={}", rate_limit)));
 		}
 		try!(opts.set_parsed_options(&format!("max_total_wal_size={}", 64 * 1024 * 1024)));
+		try!(opts.set_parsed_options("verify_checksums_in_compaction=0"));
 		opts.set_max_open_files(config.max_open_files);
 		opts.create_if_missing(true);
 		opts.set_use_fsync(false);
@@ -246,6 +248,8 @@ impl Database {
 		if !config.wal {
 			write_opts.disable_wal(true);
 		}
+		let mut read_opts = ReadOptions::new();
+		read_opts.set_verify_checksums(false);

 		let mut cfs: Vec<Column> = Vec::new();
 		let db = match config.columns {
@@ -287,6 +291,7 @@ impl Database {
 			write_opts: write_opts,
 			overlay: RwLock::new((0..(cfs.len() + 1)).map(|_| HashMap::new()).collect()),
 			cfs: cfs,
+			read_opts: read_opts,
 		})
 	}

@@ -390,8 +395,8 @@ impl Database {
 			Some(&KeyState::Delete) => Ok(None),
 			None => {
 				col.map_or_else(
-					|| self.db.get(key).map(|r| r.map(|v| v.to_vec())),
-					|c| self.db.get_cf(self.cfs[c as usize], key).map(|r| r.map(|v| v.to_vec())))
+					|| self.db.get_opt(key, &self.read_opts).map(|r| r.map(|v| v.to_vec())),
+					|c| self.db.get_cf_opt(self.cfs[c as usize], key, &self.read_opts).map(|r| r.map(|v| v.to_vec())))
 			},
 		}
 	}
@@ -399,8 +404,8 @@ impl Database {
 	/// Get value by partial key. Prefix size should match configured prefix size. Only searches flushed values.
 	// TODO: support prefix seek for unflushed ata
 	pub fn get_by_prefix(&self, col: Option<u32>, prefix: &[u8]) -> Option<Box<[u8]>> {
-		let mut iter = col.map_or_else(|| self.db.iterator(IteratorMode::From(prefix, Direction::Forward)),
-			|c| self.db.iterator_cf(self.cfs[c as usize], IteratorMode::From(prefix, Direction::Forward)).unwrap());
+		let mut iter = col.map_or_else(|| self.db.iterator_opt(IteratorMode::From(prefix, Direction::Forward), &self.read_opts),
+			|c| self.db.iterator_cf_opt(self.cfs[c as usize], IteratorMode::From(prefix, Direction::Forward), &self.read_opts).unwrap());
 		match iter.next() {
 			// TODO: use prefix_same_as_start read option (not availabele in C API currently)
 			Some((k, v)) => if k[0 .. prefix.len()] == prefix[..] { Some(v) } else { None },
@@ -411,8 +416,8 @@ impl Database {
 	/// Get database iterator for flushed data.
 	pub fn iter(&self, col: Option<u32>) -> DatabaseIterator {
 		//TODO: iterate over overlay
-		col.map_or_else(|| DatabaseIterator { iter: self.db.iterator(IteratorMode::Start) },
-			|c| DatabaseIterator { iter: self.db.iterator_cf(self.cfs[c as usize], IteratorMode::Start).unwrap() })
+		col.map_or_else(|| DatabaseIterator { iter: self.db.iterator_opt(IteratorMode::Start, &self.read_opts) },
+			|c| DatabaseIterator { iter: self.db.iterator_cf_opt(self.cfs[c as usize], IteratorMode::Start, &self.read_opts).unwrap() })
 	}
 }

--- a/util/src/misc.rs
+++ b/util/src/misc.rs
@@ -24,7 +24,7 @@ use target_info::Target;
 include!(concat!(env!("OUT_DIR"), "/version.rs"));
 include!(concat!(env!("OUT_DIR"), "/rustc_version.rs"));

-#[derive(PartialEq,Eq,Clone,Copy)]
+#[derive(PartialEq, Eq, Clone, Copy, Debug)]
 /// Boolean type for clean/dirty status.
 pub enum Filth {
 	/// Data has not been changed.
--- a/util/src/standard.rs
+++ b/util/src/standard.rs
@@ -46,4 +46,4 @@ pub use rustc_serialize::hex::{FromHex, FromHexError};
 pub use heapsize::HeapSizeOf;
 pub use itertools::Itertools;

-pub use parking_lot::{Condvar, Mutex, MutexGuard, RwLock, RwLockReadGuard, RwLockWriteGuard};
+pub use parking_lot::{Condvar, Mutex, MutexGuard, RwLock, RwLockReadGuard, RwLockWriteGuard};
Author	SHA1	Message	Date
Tomasz Drwięga	e0778fc069	[beta] EIP150.1c (#2599 ) * EIP150.1c Conflicts: ethcore/res/ethereum/expanse.json ethcore/res/ethereum/morden.json ethcore/res/ethereum/tests ethcore/src/blockchain/blockchain.rs ethcore/src/ethereum/ethash.rs ethcore/src/evm/interpreter/mod.rs json/src/spec/ethash.rs * Update json test suite (#2574) * update json test suite * comment out the incomplete test Conflicts: ethcore/res/ethereum/tests * Updating tests * Adding state tests * Updating tests * Updating HF block * Removing flushln [ci:skip] * Commenting out suicide test * New tests. * Switch to EIP tests. * Rename some stuff, combine transition tests. * Fix U256 overflows. * Name cleanups and an effort to fix tests. * Rename back for clarity. * Fix non-EIP-150 OOG CALLs * New transition block number & additional EIP150 tests * Morden transition block set; Tests updated * Added missing test	2016-10-15 15:16:26 +02:00
Arkadiy Paronyan	2ce43434f1	Revert "Bloom upgrade in beta" (#2635 )	2016-10-15 13:15:45 +02:00
Arkadiy Paronyan	18062f11dc	Remove count limit for local transactions (#2634 )	2016-10-15 12:29:27 +02:00
Nikolay Volf	d66bd3c83a	Bloom upgrade in beta (#2609 ) * bloom expand & upgrade logic * remove arc * progress tracker * comment about magic number * progress tick initial	2016-10-14 17:27:47 +02:00
Arkadiy Paronyan	935e8dcf56	Backports to beta (#2628 ) * v1.3.8 * mitigate refcell conflict in state diffing (#2601) * mitigate refcell conflict in state diffing Also uses RefCell::get_mut in a few places. * Add test case * Fixed stalled sync * Fixed tx queue limit for local transactions (#2616) * Fixed tx queue limit for local tx * Fixing test * Increas gas limit to 20x * Additional logs when transactions is removed from queue (#2617) * Database performance tweaks (#2619)	2016-10-14 17:26:35 +02:00
Arkadiy Paronyan	3c2c356f73	Tweak DB and mining defaults (#2598 ) * Increase WAL size * Decreased default work queue size	2016-10-12 20:44:25 +02:00
Arkadiy Paronyan	6b4d0cea6b	Configurable history size in beta (#2587 ) * Reduce DB history * Configurable history size * Set min history size * Test * Fixed a test and reduced the limit	2016-10-12 20:44:17 +02:00
Denis S. Soldatov aka General-Beck	13de1ebc8e	Update gitlab-ci remove arm builds from `master`	2016-10-13 00:20:33 +07:00
Arkadiy Paronyan	1fdb033db4	Backports to beta (#2592 ) * TX queue gas limit config and allow local transactions over the gas limit (#2553) * Gas limit config; Allow local transactions over the limit * Fix typo [ci:skip] * v1.3.7	2016-10-12 17:33:59 +02:00
Denis S. Soldatov aka General-Beck	c1f0ea2016	Update gitlab-ci installer.exe -> InstallParity.exe	2016-10-12 22:33:17 +07:00
Denis S. Soldatov aka General-Beck	964f556284	Update gitlab-ci checksum -> parity.md5	2016-10-12 21:29:58 +07:00
Denis S. Soldatov aka General-Beck	8fba01a208	Update gitlab-ci fix S3 path for win	2016-10-12 20:18:53 +07:00
Denis S. Soldatov aka General-Beck	77b49623ff	Update gitlab-ci fix win build	2016-10-12 19:55:21 +07:00
Denis S. Soldatov aka General-Beck	2a29d7a76f	Update gitlab-ci update windows biuld (add .exe .zip *.md5	2016-10-12 19:22:28 +07:00
Denis S. Soldatov aka General-Beck	66f684548d	Update gitlab-ci fix windows installer	2016-10-12 16:21:12 +07:00
Denis S. Soldatov aka General-Beck	ccebe473d0	Update gitlab-ci fix errors in windows build	2016-10-12 13:27:22 +07:00
Denis S. Soldatov aka General-Beck	9707e61525	Update gitlab-ci [ci:skip] Deny warnings in windows build	2016-10-12 01:54:43 +07:00
Denis S. Soldatov aka General-Beck	039594de92	Update gitlab-ci switch to curl in win build	2016-10-12 01:39:53 +07:00
Denis S. Soldatov aka General-Beck	69441b1322	Update gitlab-ci add windows installer	2016-10-12 00:08:24 +07:00
Arkadiy Paronyan	8492e3e61d	Backports to beta v1.3.6 (#2571 ) * v1.3.6 * Print backtrace on panic (#2535) * Don't activate peers on connect; Test (#2537) * Removing unwarps from sync module (#2551) * Remove unwrap from client module (#2554) * remove unwraps in client * imporve block hash expect message * mining perf trace * Fixed race condition in trace import (#2555)	2016-10-11 15:53:45 +02:00
Denis S. Soldatov aka General-Beck	4b7c97783b	Update gitlab-ci remove javascript tag	2016-10-08 10:51:42 +07:00
Arkadiy Paronyan	6d14c5458b	Use global state cache when mining (#2529 )	2016-10-08 02:00:06 +02:00
arkpar	9239a7cd9e	v1.3.5	2016-10-08 01:02:41 +02:00
Arkadiy Paronyan	d27ecb6527	Transaction queue limited by gas (#2528 )	2016-10-08 00:59:04 +02:00
Robert Habermeier	5502340dea	Merge pull request #2521 from ethcore/update-appveyor-rustc-beta Update appveyor rustc [beta]	2016-10-07 17:39:41 +02:00
Denis S. Soldatov aka General-Beck	2313f9b4f1	Update gitlab-ci add javascript test	2016-10-07 22:31:09 +07:00
Robert Habermeier	324a5873d7	turn off MIR for windows builds	2016-10-07 16:07:01 +02:00
Robert Habermeier	b45e7f1c41	update rustc for appveyor to 1.12.0	2016-10-07 16:06:39 +02:00
Tomasz Drwięga	64af073bd4	Increase size of transaction queue by default (#2519 ) Conflicts: ethcore/src/miner/miner.rs parity/cli/config.full.toml parity/cli/mod.rs parity/configuration.rs	2016-10-07 14:11:33 +01:00
Arkadiy Paronyan	fe83046198	Backport to beta (#2518 ) * Handle reorganizations in the state cache * Renamed and documented a few methods * Basic test * Renamed pending to buffered * Caching optimizations * Fixed a test * Fixed a test	2016-10-07 14:09:52 +01:00
Tomasz Drwięga	8031910892	[beta] Fixing RPC Filter conversion to EthFilter (#2501 ) * Fixing RPC Filter conversion to EthFilter Conflicts: rpc/src/v1/impls/eth.rs rpc/src/v1/types/filter.rs * Removing limit * Fixing rpc tests	2016-10-07 12:16:09 +01:00
Tomasz Drwięga	73a3dac38c	[beta] Using pending block only if is not old (#2515 ) * Using pending block only if not old Conflicts: ethcore/src/miner/miner.rs rpc/src/v1/impls/eth.rs rpc/src/v1/impls/eth_filter.rs * Fixing compilation issues	2016-10-07 11:46:17 +01:00
Arkadiy Paronyan	bbaf5ed4f5	Backports into beta (#2512 ) * RocksDB version bump * Preserve cache on reverting the snapshot (#2488) * Preserve cache on reverting the snapshot * Renamed merge_with into replace_with * Renamed and documented snapshotting methods * Track dirty accounts in the state (#2461) * State to track dirty accounts * Removed clone_for_snapshot * Renaming stuff * Documentation and other minor fixes * Replaced MaybeAccount with Option * Adjustable stack size for EVM (#2483) * stack size for io workers & evm threshold * rust way to remember stack size * right value * 24kb size * some stack reduction * Fixed overflow panic in handshake_panic (#2495)	2016-10-07 10:49:48 +01:00
Tomasz Drwięga	9cf777510f	CLI to specify queue ordering strategy (#2494 ) * Alter gas priorities to include gas_price also * CLI options and tests * Adding ordering by gas * whitespace [ci:skip]	2016-10-07 09:04:13 +02:00
Nikolay Volf	9b398421ce	Run inplace upgrades after version update (#2411 ) * Update migration.rs In highly unlikely scenario when the bloom update fails it will at least try again on the next run * proper exchange	2016-10-07 09:03:49 +02:00
Tomasz Drwięga	a618dcaaf0	Fixing penalization in future (#2493 )	2016-10-06 15:52:09 +01:00
Nikolay Volf	50021c7611	Fix ethstore opening all key files in the directory at once (BETA) (#2472 ) * get rid of collects & zips * not an option here!	2016-10-05 15:41:48 +02:00
Denis S. Soldatov aka General-Beck	f62d2e6ea8	Update gitlab-ci fix windows	2016-10-05 10:54:01 +07:00
Denis S. Soldatov aka General-Beck	7da8e7926d	Update gitlab-ci set RUSTFLAGS=-Zorbit=off windows	2016-10-05 08:38:33 +07:00
Denis S. Soldatov aka General-Beck	5363e75f3a	Update gitlab-ci add RUSTFLAGS=-Zorbit=false in windows build	2016-10-05 08:04:56 +07:00
Arkadiy Paronyan	31d667a29a	Merge pull request #2465 from ethcore/beta-staging Beta backports	2016-10-05 00:24:13 +02:00
arkpar	ca2bc92dda	Fixing tests	2016-10-04 23:24:16 +02:00
Marek Kotewicz	a0b71a9f52	fixed #2263 , geth keys with ciphertext shorter than 32 bytes (#2318 ) * fixed #2263, geth keys with ciphertext shorter than 32 bytes * replace unwrap with more helpful expect * tests for decrypting short secrets	2016-10-04 22:08:31 +02:00
arkpar	300c0c120b	v1.3.4	2016-10-04 22:00:59 +02:00
Nikolay Volf	b228dc7b54	IPC-library dependency fork & bump for beta (#2455 ) * bump json-ipc-server * bump again	2016-10-04 18:18:07 +02:00
Denis S. Soldatov aka General-Beck	df4d98001a	update gitlab-ci set RUST 1.11 for windows	2016-10-04 14:43:49 +08:00
Robert Habermeier	2e4672ea13	Merge pull request #2414 from ethcore/compilation-beta fix broken beta compilation (backport to beta)	2016-10-02 21:07:35 +02:00
Arkadiy Paronyan	7f7fe33bde	Jumptable cache (#2435 ) * v1.3.3 * Jumptable cache	2016-10-02 19:52:53 +02:00
Arkadiy Paronyan	3d313d592a	Disabling debug symbols due to rustc 1.12 memory usage regression	2016-10-02 09:45:27 +02:00
NikVolf	abc6970d08	fix ethkey more	2016-10-01 15:29:11 +03:00
NikVolf	fa636d402d	ethkey eq	2016-10-01 13:04:08 +03:00
NikVolf	73d6666294	some checksums	2016-10-01 00:28:31 +03:00
Denis S. Soldatov aka General-Beck	f16ccacd22	Update gitlab-ci add checksum	2016-09-30 21:03:05 +07:00
Nikolay Volf	ba3de5d3b9	rayon bump	2016-09-30 02:25:35 +03:00
Robert Habermeier	f16de5501a	fix broken beta compilation	2016-09-29 23:03:02 +03:00