update gitlab-ci

set RUST 1.11 for windows
Merge pull request #2414 from ethcore/compilation-beta
2016-10-04 14:43:49 +08:00 · 2016-10-02 21:07:35 +02:00 · 2016-10-02 19:52:53 +02:00 · 2016-10-02 09:45:27 +02:00 · 2016-10-01 15:29:11 +03:00 · 2016-10-01 13:04:08 +03:00
94 changed files with 2759 additions and 691 deletions
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -1,6 +1,6 @@
 stages:
  - build
-  - deploy
+  - test
 variables:
  GIT_DEPTH: "3"
  SIMPLECOV: "true" 
@@ -8,9 +8,60 @@ variables:
 cache:
  key: "$CI_BUILD_NAME/$CI_BUILD_REF_NAME"
  untracked: true
+linux-stable:
+  stage: build
+  image: ethcore/rust:stable
+  only:
+    - master
+    - beta
+    - tags
+    - stable
+  script:
+    - cargo build --release --verbose
+    - strip target/release/parity
+    - md5sum target/release/parity >> checksum
+    - 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/checksum --body checksum
+  tags:
+    - rust
+    - rust-stable
+  artifacts:
+    paths:
+    - target/release/parity
+    name: "stable-x86_64-unknown-linux-gnu_parity"
+linux-stable-14.04:
+  stage: build
+  image: ethcore/rust-14.04:latest
+  only:
+    - master
+    - beta
+    - tags
+    - stable
+  script:
+    - cargo build --release --verbose
+    - strip target/release/parity
+    - md5sum target/release/parity >> checksum
+    - 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/checksum --body checksum
+  tags:
+    - rust
+    - rust-14.04
+  artifacts:
+    paths:
+    - target/release/parity
+    name: "stable-x86_64-unknown-ubuntu_14_04-gnu_parity"
 linux-beta:
  stage: build
  image: ethcore/rust:beta
+  only:
+    - master
+    - beta
+    - tags
+    - stable
  script:
    - cargo build --release --verbose
    - strip target/release/parity
@@ -20,23 +71,16 @@ linux-beta:
  artifacts:
    paths:
    - target/release/parity
-    name: "${CI_BUILD_NAME}_parity"
-linux-stable:
-  stage: build
-  image: ethcore/rust:stable
-  script:
-    - cargo build --release --verbose
-    - strip target/release/parity
-  tags:
-    - rust
-    - rust-stable
-  artifacts:
-    paths:
-    - target/release/parity
-    name: "${CI_BUILD_NAME}_parity"
+    name: "beta-x86_64-unknown-linux-gnu_parity"
+  allow_failure: true
 linux-nightly:
  stage: build
  image: ethcore/rust:nightly
+  only:
+    - master
+    - beta
+    - tags
+    - stable
  script:
    - cargo build --release --verbose
    - strip target/release/parity
@@ -46,121 +90,203 @@ linux-nightly:
  artifacts:
    paths:
    - target/release/parity
-    name: "${CI_BUILD_NAME}_parity"
+    name: "nigthly-x86_64-unknown-linux-gnu_parity"
+  allow_failure: true
 linux-centos:
  stage: build
  image: ethcore/rust-centos:latest
+  only:
+    - master
+    - beta
+    - tags
+    - stable
  script:
    - export CXX="g++"
    - export CC="gcc"
    - cargo build --release --verbose
    - strip target/release/parity
+    - md5sum target/release/parity >> checksum
+    - 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/checksum --body checksum
  tags:
    - rust
    - rust-centos
  artifacts:
    paths:
    - target/release/parity
-    name: "${CI_BUILD_NAME}_parity"
+    name: "x86_64-unknown-centos-gnu_parity"
 linux-armv7:
  stage: build
-  image: ethcore/rust-arm:latest
+  image: ethcore/rust-armv7:latest
+  only:
+    - master
+    - beta
+    - tags
+    - stable
  script:
-    - export CXX=arm-linux-gnueabihf-g++
-    - export CC=arm-linux-gnueabihf-gcc
+    - rm -rf .cargo
    - mkdir -p .cargo
    - echo "[target.armv7-unknown-linux-gnueabihf]" >> .cargo/config
    - echo "linker= \"arm-linux-gnueabihf-gcc\"" >> .cargo/config
    - 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 >> checksum
+    - 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/checksum --body checksum
  tags:
    - rust
    - rust-arm
  artifacts:
    paths:
    - target/armv7-unknown-linux-gnueabihf/release/parity
-    name: "${CI_BUILD_NAME}_parity"
+    name: "armv7_unknown_linux_gnueabihf_parity"
+  allow_failure: true
 linux-arm:
  stage: build
  image: ethcore/rust-arm:latest
+  only:
+    - master
+    - beta
+    - tags
+    - stable
  script:
-    - export CXX=arm-linux-gnueabihf-g++
-    - export CC=arm-linux-gnueabihf-gcc
+    - rm -rf .cargo
    - mkdir -p .cargo
    - echo "[target.arm-unknown-linux-gnueabihf]" >> .cargo/config
    - echo "linker= \"arm-linux-gnueabihf-gcc\"" >> .cargo/config
    - 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 >> checksum
+    - 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/checksum --body checksum
  tags:
    - rust
    - rust-arm
  artifacts:
    paths:
    - target/arm-unknown-linux-gnueabihf/release/parity
-    name: "${CI_BUILD_NAME}_parity"
+    name: "arm-unknown-linux-gnueabihf_parity"
+  allow_failure: true
 linux-armv6:
  stage: build
-  image: ethcore/rust-arm:latest
+  image: ethcore/rust-armv6:latest
+  only:
+    - master
+    - beta
+    - tags
+    - stable
  script:
-    - export CXX=arm-linux-gnueabi-g++
-    - export CC=arm-linux-gnueabi-gcc
+    - rm -rf .cargo
    - mkdir -p .cargo
    - echo "[target.arm-unknown-linux-gnueabi]" >> .cargo/config
    - echo "linker= \"arm-linux-gnueabi-gcc\"" >> .cargo/config
    - 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 >> checksum 
+    - 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/checksum --body checksum
  tags:
    - rust
    - rust-arm
  artifacts:
    paths:
    - target/arm-unknown-linux-gnueabi/release/parity
-    name: "${CI_BUILD_NAME}_parity"
+    name: "arm-unknown-linux-gnueabi_parity"
+  allow_failure: true
 linux-aarch64:
  stage: build
-  image: ethcore/rust-arm:latest
+  image: ethcore/rust-aarch64:latest
+  only:
+    - master
+    - beta
+    - tags
+    - stable
  script:
-    - export CXX=aarch64-linux-gnu-g++
-    - export CC=aarch64-linux-gnu-gcc
+    - rm -rf .cargo
    - mkdir -p .cargo
    - echo "[target.aarch64-unknown-linux-gnu]" >> .cargo/config
    - echo "linker= \"aarch64-linux-gnu-gcc\"" >> .cargo/config
    - 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 >> checksum
+    - 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/checksum --body checksum
  tags:
    - rust
    - rust-arm
  artifacts:
    paths:
    - target/aarch64-unknown-linux-gnu/release/parity
-    name: "${CI_BUILD_NAME}_parity"
+    name: "aarch64-unknown-linux-gnu_parity"
+  allow_failure: true
 darwin:
  stage: build
+  only:
+    - master
+    - beta
+    - tags
+    - stable
  script:
    - cargo build --release --verbose
+    - md5sum target/release/parity >> checksum
+    - 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/checksum --body checksum
  tags:
    - osx
  artifacts:
    paths:
    - target/release/parity
-    name: "${CI_BUILD_NAME}_parity"
+    name: "x86_64-apple-darwin_parity"
 windows:
  stage: build
+  only:
+    - master
+    - beta
+    - tags
+    - stable
  script:
    - 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
-    - rustup default stable-x86_64-pc-windows-msvc
+    - rustup default 1.11.0-x86_64-pc-windows-msvc
    - cargo build --release --verbose
+    - md5sum target\release\parity >> checksum
+    - 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/checksum --body checksum
  tags:
   - rust-windows
  artifacts:
    paths:
    - target/release/parity.exe
    - target/release/parity.pdb
-    name: "${CI_BUILD_NAME}_parity"
+    name: "x86_64-pc-windows-msvc_parity"
+test-linux:
+  stage: test
+  before_script:
+    - git submodule update --init --recursive
+  script:
+    - export RUST_BACKTRACE=1
+    - ./test.sh --verbose
+  tags:
+    - rust-test
+  dependencies:
+    - linux-stable
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1,6 +1,6 @@
 [root]
 name = "parity"
-version = "1.3.0"
+version = "1.3.3"
 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)",
@@ -20,7 +20,7 @@ dependencies = [
 "ethcore-logger 1.3.0",
 "ethcore-rpc 1.3.0",
 "ethcore-signer 1.3.0",
- "ethcore-util 1.3.0",
+ "ethcore-util 1.3.3",
 "ethsync 1.3.0",
 "fdlimit 0.1.0",
 "hyper 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -112,6 +112,20 @@ name = "bloomchain"
 version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"

+[[package]]
+name = "bloomfilter"
+version = "0.0.10"
+source = "git+https://github.com/ethcore/rust-bloom-filter#e66a3f20443bc78810877390ad4da00ebdf74d78"
+dependencies = [
+ "bit-vec 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rand 0.3.14 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "byteorder"
+version = "0.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
 [[package]]
 name = "bytes"
 version = "0.3.0"
@@ -244,6 +258,8 @@ version = "1.3.0"
 dependencies = [
 "bit-set 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "bloomchain 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "bloomfilter 0.0.10 (git+https://github.com/ethcore/rust-bloom-filter)",
+ "byteorder 0.5.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "clippy 0.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam 0.2.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "env_logger 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -253,16 +269,18 @@ dependencies = [
 "ethcore-ipc 1.3.0",
 "ethcore-ipc-codegen 1.3.0",
 "ethcore-ipc-nano 1.3.0",
- "ethcore-util 1.3.0",
+ "ethcore-util 1.3.3",
 "ethjson 0.1.0",
 "ethstore 0.1.0",
+ "evmjit 1.3.0",
 "heapsize 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "hyper 0.9.4 (git+https://github.com/ethcore/hyper)",
 "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)",
+ "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)",
@@ -275,7 +293,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.0",
+ "ethcore-util 1.3.3",
 "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)",
@@ -317,7 +335,7 @@ name = "ethcore-ipc"
 version = "1.3.0"
 dependencies = [
 "ethcore-devtools 1.3.0",
- "ethcore-util 1.3.0",
+ "ethcore-util 1.3.3",
 "nanomsg 0.5.1 (git+https://github.com/ethcore/nanomsg.rs.git)",
 "semver 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
@@ -362,7 +380,7 @@ dependencies = [
 "ethcore-ipc 1.3.0",
 "ethcore-ipc-codegen 1.3.0",
 "ethcore-ipc-nano 1.3.0",
- "ethcore-util 1.3.0",
+ "ethcore-util 1.3.3",
 "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)",
@@ -374,7 +392,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.0",
+ "ethcore-util 1.3.3",
 "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)",
@@ -389,7 +407,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.0",
+ "ethcore-util 1.3.3",
 "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)",
@@ -413,7 +431,7 @@ dependencies = [
 "ethcore-devtools 1.3.0",
 "ethcore-io 1.3.0",
 "ethcore-ipc 1.3.0",
- "ethcore-util 1.3.0",
+ "ethcore-util 1.3.3",
 "ethjson 0.1.0",
 "ethsync 1.3.0",
 "json-ipc-server 0.2.4 (git+https://github.com/ethcore/json-ipc-server.git)",
@@ -436,7 +454,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.0",
+ "ethcore-util 1.3.3",
 "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)",
@@ -447,7 +465,7 @@ dependencies = [

 [[package]]
 name = "ethcore-util"
-version = "1.3.0"
+version = "1.3.3"
 dependencies = [
 "ansi_term 0.7.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "arrayvec 0.3.16 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -480,7 +498,7 @@ dependencies = [
 name = "ethjson"
 version = "0.1.0"
 dependencies = [
- "ethcore-util 1.3.0",
+ "ethcore-util 1.3.3",
 "rustc-serialize 0.3.19 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 0.7.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_codegen 0.7.9 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -528,7 +546,7 @@ dependencies = [
 "ethcore-ipc-codegen 1.3.0",
 "ethcore-ipc-nano 1.3.0",
 "ethcore-network 1.3.0",
- "ethcore-util 1.3.0",
+ "ethcore-util 1.3.3",
 "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)",
@@ -537,6 +555,13 @@ dependencies = [
 "time 0.1.35 (registry+https://github.com/rust-lang/crates.io-index)",
 ]

+[[package]]
+name = "evmjit"
+version = "1.3.0"
+dependencies = [
+ "tiny-keccak 1.0.5 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
 [[package]]
 name = "fdlimit"
 version = "0.1.0"
@@ -738,11 +763,24 @@ name = "libc"
 version = "0.2.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"

+[[package]]
+name = "linked-hash-map"
+version = "0.0.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
 [[package]]
 name = "log"
 version = "0.3.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"

+[[package]]
+name = "lru-cache"
+version = "0.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "linked-hash-map 0.0.9 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
 [[package]]
 name = "matches"
 version = "0.1.2"
@@ -1155,7 +1193,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)",
@@ -1183,7 +1221,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#84c5ac0bbd6901b6279a5480708e93eb3da6caa4"
+source = "git+https://github.com/ethcore/rust-rocksdb#485dd747a2c9a9f910fc8ac696fc9edf5fa22aa3"
 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)",
@@ -1192,7 +1230,7 @@ dependencies = [
 [[package]]
 name = "rocksdb-sys"
 version = "0.3.0"
-source = "git+https://github.com/ethcore/rust-rocksdb#84c5ac0bbd6901b6279a5480708e93eb3da6caa4"
+source = "git+https://github.com/ethcore/rust-rocksdb#485dd747a2c9a9f910fc8ac696fc9edf5fa22aa3"
 dependencies = [
 "gcc 0.3.28 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.12 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -1593,6 +1631,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"
@@ -1627,7 +1667,9 @@ dependencies = [
 "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"
 "checksum memchr 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)" = "d8b629fb514376c675b98c1421e80b151d3817ac42d7c667717d282761418d20"
 "checksum mime 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "a74cc2587bf97c49f3f5bab62860d6abf3902ca73b66b51d9b049fbdcd727bd2"
@@ -1673,7 +1715,7 @@ 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>"
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 description = "Ethcore client."
 name = "parity"
-version = "1.3.0"
+version = "1.3.3"
 license = "GPL-3.0"
 authors = ["Ethcore <admin@ethcore.io>"]
 build = "build.rs"
@@ -59,6 +59,7 @@ ui = ["dapps", "ethcore-signer/ui"]
 use-precompiled-js = ["ethcore-dapps/use-precompiled-js", "ethcore-signer/use-precompiled-js"]
 dapps = ["ethcore-dapps"]
 ipc = ["ethcore/ipc"]
+jit = ["ethcore/jit"]
 dev = ["clippy", "ethcore/dev", "ethcore-util/dev", "ethsync/dev", "ethcore-rpc/dev", "ethcore-dapps/dev", "ethcore-signer/dev"]
 json-tests = ["ethcore/json-tests"]

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

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

--- a/dapps/src/lib.rs
+++ b/dapps/src/lib.rs
@@ -100,14 +100,26 @@ impl ServerBuilder {

 	/// Asynchronously start server with no authentication,
 	/// returns result with `Server` handle on success or an error.
-	pub fn start_unsecure_http(&self, addr: &SocketAddr) -> Result<Server, ServerError> {
-		Server::start_http(addr, NoAuth, self.handler.clone(), self.dapps_path.clone())
+	pub fn start_unsecured_http(&self, addr: &SocketAddr, hosts: Option<Vec<String>>) -> Result<Server, ServerError> {
+		Server::start_http(
+			addr,
+			hosts,
+			NoAuth,
+			self.handler.clone(),
+			self.dapps_path.clone(),
+		)
 	}

 	/// Asynchronously start server with `HTTP Basic Authentication`,
 	/// return result with `Server` handle on success or an error.
-	pub fn start_basic_auth_http(&self, addr: &SocketAddr, username: &str, password: &str) -> Result<Server, ServerError> {
-		Server::start_http(addr, HttpBasicAuth::single_user(username, password), self.handler.clone(), self.dapps_path.clone())
+	pub fn start_basic_auth_http(&self, addr: &SocketAddr, hosts: Option<Vec<String>>, username: &str, password: &str) -> Result<Server, ServerError> {
+		Server::start_http(
+			addr,
+			hosts,
+			HttpBasicAuth::single_user(username, password),
+			self.handler.clone(),
+			self.dapps_path.clone(),
+		)
 	}
 }

@@ -118,7 +130,28 @@ pub struct Server {
 }

 impl Server {
-	fn start_http<A: Authorization + 'static>(addr: &SocketAddr, authorization: A, handler: Arc<IoHandler>, dapps_path: String) -> Result<Server, ServerError> {
+	/// Returns a list of allowed hosts or `None` if all hosts are allowed.
+	fn allowed_hosts(hosts: Option<Vec<String>>, bind_address: String) -> Option<Vec<String>> {
+		let mut allowed = Vec::new();
+
+		match hosts {
+			Some(hosts) => allowed.extend_from_slice(&hosts),
+			None => return None,
+		}
+
+		// Add localhost domain as valid too if listening on loopback interface.
+		allowed.push(bind_address.replace("127.0.0.1", "localhost").into());
+		allowed.push(bind_address.into());
+		Some(allowed)
+	}
+
+	fn start_http<A: Authorization + 'static>(
+		addr: &SocketAddr,
+		hosts: Option<Vec<String>>,
+		authorization: A,
+		handler: Arc<IoHandler>,
+		dapps_path: String,
+	) -> Result<Server, ServerError> {
 		let panic_handler = Arc::new(Mutex::new(None));
 		let authorization = Arc::new(authorization);
 		let endpoints = Arc::new(apps::all_endpoints(dapps_path));
@@ -129,7 +162,7 @@ impl Server {
 			special.insert(router::SpecialEndpoint::Utils, apps::utils());
 			special
 		});
-		let bind_address = format!("{}", addr);
+		let hosts = Self::allowed_hosts(hosts, format!("{}", addr));

 		try!(hyper::Server::http(addr))
 			.handle(move |_| router::Router::new(
@@ -137,7 +170,7 @@ impl Server {
 				endpoints.clone(),
 				special.clone(),
 				authorization.clone(),
-				bind_address.clone(),
+				hosts.clone(),
 			))
 			.map(|(l, srv)| {

@@ -182,3 +215,24 @@ impl From<hyper::error::Error> for ServerError {
 		}
 	}
 }
+
+#[cfg(test)]
+mod tests {
+	use super::Server;
+
+	#[test]
+	fn should_return_allowed_hosts() {
+		// given
+		let bind_address = "127.0.0.1".to_owned();
+
+		// when
+		let all = Server::allowed_hosts(None, bind_address.clone());
+		let address = Server::allowed_hosts(Some(Vec::new()), bind_address.clone());
+		let some = Server::allowed_hosts(Some(vec!["ethcore.io".into()]), bind_address.clone());
+
+		// then
+		assert_eq!(all, None);
+		assert_eq!(address, Some(vec!["localhost".into(), "127.0.0.1".into()]));
+		assert_eq!(some, Some(vec!["ethcore.io".into(), "localhost".into(), "127.0.0.1".into()]));
+	}
+}
--- a/dapps/src/router/host_validation.rs
+++ b/dapps/src/router/host_validation.rs
@@ -22,14 +22,11 @@ use hyper::net::HttpStream;
 use jsonrpc_http_server::{is_host_header_valid};
 use handlers::ContentHandler;

-
-pub fn is_valid(request: &server::Request<HttpStream>, bind_address: &str, endpoints: Vec<String>) -> bool {
-	let mut endpoints = endpoints.into_iter()
+pub fn is_valid(request: &server::Request<HttpStream>, allowed_hosts: &[String], endpoints: Vec<String>) -> bool {
+	let mut endpoints = endpoints.iter()
 		.map(|endpoint| format!("{}{}", endpoint, DAPPS_DOMAIN))
 		.collect::<Vec<String>>();
-	// Add localhost domain as valid too if listening on loopback interface.
-	endpoints.push(bind_address.replace("127.0.0.1", "localhost").into());
-	endpoints.push(bind_address.into());
+	endpoints.extend_from_slice(allowed_hosts);

 	is_host_header_valid(request, &endpoints)
 }
--- a/dapps/src/router/mod.rs
+++ b/dapps/src/router/mod.rs
@@ -45,7 +45,7 @@ pub struct Router<A: Authorization + 'static> {
 	endpoints: Arc<Endpoints>,
 	special: Arc<HashMap<SpecialEndpoint, Box<Endpoint>>>,
 	authorization: Arc<A>,
-	bind_address: String,
+	allowed_hosts: Option<Vec<String>>,
 	handler: Box<server::Handler<HttpStream> + Send>,
 }

@@ -53,9 +53,11 @@ impl<A: Authorization + 'static> server::Handler<HttpStream> for Router<A> {

 	fn on_request(&mut self, req: server::Request<HttpStream>) -> Next {
 		// Validate Host header
-		if !host_validation::is_valid(&req, &self.bind_address, self.endpoints.keys().cloned().collect()) {
-			self.handler = host_validation::host_invalid_response();
-			return self.handler.on_request(req);
+		if let Some(ref hosts) = self.allowed_hosts {
+			if !host_validation::is_valid(&req, hosts, self.endpoints.keys().cloned().collect()) {
+				self.handler = host_validation::host_invalid_response();
+				return self.handler.on_request(req);
+			}
 		}

 		// Check authorization
@@ -114,7 +116,7 @@ impl<A: Authorization> Router<A> {
 		endpoints: Arc<Endpoints>,
 		special: Arc<HashMap<SpecialEndpoint, Box<Endpoint>>>,
 		authorization: Arc<A>,
-		bind_address: String,
+		allowed_hosts: Option<Vec<String>>,
 		) -> Self {

 		let handler = special.get(&SpecialEndpoint::Rpc).unwrap().to_handler(EndpointPath::default());
@@ -123,7 +125,7 @@ impl<A: Authorization> Router<A> {
 			endpoints: endpoints,
 			special: special,
 			authorization: authorization,
-			bind_address: bind_address,
+			allowed_hosts: allowed_hosts,
 			handler: handler,
 		}
 	}
--- a/docker/ubuntu-aarch64/Dockerfile
+++ b/docker/ubuntu-aarch64/Dockerfile
@@ -23,15 +23,9 @@ RUN rustup target add aarch64-unknown-linux-gnu
 # show backtraces
 ENV RUST_BACKTRACE 1

-# set compilers
-ENV CXX aarch64-linux-gnu-g++
-ENV CC aarch64-linux-gnu-gcc
-
 # show tools
 RUN rustc -vV && \
- cargo -V && \
- gcc -v &&\
- g++ -v
+ cargo -V 

 # build parity
 RUN git clone https://github.com/ethcore/parity && \
--- a/docker/ubuntu-arm/Dockerfile
+++ b/docker/ubuntu-arm/Dockerfile
@@ -23,15 +23,9 @@ RUN rustup target add armv7-unknown-linux-gnueabihf
 # show backtraces
 ENV RUST_BACKTRACE 1

-# set compilers
-ENV CXX arm-linux-gnueabihf-g++
-ENV CC arm-linux-gnueabihf-gcc
-
 # show tools
 RUN rustc -vV && \
- cargo -V && \
- gcc -v &&\
- g++ -v
+ cargo -V

 # build parity
 RUN git clone https://github.com/ethcore/parity && \
--- 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"
@@ -35,6 +35,9 @@ ethcore-ipc = { path = "../ipc/rpc" }
 ethstore = { path = "../ethstore" }
 ethcore-ipc-nano = { path = "../ipc/nano" }
 rand = "0.3"
+lru-cache = "0.0.7"
+bloomfilter = { git = "https://github.com/ethcore/rust-bloom-filter" }
+byteorder = "0.5"

 [dependencies.hyper]
 git = "https://github.com/ethcore/hyper"
--- a/ethcore/res/ethereum/morden.json
+++ b/ethcore/res/ethereum/morden.json
@@ -8,7 +8,7 @@
 				"difficultyBoundDivisor": "0x0800",
 				"durationLimit": "0x0d",
 				"blockReward": "0x4563918244F40000",
-				"registrar": "",
+				"registrar": "0x8e4e9b13d4b45cb0befc93c3061b1408f67316b2",
 				"frontierCompatibilityModeLimit": "0x789b0"
 			}
 		}
--- a/ethcore/src/account.rs
+++ b/ethcore/src/account.rs
@@ -16,14 +16,17 @@

 //! Single account in the system.

+use std::collections::hash_map::Entry;
 use util::*;
 use pod_account::*;
 use account_db::*;
+use lru_cache::LruCache;

-use std::cell::{Ref, RefCell};
+use std::cell::{RefCell, Cell};
+
+const STORAGE_CACHE_ITEMS: usize = 4096;

 /// Single account in the system.
-#[derive(Clone)]
 pub struct Account {
 	// Balance of the account.
 	balance: U256,
@@ -31,14 +34,24 @@ pub struct Account {
 	nonce: U256,
 	// Trie-backed storage.
 	storage_root: H256,
-	// Overlay on trie-backed storage - tuple is (<clean>, <value>).
-	storage_overlay: RefCell<HashMap<H256, (Filth, 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>,
+	// LRU Cache of the trie-backed storage.
+	// This is limited to `STORAGE_CACHE_ITEMS` recent queries
+	storage_cache: RefCell<LruCache<H256, H256>>,
+	// 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.
+	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
+	code_cache: Arc<Bytes>,
+	// Account is new or has been modified.
 	filth: Filth,
+	// Account code new or has been modified.
+	code_filth: Filth,
+	// Cached address hash.
+	address_hash: Cell<Option<H256>>,
 }

 impl Account {
@@ -49,23 +62,35 @@ impl Account {
 			balance: balance,
 			nonce: nonce,
 			storage_root: SHA3_NULL_RLP,
-			storage_overlay: RefCell::new(storage.into_iter().map(|(k, v)| (k, (Filth::Dirty, v))).collect()),
-			code_hash: Some(code.sha3()),
-			code_cache: code,
+			storage_cache: Self::empty_storage_cache(),
+			storage_changes: storage,
+			code_hash: code.sha3(),
+			code_size: Some(code.len() as u64),
+			code_cache: Arc::new(code),
 			filth: Filth::Dirty,
+			code_filth: Filth::Dirty,
+			address_hash: Cell::new(None),
 		}
 	}

+	fn empty_storage_cache() -> RefCell<LruCache<H256, H256>> {
+		RefCell::new(LruCache::new(STORAGE_CACHE_ITEMS))
+	}
+
 	/// General constructor.
 	pub fn from_pod(pod: PodAccount) -> Account {
 		Account {
 			balance: pod.balance,
 			nonce: pod.nonce,
 			storage_root: SHA3_NULL_RLP,
-			storage_overlay: RefCell::new(pod.storage.into_iter().map(|(k, v)| (k, (Filth::Dirty, v))).collect()),
-			code_hash: pod.code.as_ref().map(|c| c.sha3()),
-			code_cache: pod.code.as_ref().map_or_else(|| { warn!("POD account with unknown code is being created! Assuming no code."); vec![] }, |c| c.clone()),
+			storage_cache: Self::empty_storage_cache(),
+			storage_changes: pod.storage.into_iter().collect(),
+			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: Arc::new(pod.code.map_or_else(|| { warn!("POD account with unknown code is being created! Assuming no code."); vec![] }, |c| c)),
 			filth: Filth::Dirty,
+			address_hash: Cell::new(None),
 		}
 	}

@@ -75,10 +100,14 @@ impl Account {
 			balance: balance,
 			nonce: nonce,
 			storage_root: SHA3_NULL_RLP,
-			storage_overlay: RefCell::new(HashMap::new()),
-			code_hash: Some(SHA3_EMPTY),
-			code_cache: vec![],
+			storage_cache: Self::empty_storage_cache(),
+			storage_changes: HashMap::new(),
+			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),
 		}
 	}

@@ -89,10 +118,14 @@ impl Account {
 			nonce: r.val_at(0),
 			balance: r.val_at(1),
 			storage_root: r.val_at(2),
-			storage_overlay: RefCell::new(HashMap::new()),
-			code_hash: Some(r.val_at(3)),
-			code_cache: vec![],
+			storage_cache: Self::empty_storage_cache(),
+			storage_changes: HashMap::new(),
+			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),
 		}
 	}

@@ -103,47 +136,77 @@ impl Account {
 			balance: balance,
 			nonce: nonce,
 			storage_root: SHA3_NULL_RLP,
-			storage_overlay: RefCell::new(HashMap::new()),
-			code_hash: None,
-			code_cache: vec![],
+			storage_cache: Self::empty_storage_cache(),
+			storage_changes: HashMap::new(),
+			code_hash: SHA3_EMPTY,
+			code_cache: Arc::new(vec![]),
+			code_size: None,
 			filth: Filth::Dirty,
+			code_filth: Filth::Clean,
+			address_hash: Cell::new(None),
 		}
 	}

 	/// 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.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) {
-		self.storage_overlay.borrow_mut().insert(key, (Filth::Dirty, value));
-		self.filth = Filth::Dirty;
+		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;
+			},
+			_ => {},
+		}
 	}

 	/// Get (and cache) the contents of the trie's storage at `key`.
+	/// Takes modifed storage into account.
 	pub fn storage_at(&self, db: &AccountDB, key: &H256) -> H256 {
-		self.storage_overlay.borrow_mut().entry(key.clone()).or_insert_with(||{
-			let db = SecTrieDB::new(db, &self.storage_root)
-				.expect("Account storage_root initially set to zero (valid) and only altered by SecTrieDBMut. \
-				SecTrieDBMut would not set it to an invalid state root. Therefore the root is valid and DB creation \
-				using it will not fail.");
+		if let Some(value) = self.cached_storage_at(key) {
+			return value;
+		}
+		let db = SecTrieDB::new(db, &self.storage_root)
+			.expect("Account storage_root initially set to zero (valid) and only altered by SecTrieDBMut. \
+			SecTrieDBMut would not set it to an invalid state root. Therefore the root is valid and DB creation \
+			using it will not fail.");

-			let item: U256 = match db.get(key){
-				Ok(x) => x.map_or_else(U256::zero, decode),
-				Err(e) => panic!("Encountered potential DB corruption: {}", e),
-			};
-			(Filth::Clean, item.into())
-		}).1.clone()
+		let item: U256 = match db.get(key){
+			Ok(x) => x.map_or_else(U256::zero, decode),
+			Err(e) => panic!("Encountered potential DB corruption: {}", e),
+		};
+		let value: H256 = item.into();
+		self.storage_cache.borrow_mut().insert(key.clone(), value.clone());
+		value
+	}
+
+	/// Get cached storage value if any. Returns `None` if the
+	/// key is not in the cache.
+	pub fn cached_storage_at(&self, key: &H256) -> Option<H256> {
+		if let Some(value) = self.storage_changes.get(key) {
+			return Some(value.clone())
+		}
+		if let Some(value) = self.storage_cache.borrow_mut().get_mut(key) {
+			return Some(value.clone())
+		}
+		None
 	}

 	/// return the balance associated with this account.
@@ -152,48 +215,62 @@ 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.
+	pub fn address_hash(&self, address: &Address) -> H256 {
+		let hash = self.address_hash.get();
+		hash.unwrap_or_else(|| {
+			let hash = address.sha3();
+			self.address_hash.set(Some(hash.clone()));
+			hash
+		})
 	}

 	/// 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 -
+	/// get someone who knows to call `note_code`.
+	pub fn code_size(&self) -> Option<u64> {
+		self.code_size.clone()
 	}

 	#[cfg(test)]
 	/// 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;
-				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))
+		!self.code_cache.is_empty() || (self.code_cache.is_empty() && self.code_hash == SHA3_EMPTY)
 	}

 	/// Is this a new or modified account?
 	pub fn is_dirty(&self) -> bool {
-		self.filth == Filth::Dirty
+		self.filth == Filth::Dirty || self.code_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
 	}

@@ -202,28 +279,49 @@ 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(); true },
+		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.
+	pub fn cache_code_size(&mut self, db: &AccountDB) -> bool {
+		// 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() ||
+			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
 			}
 	}

-	#[cfg(test)]
 	/// Determine whether there are any un-`commit()`-ed storage-setting operations.
-	pub fn storage_is_clean(&self) -> bool { self.storage_overlay.borrow().iter().find(|&(_, &(f, _))| f == Filth::Dirty).is_none() }
+	pub fn storage_is_clean(&self) -> bool { self.storage_changes.is_empty() }

 	#[cfg(test)]
 	/// return the storage root associated with this account or None if it has been altered via the overlay.
 	pub fn storage_root(&self) -> Option<&H256> { if self.storage_is_clean() {Some(&self.storage_root)} else {None} }

 	/// return the storage overlay.
-	pub fn storage_overlay(&self) -> Ref<HashMap<H256, (Filth, H256)>> { self.storage_overlay.borrow() }
+	pub fn storage_changes(&self) -> &HashMap<H256, H256> { &self.storage_changes }

 	/// Increment the nonce of the account by one.
 	pub fn inc_nonce(&mut self) {
@@ -233,48 +331,55 @@ impl Account {

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

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

-	/// Commit the `storage_overlay` to the backing DB and update `storage_root`.
+	/// Commit the `storage_changes` to the backing DB and update `storage_root`.
 	pub fn commit_storage(&mut self, trie_factory: &TrieFactory, db: &mut AccountDBMut) {
 		let mut t = trie_factory.from_existing(db, &mut self.storage_root)
 			.expect("Account storage_root initially set to zero (valid) and only altered by SecTrieDBMut. \
 				SecTrieDBMut would not set it to an invalid state root. Therefore the root is valid and DB creation \
 				using it will not fail.");
-		for (k, &mut (ref mut f, ref mut v)) in self.storage_overlay.borrow_mut().iter_mut() {
-			if f == &Filth::Dirty {
-				// cast key and value to trait type,
-				// so we can call overloaded `to_bytes` method
-				let res = match v.is_zero() {
-					true => t.remove(k),
-					false => t.insert(k, &encode(&U256::from(v.as_slice()))),
-				};
+		for (k, v) in self.storage_changes.drain() {
+			// cast key and value to trait type,
+			// so we can call overloaded `to_bytes` method
+			let res = match v.is_zero() {
+				true => t.remove(k.as_slice()),
+				false => t.insert(k.as_slice(), &encode(&U256::from(v.as_slice()))),
+			};

-				if let Err(e) = res {
-					warn!("Encountered potential DB corruption: {}", e);
-				}
-				*f = Filth::Clean;
+			if let Err(e) = res {
+				warn!("Encountered potential DB corruption: {}", e);
 			}
+			self.storage_cache.borrow_mut().insert(k, v);
 		}
 	}

 	/// 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()) {
-			(true, true) => self.code_hash = Some(SHA3_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_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, _) => {},
 		}
@@ -286,9 +391,59 @@ impl Account {
 		stream.append(&self.nonce);
 		stream.append(&self.balance);
 		stream.append(&self.storage_root);
-		stream.append(self.code_hash.as_ref().expect("Cannot form RLP of contract account without code."));
+		stream.append(&self.code_hash);
 		stream.out()
 	}
+
+	/// Clone basic account data
+	pub fn clone_basic(&self) -> Account {
+		Account {
+			balance: self.balance.clone(),
+			nonce: self.nonce.clone(),
+			storage_root: self.storage_root.clone(),
+			storage_cache: Self::empty_storage_cache(),
+			storage_changes: HashMap::new(),
+			code_hash: self.code_hash.clone(),
+			code_size: self.code_size.clone(),
+			code_cache: self.code_cache.clone(),
+			filth: self.filth,
+			code_filth: self.code_filth,
+			address_hash: self.address_hash.clone(),
+		}
+	}
+
+	/// Clone account data and dirty storage keys
+	pub fn clone_dirty(&self) -> Account {
+		let mut account = self.clone_basic();
+		account.storage_changes = self.storage_changes.clone();
+		account.code_cache = self.code_cache.clone();
+		account
+	}
+
+	/// Clone account data, dirty storage keys and cached storage keys.
+	pub fn clone_all(&self) -> Account {
+		let mut account = self.clone_dirty();
+		account.storage_cache = self.storage_cache.clone();
+		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());
+		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;
+		let mut cache = self.storage_cache.borrow_mut();
+		for (k, v) in other.storage_cache.into_inner().into_iter() {
+			cache.insert(k.clone() , v.clone()); //TODO: cloning should not be required here
+		}
+	}
 }

 impl fmt::Debug for Account {
@@ -383,7 +538,8 @@ 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");
 	}
@@ -394,11 +550,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
@@ -19,6 +19,7 @@
 use common::*;
 use engines::Engine;
 use state::*;
+use state_db::StateDB;
 use verification::PreverifiedBlock;
 use trace::FlatTrace;
 use evm::Factory as EvmFactory;
@@ -178,7 +179,7 @@ pub trait IsBlock {
 /// Trait for a object that has a state database.
 pub trait Drain {
 	/// Drop this object and return the underlieing database.
-	fn drain(self) -> Box<JournalDB>;
+	fn drain(self) -> StateDB;
 }

 impl IsBlock for ExecutedBlock {
@@ -233,7 +234,7 @@ impl<'x> OpenBlock<'x> {
 		vm_factory: &'x EvmFactory,
 		trie_factory: TrieFactory,
 		tracing: bool,
-		db: Box<JournalDB>,
+		db: StateDB,
 		parent: &Header,
 		last_hashes: Arc<LastHashes>,
 		author: Address,
@@ -465,7 +466,9 @@ impl LockedBlock {

 impl Drain for LockedBlock {
 	/// Drop this object and return the underlieing database.
-	fn drain(self) -> Box<JournalDB> { self.block.state.drop().1 }
+	fn drain(self) -> StateDB {
+		self.block.state.drop().1
+	}
 }

 impl SealedBlock {
@@ -481,7 +484,9 @@ impl SealedBlock {

 impl Drain for SealedBlock {
 	/// Drop this object and return the underlieing database.
-	fn drain(self) -> Box<JournalDB> { self.block.state.drop().1 }
+	fn drain(self) -> StateDB {
+		self.block.state.drop().1
+	}
 }

 impl IsBlock for SealedBlock {
@@ -496,7 +501,7 @@ pub fn enact(
 	uncles: &[Header],
 	engine: &Engine,
 	tracing: bool,
-	db: Box<JournalDB>,
+	db: StateDB,
 	parent: &Header,
 	last_hashes: Arc<LastHashes>,
 	vm_factory: &EvmFactory,
@@ -505,7 +510,7 @@ pub fn enact(
 	{
 		if ::log::max_log_level() >= ::log::LogLevel::Trace {
 			let s = try!(State::from_existing(db.boxed_clone(), parent.state_root().clone(), engine.account_start_nonce(), trie_factory.clone()));
-			trace!("enact(): root={}, author={}, author_balance={}\n", s.root(), header.author(), s.balance(&header.author()));
+			trace!(target: "enact", "num={}, root={}, author={}, author_balance={}\n", header.number(), s.root(), header.author(), s.balance(&header.author()));
 		}
 	}

@@ -529,7 +534,7 @@ pub fn enact_bytes(
 	block_bytes: &[u8],
 	engine: &Engine,
 	tracing: bool,
-	db: Box<JournalDB>,
+	db: StateDB,
 	parent: &Header,
 	last_hashes: Arc<LastHashes>,
 	vm_factory: &EvmFactory,
@@ -546,7 +551,7 @@ pub fn enact_verified(
 	block: &PreverifiedBlock,
 	engine: &Engine,
 	tracing: bool,
-	db: Box<JournalDB>,
+	db: StateDB,
 	parent: &Header,
 	last_hashes: Arc<LastHashes>,
 	vm_factory: &EvmFactory,
@@ -562,7 +567,7 @@ pub fn enact_and_seal(
 	block_bytes: &[u8],
 	engine: &Engine,
 	tracing: bool,
-	db: Box<JournalDB>,
+	db: StateDB,
 	parent: &Header,
 	last_hashes: Arc<LastHashes>,
 	vm_factory: &EvmFactory,
@@ -583,9 +588,9 @@ mod tests {
 		use spec::*;
 		let spec = Spec::new_test();
 		let genesis_header = spec.genesis_header();
-		let mut db_result = get_temp_journal_db();
+		let mut db_result = get_temp_state_db();
 		let mut db = db_result.take();
-		spec.ensure_db_good(db.as_hashdb_mut()).unwrap();
+		spec.ensure_db_good(&mut db).unwrap();
 		let last_hashes = Arc::new(vec![genesis_header.hash()]);
 		let vm_factory = Default::default();
 		let b = OpenBlock::new(&*spec.engine, &vm_factory, Default::default(), false, db, &genesis_header, last_hashes, Address::zero(), (3141562.into(), 31415620.into()), vec![]).unwrap();
@@ -600,9 +605,9 @@ mod tests {
 		let engine = &*spec.engine;
 		let genesis_header = spec.genesis_header();

-		let mut db_result = get_temp_journal_db();
+		let mut db_result = get_temp_state_db();
 		let mut db = db_result.take();
-		spec.ensure_db_good(db.as_hashdb_mut()).unwrap();
+		spec.ensure_db_good(&mut db).unwrap();
 		let vm_factory = Default::default();
 		let last_hashes = Arc::new(vec![genesis_header.hash()]);
 		let b = OpenBlock::new(engine, &vm_factory, Default::default(), false, db, &genesis_header, last_hashes.clone(), Address::zero(), (3141562.into(), 31415620.into()), vec![]).unwrap()
@@ -610,16 +615,16 @@ mod tests {
 		let orig_bytes = b.rlp_bytes();
 		let orig_db = b.drain();

-		let mut db_result = get_temp_journal_db();
+		let mut db_result = get_temp_state_db();
 		let mut db = db_result.take();
-		spec.ensure_db_good(db.as_hashdb_mut()).unwrap();
+		spec.ensure_db_good(&mut db).unwrap();
 		let e = enact_and_seal(&orig_bytes, engine, false, db, &genesis_header, last_hashes, &Default::default(), Default::default()).unwrap();

 		assert_eq!(e.rlp_bytes(), orig_bytes);

 		let db = e.drain();
-		assert_eq!(orig_db.keys(), db.keys());
-		assert!(orig_db.keys().iter().filter(|k| orig_db.get(k.0) != db.get(k.0)).next() == None);
+		assert_eq!(orig_db.journal_db().keys(), db.journal_db().keys());
+		assert!(orig_db.journal_db().keys().iter().filter(|k| orig_db.journal_db().get(k.0) != db.journal_db().get(k.0)).next() == None);
 	}

 	#[test]
@@ -629,9 +634,9 @@ mod tests {
 		let engine = &*spec.engine;
 		let genesis_header = spec.genesis_header();

-		let mut db_result = get_temp_journal_db();
+		let mut db_result = get_temp_state_db();
 		let mut db = db_result.take();
-		spec.ensure_db_good(db.as_hashdb_mut()).unwrap();
+		spec.ensure_db_good(&mut db).unwrap();
 		let vm_factory = Default::default();
 		let last_hashes = Arc::new(vec![genesis_header.hash()]);
 		let mut open_block = OpenBlock::new(engine, &vm_factory, Default::default(), false, db, &genesis_header, last_hashes.clone(), Address::zero(), (3141562.into(), 31415620.into()), vec![]).unwrap();
@@ -646,9 +651,9 @@ mod tests {
 		let orig_bytes = b.rlp_bytes();
 		let orig_db = b.drain();

-		let mut db_result = get_temp_journal_db();
+		let mut db_result = get_temp_state_db();
 		let mut db = db_result.take();
-		spec.ensure_db_good(db.as_hashdb_mut()).unwrap();
+		spec.ensure_db_good(&mut db).unwrap();
 		let e = enact_and_seal(&orig_bytes, engine, false, db, &genesis_header, last_hashes, &Default::default(), Default::default()).unwrap();

 		let bytes = e.rlp_bytes();
@@ -657,7 +662,7 @@ mod tests {
 		assert_eq!(uncles[1].extra_data, b"uncle2");

 		let db = e.drain();
-		assert_eq!(orig_db.keys(), db.keys());
-		assert!(orig_db.keys().iter().filter(|k| orig_db.get(k.0) != db.get(k.0)).next() == None);
+		assert_eq!(orig_db.journal_db().keys(), db.journal_db().keys());
+		assert!(orig_db.journal_db().keys().iter().filter(|k| orig_db.journal_db().get(k.0) != db.journal_db().get(k.0)).next() == None);
 	}
 }
--- a/ethcore/src/blockchain/block_info.rs
+++ b/ethcore/src/blockchain/block_info.rs
@@ -31,7 +31,7 @@ pub struct BlockInfo {
 }

 /// Describes location of newly inserted block.
-#[derive(Clone)]
+#[derive(Debug, Clone)]
 pub enum BlockLocation {
 	/// It's part of the canon chain.
 	CanonChain,
@@ -43,7 +43,7 @@ pub enum BlockLocation {
 	BranchBecomingCanonChain(BranchBecomingCanonChainData),
 }

-#[derive(Clone)]
+#[derive(Debug, Clone)]
 pub struct BranchBecomingCanonChainData {
 	/// Hash of the newest common ancestor with old canon chain.
 	pub ancestor: H256,
--- a/ethcore/src/blockchain/blockchain.rs
+++ b/ethcore/src/blockchain/blockchain.rs
@@ -165,7 +165,7 @@ pub struct BlockChain {

 	pending_best_block: RwLock<Option<BestBlock>>,
 	pending_block_hashes: RwLock<HashMap<BlockNumber, H256>>,
-	pending_transaction_addresses: RwLock<HashMap<H256, TransactionAddress>>,
+	pending_transaction_addresses: RwLock<HashMap<H256, Option<TransactionAddress>>>,
 }

 impl BlockProvider for BlockChain {
@@ -584,8 +584,8 @@ impl BlockChain {
 				block_hashes: self.prepare_block_hashes_update(bytes, &info),
 				block_details: self.prepare_block_details_update(bytes, &info),
 				block_receipts: self.prepare_block_receipts_update(receipts, &info),
-				transactions_addresses: self.prepare_transaction_addresses_update(bytes, &info),
 				blocks_blooms: self.prepare_block_blooms_update(bytes, &info),
+				transactions_addresses: self.prepare_transaction_addresses_update(bytes, &info),
 				info: info,
 				block: bytes
 			}, is_best);
@@ -618,8 +618,8 @@ impl BlockChain {
 				block_hashes: self.prepare_block_hashes_update(bytes, &info),
 				block_details: update,
 				block_receipts: self.prepare_block_receipts_update(receipts, &info),
-				transactions_addresses: self.prepare_transaction_addresses_update(bytes, &info),
 				blocks_blooms: self.prepare_block_blooms_update(bytes, &info),
+				transactions_addresses: self.prepare_transaction_addresses_update(bytes, &info),
 				info: info,
 				block: bytes,
 			}, is_best);
@@ -687,8 +687,8 @@ impl BlockChain {
 			block_hashes: self.prepare_block_hashes_update(bytes, &info),
 			block_details: self.prepare_block_details_update(bytes, &info),
 			block_receipts: self.prepare_block_receipts_update(receipts, &info),
-			transactions_addresses: self.prepare_transaction_addresses_update(bytes, &info),
 			blocks_blooms: self.prepare_block_blooms_update(bytes, &info),
+			transactions_addresses: self.prepare_transaction_addresses_update(bytes, &info),
 			info: info.clone(),
 			block: bytes,
 		}, true);
@@ -744,8 +744,9 @@ impl BlockChain {
 			let mut write_details = self.block_details.write();
 			batch.extend_with_cache(DB_COL_EXTRA, &mut *write_details, update.block_details, CacheUpdatePolicy::Overwrite);

+			let mut cache_man = self.cache_man.write();
 			for hash in block_hashes.into_iter() {
-				self.note_used(CacheID::BlockDetails(hash));
+				cache_man.note_used(CacheID::BlockDetails(hash));
 			}
 		}

@@ -780,11 +781,11 @@ impl BlockChain {
 			let mut write_txs = self.pending_transaction_addresses.write();

 			batch.extend_with_cache(DB_COL_EXTRA, &mut *write_hashes, update.block_hashes, CacheUpdatePolicy::Overwrite);
-			batch.extend_with_cache(DB_COL_EXTRA, &mut *write_txs, update.transactions_addresses, CacheUpdatePolicy::Overwrite);
+			batch.extend_with_option_cache(DB_COL_EXTRA, &mut *write_txs, update.transactions_addresses, CacheUpdatePolicy::Overwrite);
 		}
 	}

-	/// Applt pending insertion updates
+	/// Apply pending insertion updates
 	pub fn commit(&self) {
 		let mut pending_best_block = self.pending_best_block.write();
 		let mut pending_write_hashes = self.pending_block_hashes.write();
@@ -798,18 +799,26 @@ impl BlockChain {
 			*best_block = block;
 		}

+		let pending_txs = mem::replace(&mut *pending_write_txs, HashMap::new());
+		let (retracted_txs, enacted_txs) = pending_txs.into_iter().partition::<HashMap<_, _>, _>(|&(_, ref value)| value.is_none());
+
 		let pending_hashes_keys: Vec<_> = pending_write_hashes.keys().cloned().collect();
-		let pending_txs_keys: Vec<_> = pending_write_txs.keys().cloned().collect();
+		let enacted_txs_keys: Vec<_> = enacted_txs.keys().cloned().collect();

 		write_hashes.extend(mem::replace(&mut *pending_write_hashes, HashMap::new()));
-		write_txs.extend(mem::replace(&mut *pending_write_txs, HashMap::new()));
+		write_txs.extend(enacted_txs.into_iter().map(|(k, v)| (k, v.expect("Transactions were partitioned; qed"))));

-		for n in pending_hashes_keys.into_iter() {
-			self.note_used(CacheID::BlockHashes(n));
+		for hash in retracted_txs.keys() {
+			write_txs.remove(hash);
 		}

-		for hash in pending_txs_keys.into_iter() {
-			self.note_used(CacheID::TransactionAddresses(hash));
+		let mut cache_man = self.cache_man.write();
+		for n in pending_hashes_keys.into_iter() {
+			cache_man.note_used(CacheID::BlockHashes(n));
+		}
+
+		for hash in enacted_txs_keys {
+			cache_man.note_used(CacheID::TransactionAddresses(hash));
 		}
 	}

@@ -910,19 +919,56 @@ impl BlockChain {
 	}

 	/// This function returns modified transaction addresses.
-	fn prepare_transaction_addresses_update(&self, block_bytes: &[u8], info: &BlockInfo) -> HashMap<H256, TransactionAddress> {
+	fn prepare_transaction_addresses_update(&self, block_bytes: &[u8], info: &BlockInfo) -> HashMap<H256, Option<TransactionAddress>> {
 		let block = BlockView::new(block_bytes);
 		let transaction_hashes = block.transaction_hashes();

-		transaction_hashes.into_iter()
-			.enumerate()
-			.fold(HashMap::new(), |mut acc, (i ,tx_hash)| {
-				acc.insert(tx_hash, TransactionAddress {
-					block_hash: info.hash.clone(),
-					index: i
+		match info.location {
+			BlockLocation::CanonChain => {
+				transaction_hashes.into_iter()
+					.enumerate()
+					.map(|(i ,tx_hash)| {
+						(tx_hash, Some(TransactionAddress {
+							block_hash: info.hash.clone(),
+							index: i
+						}))
+					})
+					.collect()
+			},
+			BlockLocation::BranchBecomingCanonChain(ref data) => {
+				let addresses = data.enacted.iter()
+					.flat_map(|hash| {
+						let bytes = self.block_body(hash).expect("Enacted block must be in database.");
+						let hashes = BodyView::new(&bytes).transaction_hashes();
+						hashes.into_iter()
+							.enumerate()
+							.map(|(i, tx_hash)| (tx_hash, Some(TransactionAddress {
+								block_hash: hash.clone(),
+								index: i,
+							})))
+							.collect::<HashMap<H256, Option<TransactionAddress>>>()
+					});
+
+				let current_addresses = transaction_hashes.into_iter()
+					.enumerate()
+					.map(|(i ,tx_hash)| {
+						(tx_hash, Some(TransactionAddress {
+							block_hash: info.hash.clone(),
+							index: i
+						}))
+					});
+
+				let retracted = data.retracted.iter().flat_map(|hash| {
+					let bytes = self.block_body(hash).expect("Retracted block must be in database.");
+					let hashes = BodyView::new(&bytes).transaction_hashes();
+					hashes.into_iter().map(|hash| (hash, None)).collect::<HashMap<H256, Option<TransactionAddress>>>()
 				});
-				acc
-			})
+
+				// The order here is important! Don't remove transaction if it was part of enacted blocks as well.
+				retracted.chain(addresses).chain(current_addresses).collect()
+			},
+			BlockLocation::Branch => HashMap::new(),
+		}
 	}

 	/// This functions returns modified blocks blooms.
@@ -1070,7 +1116,6 @@ impl BlockChain {
 #[cfg(test)]
 mod tests {
 	#![cfg_attr(feature="dev", allow(similar_names))]
-	use std::str::FromStr;
 	use std::sync::Arc;
 	use rustc_serialize::hex::FromHex;
 	use util::{Database, DatabaseConfig};
@@ -1081,8 +1126,10 @@ mod tests {
 	use tests::helpers::*;
 	use devtools::*;
 	use blockchain::generator::{ChainGenerator, ChainIterator, BlockFinalizer};
+	use blockchain::extras::TransactionAddress;
 	use views::BlockView;
 	use client;
+	use transaction::{Transaction, Action};

 	fn new_db(path: &str) -> Arc<Database> {
 		Arc::new(Database::open(&DatabaseConfig::with_columns(client::DB_NO_OF_COLUMNS), path).unwrap())
@@ -1217,6 +1264,170 @@ mod tests {
 		// TODO: insert block that already includes one of them as an uncle to check it's not allowed.
 	}

+	#[test]
+	fn test_fork_transaction_addresses() {
+		let mut canon_chain = ChainGenerator::default();
+		let mut finalizer = BlockFinalizer::default();
+		let genesis = canon_chain.generate(&mut finalizer).unwrap();
+		let mut fork_chain = canon_chain.fork(1);
+		let mut fork_finalizer = finalizer.fork();
+
+		let t1 = Transaction {
+			nonce: 0.into(),
+			gas_price: 0.into(),
+			gas: 100_000.into(),
+			action: Action::Create,
+			value: 100.into(),
+			data: "601080600c6000396000f3006000355415600957005b60203560003555".from_hex().unwrap(),
+		}.sign(&"".sha3());
+
+
+		let b1a = canon_chain
+			.with_transaction(t1.clone())
+			.generate(&mut finalizer).unwrap();
+
+		// Empty block
+		let b1b = fork_chain
+			.generate(&mut fork_finalizer).unwrap();
+
+		let b2 = fork_chain
+			.generate(&mut fork_finalizer).unwrap();
+
+		let b1a_hash = BlockView::new(&b1a).header_view().sha3();
+		let b2_hash = BlockView::new(&b2).header_view().sha3();
+
+		let t1_hash = t1.hash();
+
+		let temp = RandomTempPath::new();
+		let db = new_db(temp.as_str());
+		let bc = BlockChain::new(Config::default(), &genesis, db.clone());
+
+		let mut batch = db.transaction();
+		let _ = bc.insert_block(&mut batch, &b1a, vec![]);
+		bc.commit();
+		let _ = bc.insert_block(&mut batch, &b1b, vec![]);
+		bc.commit();
+		db.write(batch).unwrap();
+
+		assert_eq!(bc.best_block_hash(), b1a_hash);
+		assert_eq!(bc.transaction_address(&t1_hash), Some(TransactionAddress {
+			block_hash: b1a_hash.clone(),
+			index: 0,
+		}));
+
+		// now let's make forked chain the canon chain
+		let mut batch = db.transaction();
+		let _ = bc.insert_block(&mut batch, &b2, vec![]);
+		bc.commit();
+		db.write(batch).unwrap();
+
+		// Transaction should be retracted
+		assert_eq!(bc.best_block_hash(), b2_hash);
+		assert_eq!(bc.transaction_address(&t1_hash), None);
+	}
+
+
+
+	#[test]
+	fn test_overwriting_transaction_addresses() {
+		let mut canon_chain = ChainGenerator::default();
+		let mut finalizer = BlockFinalizer::default();
+		let genesis = canon_chain.generate(&mut finalizer).unwrap();
+		let mut fork_chain = canon_chain.fork(1);
+		let mut fork_finalizer = finalizer.fork();
+
+		let t1 = Transaction {
+			nonce: 0.into(),
+			gas_price: 0.into(),
+			gas: 100_000.into(),
+			action: Action::Create,
+			value: 100.into(),
+			data: "601080600c6000396000f3006000355415600957005b60203560003555".from_hex().unwrap(),
+		}.sign(&"".sha3());
+
+		let t2 = Transaction {
+			nonce: 1.into(),
+			gas_price: 0.into(),
+			gas: 100_000.into(),
+			action: Action::Create,
+			value: 100.into(),
+			data: "601080600c6000396000f3006000355415600957005b60203560003555".from_hex().unwrap(),
+		}.sign(&"".sha3());
+
+		let t3 = Transaction {
+			nonce: 2.into(),
+			gas_price: 0.into(),
+			gas: 100_000.into(),
+			action: Action::Create,
+			value: 100.into(),
+			data: "601080600c6000396000f3006000355415600957005b60203560003555".from_hex().unwrap(),
+		}.sign(&"".sha3());
+
+		let b1a = canon_chain
+			.with_transaction(t1.clone())
+			.with_transaction(t2.clone())
+			.generate(&mut finalizer).unwrap();
+
+		// insert transactions in different order
+		let b1b = fork_chain
+			.with_transaction(t2.clone())
+			.with_transaction(t1.clone())
+			.generate(&mut fork_finalizer).unwrap();
+
+		let b2 = fork_chain
+			.with_transaction(t3.clone())
+			.generate(&mut fork_finalizer).unwrap();
+
+		let b1a_hash = BlockView::new(&b1a).header_view().sha3();
+		let b1b_hash = BlockView::new(&b1b).header_view().sha3();
+		let b2_hash = BlockView::new(&b2).header_view().sha3();
+
+		let t1_hash = t1.hash();
+		let t2_hash = t2.hash();
+		let t3_hash = t3.hash();
+
+		let temp = RandomTempPath::new();
+		let db = new_db(temp.as_str());
+		let bc = BlockChain::new(Config::default(), &genesis, db.clone());
+
+		let mut batch = db.transaction();
+		let _ = bc.insert_block(&mut batch, &b1a, vec![]);
+		bc.commit();
+		let _ = bc.insert_block(&mut batch, &b1b, vec![]);
+		bc.commit();
+		db.write(batch).unwrap();
+
+		assert_eq!(bc.best_block_hash(), b1a_hash);
+		assert_eq!(bc.transaction_address(&t1_hash), Some(TransactionAddress {
+			block_hash: b1a_hash.clone(),
+			index: 0,
+		}));
+		assert_eq!(bc.transaction_address(&t2_hash), Some(TransactionAddress {
+			block_hash: b1a_hash.clone(),
+			index: 1,
+		}));
+
+		// now let's make forked chain the canon chain
+		let mut batch = db.transaction();
+		let _ = bc.insert_block(&mut batch, &b2, vec![]);
+		bc.commit();
+		db.write(batch).unwrap();
+
+		assert_eq!(bc.best_block_hash(), b2_hash);
+		assert_eq!(bc.transaction_address(&t1_hash), Some(TransactionAddress {
+			block_hash: b1b_hash.clone(),
+			index: 1,
+		}));
+		assert_eq!(bc.transaction_address(&t2_hash), Some(TransactionAddress {
+			block_hash: b1b_hash.clone(),
+			index: 0,
+		}));
+		assert_eq!(bc.transaction_address(&t3_hash), Some(TransactionAddress {
+			block_hash: b2_hash.clone(),
+			index: 0,
+		}));
+	}
+
 	#[test]
 	#[cfg_attr(feature="dev", allow(cyclomatic_complexity))]
 	fn test_small_fork() {
@@ -1417,7 +1628,7 @@ mod tests {
 	fn find_transaction_by_hash() {
 		let genesis = "f901fcf901f7a00000000000000000000000000000000000000000000000000000000000000000a01dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347948888f1f195afa192cfee860698584c030f4c9db1a0af81e09f8c46ca322193edfda764fa7e88e81923f802f1d325ec0b0308ac2cd0a056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421a056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421b9010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000830200008083023e38808454c98c8142a056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421880102030405060708c0c0".from_hex().unwrap();
 		let b1 = "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".from_hex().unwrap();
-		let b1_hash = H256::from_str("f53f268d23a71e85c7d6d83a9504298712b84c1a2ba220441c86eeda0bf0b6e3").unwrap();
+		let b1_hash: H256 = "f53f268d23a71e85c7d6d83a9504298712b84c1a2ba220441c86eeda0bf0b6e3".into();

 		let temp = RandomTempPath::new();
 		let db = new_db(temp.as_str());
@@ -1445,11 +1656,11 @@ mod tests {
 	#[test]
 	fn test_bloom_filter_simple() {
 		// TODO: From here
-		let bloom_b1 = H2048::from_str("00000020000000000000000000000000000000000000000002000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008000400000000000000000000002000").unwrap();
+		let bloom_b1: H2048 = "00000020000000000000000000000000000000000000000002000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008000400000000000000000000002000".into();

-		let bloom_b2 = H2048::from_str("00000000000000000000000000000000000000000000020000001000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000008000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000000000000000000000000002000000000000000000040000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
+		let bloom_b2: H2048 = "00000000000000000000000000000000000000000000020000001000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000008000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000000000000000000000000002000000000000000000040000000000000000000000000000000000000000000000000000000000000000000000000000000000000000".into();

-		let bloom_ba = H2048::from_str("00000000000000000000000000000000000000000000020000000800000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000008000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000000000000000000000000002000000000000000000040000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
+		let bloom_ba: H2048 = "00000000000000000000000000000000000000000000020000000800000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000008000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000000000000000000000000002000000000000000000040000000000000000000000000000000000000000000000000000000000000000000000000000000000000000".into();

 		let mut canon_chain = ChainGenerator::default();
 		let mut finalizer = BlockFinalizer::default();
--- a/ethcore/src/blockchain/extras.rs
+++ b/ethcore/src/blockchain/extras.rs
@@ -176,7 +176,7 @@ impl Encodable for BlockDetails {
 }

 /// Represents address of certain transaction within block
-#[derive(Clone)]
+#[derive(Debug, PartialEq, Clone)]
 pub struct TransactionAddress {
 	/// Block hash
 	pub block_hash: H256,
--- a/ethcore/src/blockchain/generator/block.rs
+++ b/ethcore/src/blockchain/generator/block.rs
@@ -16,7 +16,6 @@

 use util::rlp::*;
 use util::{H256, H2048};
-use util::U256;
 use util::bytes::Bytes;
 use header::Header;
 use transaction::SignedTransaction;
@@ -24,6 +23,7 @@ use transaction::SignedTransaction;
 use super::fork::Forkable;
 use super::bloom::WithBloom;
 use super::complete::CompleteBlock;
+use super::transaction::WithTransaction;

 /// Helper structure, used for encoding blocks.
 #[derive(Default)]
@@ -44,7 +44,8 @@ impl Encodable for Block {

 impl Forkable for Block {
 	fn fork(mut self, fork_number: usize) -> Self where Self: Sized {
-		self.header.difficulty = self.header.difficulty - U256::from(fork_number);
+		let difficulty = self.header.difficulty().clone() - fork_number.into();
+		self.header.difficulty = difficulty;
 		self
 	}
 }
@@ -56,6 +57,13 @@ impl WithBloom for Block {
 	}
 }

+impl WithTransaction for Block {
+	fn with_transaction(mut self, transaction: SignedTransaction) -> Self where Self: Sized {
+		self.transactions.push(transaction);
+		self
+	}
+}
+
 impl CompleteBlock for Block {
 	fn complete(mut self, parent_hash: H256) -> Bytes {
 		self.header.parent_hash = parent_hash;
--- a/ethcore/src/blockchain/generator/generator.rs
+++ b/ethcore/src/blockchain/generator/generator.rs
@@ -18,10 +18,12 @@ use util::hash::H2048;
 use util::numbers::U256;
 use util::bytes::Bytes;
 use header::BlockNumber;
+use transaction::SignedTransaction;
 use super::fork::Fork;
 use super::bloom::Bloom;
 use super::complete::{BlockFinalizer, CompleteBlock, Complete};
 use super::block::Block;
+use super::transaction::Transaction;

 /// Chain iterator interface.
 pub trait ChainIterator: Iterator + Sized {
@@ -30,6 +32,8 @@ pub trait ChainIterator: Iterator + Sized {
 	fn fork(&self, fork_number: usize) -> Fork<Self> where Self: Clone;
 	/// Should be called to make every consecutive block have given bloom.
 	fn with_bloom(&mut self, bloom: H2048) -> Bloom<Self>;
+	/// Should be called to make every consecutive block have given transaction.
+	fn with_transaction(&mut self, transaction: SignedTransaction) -> Transaction<Self>;
 	/// Should be called to complete block. Without complete, block may have incorrect hash.
 	fn complete<'a>(&'a mut self, finalizer: &'a mut BlockFinalizer) -> Complete<'a, Self>;
 	/// Completes and generates block.
@@ -51,6 +55,13 @@ impl<I> ChainIterator for I where I: Iterator + Sized {
 		}
 	}

+	fn with_transaction(&mut self, transaction: SignedTransaction) -> Transaction<Self> {
+		Transaction {
+			iter: self,
+			transaction: transaction,
+		}
+	}
+
 	fn complete<'a>(&'a mut self, finalizer: &'a mut BlockFinalizer) -> Complete<'a, Self> {
 		Complete {
 			iter: self,
@@ -85,7 +96,7 @@ impl Default for ChainGenerator {
 	fn default() -> Self {
 		ChainGenerator {
 			number: 0,
-			difficulty: U256::from(1000),
+			difficulty: 1000.into(),
 		}
 	}
 }
--- a/ethcore/src/blockchain/generator/mod.rs
+++ b/ethcore/src/blockchain/generator/mod.rs
@@ -21,6 +21,7 @@ mod block;
 mod complete;
 mod fork;
 pub mod generator;
+mod transaction;

 pub use self::complete::BlockFinalizer;
 pub use self::generator::{ChainIterator, ChainGenerator};
--- a/ethcore/src/blockchain/generator/transaction.rs
+++ b/ethcore/src/blockchain/generator/transaction.rs
@@ -0,0 +1,35 @@
+// 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 transaction::SignedTransaction;
+
+pub trait WithTransaction {
+	fn with_transaction(self, transaction: SignedTransaction) -> Self where Self: Sized;
+}
+
+pub struct Transaction<'a, I> where I: 'a {
+	pub iter: &'a mut I,
+	pub transaction: SignedTransaction,
+}
+
+impl <'a, I> Iterator for Transaction<'a, I> where I: Iterator, <I as Iterator>::Item: WithTransaction {
+	type Item = <I as Iterator>::Item;
+
+	#[inline]
+	fn next(&mut self) -> Option<Self::Item> {
+		self.iter.next().map(|item| item.with_transaction(self.transaction.clone()))
+	}
+}
--- a/ethcore/src/blockchain/update.rs
+++ b/ethcore/src/blockchain/update.rs
@@ -17,8 +17,8 @@ pub struct ExtrasUpdate<'a> {
 	pub block_details: HashMap<H256, BlockDetails>,
 	/// Modified block receipts.
 	pub block_receipts: HashMap<H256, BlockReceipts>,
-	/// Modified transaction addresses.
-	pub transactions_addresses: HashMap<H256, TransactionAddress>,
 	/// Modified blocks blooms.
 	pub blocks_blooms: HashMap<LogGroupPosition, BloomGroup>,
+	/// Modified transaction addresses (None signifies removed transactions).
+	pub transactions_addresses: HashMap<H256, Option<TransactionAddress>>,
 }
--- a/ethcore/src/client/client.rs
+++ b/ethcore/src/client/client.rs
@@ -13,7 +13,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::collections::{HashSet, HashMap, VecDeque};
+use std::collections::{HashSet, HashMap, BTreeMap, VecDeque};
 use std::sync::{Arc, Weak};
 use std::path::{Path};
 use std::fmt;
@@ -23,7 +23,6 @@ use time::precise_time_ns;

 // util
 use util::{journaldb, rlp, Bytes, View, PerfTimer, Itertools, Mutex, RwLock};
-use util::journaldb::JournalDB;
 use util::rlp::{UntrustedRlp};
 use util::numbers::*;
 use util::sha3::*;
@@ -49,8 +48,11 @@ use types::filter::Filter;
 use log_entry::LocalizedLogEntry;
 use block_queue::{BlockQueue, BlockQueueInfo};
 use blockchain::{BlockChain, BlockProvider, TreeRoute, ImportRoute};
-use client::{BlockID, TransactionID, UncleID, TraceId, ClientConfig, BlockChainClient, MiningBlockChainClient,
-	TraceFilter, CallAnalytics, BlockImportError, Mode, ChainNotify};
+use client::{
+	BlockID, TransactionID, UncleID, TraceId, ClientConfig, BlockChainClient,
+	MiningBlockChainClient, TraceFilter, CallAnalytics, BlockImportError, Mode,
+	ChainNotify
+};
 use client::Error as ClientError;
 use env_info::EnvInfo;
 use executive::{Executive, Executed, TransactOptions, contract_address};
@@ -62,6 +64,7 @@ use evm::Factory as EvmFactory;
 use miner::{Miner, MinerService};
 use util::TrieFactory;
 use snapshot::{self, io as snapshot_io};
+use state_db::StateDB;

 // re-export
 pub use types::blockchain_info::BlockChainInfo;
@@ -121,7 +124,7 @@ pub struct Client {
 	tracedb: Arc<TraceDB<BlockChain>>,
 	engine: Arc<Engine>,
 	db: Arc<Database>,
-	state_db: Mutex<Box<JournalDB>>,
+	state_db: Mutex<StateDB>,
 	block_queue: BlockQueue,
 	report: RwLock<ClientReport>,
 	import_lock: Mutex<()>,
@@ -151,8 +154,10 @@ pub const DB_COL_BODIES: Option<u32> = Some(2);
 pub const DB_COL_EXTRA: Option<u32> = Some(3);
 /// Column for Traces
 pub const DB_COL_TRACE: Option<u32> = Some(4);
+/// Column for Traces
+pub const DB_COL_ACCOUNT_BLOOM: Option<u32> = Some(5);
 /// Number of columns in DB
-pub const DB_NO_OF_COLUMNS: Option<u32> = Some(5);
+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> {
@@ -181,14 +186,15 @@ impl Client {
 		let chain = Arc::new(BlockChain::new(config.blockchain, &gb, db.clone()));
 		let tracedb = Arc::new(try!(TraceDB::new(config.tracing, db.clone(), chain.clone())));

-		let mut state_db = journaldb::new(db.clone(), config.pruning, DB_COL_STATE);
-		if state_db.is_empty() && try!(spec.ensure_db_good(state_db.as_hashdb_mut())) {
+		let journal_db = journaldb::new(db.clone(), config.pruning, DB_COL_STATE);
+		let mut state_db = StateDB::new(journal_db);
+		if state_db.journal_db().is_empty() && try!(spec.ensure_db_good(&mut state_db)) {
 			let batch = DBTransaction::new(&db);
 			try!(state_db.commit(&batch, 0, &spec.genesis_header().hash(), None));
 			try!(db.write(batch).map_err(ClientError::Database));
 		}

-		if !chain.block_header(&chain.best_block_hash()).map_or(true, |h| state_db.contains(h.state_root())) {
+		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());
 		}

@@ -298,7 +304,8 @@ impl Client {
 		// Enact Verified Block
 		let parent = chain_has_parent.unwrap();
 		let last_hashes = self.build_last_hashes(header.parent_hash.clone());
-		let db = self.state_db.lock().boxed_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());
 		if let Err(e) = enact_result {
@@ -440,7 +447,8 @@ impl Client {
 		// CHECK! I *think* this is fine, even if the state_root is equal to another
 		// already-imported block of the same number.
 		// TODO: Prove it with a test.
-		block.drain().commit(&batch, number, hash, ancient).expect("DB commit failed.");
+		let mut state = block.drain();
+		state.commit(&batch, number, hash, ancient).expect("DB commit failed.");

 		let route = self.chain.insert_block(&batch, block_data, receipts);
 		self.tracedb.import(&batch, TraceImportRequest {
@@ -453,7 +461,6 @@ impl Client {
 		// Final commit to the DB
 		self.db.write_buffered(batch).expect("DB write failed.");
 		self.chain.commit();
-
 		self.update_last_hashes(&parent, hash);
 		route
 	}
@@ -597,7 +604,7 @@ impl Client {
 	/// Take a snapshot at the given block.
 	/// If the ID given is "latest", this will default to 1000 blocks behind.
 	pub fn take_snapshot<W: snapshot_io::SnapshotWriter + Send>(&self, writer: W, at: BlockID, p: &snapshot::Progress) -> Result<(), ::error::Error> {
-		let db = self.state_db.lock().boxed_clone();
+		let db = self.state_db.lock().journal_db().boxed_clone();
 		let best_block_number = self.chain_info().best_block_number;
 		let block_number = try!(self.block_number(at).ok_or(snapshot::Error::InvalidStartingBlock(at)));

@@ -801,7 +808,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> {
@@ -878,7 +885,7 @@ impl BlockChainClient for Client {
 	}

 	fn state_data(&self, hash: &H256) -> Option<Bytes> {
-		self.state_db.lock().state(hash)
+		self.state_db.lock().journal_db().state(hash)
 	}

 	fn block_receipts(&self, hash: &H256) -> Option<Bytes> {
@@ -916,6 +923,10 @@ impl BlockChainClient for Client {
 		}
 	}

+	fn additional_params(&self) -> BTreeMap<String, String> {
+		self.engine.additional_params().into_iter().collect()
+	}
+
 	fn blocks_with_bloom(&self, bloom: &H2048, from_block: BlockID, to_block: BlockID) -> Option<Vec<BlockNumber>> {
 		match (self.block_number(from_block), self.block_number(to_block)) {
 			(Some(from), Some(to)) => Some(self.chain.blocks_with_bloom(bloom, from, to)),
@@ -1073,6 +1084,8 @@ impl MiningBlockChainClient for Client {
 		let number = block.header().number();

 		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);

--- a/ethcore/src/client/test_client.rs
+++ b/ethcore/src/client/test_client.rs
@@ -21,9 +21,11 @@ use util::*;
 use devtools::*;
 use transaction::{Transaction, LocalizedTransaction, SignedTransaction, Action};
 use blockchain::TreeRoute;
-use client::{BlockChainClient, MiningBlockChainClient, BlockChainInfo, BlockStatus, BlockID,
-	TransactionID, UncleID, TraceId, TraceFilter, LastHashes, CallAnalytics,
-	BlockImportError};
+use client::{
+	BlockChainClient, MiningBlockChainClient, BlockChainInfo, BlockStatus, BlockID,
+	TransactionID, UncleID, TraceId, TraceFilter, LastHashes, CallAnalytics, BlockImportError,
+	DB_NO_OF_COLUMNS, DB_COL_STATE,
+};
 use header::{Header as BlockHeader, BlockNumber};
 use filter::Filter;
 use log_entry::LocalizedLogEntry;
@@ -39,6 +41,7 @@ use block::{OpenBlock, SealedBlock};
 use executive::Executed;
 use error::CallError;
 use trace::LocalizedTrace;
+use state_db::StateDB;

 /// Test client.
 pub struct TestBlockChainClient {
@@ -246,13 +249,14 @@ impl TestBlockChainClient {
 	}
 }

-pub fn get_temp_journal_db() -> GuardedTempResult<Box<JournalDB>> {
+pub fn get_temp_state_db() -> GuardedTempResult<StateDB> {
 	let temp = RandomTempPath::new();
-	let db = Database::open_default(temp.as_str()).unwrap();
-	let journal_db = journaldb::new(Arc::new(db), journaldb::Algorithm::EarlyMerge, None);
+	let db = Database::open(&DatabaseConfig::with_columns(DB_NO_OF_COLUMNS), temp.as_str()).unwrap();
+	let journal_db = journaldb::new(Arc::new(db), journaldb::Algorithm::EarlyMerge, DB_COL_STATE);
+	let state_db = StateDB::new(journal_db);
 	GuardedTempResult {
 		_temp: temp,
-		result: Some(journal_db)
+		result: Some(state_db)
 	}
 }

@@ -260,9 +264,9 @@ impl MiningBlockChainClient for TestBlockChainClient {
 	fn prepare_open_block(&self, author: Address, gas_range_target: (U256, U256), extra_data: Bytes) -> OpenBlock {
 		let engine = &*self.spec.engine;
 		let genesis_header = self.spec.genesis_header();
-		let mut db_result = get_temp_journal_db();
+		let mut db_result = get_temp_state_db();
 		let mut db = db_result.take();
-		self.spec.ensure_db_good(db.as_hashdb_mut()).unwrap();
+		self.spec.ensure_db_good(&mut db).unwrap();

 		let last_hashes = vec![genesis_header.hash()];
 		let mut open_block = OpenBlock::new(
@@ -347,11 +351,11 @@ impl BlockChainClient for TestBlockChainClient {
 	}

 	fn transaction(&self, _id: TransactionID) -> Option<LocalizedTransaction> {
-		unimplemented!();
+		None
 	}

 	fn uncle(&self, _id: UncleID) -> Option<Bytes> {
-		unimplemented!();
+		None
 	}

 	fn transaction_receipt(&self, id: TransactionID) -> Option<LocalizedReceipt> {
@@ -517,6 +521,10 @@ impl BlockChainClient for TestBlockChainClient {
 	fn clear_queue(&self) {
 	}

+	fn additional_params(&self) -> BTreeMap<String, String> {
+		Default::default()
+	}
+
 	fn chain_info(&self) -> BlockChainInfo {
 		BlockChainInfo {
 			total_difficulty: *self.difficulty.read(),
--- a/ethcore/src/client/traits.rs
+++ b/ethcore/src/client/traits.rs
@@ -14,6 +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::collections::{BTreeMap};
 use util::bytes::Bytes;
 use util::hash::{Address, H256, H2048};
 use util::numbers::U256;
@@ -150,6 +151,9 @@ pub trait BlockChainClient : Sync + Send {
 	/// Get blockchain information.
 	fn chain_info(&self) -> BlockChainInfo;

+	/// Get the registrar address, if it exists.
+	fn additional_params(&self) -> BTreeMap<String, String>;
+
 	/// Get the best block header.
 	fn best_block_header(&self) -> Bytes;

--- a/ethcore/src/db.rs
+++ b/ethcore/src/db.rs
@@ -64,6 +64,9 @@ pub trait Writable {
 	/// Writes the value into the database.
 	fn write<T, R>(&self, col: Option<u32>, key: &Key<T, Target = R>, value: &T) where T: Encodable, R: Deref<Target = [u8]>;

+	/// Deletes key from the databse.
+	fn delete<T, R>(&self, col: Option<u32>, key: &Key<T, Target = R>) where T: Encodable, R: Deref<Target = [u8]>;
+
 	/// Writes the value into the database and updates the cache.
 	fn write_with_cache<K, T, R>(&self, col: Option<u32>, cache: &mut Cache<K, T>, key: K, value: T, policy: CacheUpdatePolicy) where
 	K: Key<T, Target = R> + Hash + Eq,
@@ -100,6 +103,34 @@ pub trait Writable {
 			},
 		}
 	}
+
+	/// Writes and removes the values into the database and updates the cache.
+	fn extend_with_option_cache<K, T, R>(&self, col: Option<u32>, cache: &mut Cache<K, Option<T>>, values: HashMap<K, Option<T>>, policy: CacheUpdatePolicy) where
+	K: Key<T, Target = R> + Hash + Eq,
+	T: Encodable,
+	R: Deref<Target = [u8]> {
+		match policy {
+			CacheUpdatePolicy::Overwrite => {
+				for (key, value) in values.into_iter() {
+					match value {
+						Some(ref v) => self.write(col, &key, v),
+						None => self.delete(col, &key),
+					}
+					cache.insert(key, value);
+				}
+			},
+			CacheUpdatePolicy::Remove => {
+				for (key, value) in values.into_iter() {
+					match value {
+						Some(v) => self.write(col, &key, &v),
+						None => self.delete(col, &key),
+					}
+					cache.remove(&key);
+				}
+			},
+		}
+	}
+
 }

 /// Should be used to read values from database.
@@ -154,6 +185,13 @@ impl Writable for DBTransaction {
 			panic!("db put failed, key: {:?}, err: {:?}", &key.key() as &[u8], err);
 		}
 	}
+
+	fn delete<T, R>(&self, col: Option<u32>, key: &Key<T, Target = R>) where T: Encodable, R: Deref<Target = [u8]> {
+		let result = DBTransaction::delete(self, col, &key.key());
+		if let Err(err) = result {
+			panic!("db delete failed, key: {:?}, err: {:?}", &key.key() as &[u8], err);
+		}
+	}
 }

 impl Readable for Database {
--- a/ethcore/src/engines/basic_authority.rs
+++ b/ethcore/src/engines/basic_authority.rs
@@ -248,9 +248,9 @@ mod tests {
 		let spec = new_test_authority();
 		let engine = &*spec.engine;
 		let genesis_header = spec.genesis_header();
-		let mut db_result = get_temp_journal_db();
+		let mut db_result = get_temp_state_db();
 		let mut db = db_result.take();
-		spec.ensure_db_good(db.as_hashdb_mut()).unwrap();
+		spec.ensure_db_good(&mut db).unwrap();
 		let last_hashes = Arc::new(vec![genesis_header.hash()]);
 		let vm_factory = Default::default();
 		let b = OpenBlock::new(engine, &vm_factory, Default::default(), false, db, &genesis_header, last_hashes, addr, (3141562.into(), 31415620.into()), vec![]).unwrap();
--- a/ethcore/src/engines/instant_seal.rs
+++ b/ethcore/src/engines/instant_seal.rs
@@ -82,9 +82,9 @@ mod tests {
 		let spec = new_test_instant();
 		let engine = &*spec.engine;
 		let genesis_header = spec.genesis_header();
-		let mut db_result = get_temp_journal_db();
+		let mut db_result = get_temp_state_db();
 		let mut db = db_result.take();
-		spec.ensure_db_good(db.as_hashdb_mut()).unwrap();
+		spec.ensure_db_good(&mut db).unwrap();
 		let last_hashes = Arc::new(vec![genesis_header.hash()]);
 		let vm_factory = Default::default();
 		let b = OpenBlock::new(engine, &vm_factory, Default::default(), false, db, &genesis_header, last_hashes, addr, (3141562.into(), 31415620.into()), vec![]).unwrap();
--- a/ethcore/src/engines/mod.rs
+++ b/ethcore/src/engines/mod.rs
@@ -44,6 +44,9 @@ pub trait Engine : Sync + Send {
 	/// Additional engine-specific information for the user/developer concerning `header`.
 	fn extra_info(&self, _header: &Header) -> HashMap<String, String> { HashMap::new() }

+	/// Additional information.
+	fn additional_params(&self) -> HashMap<String, String> { HashMap::new() } 
+
 	/// Get the general parameters of the chain.
 	fn params(&self) -> &CommonParams;

--- a/ethcore/src/ethereum/ethash.rs
+++ b/ethcore/src/ethereum/ethash.rs
@@ -92,6 +92,7 @@ impl Engine for Ethash {
 	fn seal_fields(&self) -> usize { 2 }

 	fn params(&self) -> &CommonParams { &self.params }
+	fn additional_params(&self) -> HashMap<String, String> { hash_map!["registrar".to_owned() => self.ethash_params.registrar.hex()] }

 	fn builtins(&self) -> &BTreeMap<Address, Builtin> {
 		&self.builtins
@@ -352,9 +353,9 @@ mod tests {
 		let spec = new_morden();
 		let engine = &*spec.engine;
 		let genesis_header = spec.genesis_header();
-		let mut db_result = get_temp_journal_db();
+		let mut db_result = get_temp_state_db();
 		let mut db = db_result.take();
-		spec.ensure_db_good(db.as_hashdb_mut()).unwrap();
+		spec.ensure_db_good(&mut db).unwrap();
 		let last_hashes = Arc::new(vec![genesis_header.hash()]);
 		let vm_factory = Default::default();
 		let b = OpenBlock::new(engine, &vm_factory, Default::default(), false, db, &genesis_header, last_hashes, Address::zero(), (3141562.into(), 31415620.into()), vec![]).unwrap();
@@ -367,9 +368,9 @@ mod tests {
 		let spec = new_morden();
 		let engine = &*spec.engine;
 		let genesis_header = spec.genesis_header();
-		let mut db_result = get_temp_journal_db();
+		let mut db_result = get_temp_state_db();
 		let mut db = db_result.take();
-		spec.ensure_db_good(db.as_hashdb_mut()).unwrap();
+		spec.ensure_db_good(&mut db).unwrap();
 		let last_hashes = Arc::new(vec![genesis_header.hash()]);
 		let vm_factory = Default::default();
 		let mut b = OpenBlock::new(engine, &vm_factory, Default::default(), false, db, &genesis_header, last_hashes, Address::zero(), (3141562.into(), 31415620.into()), vec![]).unwrap();
--- a/ethcore/src/ethereum/mod.rs
+++ b/ethcore/src/ethereum/mod.rs
@@ -65,9 +65,9 @@ mod tests {
 		let spec = new_morden();
 		let engine = &spec.engine;
 		let genesis_header = spec.genesis_header();
-		let mut db_result = get_temp_journal_db();
+		let mut db_result = get_temp_state_db();
 		let mut db = db_result.take();
-		spec.ensure_db_good(db.as_hashdb_mut()).unwrap();
+		spec.ensure_db_good(&mut db).unwrap();
 		let s = State::from_existing(db, genesis_header.state_root.clone(), engine.account_start_nonce(), Default::default()).unwrap();
 		assert_eq!(s.balance(&address_from_hex("0000000000000000000000000000000000000001")), U256::from(1u64));
 		assert_eq!(s.balance(&address_from_hex("0000000000000000000000000000000000000002")), U256::from(1u64));
--- a/ethcore/src/evm/ext.rs
+++ b/ethcore/src/evm/ext.rs
@@ -81,7 +81,10 @@ 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;

 	/// Creates log entry with given topics and data
 	fn log(&mut self, topics: Vec<H256>, data: &[u8]);
--- 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/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::*;
@@ -53,6 +55,17 @@ fn color(instruction: Instruction, name: &'static str) -> String {
 type CodePosition = usize;
 type ProgramCounter = usize;

+const ONE: U256 = U256([1, 0, 0, 0]);
+const TWO: U256 = U256([2, 0, 0, 0]);
+const TWO_POW_5: U256 = U256([0x20, 0, 0, 0]);
+const TWO_POW_8: U256 = U256([0x100, 0, 0, 0]);
+const TWO_POW_16: U256 = U256([0x10000, 0, 0, 0]);
+const TWO_POW_24: U256 = U256([0x1000000, 0, 0, 0]);
+const TWO_POW_64: U256 = U256([0, 0x1, 0, 0]); // 0x1 00000000 00000000
+const TWO_POW_96: U256 = U256([0, 0x100000000, 0, 0]); //0x1 00000000 00000000 00000000
+const TWO_POW_224: U256 = U256([0, 0, 0, 0x100000000]); //0x1 00000000 00000000 00000000 00000000 00000000 00000000 00000000
+const TWO_POW_248: U256 = U256([0, 0, 0, 0x100000000000000]); //0x1 00000000 00000000 00000000 00000000 00000000 00000000 00000000 000000
+
 /// Abstraction over raw vector of Bytes. Easier state management of PC.
 struct CodeReader<'a> {
 	position: ProgramCounter,
@@ -87,9 +100,9 @@ enum InstructionResult<Gas> {


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

@@ -98,7 +111,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());
@@ -177,6 +190,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();
@@ -471,14 +492,14 @@ impl<Cost: CostType> Interpreter<Cost> {
 			},
 			instructions::EXTCODESIZE => {
 				let address = u256_to_address(&stack.pop_back());
-				let len = ext.extcode(&address).len();
+				let len = ext.extcode_len(&address);
 				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());
@@ -599,7 +620,19 @@ impl<Cost: CostType> Interpreter<Cost> {
 				let a = stack.pop_back();
 				let b = stack.pop_back();
 				stack.push(if !self.is_zero(&b) {
-					a.overflowing_div(b).0
+					match b {
+						ONE => a,
+						TWO => a >> 1,
+						TWO_POW_5 => a >> 5,
+						TWO_POW_8 => a >> 8,
+						TWO_POW_16 => a >> 16,
+						TWO_POW_24 => a >> 24,
+						TWO_POW_64 => a >> 64,
+						TWO_POW_96 => a >> 96,
+						TWO_POW_224 => a >> 224,
+						TWO_POW_248 => a >> 248,
+						_ => a.overflowing_div(b).0,
+					}
 				} else {
 					U256::zero()
 				});
@@ -767,23 +800,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) {
@@ -810,15 +826,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 = 4096;
+
+/// 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/jit.rs
+++ b/ethcore/src/evm/jit.rs
@@ -18,6 +18,7 @@
 use common::*;
 use evmjit;
 use evm::{self, GasLeft};
+use types::executed::CallType;

 /// Should be used to convert jit types to ethcore
 trait FromJit<T>: Sized {
@@ -77,10 +78,11 @@ impl IntoJit<evmjit::I256> for U256 {
 impl IntoJit<evmjit::I256> for H256 {
 	fn into_jit(self) -> evmjit::I256 {
 		let mut ret = [0; 4];
-		for i in 0..self.bytes().len() {
-			let rev = self.bytes().len() - 1 - i;
+		let len = self.len();
+		for i in 0..len {
+			let rev = len - 1 - i;
 			let pos = rev / 8;
-			ret[pos] += (self.bytes()[i] as u64) << ((rev % 8) * 8);
+			ret[pos] += (self[i] as u64) << ((rev % 8) * 8);
 		}
 		evmjit::I256 { words: ret }
 	}
@@ -194,6 +196,7 @@ impl<'a> evmjit::Ext for ExtAdapter<'a> {
 				receive_address: *const evmjit::H256,
 				code_address: *const evmjit::H256,
 				transfer_value: *const evmjit::I256,
+				// Ignoring apparent value - it's handled correctly in executive.
 				_apparent_value: *const evmjit::I256,
 				in_beg: *const u8,
 				in_size: u64,
@@ -207,10 +210,12 @@ impl<'a> evmjit::Ext for ExtAdapter<'a> {
 		let receive_address = unsafe { Address::from_jit(&*receive_address) };
 		let code_address = unsafe { Address::from_jit(&*code_address) };
 		let transfer_value = unsafe { U256::from_jit(&*transfer_value) };
-		let value = Some(transfer_value);

 		// receive address and code address are the same in normal calls
 		let is_callcode = receive_address != code_address;
+		let is_delegatecall = is_callcode && sender_address != receive_address;
+
+		let value = if is_delegatecall { None } else { Some(transfer_value) };

 		if !is_callcode && !self.ext.exists(&code_address) {
 			gas_cost = gas_cost + U256::from(self.ext.schedule().call_new_account_gas);
@@ -239,6 +244,12 @@ impl<'a> evmjit::Ext for ExtAdapter<'a> {
 			}
 		}

+		let call_type = match (is_callcode, is_delegatecall) {
+			(_, true) => CallType::DelegateCall,
+			(true, false) => CallType::CallCode,
+			(false, false) => CallType::Call,
+		};
+
 		match self.ext.call(
 					  &call_gas,
 					  &sender_address,
@@ -246,7 +257,9 @@ impl<'a> evmjit::Ext for ExtAdapter<'a> {
 					  value,
 					  unsafe { slice::from_raw_parts(in_beg, in_size as usize) },
 					  &code_address,
-					  unsafe { slice::from_raw_parts_mut(out_beg, out_size as usize) }) {
+					  unsafe { slice::from_raw_parts_mut(out_beg, out_size as usize) },
+					  call_type,
+					  ) {
 			evm::MessageCallResult::Success(gas_left) => unsafe {
 				*io_gas = (gas + gas_left).low_u64();
 				true
--- 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,12 @@ 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 {
+		self.codes.get(address).map_or(0, |c| c.len() as u64)
 	}

 	fn log(&mut self, topics: Vec<H256>, data: &[u8]) {
@@ -180,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()
 	};

@@ -207,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 = {
@@ -227,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 = {
@@ -247,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 = {
@@ -269,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 = {
@@ -291,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 = {
@@ -325,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);
@@ -346,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 = {
@@ -378,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 = {
@@ -402,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());

@@ -424,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();

@@ -445,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;

@@ -465,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;

@@ -485,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;

@@ -505,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;

@@ -525,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;

@@ -544,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 = {
@@ -562,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 = {
@@ -580,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 = {
@@ -598,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 = {
@@ -616,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 = {
@@ -635,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 = {
@@ -654,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 = {
@@ -673,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 = {
@@ -693,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 = {
@@ -714,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 = {
@@ -735,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 = {
@@ -758,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 = {
@@ -779,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 = {
@@ -798,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 = {
@@ -818,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 = {
@@ -838,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 = {
@@ -858,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 = {
@@ -881,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 = {
@@ -904,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
@@ -167,13 +167,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 +190,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,
 				};
@@ -510,7 +512,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 +571,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 +626,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();
@@ -734,7 +736,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 +824,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 +876,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 +933,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 +983,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 +1184,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,12 @@ 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 {
+		self.state.code_size(address).unwrap_or(0)
 	}

 	#[cfg_attr(feature="dev", allow(match_ref_pats))]
--- a/ethcore/src/json_tests/executive.rs
+++ b/ethcore/src/json_tests/executive.rs
@@ -128,10 +128,14 @@ 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)
 	}

+	fn extcode_len(&self, address: &Address) -> u64  {
+		self.ext.extcode_len(address)
+	}
+
 	fn log(&mut self, topics: Vec<H256>, data: &[u8]) {
 		self.ext.log(topics, data)
 	}
@@ -229,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/lib.rs
+++ b/ethcore/src/lib.rs
@@ -100,8 +100,12 @@ extern crate ethcore_ipc_nano as nanoipc;
 extern crate ethcore_devtools as devtools;
 extern crate rand;
 extern crate bit_set;
+extern crate lru_cache;
+extern crate bloomfilter;
+extern crate byteorder;

-#[cfg(feature = "jit" )] extern crate evmjit;
+#[cfg(feature = "jit" )]
+extern crate evmjit;

 pub mod account_provider;
 pub mod engines;
@@ -130,6 +134,7 @@ mod basic_types;
 mod env_info;
 mod pod_account;
 mod state;
+mod state_db;
 mod account;
 mod account_db;
 mod builtin;
--- a/ethcore/src/migrations/account_bloom.rs
+++ b/ethcore/src/migrations/account_bloom.rs
@@ -0,0 +1,104 @@
+// 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/>.
+
+//! Bloom upgrade
+
+use client::{DB_COL_EXTRA, DB_COL_HEADERS, DB_NO_OF_COLUMNS, DB_COL_STATE, DB_COL_ACCOUNT_BLOOM};
+use state_db::{ACCOUNT_BLOOM_SPACE, DEFAULT_ACCOUNT_PRESET, StateDB, ACCOUNT_BLOOM_HASHCOUNT_KEY};
+use util::trie::TrieDB;
+use views::HeaderView;
+use bloomfilter::Bloom;
+use util::migration::Error;
+use util::journaldb;
+use util::{H256, FixedHash, BytesConvertable};
+use util::{Database, DatabaseConfig, DBTransaction, CompactionProfile};
+use std::path::Path;
+
+fn check_bloom_exists(db: &Database) -> bool {
+	let hash_count_entry = db.get(DB_COL_ACCOUNT_BLOOM, ACCOUNT_BLOOM_HASHCOUNT_KEY)
+		.expect("Low-level database error");
+
+	hash_count_entry.is_some()
+}
+
+/// Account bloom upgrade routine. If bloom already present, does nothing.
+/// If database empty (no best block), does nothing.
+/// Can be called on upgraded database with no issues (will do nothing).
+pub fn upgrade_account_bloom(db_path: &Path) -> Result<(), Error> {
+	let path = try!(db_path.to_str().ok_or(Error::MigrationImpossible));
+	trace!(target: "migration", "Account bloom upgrade at {:?}", db_path);
+
+	let source = try!(Database::open(&DatabaseConfig {
+		max_open_files: 64,
+		cache_size: None,
+		compaction: CompactionProfile::default(),
+		columns: DB_NO_OF_COLUMNS,
+		wal: true,
+	}, path));
+
+	let best_block_hash = match try!(source.get(DB_COL_EXTRA, b"best")) {
+		// no migration needed
+		None => {
+			trace!(target: "migration", "No best block hash, skipping");
+			return Ok(());
+		},
+		Some(hash) => hash,
+	};
+	let best_block_header = match try!(source.get(DB_COL_HEADERS, &best_block_hash)) {
+		// no best block, nothing to do
+		None => {
+			trace!(target: "migration", "No best block header, skipping");
+			return Ok(())
+		},
+		Some(x) => x,
+	};
+	let state_root = HeaderView::new(&best_block_header).state_root();
+
+	if check_bloom_exists(&source) {
+		// bloom already exists, nothing to do
+		trace!(target: "migration", "Bloom already present, skipping");
+		return Ok(())
+	}
+
+	println!("Adding accounts bloom (one-time upgrade)");
+	let db = ::std::sync::Arc::new(source);
+	let bloom_journal = {
+		let mut bloom = Bloom::new(ACCOUNT_BLOOM_SPACE, DEFAULT_ACCOUNT_PRESET);
+		// no difference what algorithm is passed, since there will be no writes
+		let state_db = journaldb::new(
+			db.clone(),
+			journaldb::Algorithm::OverlayRecent,
+			DB_COL_STATE);
+		let account_trie = try!(TrieDB::new(state_db.as_hashdb(), &state_root).map_err(|e| Error::Custom(format!("Cannot open trie: {:?}", e))));
+		for (ref account_key, _) in account_trie.iter() {
+			let account_key_hash = H256::from_slice(&account_key);
+			bloom.set(account_key_hash.as_slice());
+		}
+
+		bloom.drain_journal()
+	};
+
+	trace!(target: "migration", "Generated {} bloom updates", bloom_journal.entries.len());
+
+	let batch = DBTransaction::new(&db);
+	try!(StateDB::commit_bloom(&batch, bloom_journal).map_err(|_| Error::Custom("Failed to commit bloom".to_owned())));
+	try!(db.write(batch));
+
+	trace!(target: "migration", "Finished bloom update");
+
+
+	Ok(())
+}
--- a/ethcore/src/migrations/mod.rs
+++ b/ethcore/src/migrations/mod.rs
@@ -23,3 +23,9 @@ pub mod extras;
 mod v9;
 pub use self::v9::ToV9;
 pub use self::v9::Extract;
+
+mod account_bloom;
+pub use self::account_bloom::upgrade_account_bloom;
+
+mod v10;
+pub use self::v10::ToV10;
--- a/ethcore/src/migrations/v10.rs
+++ b/ethcore/src/migrations/v10.rs
@@ -0,0 +1,35 @@
+// 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/>.
+
+//! This migration compresses the state db.
+
+use util::migration::SimpleMigration;
+
+/// Compressing migration.
+#[derive(Default)]
+pub struct ToV10;
+
+impl SimpleMigration for ToV10 {
+	fn version(&self) -> u32 {
+		10
+	}
+
+	fn columns(&self) -> Option<u32> { Some(6) }
+
+	fn simple_migrate(&mut self, key: Vec<u8>, value: Vec<u8>) -> Option<(Vec<u8>, Vec<u8>)> {
+		Some((key, value))
+	}
+}
--- a/ethcore/src/miner/miner.rs
+++ b/ethcore/src/miner/miner.rs
@@ -23,10 +23,11 @@ use account_provider::AccountProvider;
 use views::{BlockView, HeaderView};
 use state::State;
 use client::{MiningBlockChainClient, Executive, Executed, EnvInfo, TransactOptions, BlockID, CallAnalytics};
+use executive::contract_address;
 use block::{ClosedBlock, IsBlock, Block};
 use error::*;
-use transaction::SignedTransaction;
-use receipt::Receipt;
+use transaction::{Action, SignedTransaction};
+use receipt::{Receipt, RichReceipt};
 use spec::Spec;
 use engines::Engine;
 use miner::{MinerService, MinerStatus, TransactionQueue, AccountDetails, TransactionOrigin};
@@ -285,6 +286,7 @@ impl Miner {
 		};

 		let mut invalid_transactions = HashSet::new();
+		let mut transactions_to_penalize = HashSet::new();
 		let block_number = open_block.block().fields().header.number();
 		// TODO: push new uncles, too.
 		for tx in transactions {
@@ -292,6 +294,12 @@ impl Miner {
 			match open_block.push_transaction(tx, None) {
 				Err(Error::Execution(ExecutionError::BlockGasLimitReached { gas_limit, gas_used, gas })) => {
 					debug!(target: "miner", "Skipping adding transaction to block because of gas limit: {:?} (limit: {:?}, used: {:?}, gas: {:?})", hash, gas_limit, gas_used, gas);
+
+					// Penalize transaction if it's above current gas limit
+					if gas > gas_limit {
+						transactions_to_penalize.insert(hash);
+					}
+
 					// Exit early if gas left is smaller then min_tx_gas
 					let min_tx_gas: U256 = 21000.into();	// TODO: figure this out properly.
 					if gas_limit - gas_used < min_tx_gas {
@@ -327,6 +335,9 @@ impl Miner {
 			for hash in invalid_transactions.into_iter() {
 				queue.remove_invalid(&hash, &fetch_account);
 			}
+			for hash in transactions_to_penalize {
+				queue.penalize(&hash);
+			}
 		}

 		if !block.transactions().is_empty() {
@@ -527,7 +538,7 @@ impl MinerService for Miner {

 	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))
+		sealing_work.queue.peek_last_ref().map_or_else(|| chain.latest_code(address), |b| b.block().fields().state.code(address).map(|c| (*c).clone()))
 	}

 	fn set_author(&self, author: Address) {
@@ -712,6 +723,35 @@ impl MinerService for Miner {
 		}
 	}

+	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)) => {
+				let txs = pending.transactions();
+				txs.iter()
+					.map(|t| t.hash())
+					.position(|t| t == *hash)
+					.map(|index| {
+						let prev_gas = if index == 0 { Default::default() } else { pending.receipts()[index - 1].gas_used };
+						let ref tx = txs[index];
+						let ref receipt = pending.receipts()[index];
+						RichReceipt {
+							transaction_hash: hash.clone(),
+							transaction_index: index,
+							cumulative_gas_used: receipt.gas_used,
+							gas_used: receipt.gas_used - prev_gas,
+							contract_address: match tx.action {
+								Action::Call(_) => None,
+								Action::Create => Some(contract_address(&tx.sender().unwrap(), &tx.nonce)),
+							},
+							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()) {
@@ -839,7 +879,7 @@ impl MinerService for Miner {
 			out_of_chain.for_each(|txs| {
 				let mut transaction_queue = self.transaction_queue.lock();
 				let _ = self.add_transactions_to_queue(
-					chain, txs, TransactionOrigin::External, &mut transaction_queue
+					chain, txs, TransactionOrigin::RetractedBlock, &mut transaction_queue
 				);
 			});
 		}
--- a/ethcore/src/miner/mod.rs
+++ b/ethcore/src/miner/mod.rs
@@ -56,7 +56,7 @@ use std::collections::BTreeMap;
 use util::{H256, U256, Address, Bytes};
 use client::{MiningBlockChainClient, Executed, CallAnalytics};
 use block::ClosedBlock;
-use receipt::Receipt;
+use receipt::{RichReceipt, Receipt};
 use error::{Error, CallError};
 use transaction::SignedTransaction;

@@ -146,6 +146,9 @@ pub trait MinerService : Send + Sync {
 	/// Get a list of all pending receipts.
 	fn pending_receipts(&self) -> BTreeMap<H256, Receipt>;

+	/// Get a particular reciept.
+	fn pending_receipt(&self, 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
@@ -99,6 +99,8 @@ pub enum TransactionOrigin {
 	Local,
 	/// External transaction received from network
 	External,
+	/// Transactions from retracted blocks
+	RetractedBlock,
 }

 impl PartialOrd for TransactionOrigin {
@@ -113,10 +115,11 @@ impl Ord for TransactionOrigin {
 			return Ordering::Equal;
 		}

-		if *self == TransactionOrigin::Local {
-			Ordering::Less
-		} else {
-			Ordering::Greater
+		match (*self, *other) {
+			(TransactionOrigin::RetractedBlock, _) => Ordering::Less,
+			(_, TransactionOrigin::RetractedBlock) => Ordering::Greater,
+			(TransactionOrigin::Local, _) => Ordering::Less,
+			_ => Ordering::Greater,
 		}
 	}
 }
@@ -131,10 +134,15 @@ struct TransactionOrder {
 	/// Gas Price of the transaction.
 	/// Low gas price = Low priority (processed later)
 	gas_price: U256,
+	/// Gas (limit) of the transaction.
+	/// Low gas limit = High priority (processed earlier)
+	gas: U256,
 	/// Hash to identify associated transaction
 	hash: H256,
 	/// Origin of the transaction
 	origin: TransactionOrigin,
+	/// Penalties
+	penalties: usize,
 }


@@ -143,8 +151,10 @@ impl TransactionOrder {
 		TransactionOrder {
 			nonce_height: tx.nonce() - base_nonce,
 			gas_price: tx.transaction.gas_price,
+			gas: tx.transaction.gas,
 			hash: tx.hash(),
 			origin: tx.origin,
+			penalties: 0,
 		}
 	}

@@ -152,6 +162,11 @@ impl TransactionOrder {
 		self.nonce_height = nonce - base_nonce;
 		self
 	}
+
+	fn penalize(mut self) -> Self {
+		self.penalties = self.penalties.saturating_add(1);
+		self
+	}
 }

 impl Eq for TransactionOrder {}
@@ -168,6 +183,11 @@ impl PartialOrd for TransactionOrder {

 impl Ord for TransactionOrder {
 	fn cmp(&self, b: &TransactionOrder) -> Ordering {
+		// First check number of penalties
+		if self.penalties != b.penalties {
+			return self.penalties.cmp(&b.penalties);
+		}
+
 		// First check nonce_height
 		if self.nonce_height != b.nonce_height {
 			return self.nonce_height.cmp(&b.nonce_height);
@@ -179,11 +199,18 @@ impl Ord for TransactionOrder {
 			return self.origin.cmp(&b.origin);
 		}

-		// Then compare gas_prices
-		let a_gas = self.gas_price;
-		let b_gas = b.gas_price;
+		// Then compare gas usage
+		let a_gas = self.gas;
+		let b_gas = b.gas;
 		if a_gas != b_gas {
-			return b_gas.cmp(&a_gas);
+			return a_gas.cmp(&b_gas);
+		}
+
+		// 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);
 		}

 		// Compare hashes
@@ -321,7 +348,7 @@ 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; // %
+const GAS_LIMIT_HYSTERESIS: usize = 10; // (100/GAS_LIMIT_HYSTERESIS) %

 /// `TransactionQueue` implementation
 pub struct TransactionQueue {
@@ -504,6 +531,39 @@ impl TransactionQueue {
 		assert_eq!(self.future.by_priority.len() + self.current.by_priority.len(), self.by_hash.len());
 	}

+	/// Penalize transactions from sender of transaction with given hash.
+	/// I.e. it should change the priority of the transaction in the queue.
+	///
+	/// NOTE: We need to penalize all transactions from particular sender
+	/// to avoid breaking invariants in queue (ordered by nonces).
+	/// Consecutive transactions from this sender would fail otherwise (because of invalid nonce).
+	pub fn penalize(&mut self, transaction_hash: &H256) {
+		let transaction = match self.by_hash.get(transaction_hash) {
+			None => return,
+			Some(t) => t,
+		};
+		let sender = transaction.sender();
+
+		// Penalize all transactions from this sender
+		let nonces_from_sender = match self.current.by_address.row(&sender) {
+			Some(row_map) => row_map.keys().cloned().collect::<Vec<U256>>(),
+			None => vec![],
+		};
+		for k in nonces_from_sender {
+			let order = self.current.drop(&sender, &k).unwrap();
+			self.current.insert(sender, k, order.penalize());
+		}
+		// Same thing for future
+		let nonces_from_sender = match self.future.by_address.row(&sender) {
+			Some(row_map) => row_map.keys().cloned().collect::<Vec<U256>>(),
+			None => vec![],
+		};
+		for k in nonces_from_sender {
+			let order = self.future.drop(&sender, &k).unwrap();
+			self.current.insert(sender, k, order.penalize());
+		}
+	}
+
 	/// Removes invalid transaction identified by hash from queue.
 	/// Assumption is that this transaction nonce is not related to client nonce,
 	/// so transactions left in queue are processed according to client nonce.
@@ -577,7 +637,10 @@ impl TransactionQueue {
 			// Goes to future or is removed
 			let order = self.current.drop(sender, &k).unwrap();
 			if k >= current_nonce {
-				self.future.insert(*sender, k, order.update_height(k, current_nonce));
+				let order = order.update_height(k, current_nonce);
+				if let Some(old) = self.future.insert(*sender, k, order.clone()) {
+					Self::replace_orders(*sender, k, old, order, &mut self.future, &mut self.by_hash);
+				}
 			} else {
 				trace!(target: "txqueue", "Removing old transaction: {:?} (nonce: {} < {})", order.hash, k, current_nonce);
 				self.by_hash.remove(&order.hash).expect("All transactions in `future` are also in `by_hash`");
@@ -641,7 +704,9 @@ impl TransactionQueue {
 				self.future.by_priority.remove(&order);
 				// Put to current
 				let order = order.update_height(current_nonce, first_nonce);
-				self.current.insert(address, current_nonce, order);
+				if let Some(old) = self.current.insert(address, current_nonce, order.clone()) {
+					Self::replace_orders(address, current_nonce, old, order, &mut self.current, &mut self.by_hash);
+				}
 				update_last_nonce_to = Some(current_nonce);
 				current_nonce = current_nonce + U256::one();
 			}
@@ -673,45 +738,51 @@ impl TransactionQueue {

 		let address = tx.sender();
 		let nonce = tx.nonce();
-
-		let next_nonce = self.last_nonces
-			.get(&address)
-			.cloned()
-			.map_or(state_nonce, |n| n + U256::one());
+		let hash = tx.hash();

 		// The transaction might be old, let's check that.
 		// This has to be the first test, otherwise calculating
 		// nonce height would result in overflow.
 		if nonce < state_nonce {
 			// Droping transaction
-			trace!(target: "txqueue", "Dropping old transaction: {:?} (nonce: {} < {})", tx.hash(), nonce, next_nonce);
+			trace!(target: "txqueue", "Dropping old transaction: {:?} (nonce: {} < {})", hash, nonce, state_nonce);
 			return Err(TransactionError::Old);
-		} else if nonce > next_nonce {
+		}
+
+		// Update nonces of transactions in future (remove old transactions)
+		self.update_future(&address, state_nonce);
+		// State nonce could be updated. Maybe there are some more items waiting in future?
+		self.move_matching_future_to_current(address, state_nonce, state_nonce);
+		// Check the next expected nonce (might be updated by move above)
+		let next_nonce = self.last_nonces
+			.get(&address)
+			.cloned()
+			.map_or(state_nonce, |n| n + U256::one());
+
+		// Future transaction
+		if nonce > next_nonce {
 			// We have a gap - put to future.
-			// Update nonces of transactions in future (remove old transactions)
-			self.update_future(&address, state_nonce);
 			// 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)));
-			// Return an error if this transaction is not imported because of limit.
-			try!(check_if_removed(&address, &nonce, self.future.enforce_limit(&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.
+			try!(check_if_removed(&address, &nonce, removed));
+
+			debug!(target: "txqueue", "Importing transaction to future: {:?}", hash);
+			debug!(target: "txqueue", "status: {:?}", self.status());
 			return Ok(TransactionImportResult::Future);
 		}
+
+		// We might have filled a gap - move some more transactions from future
+		self.move_matching_future_to_current(address, nonce, state_nonce);
+		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)));
 		// 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);
-		// Update nonces of transactions in future
-		self.update_future(&address, state_nonce);
-		// Maybe there are some more items waiting in future?
-		self.move_matching_future_to_current(address, nonce + U256::one(), state_nonce);
-		// There might be exactly the same transaction waiting in future
-		// same (sender, nonce), but above function would not move it.
-		if let Some(order) = self.future.drop(&address, &nonce) {
-			// Let's insert that transaction to current (if it has higher gas_price)
-			let future_tx = self.by_hash.remove(&order.hash).expect("All transactions in `future` are always in `by_hash`.");
-			// if transaction in `current` (then one we are importing) is replaced it means that it has to low gas_price
-			try!(check_too_cheap(!Self::replace_transaction(future_tx, state_nonce, &mut self.current, &mut self.by_hash)));
-		}

 		// Also enforce the limit
 		let removed = self.current.enforce_limit(&mut self.by_hash);
@@ -755,24 +826,28 @@ impl TransactionQueue {


 		if let Some(old) = set.insert(address, nonce, order.clone()) {
-			// There was already transaction in queue. Let's check which one should stay
-			let old_fee = old.gas_price;
-			let new_fee = order.gas_price;
-			if old_fee.cmp(&new_fee) == Ordering::Greater {
-				// Put back old transaction since it has greater priority (higher gas_price)
-				set.insert(address, nonce, old);
-				// and remove new one
-				by_hash.remove(&hash).expect("The hash has been just inserted and no other line is altering `by_hash`.");
-				false
-			} else {
-				// 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
-			}
+			Self::replace_orders(address, nonce, old, order, set, by_hash)
 		} else {
 			true
 		}
 	}
+
+	fn replace_orders(address: Address, nonce: U256, old: TransactionOrder, order: TransactionOrder, set: &mut TransactionSet, by_hash: &mut HashMap<H256, VerifiedTransaction>) -> bool {
+		// There was already transaction in queue. Let's check which one should stay
+		let old_fee = old.gas_price;
+		let new_fee = order.gas_price;
+		if old_fee.cmp(&new_fee) == Ordering::Greater {
+			// 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 {
+			// 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
+		}
+	}
 }

 fn check_too_cheap(is_in: bool) -> Result<(), TransactionError> {
@@ -814,25 +889,40 @@ mod test {
 		}
 	}

-	fn new_unsigned_tx(nonce: U256) -> Transaction {
+	fn default_nonce_val() -> U256 {
+		123.into()
+	}
+
+	fn default_gas_val() -> U256 {
+		100_000.into()
+	}
+
+	fn default_gas_price_val() -> U256 {
+		1.into()
+	}
+
+	fn new_unsigned_tx_with_gas(nonce: U256, gas: U256, gas_price: U256) -> Transaction {
 		Transaction {
 			action: Action::Create,
 			value: U256::from(100),
 			data: "3331600055".from_hex().unwrap(),
-			gas: U256::from(100_000),
-			gas_price: U256::one(),
+			gas: gas,
+			gas_price: gas_price,
 			nonce: nonce
 		}
 	}

-	fn new_tx() -> SignedTransaction {
-		let keypair = KeyPair::create().unwrap();
-		new_unsigned_tx(U256::from(123)).sign(keypair.secret())
+	fn new_unsigned_tx(nonce: U256) -> Transaction {
+		new_unsigned_tx_with_gas(nonce, default_gas_val(), default_gas_price_val())
 	}

+	fn new_tx_with_gas(gas: U256, gas_price: U256) -> SignedTransaction {
+		let keypair = KeyPair::create().unwrap();
+		new_unsigned_tx_with_gas(default_nonce_val(), gas, gas_price).sign(keypair.secret())
+	}

-	fn default_nonce_val() -> U256 {
-		U256::from(123)
+	fn new_tx() -> SignedTransaction {
+		new_tx_with_gas(default_gas_val(), default_gas_price_val())
 	}

 	fn default_nonce(_address: &Address) -> AccountDetails {
@@ -846,10 +936,10 @@ mod test {
 	fn new_similar_txs() -> (SignedTransaction, SignedTransaction) {
 		let keypair = KeyPair::create().unwrap();
 		let secret = &keypair.secret();
-		let nonce = U256::from(123);
+		let nonce = default_nonce_val();
 		let tx = new_unsigned_tx(nonce);
 		let mut tx2 = new_unsigned_tx(nonce);
-		tx2.gas_price = U256::from(2);
+		tx2.gas_price = 2.into();

 		(tx.sign(secret), tx2.sign(secret))
 	}
@@ -858,6 +948,18 @@ mod test {
 		new_txs_with_gas_price_diff(second_nonce, U256::zero())
 	}

+	fn new_txs_with_higher_gas_price(gas_price: U256) -> (SignedTransaction, SignedTransaction) {
+		let keypair = KeyPair::create().unwrap();
+		let secret = &keypair.secret();
+		let nonce = U256::from(123);
+		let mut tx = new_unsigned_tx(nonce);
+		tx.gas_price = tx.gas_price + gas_price;
+		let mut tx2 = new_unsigned_tx(nonce + 1.into());
+		tx2.gas_price = tx2.gas_price + gas_price;
+
+		(tx.sign(secret), tx2.sign(secret))
+	}
+
 	fn new_txs_with_gas_price_diff(second_nonce: U256, gas_price: U256) -> (SignedTransaction, SignedTransaction) {
 		let keypair = KeyPair::create().unwrap();
 		let secret = &keypair.secret();
@@ -869,6 +971,17 @@ mod test {
 		(tx.sign(secret), tx2.sign(secret))
 	}

+	#[test]
+	fn test_ordering() {
+		assert_eq!(TransactionOrigin::Local.cmp(&TransactionOrigin::External), Ordering::Less);
+		assert_eq!(TransactionOrigin::RetractedBlock.cmp(&TransactionOrigin::Local), Ordering::Less);
+		assert_eq!(TransactionOrigin::RetractedBlock.cmp(&TransactionOrigin::External), Ordering::Less);
+
+		assert_eq!(TransactionOrigin::External.cmp(&TransactionOrigin::Local), Ordering::Greater);
+		assert_eq!(TransactionOrigin::Local.cmp(&TransactionOrigin::RetractedBlock), Ordering::Greater);
+		assert_eq!(TransactionOrigin::External.cmp(&TransactionOrigin::RetractedBlock), Ordering::Greater);
+	}
+
 	#[test]
 	fn should_create_transaction_set() {
 		// given
@@ -972,6 +1085,31 @@ mod test {
 		assert_eq!(txq.top_transactions()[0], tx2);
 	}

+	#[test]
+	fn should_move_all_transactions_from_future() {
+		// given
+		let mut txq = TransactionQueue::new();
+		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() };
+
+		// First insert one transaction to future
+		let res = txq.add(tx.clone(), &prev_nonce, TransactionOrigin::External);
+		assert_eq!(res.unwrap(), TransactionImportResult::Future);
+		assert_eq!(txq.status().future, 1);
+
+		// now import second transaction to current
+		let res = txq.add(tx2.clone(), &default_nonce, TransactionOrigin::External);
+
+		// then
+		assert_eq!(res.unwrap(), TransactionImportResult::Current);
+		assert_eq!(txq.status().pending, 2);
+		assert_eq!(txq.status().future, 0);
+		assert_eq!(txq.current.by_priority.len(), 2);
+		assert_eq!(txq.current.by_address.len(), 2);
+		assert_eq!(txq.top_transactions()[0], tx);
+		assert_eq!(txq.top_transactions()[1], tx2);
+	}

 	#[test]
 	fn should_import_tx() {
@@ -988,6 +1126,39 @@ mod test {
 		assert_eq!(stats.pending, 1);
 	}

+	#[test]
+	fn should_order_by_gas() {
+		// given
+		let mut txq = TransactionQueue::new();
+		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());
+		let tx4 = new_tx_with_gas(50000.into(), 20.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!(unwrap_tx_err(res3), TransactionError::InsufficientGasPrice {
+			minimal: U256::from(15),
+			got: U256::from(10),
+		});
+		assert_eq!(res4.unwrap(), TransactionImportResult::Current);
+		let stats = txq.status();
+		assert_eq!(stats.pending, 3);
+		assert_eq!(txq.top_transactions()[0].gas, 40000.into());
+		assert_eq!(txq.top_transactions()[1].gas, 50000.into());
+		assert_eq!(txq.top_transactions()[2].gas, 50000.into());
+		assert_eq!(txq.top_transactions()[1].gas_price, 40.into());
+		assert_eq!(txq.top_transactions()[2].gas_price, 20.into());
+	}
+
 	#[test]
 	fn gas_limit_should_never_overflow() {
 		// given
@@ -1024,7 +1195,6 @@ mod test {
 		assert_eq!(stats.future, 0);
 	}

-
 	#[test]
 	fn should_drop_transactions_from_senders_without_balance() {
 		// given
@@ -1086,7 +1256,7 @@ mod test {
 	}

 	#[test]
-	fn should_reject_incorectly_signed_transaction() {
+	fn should_reject_incorrectly_signed_transaction() {
 		// given
 		let mut txq = TransactionQueue::new();
 		let tx = new_unsigned_tx(U256::from(123));
@@ -1149,6 +1319,27 @@ mod test {
 		assert_eq!(top.len(), 2);
 	}

+	#[test]
+	fn should_prioritize_reimported_transactions_within_same_nonce_height() {
+		// given
+		let mut txq = TransactionQueue::new();
+		let tx = new_tx();
+		// the second one has same nonce but higher `gas_price`
+		let (_, tx2) = new_similar_txs();
+
+		// when
+		// first insert local one with higher gas price
+		txq.add(tx2.clone(), &default_nonce, TransactionOrigin::Local).unwrap();
+		// then the one with lower gas price, but from retracted block
+		txq.add(tx.clone(), &default_nonce, TransactionOrigin::RetractedBlock).unwrap();
+
+		// then
+		let top = txq.top_transactions();
+		assert_eq!(top[0], tx); // retracted should be first
+		assert_eq!(top[1], tx2);
+		assert_eq!(top.len(), 2);
+	}
+
 	#[test]
 	fn should_not_prioritize_local_transactions_with_different_nonce_height() {
 		// given
@@ -1166,6 +1357,39 @@ mod test {
 		assert_eq!(top.len(), 2);
 	}

+	#[test]
+	fn should_penalize_transactions_from_sender() {
+		// given
+		let mut txq = TransactionQueue::new();
+		// 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(), &default_nonce, TransactionOrigin::External).unwrap();
+		txq.add(txb.clone(), &default_nonce, TransactionOrigin::External).unwrap();
+		txq.add(tx1.clone(), &default_nonce, TransactionOrigin::External).unwrap();
+		txq.add(tx2.clone(), &default_nonce, TransactionOrigin::External).unwrap();
+
+		let top = txq.top_transactions();
+		assert_eq!(top[0], tx1);
+		assert_eq!(top[1], txa);
+		assert_eq!(top[2], tx2);
+		assert_eq!(top[3], txb);
+		assert_eq!(top.len(), 4);
+
+		// when
+		txq.penalize(&tx1.hash());
+
+		// then
+		let top = txq.top_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_return_pending_hashes() {
 			// given
--- a/ethcore/src/pod_account.rs
+++ b/ethcore/src/pod_account.rs
@@ -47,7 +47,7 @@ impl PodAccount {
 		PodAccount {
 			balance: *acc.balance(),
 			nonce: *acc.nonce(),
-			storage: acc.storage_overlay().iter().fold(BTreeMap::new(), |mut m, (k, &(_, ref v))| {m.insert(k.clone(), v.clone()); m}),
+			storage: acc.storage_changes().iter().fold(BTreeMap::new(), |mut m, (k, v)| {m.insert(k.clone(), v.clone()); m}),
 			code: acc.code().map(|x| x.to_vec()),
 		}
 	}
--- a/ethcore/src/snapshot/account.rs
+++ b/ethcore/src/snapshot/account.rs
@@ -143,7 +143,7 @@ impl Account {
 #[cfg(test)]
 mod tests {
 	use account_db::{AccountDB, AccountDBMut};
-	use tests::helpers::get_temp_journal_db;
+	use tests::helpers::get_temp_state_db;
 	use snapshot::tests::helpers::fill_storage;

 	use util::{SHA3_NULL_RLP, SHA3_EMPTY};
@@ -154,8 +154,7 @@ mod tests {

 	#[test]
 	fn encoding_basic() {
-		let mut db = get_temp_journal_db();
-		let mut db = &mut **db;
+		let mut db = get_temp_state_db();
 		let addr = Address::random();

 		let account = Account {
@@ -175,8 +174,7 @@ mod tests {

 	#[test]
 	fn encoding_storage() {
-		let mut db = get_temp_journal_db();
-		let mut db = &mut **db;
+		let mut db = get_temp_state_db();
 		let addr = Address::random();

 		let account = {
@@ -198,4 +196,4 @@ mod tests {
 		let fat_rlp = UntrustedRlp::new(&fat_rlp);
 		assert_eq!(Account::from_fat_rlp(&mut AccountDBMut::new(db.as_hashdb_mut(), &addr), fat_rlp).unwrap(), account);
 	}
-}
+}
--- a/ethcore/src/snapshot/mod.rs
+++ b/ethcore/src/snapshot/mod.rs
@@ -25,8 +25,9 @@ use blockchain::{BlockChain, BlockProvider};
 use engines::Engine;
 use ids::BlockID;
 use views::BlockView;
+use super::state_db::StateDB;

-use util::{Bytes, Hashable, HashDB, snappy, TrieDB, TrieDBMut, TrieMut};
+use util::{Bytes, Hashable, HashDB, snappy, TrieDB, TrieDBMut, TrieMut, BytesConvertable};
 use util::Mutex;
 use util::hash::{FixedHash, H256};
 use util::journaldb::{self, Algorithm, JournalDB};
@@ -453,7 +454,7 @@ impl StateRebuilder {
 			Ok::<_, ::error::Error>(())
 		}));

-
+		let mut bloom = StateDB::load_bloom(&backing);
 		// batch trie writes
 		{
 			let mut account_trie = if self.state_root != SHA3_NULL_RLP {
@@ -463,11 +464,14 @@ impl StateRebuilder {
 			};

 			for (hash, thin_rlp) in pairs {
+				bloom.set(hash.as_slice());
 				try!(account_trie.insert(&hash, &thin_rlp));
 			}
 		}

+		let bloom_journal = bloom.drain_journal();
 		let batch = backing.transaction();
+		try!(StateDB::commit_bloom(&batch, bloom_journal));
 		try!(self.db.inject(&batch));
 		try!(backing.write(batch).map_err(::util::UtilError::SimpleString));
 		trace!(target: "snapshot", "current state root: {:?}", self.state_root);
--- a/ethcore/src/spec/spec.rs
+++ b/ethcore/src/spec/spec.rs
@@ -20,6 +20,7 @@ use common::*;
 use engines::{Engine, NullEngine, InstantSeal, BasicAuthority};
 use pod_state::*;
 use account_db::*;
+use state_db::StateDB;
 use super::genesis::Genesis;
 use super::seal::Generic as GenericSeal;
 use ethereum;
@@ -229,19 +230,20 @@ impl Spec {
 	}

 	/// Ensure that the given state DB has the trie nodes in for the genesis state.
-	pub fn ensure_db_good(&self, db: &mut HashDB) -> Result<bool, Box<TrieError>> {
-		if !db.contains(&self.state_root()) {
+	pub fn ensure_db_good(&self, db: &mut StateDB) -> Result<bool, Box<TrieError>> {
+		if !db.as_hashdb().contains(&self.state_root()) {
 			let mut root = H256::new();
 			{
-				let mut t = SecTrieDBMut::new(db, &mut root);
+				let mut t = SecTrieDBMut::new(db.as_hashdb_mut(), &mut root);
 				for (address, account) in self.genesis_state.get().iter() {
 					try!(t.insert(address.as_slice(), &account.rlp()));
 				}
 			}
 			for (address, account) in self.genesis_state.get().iter() {
-				account.insert_additional(&mut AccountDBMut::new(db, address));
+				db.note_account_bloom(address);
+				account.insert_additional(&mut AccountDBMut::new(db.as_hashdb_mut(), address));
 			}
-			assert!(db.contains(&self.state_root()));
+			assert!(db.as_hashdb().contains(&self.state_root()));
 			Ok(true)
 		} else { Ok(false) }
 	}
--- a/ethcore/src/state.rs
+++ b/ethcore/src/state.rs
@@ -25,6 +25,7 @@ use trace::FlatTrace;
 use pod_account::*;
 use pod_state::{self, PodState};
 use types::state_diff::StateDiff;
+use state_db::StateDB;

 /// Used to return information about an `State::apply` operation.
 pub struct ApplyOutcome {
@@ -37,23 +38,92 @@ 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,
+}
+
+impl AccountEntry {
+	fn is_dirty(&self) -> bool {
+		match *self {
+			AccountEntry::Cached(ref a) => a.is_dirty(),
+			AccountEntry::Killed => true,
+			AccountEntry::Missing => false,
+		}
+	}
+
+	/// Clone dirty data into new `AccountEntry`.
+	/// 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,
+		}
+	}
+
+	/// 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,
+		}
+	}
+}
+
 /// Representation of the entire state of all accounts in the system.
+///
+/// `State` can work together with `StateDB` to share account cache.
+///
+/// Local cache contains changes made locally and changes accumulated
+/// locally from previous commits. Global cache reflects the database
+/// state and never contains any changes.
+///
+/// Account data can be in the following cache states:
+/// * In global but not local - something that was queried from the database,
+/// but never modified
+/// * In local but not global - something that was just added (e.g. new account)
+/// * In both with the same value - something that was changed to a new value,
+/// but changed back to a previous block in the same block (same State instance)
+/// * In both with different values - something that was overwritten with a
+/// new value.
+///
+/// All read-only state queries check local cache/modifications first,
+/// then global state cache. If data is not found in any of the caches
+/// it is loaded from the DB to the local cache.
+///
+/// Upon destruction all the local cache data merged into the global cache.
+/// The merge might be rejected if current state is non-canonical.
 pub struct State {
-	db: Box<JournalDB>,
+	db: StateDB,
 	root: H256,
-	cache: RefCell<HashMap<Address, Option<Account>>>,
-	snapshots: RefCell<Vec<HashMap<Address, Option<Option<Account>>>>>,
+	cache: RefCell<HashMap<Address, AccountEntry>>,
+	snapshots: RefCell<Vec<HashMap<Address, Option<AccountEntry>>>>,
 	account_start_nonce: U256,
 	trie_factory: TrieFactory,
 }

+#[derive(Copy, Clone)]
+enum RequireCache {
+	None,
+	CodeSize,
+	Code,
+}
+
 const SEC_TRIE_DB_UNWRAP_STR: &'static str = "A state can only be created with valid root. Creating a SecTrieDB with a valid root will not fail. \
 			 Therefore creating a SecTrieDB with this state's root will not fail.";

 impl State {
 	/// Creates new state with empty state root
 	#[cfg(test)]
-	pub fn new(mut db: Box<JournalDB>, account_start_nonce: U256, trie_factory: TrieFactory) -> State {
+	pub fn new(mut db: StateDB, account_start_nonce: U256, trie_factory: TrieFactory) -> State {
 		let mut root = H256::new();
 		{
 			// init trie and reset root too null
@@ -71,7 +141,7 @@ impl State {
 	}

 	/// Creates new state with existing state root
-	pub fn from_existing(db: Box<JournalDB>, root: H256, account_start_nonce: U256, trie_factory: TrieFactory) -> Result<State, TrieError> {
+	pub fn from_existing(db: StateDB, root: H256, account_start_nonce: U256, trie_factory: TrieFactory) -> Result<State, TrieError> {
 		if !db.as_hashdb().contains(&root) {
 			return Err(TrieError::InvalidStateRoot(root));
 		}
@@ -115,14 +185,21 @@ impl State {
 						self.cache.borrow_mut().insert(k, v);
 					},
 					None => {
-						self.cache.borrow_mut().remove(&k);
+						match self.cache.borrow_mut().entry(k) {
+							::std::collections::hash_map::Entry::Occupied(e) => {
+								if e.get().is_dirty() {
+									e.remove();
+								}
+							},
+							_ => {}
+						}
 					}
 				}
 			}
 		}
 	}

-	fn insert_cache(&self, address: &Address, account: Option<Account>) {
+	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));
@@ -135,13 +212,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).cloned());
+				snapshot.insert(address.clone(), self.cache.borrow().get(address).map(AccountEntry::clone_for_snapshot));
 			}
 		}
 	}

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

@@ -153,41 +231,100 @@ 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, Some(Account::new_contract(balance, self.account_start_nonce)));
+		self.insert_cache(contract, AccountEntry::Cached(Account::new_contract(balance, self.account_start_nonce)));
 	}

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

 	/// Determine whether an account exists.
 	pub fn exists(&self, a: &Address) -> bool {
-		self.ensure_cached(a, false, |a| a.is_some())
+		self.ensure_cached(a, RequireCache::None, |a| a.is_some())
 	}

 	/// Get the balance of account `a`.
 	pub fn balance(&self, a: &Address) -> U256 {
-		self.ensure_cached(a, false,
+		self.ensure_cached(a, RequireCache::None,
 			|a| a.as_ref().map_or(U256::zero(), |account| *account.balance()))
 	}

 	/// Get the nonce of account `a`.
 	pub fn nonce(&self, a: &Address) -> U256 {
-		self.ensure_cached(a, false,
+		self.ensure_cached(a, RequireCache::None,
 			|a| a.as_ref().map_or(self.account_start_nonce, |account| *account.nonce()))
 	}

 	/// Mutate storage of account `address` so that it is `value` for `key`.
 	pub fn storage_at(&self, address: &Address, key: &H256) -> H256 {
-		self.ensure_cached(address, false,
-			|a| a.as_ref().map_or(H256::new(), |a|a.storage_at(&AccountDB::new(self.db.as_hashdb(), address), key)))
+		// Storage key search and update works like this:
+		// 1. Check bloom to see if account never used surely
+		// 2. If there's an entry for the account in the local cache check for the key and return it if found.
+		// 3. If there's an entry for the account in the global cache check for the key or load it into that account.
+		// 4. If account is missing in the global cache load it into the local cache and cache the key there.
+
+		// check bloom
+
+		// check local cache first without updating
+		{
+			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) => {
+						if let Some(value) = account.cached_storage_at(key) {
+							return value;
+						} else {
+							local_account = Some(maybe_acc);
+						}
+					},
+					_ => return H256::new(),
+				}
+			}
+			// check the global cache and and cache storage key there if found,
+			// otherwise cache the account localy and cache storage key there.
+			if let Some(result) = self.db.get_cached(address, |acc| acc.map_or(H256::new(), |a| a.storage_at(&AccountDB::from_hash(self.db.as_hashdb(), a.address_hash(address)), key))) {
+				return result;
+			}
+			if let Some(ref mut acc) = local_account {
+				if let AccountEntry::Cached(ref account) = **acc {
+					return account.storage_at(&AccountDB::from_hash(self.db.as_hashdb(), account.address_hash(address)), key)
+				} else {
+					return H256::new()
+				}
+			}
+		}
+		// account is not found in the global cache, get from the DB and insert into local
+		if !self.db.check_account_bloom(address) { return H256::zero() }
+		let db = self.trie_factory.readonly(self.db.as_hashdb(), &self.root).expect(SEC_TRIE_DB_UNWRAP_STR);
+		let maybe_acc = match db.get(address) {
+			Ok(acc) => acc.map(Account::from_rlp),
+			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),
+		}
+		r
 	}

-	/// Mutate storage of account `a` so that it is `value` for `key`.
-	pub fn code(&self, a: &Address) -> Option<Bytes> {
-		self.ensure_cached(a, true,
-			|a| a.as_ref().map_or(None, |a|a.code().map(|x|x.to_vec())))
+	/// Get accounts' code.
+	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().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.
+	pub fn code_size(&self, a: &Address) -> Option<u64> {
+		self.ensure_cached(a, RequireCache::CodeSize,
+			|a| a.as_ref().and_then(|a| a.code_size()))
 	}

 	/// Add `incr` to the balance of account `a`.
@@ -241,26 +378,26 @@ impl State {
 //		trace!("Applied transaction. Diff:\n{}\n", state_diff::diff_pod(&old, &self.to_pod()));
 		try!(self.commit());
 		let receipt = Receipt::new(self.root().clone(), e.cumulative_gas_used, e.logs);
-//		trace!("Transaction receipt: {:?}", receipt);
+		trace!(target: "state", "Transaction receipt: {:?}", receipt);
 		Ok(ApplyOutcome{receipt: receipt, trace: e.trace})
 	}

 	/// Commit accounts to SecTrieDBMut. This is similar to cpp-ethereum's dev::eth::commit.
 	/// `accounts` is mutable because we may need to commit the code or storage and record that.
 	#[cfg_attr(feature="dev", allow(match_ref_pats))]
-	pub fn commit_into(
+	fn commit_into(
 		trie_factory: &TrieFactory,
-		db: &mut HashDB,
+		db: &mut StateDB,
 		root: &mut H256,
-		accounts: &mut HashMap<Address,
-		Option<Account>>
+		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 Some(ref mut account) if account.is_dirty() => {
-					let mut account_db = AccountDBMut::new(db, address);
+				&mut&mut AccountEntry::Cached(ref mut account) if account.is_dirty() => {
+					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);
 					account.commit_code(&mut account_db);
 				}
@@ -269,15 +406,18 @@ impl State {
 		}

 		{
-			let mut trie = trie_factory.from_existing(db, root).unwrap();
+			let mut trie = trie_factory.from_existing(db.as_hashdb_mut(), root).unwrap();
 			for (address, ref mut a) in accounts.iter_mut() {
 				match **a {
-					Some(ref mut account) if account.is_dirty() => {
+					AccountEntry::Cached(ref mut account) if account.is_dirty() => {
 						account.set_clean();
-						try!(trie.insert(address, &account.rlp()))
+						try!(trie.insert(address, &account.rlp()));
 					},
-					None => try!(trie.remove(address)),
-					_ => (),
+					AccountEntry::Killed => {
+						try!(trie.remove(address));
+						**a = AccountEntry::Missing;
+					},
+					_ => {},
 				}
 			}
 		}
@@ -285,10 +425,27 @@ impl State {
 		Ok(())
 	}

+	fn commit_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);
+				},
+				_ => {},
+			}
+		}
+	}
+
 	/// Commits our cached account changes into the trie.
 	pub fn commit(&mut self) -> Result<(), Error> {
 		assert!(self.snapshots.borrow().is_empty());
-		Self::commit_into(&self.trie_factory, self.db.as_hashdb_mut(), &mut self.root, &mut *self.cache.borrow_mut())
+		Self::commit_into(&self.trie_factory, &mut self.db, &mut self.root, &mut *self.cache.borrow_mut())
 	}

 	/// Clear state cache
@@ -302,7 +459,8 @@ impl State {
 	pub fn populate_from(&mut self, accounts: PodState) {
 		assert!(self.snapshots.borrow().is_empty());
 		for (add, acc) in accounts.drain().into_iter() {
-			self.cache.borrow_mut().insert(add, Some(Account::from_pod(acc)));
+			self.db.note_account_bloom(&add);
+			self.cache.borrow_mut().insert(add, AccountEntry::Cached(Account::from_pod(acc)));
 		}
 	}

@@ -312,7 +470,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 Some(ref acc) = *opt {
+			if let AccountEntry::Cached(ref acc) = *opt {
 				m.insert(add.clone(), PodAccount::from_account(acc));
 			}
 			m
@@ -321,7 +479,7 @@ impl State {

 	fn query_pod(&mut self, query: &PodState) {
 		for (ref address, ref pod_account) in query.get() {
-			self.ensure_cached(address, true, |a| {
+			self.ensure_cached(address, RequireCache::Code, |a| {
 				if a.is_some() {
 					for key in pod_account.storage.keys() {
 						self.storage_at(address, key);
@@ -340,26 +498,61 @@ impl State {
 		pod_state::diff_pod(&state_pre.to_pod(), &pod_state_post)
 	}

-	/// Ensure account `a` is in our cache of the trie DB and return a handle for getting it.
-	/// `require_code` requires that the code be cached, too.
-	fn ensure_cached<'a, F, U>(&'a self, a: &'a Address, require_code: bool, f: F) -> U
-		where F: FnOnce(&Option<Account>) -> U {
-		let have_key = self.cache.borrow().contains_key(a);
-		if !have_key {
-			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(acc) => acc.map(Account::from_rlp),
-				Err(e) => panic!("Potential DB corruption encountered: {}", e),
-			};
-			self.insert_cache(a, maybe_acc);
-		}
-		if require_code {
-			if let Some(ref mut account) = self.cache.borrow_mut().get_mut(a).unwrap().as_mut() {
-				account.cache_code(&AccountDB::new(self.db.as_hashdb(), a));
+	fn update_account_cache(require: RequireCache, account: &mut Account, address: &Address, db: &HashDB) {
+		match require {
+			RequireCache::None => {},
+			RequireCache::Code => {
+				let address_hash = account.address_hash(address);
+				account.cache_code(&AccountDB::from_hash(db, address_hash));
+			}
+			RequireCache::CodeSize => {
+				let address_hash = account.address_hash(address);
+				account.cache_code_size(&AccountDB::from_hash(db, address_hash));
 			}
 		}
+	}

-		f(self.cache.borrow().get(a).unwrap())
+	/// Check caches for required data
+	/// First searches for account in the local, then the shared cache.
+	/// Populates local cache if nothing found.
+	fn ensure_cached<F, U>(&self, a: &Address, require: RequireCache, f: F) -> U
+		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 {
+				Self::update_account_cache(require, account, a, self.db.as_hashdb());
+				return f(Some(account));
+			}
+			return f(None);
+		}
+		// check global cache
+		let result = self.db.get_cached(a, |mut acc| {
+			if let Some(ref mut account) = acc {
+				Self::update_account_cache(require, account, a, self.db.as_hashdb());
+			}
+			f(acc.map(|a| &*a))
+		});
+		match result {
+			Some(r) => r,
+			None => {
+				// not found in the global cache, get from the DB and insert into local
+				if !self.db.check_account_bloom(a) { return f(None); }
+				let db = self.trie_factory.readonly(self.db.as_hashdb(), &self.root).expect(SEC_TRIE_DB_UNWRAP_STR);
+				let mut maybe_acc = match db.get(a) {
+					Ok(acc) => acc.map(Account::from_rlp),
+					Err(e) => panic!("Potential DB corruption encountered: {}", e),
+				};
+				if let Some(ref mut account) = maybe_acc.as_mut() {
+					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),
+				}
+				r
+			}
+		}
 	}

 	/// Pull account `a` in our cache from the trie DB. `require_code` requires that the code be cached, too.
@@ -374,28 +567,45 @@ impl State {
 	{
 		let contains_key = self.cache.borrow().contains_key(a);
 		if !contains_key {
-			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(acc) => acc.map(Account::from_rlp),
-				Err(e) => panic!("Potential DB corruption encountered: {}", e),
-			};
-
-			self.insert_cache(a, maybe_acc);
+			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),
+				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,
+							Err(e) => panic!("Potential DB corruption encountered: {}", e),
+						};
+						maybe_acc
+					}
+					else {
+						AccountEntry::Missing
+					};
+					self.insert_cache(a, maybe_acc);
+				}
+			}
 		} else {
 			self.note_cache(a);
 		}

 		match self.cache.borrow_mut().get_mut(a).unwrap() {
-			&mut Some(ref mut acc) => not_default(acc),
-			slot @ &mut None => *slot = Some(default()),
+			&mut AccountEntry::Cached(ref mut acc) => not_default(acc),
+			slot => *slot = AccountEntry::Cached(default()),
 		}

 		RefMut::map(self.cache.borrow_mut(), |c| {
-			let account = c.get_mut(a).unwrap().as_mut().unwrap();
-			if require_code {
-				account.cache_code(&AccountDB::new(self.db.as_hashdb(), a));
+			match c.get_mut(a).unwrap() {
+				&mut AccountEntry::Cached(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));
+					}
+					account
+				},
+				_ => panic!("Required account must always exist; qed"),
 			}
-			account
 		})
 	}
 }
@@ -408,11 +618,21 @@ impl fmt::Debug for State {

 impl Clone for State {
 	fn clone(&self) -> 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() {
+					cache.insert(key.clone(), entry);
+				}
+			}
+			cache
+		};
+
 		State {
 			db: self.db.boxed_clone(),
 			root: self.root.clone(),
-			cache: RefCell::new(self.cache.borrow().clone()),
-			snapshots: RefCell::new(self.snapshots.borrow().clone()),
+			cache: RefCell::new(cache),
+			snapshots: RefCell::new(Vec::new()),
 			account_start_nonce: self.account_start_nonce.clone(),
 			trie_factory: self.trie_factory.clone(),
 		}
@@ -1302,14 +1522,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]
--- a/ethcore/src/state_db.rs
+++ b/ethcore/src/state_db.rs
@@ -0,0 +1,231 @@
+// 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 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 bloomfilter::{Bloom, BloomJournal};
+use util::Database;
+use client::DB_COL_ACCOUNT_BLOOM;
+use byteorder::{LittleEndian, ByteOrder};
+
+const STATE_CACHE_ITEMS: usize = 65536;
+
+struct AccountCache {
+	/// DB Account cache. `None` indicates that account is known to be missing.
+	accounts: LruCache<Address, Option<Account>>,
+}
+
+/// State database abstraction.
+/// Manages shared global state cache.
+/// A clone of `StateDB` may be created as canonical or not.
+/// For canonical clones cache changes are accumulated and applied
+/// on commit.
+/// For non-canonical clones cache is cleared on commit.
+pub struct StateDB {
+	db: Box<JournalDB>,
+	account_cache: Arc<Mutex<AccountCache>>,
+	cache_overlay: Vec<(Address, Option<Account>)>,
+	is_canon: bool,
+	account_bloom: Arc<Mutex<Bloom>>,
+}
+
+pub const ACCOUNT_BLOOM_SPACE: usize = 1048576;
+pub const DEFAULT_ACCOUNT_PRESET: usize = 1000000;
+
+pub const ACCOUNT_BLOOM_HASHCOUNT_KEY: &'static [u8] = b"account_hash_count";
+
+impl StateDB {
+	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");
+
+		if hash_count_entry.is_none() {
+			return Bloom::new(ACCOUNT_BLOOM_SPACE, DEFAULT_ACCOUNT_PRESET);
+		}
+		let hash_count_bytes = hash_count_entry.unwrap();
+		assert_eq!(hash_count_bytes.len(), 1);
+		let hash_count = hash_count_bytes[0];
+
+		let mut bloom_parts = vec![0u64; ACCOUNT_BLOOM_SPACE / 8];
+		let mut key = [0u8; 8];
+		for i in 0..ACCOUNT_BLOOM_SPACE / 8 {
+			LittleEndian::write_u64(&mut key, i as u64);
+			bloom_parts[i] = db.get(DB_COL_ACCOUNT_BLOOM, &key).expect("low-level database error")
+				.and_then(|val| Some(LittleEndian::read_u64(&val[..])))
+				.unwrap_or(0u64);
+		}
+
+		let bloom = Bloom::from_parts(&bloom_parts, hash_count as u32);
+		trace!(target: "account_bloom", "Bloom is {:?} full, hash functions count = {:?}", bloom.how_full(), hash_count);
+		bloom
+	}
+
+	/// Create a new instance wrapping `JournalDB`
+	pub fn new(db: Box<JournalDB>) -> 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_bloom: Arc::new(Mutex::new(bloom)),
+		}
+	}
+
+	pub fn check_account_bloom(&self, address: &Address) -> bool {
+		trace!(target: "account_bloom", "Check account bloom: {:?}", address);
+		let bloom = self.account_bloom.lock();
+		bloom.check(address.sha3().as_slice())
+	}
+
+	pub fn note_account_bloom(&self, address: &Address) {
+		trace!(target: "account_bloom", "Note account bloom: {:?}", address);
+		let mut bloom = self.account_bloom.lock();
+		bloom.set(address.sha3().as_slice());
+	}
+
+	pub fn commit_bloom(batch: &DBTransaction, journal: BloomJournal) -> Result<(), UtilError> {
+		assert!(journal.hash_functions <= 255);
+		try!(batch.put(DB_COL_ACCOUNT_BLOOM, ACCOUNT_BLOOM_HASHCOUNT_KEY, &vec![journal.hash_functions as u8]));
+		let mut key = [0u8; 8];
+		let mut val = [0u8; 8];
+
+		for (bloom_part_index, bloom_part_value) in journal.entries {
+			LittleEndian::write_u64(&mut key, bloom_part_index as u64);
+			LittleEndian::write_u64(&mut val, bloom_part_value);
+			try!(batch.put(DB_COL_ACCOUNT_BLOOM, &key, &val));
+		}
+		Ok(())
+	}
+
+	/// 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.
+	pub fn commit(&mut self, batch: &DBTransaction, now: u64, id: &H256, end: Option<(u64, H256)>) -> Result<u32, UtilError> {
+		{
+			let mut bloom_lock = self.account_bloom.lock();
+			try!(Self::commit_bloom(batch, bloom_lock.drain_journal()));
+		}
+
+		let records = try!(self.db.commit(batch, now, id, end));
+		if self.is_canon {
+			self.commit_cache();
+		} else {
+			self.clear_cache();
+		}
+		Ok(records)
+	}
+
+	/// Returns an interface to HashDB.
+	pub fn as_hashdb(&self) -> &HashDB {
+		self.db.as_hashdb()
+	}
+
+	/// Returns an interface to mutable HashDB.
+	pub fn as_hashdb_mut(&mut self) -> &mut HashDB {
+		self.db.as_hashdb_mut()
+	}
+
+	/// Clone the database.
+	pub fn boxed_clone(&self) -> StateDB {
+		StateDB {
+			db: self.db.boxed_clone(),
+			account_cache: self.account_cache.clone(),
+			cache_overlay: Vec::new(),
+			is_canon: false,
+			account_bloom: self.account_bloom.clone(),
+		}
+	}
+
+	/// Clone the database for a canonical state.
+	pub fn boxed_clone_canon(&self) -> StateDB {
+		StateDB {
+			db: self.db.boxed_clone(),
+			account_cache: self.account_cache.clone(),
+			cache_overlay: Vec::new(),
+			is_canon: true,
+			account_bloom: self.account_bloom.clone(),
+		}
+	}
+
+	/// Check if pruning is enabled on the database.
+	pub fn is_pruned(&self) -> bool {
+		self.db.is_pruned()
+	}
+
+	/// Heap size used.
+	pub fn mem_used(&self) -> usize {
+		self.db.mem_used() //TODO: + self.account_cache.lock().heap_size_of_children()
+	}
+
+	/// Returns underlying `JournalDB`.
+	pub fn journal_db(&self) -> &JournalDB {
+		&*self.db
+	}
+
+	/// Enqueue cache change.
+	pub fn cache_account(&mut self, addr: Address, data: Option<Account>) {
+		self.cache_overlay.push((addr, data));
+	}
+
+	/// 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();
+	}
+
+	/// 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.
+	pub fn get_cached_account(&self, addr: &Address) -> Option<Option<Account>> {
+		if !self.is_canon {
+			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.
+	pub fn get_cached<F, U>(&self, a: &Address, f: F) -> Option<U>
+		where F: FnOnce(Option<&mut Account>) -> U {
+		if !self.is_canon {
+			return None;
+		}
+		let mut cache = self.account_cache.lock();
+		cache.accounts.get_mut(a).map(|c| f(c.as_mut()))
+	}
+}
+
--- a/ethcore/src/tests/client.rs
+++ b/ethcore/src/tests/client.rs
@@ -16,6 +16,7 @@

 use io::IoChannel;
 use client::{BlockChainClient, MiningBlockChainClient, Client, ClientConfig, BlockID};
+use ethereum;
 use block::IsBlock;
 use tests::helpers::*;
 use common::*;
@@ -31,6 +32,14 @@ fn imports_from_empty() {
 	client.flush_queue();
 }

+#[test]
+fn should_return_registrar() {
+	let dir = RandomTempPath::new();
+	let spec = ethereum::new_morden();
+	let client = Client::new(ClientConfig::default(), &spec, dir.as_path(), Arc::new(Miner::with_spec(&spec)), IoChannel::disconnected()).unwrap();
+	assert_eq!(client.additional_params().get("registrar"), Some(&"8e4e9b13d4b45cb0befc93c3061b1408f67316b2".to_owned()));
+}
+
 #[test]
 fn returns_state_root_basic() {
 	let client_result = generate_dummy_client(6);
--- a/ethcore/src/tests/helpers.rs
+++ b/ethcore/src/tests/helpers.rs
@@ -18,6 +18,7 @@ use io::*;
 use client::{self, BlockChainClient, Client, ClientConfig};
 use common::*;
 use spec::*;
+use state_db::StateDB;
 use block::{OpenBlock, Drain};
 use blockchain::{BlockChain, Config as BlockChainConfig};
 use state::*;
@@ -136,9 +137,9 @@ pub fn generate_dummy_client_with_spec_and_data<F>(get_test_spec: F, block_numbe
 	let client = Client::new(ClientConfig::default(), &test_spec, dir.as_path(), Arc::new(Miner::with_spec(&test_spec)), IoChannel::disconnected()).unwrap();
 	let test_engine = &*test_spec.engine;

-	let mut db_result = get_temp_journal_db();
+	let mut db_result = get_temp_state_db();
 	let mut db = db_result.take();
-	test_spec.ensure_db_good(db.as_hashdb_mut()).unwrap();
+	test_spec.ensure_db_good(&mut db).unwrap();
 	let vm_factory = Default::default();
 	let genesis_header = test_spec.genesis_header();

@@ -303,9 +304,9 @@ pub fn generate_dummy_empty_blockchain() -> GuardedTempResult<BlockChain> {
 	}
 }

-pub fn get_temp_journal_db() -> GuardedTempResult<Box<JournalDB>> {
+pub fn get_temp_state_db() -> GuardedTempResult<StateDB> {
 	let temp = RandomTempPath::new();
-	let journal_db = get_temp_journal_db_in(temp.as_path());
+	let journal_db = get_temp_state_db_in(temp.as_path());

 	GuardedTempResult {
 		_temp: temp,
@@ -315,7 +316,7 @@ pub fn get_temp_journal_db() -> GuardedTempResult<Box<JournalDB>> {

 pub fn get_temp_state() -> GuardedTempResult<State> {
 	let temp = RandomTempPath::new();
-	let journal_db = get_temp_journal_db_in(temp.as_path());
+	let journal_db = get_temp_state_db_in(temp.as_path());

 	GuardedTempResult {
 	    _temp: temp,
@@ -323,13 +324,14 @@ pub fn get_temp_state() -> GuardedTempResult<State> {
 	}
 }

-pub fn get_temp_journal_db_in(path: &Path) -> Box<JournalDB> {
+pub fn get_temp_state_db_in(path: &Path) -> StateDB {
 	let db = new_db(path.to_str().expect("Only valid utf8 paths for tests."));
-	journaldb::new(db.clone(), journaldb::Algorithm::EarlyMerge, None)
+	let journal_db = journaldb::new(db.clone(), journaldb::Algorithm::EarlyMerge, client::DB_COL_STATE);
+	StateDB::new(journal_db)
 }

 pub fn get_temp_state_in(path: &Path) -> State {
-	let journal_db = get_temp_journal_db_in(path);
+	let journal_db = get_temp_state_db_in(path);
 	State::new(journal_db, U256::from(0), Default::default())
 }

--- a/ethcore/src/trace/executive_tracer.rs
+++ b/ethcore/src/trace/executive_tracer.rs
@@ -52,11 +52,12 @@ fn update_trace_address(traces: Vec<FlatTrace>) -> Vec<FlatTrace> {
 	let mut subtrace_subtraces_left = 0;
 	traces.into_iter().map(|mut trace| {
 		let is_top_subtrace = trace.trace_address.is_empty();
+		let is_subtrace = trace.trace_address.len() == 1;
 		trace.trace_address.push_front(top_subtrace_index);

 		if is_top_subtrace {
 			subtrace_subtraces_left = trace.subtraces;
-		} else {
+		} else if is_subtrace {
 			subtrace_subtraces_left -= 1;
 		}

--- a/ethcore/src/types/receipt.rs
+++ b/ethcore/src/types/receipt.rs
@@ -80,6 +80,23 @@ impl HeapSizeOf for Receipt {
 	}
 }

+/// Receipt with additional info.
+#[derive(Debug, Clone, PartialEq, Binary)]
+pub struct RichReceipt {
+	/// Transaction hash.
+	pub transaction_hash: H256,
+	/// Transaction index.
+	pub transaction_index: usize,
+	/// The total gas used in the block following execution of the transaction.
+	pub cumulative_gas_used: U256,
+	/// The gas used in the execution of the transaction. Note the difference of meaning to `Receipt::gas_used`.
+	pub gas_used: U256,
+	/// Contract address.
+	pub contract_address: Option<Address>,
+	/// Logs
+	pub logs: Vec<LogEntry>,
+}
+
 /// Receipt with additional info.
 #[derive(Debug, Clone, PartialEq, Binary)]
 pub struct LocalizedReceipt {
--- 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/logger/src/lib.rs
+++ b/logger/src/lib.rs
@@ -89,10 +89,10 @@ pub fn setup_log(config: &Config) -> Result<Arc<RotatingLogger>, String> {
 		let timestamp = time::strftime("%Y-%m-%d %H:%M:%S %Z", &time::now()).unwrap();

 		let with_color = if max_log_level() <= LogLevelFilter::Info {
-			format!("{}{}", Colour::Black.bold().paint(timestamp), record.args())
+			format!("{} {}", Colour::Black.bold().paint(timestamp), record.args())
 		} else {
 			let name = thread::current().name().map_or_else(Default::default, |x| format!("{}", Colour::Blue.bold().paint(x)));
-			format!("{}{} {} {}  {}", Colour::Black.bold().paint(timestamp), name, record.level(), record.target(), record.args())
+			format!("{} {} {} {}  {}", Colour::Black.bold().paint(timestamp), name, record.level(), record.target(), record.args())
 		};

 		let removed_color = kill_color(with_color.as_ref());
--- 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 0
+!define VERSIONBUILD 3

 !addplugindir .\

--- a/parity/cli.rs
+++ b/parity/cli.rs
@@ -132,6 +132,11 @@ API and Console Options:
  --dapps-interface IP     Specify the hostname portion of the Dapps
                           server, IP should be an interface's IP address,
                           or local [default: local].
+  --dapps-hosts HOSTS      List of allowed Host header values. This option will
+                           validate the Host header sent by the browser, it
+                           is additional security against some attack
+                           vectors. Special options: "all", "none",
+                           [default: none].
  --dapps-user USERNAME    Specify username for Dapps server. It will be
                           used in HTTP Basic Authentication Scheme.
                           If --dapps-pass is not specified you will be
@@ -343,6 +348,7 @@ pub struct Args {
 	pub flag_no_dapps: bool,
 	pub flag_dapps_port: u16,
 	pub flag_dapps_interface: String,
+	pub flag_dapps_hosts: String,
 	pub flag_dapps_user: Option<String>,
 	pub flag_dapps_pass: Option<String>,
 	pub flag_dapps_path: String,
--- a/parity/configuration.rs
+++ b/parity/configuration.rs
@@ -355,6 +355,7 @@ impl Configuration {
 			enabled: self.dapps_enabled(),
 			interface: self.dapps_interface(),
 			port: self.args.flag_dapps_port,
+			hosts: self.dapps_hosts(),
 			user: self.args.flag_dapps_user.clone(),
 			pass: self.args.flag_dapps_pass.clone(),
 			dapps_path: self.directories().dapps,
@@ -474,6 +475,16 @@ impl Configuration {
 		Some(hosts)
 	}

+	fn dapps_hosts(&self) -> Option<Vec<String>> {
+		match self.args.flag_dapps_hosts.as_ref() {
+			"none" => return Some(Vec::new()),
+			"all" => return None,
+			_ => {}
+		}
+		let hosts = self.args.flag_dapps_hosts.split(',').map(|h| h.into()).collect();
+		Some(hosts)
+	}
+
 	fn ipc_config(&self) -> Result<IpcConfiguration, String> {
 		let conf = IpcConfiguration {
 			enabled: !(self.args.flag_ipcdisable || self.args.flag_ipc_off || self.args.flag_no_ipc),
@@ -832,6 +843,23 @@ mod tests {
 		assert_eq!(conf3.rpc_hosts(), Some(vec!["ethcore.io".into(), "something.io".into()]));
 	}

+	#[test]
+	fn should_parse_dapps_hosts() {
+		// given
+
+		// when
+		let conf0 = parse(&["parity"]);
+		let conf1 = parse(&["parity", "--dapps-hosts", "none"]);
+		let conf2 = parse(&["parity", "--dapps-hosts", "all"]);
+		let conf3 = parse(&["parity", "--dapps-hosts", "ethcore.io,something.io"]);
+
+		// then
+		assert_eq!(conf0.dapps_hosts(), Some(Vec::new()));
+		assert_eq!(conf1.dapps_hosts(), Some(Vec::new()));
+		assert_eq!(conf2.dapps_hosts(), None);
+		assert_eq!(conf3.dapps_hosts(), Some(vec!["ethcore.io".into(), "something.io".into()]));
+	}
+
 	#[test]
 	fn should_disable_signer_in_geth_compat() {
 		// given
--- a/parity/dapps.rs
+++ b/parity/dapps.rs
@@ -15,21 +15,16 @@
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.

 use std::sync::Arc;
-use std::net::SocketAddr;
 use io::PanicHandler;
 use rpc_apis;
 use helpers::replace_home;

-#[cfg(feature = "dapps")]
-pub use ethcore_dapps::Server as WebappServer;
-#[cfg(not(feature = "dapps"))]
-pub struct WebappServer;
-
 #[derive(Debug, PartialEq, Clone)]
 pub struct Configuration {
 	pub enabled: bool,
 	pub interface: String,
 	pub port: u16,
+	pub hosts: Option<Vec<String>>,
 	pub user: Option<String>,
 	pub pass: Option<String>,
 	pub dapps_path: String,
@@ -41,6 +36,7 @@ impl Default for Configuration {
 			enabled: true,
 			interface: "127.0.0.1".into(),
 			port: 8080,
+			hosts: Some(Vec::new()),
 			user: None,
 			pass: None,
 			dapps_path: replace_home("$HOME/.parity/dapps"),
@@ -72,48 +68,68 @@ pub fn new(configuration: Configuration, deps: Dependencies) -> Result<Option<We
 		(username.to_owned(), password)
 	});

-	Ok(Some(try!(setup_dapps_server(deps, configuration.dapps_path, &addr, auth))))
+	Ok(Some(try!(setup_dapps_server(deps, configuration.dapps_path, &addr, configuration.hosts, auth))))
 }

+pub use self::server::setup_dapps_server;
+pub use self::server::WebappServer;
+
 #[cfg(not(feature = "dapps"))]
-pub fn setup_dapps_server(
-	_deps: Dependencies,
-	_dapps_path: String,
-	_url: &SocketAddr,
-	_auth: Option<(String, String)>,
-) -> Result<WebappServer, String> {
-	Err("Your Parity version has been compiled without WebApps support.".into())
-}
+mod server {
+	use super::Dependencies;
+	use std::net::SocketAddr;

-#[cfg(feature = "dapps")]
-pub fn setup_dapps_server(
-	deps: Dependencies,
-	dapps_path: String,
-	url: &SocketAddr,
-	auth: Option<(String, String)>
-) -> Result<WebappServer, String> {
-	use ethcore_dapps as dapps;
-
-	let server = dapps::ServerBuilder::new(dapps_path);
-	let server = rpc_apis::setup_rpc(server, deps.apis.clone(), rpc_apis::ApiSet::UnsafeContext);
-	let start_result = match auth {
-		None => {
-			server.start_unsecure_http(url)
-		},
-		Some((username, password)) => {
-			server.start_basic_auth_http(url, &username, &password)
-		},
-	};
-
-	match start_result {
-		Err(dapps::ServerError::IoError(err)) => Err(format!("WebApps io error: {}", err)),
-		Err(e) => Err(format!("WebApps error: {:?}", e)),
-		Ok(server) => {
-			server.set_panic_handler(move || {
-				deps.panic_handler.notify_all("Panic in WebApp thread.".to_owned());
-			});
-			Ok(server)
-		},
+	pub struct WebappServer;
+	pub fn setup_dapps_server(
+		_deps: Dependencies,
+		_dapps_path: String,
+		_url: &SocketAddr,
+		_allowed_hosts: Option<Vec<String>>,
+		_auth: Option<(String, String)>,
+	) -> Result<WebappServer, String> {
+		Err("Your Parity version has been compiled without WebApps support.".into())
+	}
+}
+
+#[cfg(feature = "dapps")]
+mod server {
+	use super::Dependencies;
+	use std::net::SocketAddr;
+
+	use rpc_apis;
+
+	pub use ethcore_dapps::Server as WebappServer;
+
+	pub fn setup_dapps_server(
+		deps: Dependencies,
+		dapps_path: String,
+		url: &SocketAddr,
+		allowed_hosts: Option<Vec<String>>,
+		auth: Option<(String, String)>
+	) -> Result<WebappServer, String> {
+		use ethcore_dapps as dapps;
+
+		let server = dapps::ServerBuilder::new(dapps_path);
+		let server = rpc_apis::setup_rpc(server, deps.apis.clone(), rpc_apis::ApiSet::UnsafeContext);
+		let start_result = match auth {
+			None => {
+				server.start_unsecured_http(url, allowed_hosts)
+			},
+			Some((username, password)) => {
+				server.start_basic_auth_http(url, allowed_hosts, &username, &password)
+			},
+		};
+
+		match start_result {
+			Err(dapps::ServerError::IoError(err)) => Err(format!("WebApps io error: {}", err)),
+			Err(e) => Err(format!("WebApps error: {:?}", e)),
+			Ok(server) => {
+				server.set_panic_handler(move || {
+					deps.panic_handler.notify_all("Panic in WebApp thread.".to_owned());
+				});
+				Ok(server)
+			},
+		}
 	}
 }

--- a/parity/migration.rs
+++ b/parity/migration.rs
@@ -29,7 +29,7 @@ use ethcore::migrations::Extract;
 /// Database is assumed to be at default version, when no version file is found.
 const DEFAULT_VERSION: u32 = 5;
 /// Current version of database models.
-const CURRENT_VERSION: u32 = 9;
+const CURRENT_VERSION: u32 = 10;
 /// First version of the consolidated database.
 const CONSOLIDATION_VERSION: u32 = 9;
 /// Defines how many items are migrated to the new version of database at once.
@@ -140,7 +140,12 @@ pub fn default_migration_settings(compaction_profile: &CompactionProfile) -> Mig

 /// Migrations on the consolidated database.
 fn consolidated_database_migrations(compaction_profile: &CompactionProfile) -> Result<MigrationManager, Error> {
-	let manager = MigrationManager::new(default_migration_settings(compaction_profile));
+	let mut manager = MigrationManager::new(default_migration_settings(compaction_profile));
+	// this won't ever fire, because version will be already 9
+	// added because migration api should know that it should open database with 5 columns
+	try!(manager.add_migration(migrations::ToV9::new(Some(5), migrations::Extract::All)).map_err(|_| Error::MigrationImpossible));
+	// this will
+	try!(manager.add_migration(migrations::ToV10).map_err(|_| Error::MigrationImpossible));
 	Ok(manager)
 }

@@ -180,7 +185,6 @@ fn consolidate_database(
 	Ok(())
 }

-
 /// Migrates database at given position with given migration rules.
 fn migrate_database(version: u32, db_path: PathBuf, mut migrations: MigrationManager) -> Result<(), Error> {
 	// check if migration is needed
@@ -215,6 +219,12 @@ fn exists(path: &Path) -> bool {
 	fs::metadata(path).is_ok()
 }

+// in-place upgrades that do nothing when called repeatedly
+fn run_inplace_upgrades(path: &Path) -> Result<(), Error> {
+	try!(migrations::upgrade_account_bloom(path));
+	Ok(())
+}
+
 /// Migrates the database.
 pub fn migrate(path: &Path, pruning: Algorithm, compaction_profile: CompactionProfile) -> Result<(), Error> {
 	// read version file.
@@ -228,6 +238,7 @@ pub fn migrate(path: &Path, pruning: Algorithm, compaction_profile: CompactionPr

 	// We are in the latest version, yay!
 	if version == CURRENT_VERSION {
+		try!(run_inplace_upgrades(consolidated_database_path(path).as_path()));
 		return Ok(())
 	}

@@ -259,6 +270,8 @@ pub fn migrate(path: &Path, pruning: Algorithm, compaction_profile: CompactionPr
 		println!("Migration finished");
 	}

+	try!(run_inplace_upgrades(consolidated_database_path(path).as_path()));
+
 	// update version file.
 	update_version(path)
 }
--- a/parity/signer.rs
+++ b/parity/signer.rs
@@ -68,7 +68,7 @@ fn codes_path(path: String) -> PathBuf {

 pub fn new_token(path: String) -> Result<String, String> {
 	generate_new_token(path)
-		.map(|code| format!("This key code will authorise your System Signer UI: {}", Colour::White.bold().paint(code)))
+		.map(|code| format!("This key code will authorise your System Signer UI: {}", code))
 		.map_err(|err| format!("Error generating token: {:?}", err))
 }

--- a/rpc/src/v1/impls/eth.rs
+++ b/rpc/src/v1/impls/eth.rs
@@ -107,7 +107,7 @@ impl<C, S: ?Sized, M, EM> EthClient<C, S, M, EM> where
 				let view = block_view.header_view();
 				let block = Block {
 					hash: Some(view.sha3().into()),
-					size: Some(bytes.len()),
+					size: Some(bytes.len().into()),
 					parent_hash: view.parent_hash().into(),
 					uncles_hash: view.uncles_hash().into(),
 					author: view.author().into(),
@@ -433,11 +433,14 @@ impl<C, S: ?Sized, M, EM> Eth for EthClient<C, S, M, EM> where
 		try!(self.active());
 		from_params::<(RpcH256,)>(params)
 			.and_then(|(hash,)| {
-				let miner = take_weak!(self.miner);
 				let hash: H256 = hash.into();
-				match miner.transaction(&hash) {
-					Some(pending_tx) => to_value(&Transaction::from(pending_tx)),
-					None => self.transaction(TransactionID::Hash(hash))
+				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));
+				match maybe_tx {
+					Some(t) => to_value(&t),
+					None => Ok(Value::Null),
 				}
 			})
 	}
@@ -460,8 +463,8 @@ impl<C, S: ?Sized, M, EM> Eth for EthClient<C, S, M, EM> where
 			.and_then(|(hash,)| {
 				let miner = take_weak!(self.miner);
 				let hash: H256 = hash.into();
-				match miner.pending_receipts().get(&hash) {
-					Some(receipt) if self.options.allow_pending_receipt_query => to_value(&Receipt::from(receipt.clone())),
+				match (miner.pending_receipt(&hash), self.options.allow_pending_receipt_query) {
+					(Some(receipt), true) => to_value(&Receipt::from(receipt)),
 					_ => {
 						let client = take_weak!(self.client);
 						let receipt = client.transaction_receipt(TransactionID::Hash(hash));
--- a/rpc/src/v1/impls/ethcore.rs
+++ b/rpc/src/v1/impls/ethcore.rs
@@ -15,17 +15,18 @@
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.

 //! Ethcore-specific rpc implementation.
-use util::{RotatingLogger};
-use util::misc::version_data;
 use std::sync::{Arc, Weak};
+use std::str::FromStr;
 use std::collections::{BTreeMap};
+use util::{RotatingLogger, Address};
+use util::misc::version_data;
 use ethsync::{SyncProvider, ManageNetwork};
 use ethcore::miner::MinerService;
 use ethcore::client::{MiningBlockChainClient};

 use jsonrpc_core::*;
 use v1::traits::Ethcore;
-use v1::types::{Bytes, U256, Peers};
+use v1::types::{Bytes, U256, Peers, H160, Transaction};
 use v1::helpers::{errors, SigningQueue, ConfirmationsQueue, NetworkSettings};
 use v1::helpers::params::expect_no_params;

@@ -54,7 +55,7 @@ impl<C, M, S: ?Sized> EthcoreClient<C, M, S> where C: MiningBlockChainClient, M:
 		logger: Arc<RotatingLogger>,
 		settings: Arc<NetworkSettings>,
 		queue: Option<Arc<ConfirmationsQueue>>
-		) -> Self {
+	) -> Self {
 		EthcoreClient {
 			client: Arc::downgrade(client),
 			miner: Arc::downgrade(miner),
@@ -150,6 +151,17 @@ impl<C, M, S: ?Sized> Ethcore for EthcoreClient<C, M, S> where M: MinerService +
 		to_value(&self.settings.name)
 	}

+	fn registry_address(&self, params: Params) -> Result<Value, Error> {
+		try!(self.active());
+		try!(expect_no_params(params));
+		let r = take_weak!(self.client)
+			.additional_params()
+			.get("registrar")
+			.and_then(|s| Address::from_str(s).ok())
+			.map(|s| H160::from(s));
+		to_value(&r)
+	}
+
 	fn rpc_settings(&self, params: Params) -> Result<Value, Error> {
 		try!(self.active());
 		try!(expect_no_params(params));
@@ -188,4 +200,11 @@ impl<C, M, S: ?Sized> Ethcore for EthcoreClient<C, M, S> where M: MinerService +
 			Some(ref queue) => to_value(&queue.len()),
 		}
 	}
+
+	fn pending_transactions(&self, params: Params) -> Result<Value, Error> {
+		try!(self.active());
+		try!(expect_no_params(params));
+
+		to_value(&take_weak!(self.miner).all_transactions().into_iter().map(Into::into).collect::<Vec<Transaction>>())
+	}
 }
--- a/rpc/src/v1/tests/helpers/miner_service.rs
+++ b/rpc/src/v1/tests/helpers/miner_service.rs
@@ -22,7 +22,7 @@ use ethcore::error::{Error, CallError};
 use ethcore::client::{MiningBlockChainClient, Executed, CallAnalytics};
 use ethcore::block::{ClosedBlock, IsBlock};
 use ethcore::transaction::SignedTransaction;
-use ethcore::receipt::Receipt;
+use ethcore::receipt::{Receipt, RichReceipt};
 use ethcore::miner::{MinerService, MinerStatus, TransactionImportResult};

 /// Test miner service.
@@ -198,6 +198,20 @@ impl MinerService for TestMinerService {
 		self.pending_transactions.lock().values().cloned().collect()
 	}

+	fn pending_receipt(&self, 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|
+			RichReceipt {
+				transaction_hash: Default::default(),
+				transaction_index: Default::default(),
+				cumulative_gas_used: r.gas_used.clone(),
+				gas_used: r.gas_used.clone(),
+				contract_address: None,
+				logs: r.logs.clone(),
+			}
+		)
+	}
+
 	fn pending_receipts(&self) -> BTreeMap<H256, Receipt> {
 		self.pending_receipts.lock().clone()
 	}
@@ -235,7 +249,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/tests/mocked/ethcore.rs
+++ b/rpc/src/v1/tests/mocked/ethcore.rs
@@ -286,3 +286,18 @@ fn rpc_ethcore_unsigned_transactions_count_when_signer_disabled() {

 	assert_eq!(io.handle_request(request), Some(response.to_owned()));
 }
+
+#[test]
+fn rpc_ethcore_pending_transactions() {
+	let miner = miner_service();
+	let client = client_service();
+	let sync = sync_provider();
+	let net = network_service();
+	let io = IoHandler::new();
+	io.add_delegate(ethcore_client(&client, &miner, &sync, &net).to_delegate());
+
+	let request = r#"{"jsonrpc": "2.0", "method": "ethcore_pendingTransactions", "params":[], "id": 1}"#;
+	let response = r#"{"jsonrpc":"2.0","result":[],"id":1}"#;
+
+	assert_eq!(io.handle_request(request), Some(response.to_owned()));
+}
--- a/rpc/src/v1/traits/ethcore.rs
+++ b/rpc/src/v1/traits/ethcore.rs
@@ -67,6 +67,12 @@ pub trait Ethcore: Sized + Send + Sync + 'static {
 	/// Returns error when signer is disabled
 	fn unsigned_transactions_count(&self, _: Params) -> Result<Value, Error>;

+	/// Returns the value of the registrar for this network.
+	fn registry_address(&self, _: Params) -> Result<Value, Error>;
+
+	/// Returns all transactions in transaction queue.
+	fn pending_transactions(&self, _: Params) -> Result<Value, Error>;
+
 	/// Should be used to convert object to io delegate.
 	fn to_delegate(self) -> IoDelegate<Self> {
 		let mut delegate = IoDelegate::new(Arc::new(self));
@@ -86,7 +92,8 @@ pub trait Ethcore: Sized + Send + Sync + 'static {
 		delegate.add_method("ethcore_defaultExtraData", Ethcore::default_extra_data);
 		delegate.add_method("ethcore_gasPriceStatistics", Ethcore::gas_price_statistics);
 		delegate.add_method("ethcore_unsignedTransactionsCount", Ethcore::unsigned_transactions_count);
-
+		delegate.add_method("ethcore_registryAddress", Ethcore::registry_address);
+		delegate.add_method("ethcore_pendingTransactions", Ethcore::pending_transactions);
 		delegate
 	}
 }
--- a/rpc/src/v1/types/block.rs
+++ b/rpc/src/v1/types/block.rs
@@ -90,7 +90,7 @@ pub struct Block {
 	/// Transactions
 	pub transactions: BlockTransactions,
 	/// Size in bytes
-	pub size: Option<usize>,
+	pub size: Option<U256>,
 }

 #[cfg(test)]
@@ -132,10 +132,10 @@ mod tests {
 			seal_fields: vec![Bytes::default(), Bytes::default()],
 			uncles: vec![],
 			transactions: BlockTransactions::Hashes(vec![].into()),
-			size: Some(69usize),
+			size: Some(69.into()),
 		};

 		let serialized = serde_json::to_string(&block).unwrap();
-		assert_eq!(serialized, r#"{"hash":"0x0000000000000000000000000000000000000000000000000000000000000000","parentHash":"0x0000000000000000000000000000000000000000000000000000000000000000","sha3Uncles":"0x0000000000000000000000000000000000000000000000000000000000000000","author":"0x0000000000000000000000000000000000000000","miner":"0x0000000000000000000000000000000000000000","stateRoot":"0x0000000000000000000000000000000000000000000000000000000000000000","transactionsRoot":"0x0000000000000000000000000000000000000000000000000000000000000000","receiptsRoot":"0x0000000000000000000000000000000000000000000000000000000000000000","number":"0x00","gasUsed":"0x00","gasLimit":"0x00","extraData":"0x","logsBloom":"0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000","timestamp":"0x00","difficulty":"0x00","totalDifficulty":"0x00","sealFields":["0x","0x"],"uncles":[],"transactions":[],"size":69}"#);
+		assert_eq!(serialized, r#"{"hash":"0x0000000000000000000000000000000000000000000000000000000000000000","parentHash":"0x0000000000000000000000000000000000000000000000000000000000000000","sha3Uncles":"0x0000000000000000000000000000000000000000000000000000000000000000","author":"0x0000000000000000000000000000000000000000","miner":"0x0000000000000000000000000000000000000000","stateRoot":"0x0000000000000000000000000000000000000000000000000000000000000000","transactionsRoot":"0x0000000000000000000000000000000000000000000000000000000000000000","receiptsRoot":"0x0000000000000000000000000000000000000000000000000000000000000000","number":"0x00","gasUsed":"0x00","gasLimit":"0x00","extraData":"0x","logsBloom":"0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000","timestamp":"0x00","difficulty":"0x00","totalDifficulty":"0x00","sealFields":["0x","0x"],"uncles":[],"transactions":[],"size":"0x45"}"#);
 	}
 }
--- a/rpc/src/v1/types/bytes.rs
+++ b/rpc/src/v1/types/bytes.rs
@@ -70,10 +70,12 @@ impl Visitor for BytesVisitor {
 	type Value = Bytes;

 	fn visit_str<E>(&mut self, value: &str) -> Result<Self::Value, E> where E: Error {
-		if value.len() >= 2 && &value[0..2] == "0x" {
-			Ok(Bytes::new(FromHex::from_hex(&value[2..]).unwrap_or_else(|_| vec![])))
+		if value.is_empty() {
+			Ok(Bytes::new(Vec::new()))
+		} else if value.len() >= 2 && &value[0..2] == "0x" && value.len() & 1 == 0 {
+			Ok(Bytes::new(try!(FromHex::from_hex(&value[2..]).map_err(|_| Error::custom("invalid hex")))))
 		} else {
-			Err(Error::custom("invalid hex"))
+			Err(Error::custom("invalid format"))
 		}
 	}

@@ -95,5 +97,32 @@ mod tests {
 		let serialized = serde_json::to_string(&bytes).unwrap();
 		assert_eq!(serialized, r#""0x0123456789abcdef""#);
 	}
+
+	#[test]
+	fn test_bytes_deserialize() {
+		// TODO [ToDr] Uncomment when Mist starts sending correct data
+		// let bytes1: Result<Bytes, serde_json::Error> = serde_json::from_str(r#""""#);
+		let bytes2: Result<Bytes, serde_json::Error> = serde_json::from_str(r#""0x123""#);
+		let bytes3: Result<Bytes, serde_json::Error> = serde_json::from_str(r#""0xgg""#);
+
+		let bytes4: Bytes = serde_json::from_str(r#""0x""#).unwrap();
+		let bytes5: Bytes = serde_json::from_str(r#""0x12""#).unwrap();
+		let bytes6: Bytes = serde_json::from_str(r#""0x0123""#).unwrap();
+		let bytes7: Bytes = serde_json::from_str(r#""0x0123456789abcdef""#).unwrap();
+
+		// assert!(bytes1.is_err());
+		assert!(bytes2.is_err());
+		assert!(bytes3.is_err());
+		assert_eq!(bytes4, Bytes(vec![]));
+		assert_eq!(bytes5, Bytes(vec![0x12]));
+		assert_eq!(bytes6, Bytes(vec![0x1, 0x23]));
+		assert_eq!(bytes7, Bytes(vec![0x1, 0x23, 0x45,0x67,0x89, 0xab, 0xcd, 0xef]));
+	}
+
+	#[test]
+	fn test_bytes_lenient_against_the_spec_deserialize_for_empty_string_for_geth_compatibility() {
+		let deserialized: Bytes = serde_json::from_str(r#""""#).unwrap();
+		assert_eq!(deserialized, Bytes(Vec::new()));
+	}
 }

--- 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/receipt.rs
+++ b/rpc/src/v1/types/receipt.rs
@@ -15,7 +15,7 @@
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.

 use v1::types::{Log, H160, H256, U256};
-use ethcore::receipt::{Receipt as EthReceipt, LocalizedReceipt};
+use ethcore::receipt::{Receipt as EthReceipt, RichReceipt, LocalizedReceipt};

 /// Receipt
 #[derive(Debug, Serialize)]
@@ -37,7 +37,7 @@ pub struct Receipt {
 	pub cumulative_gas_used: U256,
 	/// Gas used
 	#[serde(rename="gasUsed")]
-	pub gas_used: U256,
+	pub gas_used: Option<U256>,
 	/// Contract address
 	#[serde(rename="contractAddress")]
 	pub contract_address: Option<H160>,
@@ -53,7 +53,22 @@ impl From<LocalizedReceipt> for Receipt {
 			block_hash: Some(r.block_hash.into()),
 			block_number: Some(r.block_number.into()),
 			cumulative_gas_used: r.cumulative_gas_used.into(),
-			gas_used: r.gas_used.into(),
+			gas_used: Some(r.gas_used.into()),
+			contract_address: r.contract_address.map(Into::into),
+			logs: r.logs.into_iter().map(Into::into).collect(),
+		}
+	}
+}
+
+impl From<RichReceipt> for Receipt {
+	fn from(r: RichReceipt) -> Self {
+		Receipt {
+			transaction_hash: Some(r.transaction_hash.into()),
+			transaction_index: Some(r.transaction_index.into()),
+			block_hash: None,
+			block_number: None,
+			cumulative_gas_used: r.cumulative_gas_used.into(),
+			gas_used: Some(r.gas_used.into()),
 			contract_address: r.contract_address.map(Into::into),
 			logs: r.logs.into_iter().map(Into::into).collect(),
 		}
@@ -68,7 +83,7 @@ impl From<EthReceipt> for Receipt {
 			block_hash: None,
 			block_number: None,
 			cumulative_gas_used: r.gas_used.into(),
-			gas_used: r.gas_used.into(),
+			gas_used: None,
 			contract_address: None,
 			logs: r.logs.into_iter().map(Into::into).collect(),
 		}
@@ -91,7 +106,7 @@ mod tests {
 			block_hash: Some(H256::from_str("ed76641c68a1c641aee09a94b3b471f4dc0316efe5ac19cf488e2674cf8d05b5").unwrap()),
 			block_number: Some(U256::from(0x4510c)),
 			cumulative_gas_used: U256::from(0x20),
-			gas_used: U256::from(0x10),
+			gas_used: Some(U256::from(0x10)),
 			contract_address: None,
 			logs: vec![Log {
 				address: H160::from_str("33990122638b9132ca29c723bdf037f1a891a70c").unwrap(),
--- a/rpc/src/v1/types/trace.rs
+++ b/rpc/src/v1/types/trace.rs
@@ -32,14 +32,14 @@ pub struct MemoryDiff {
 	/// Offset into memory the change begins.
 	pub off: usize,
 	/// The changed data.
-	pub data: Vec<u8>,
+	pub data: Bytes,
 }

 impl From<et::MemoryDiff> for MemoryDiff {
 	fn from(c: et::MemoryDiff) -> Self {
 		MemoryDiff {
 			off: c.offset,
-			data: c.data,
+			data: c.data.into(),
 		}
 	}
 }
@@ -99,6 +99,7 @@ pub struct VMOperation {
 	/// Information concerning the execution of the operation.
 	pub ex: Option<VMExecutedOperation>,
 	/// Subordinate trace of the CALL/CREATE if applicable.
+	#[serde(bound="VMTrace: Serialize")]
 	pub sub: Option<VMTrace>,
 }

@@ -117,7 +118,7 @@ impl From<(et::VMOperation, Option<et::VMTrace>)> for VMOperation {
 /// A record of a full VM trace for a CALL/CREATE.
 pub struct VMTrace {
 	/// The code to be executed.
-	pub code: Vec<u8>,
+	pub code: Bytes,
 	/// The operations executed.
 	pub ops: Vec<VMOperation>,
 }
@@ -127,7 +128,7 @@ impl From<et::VMTrace> for VMTrace {
 		let mut subs = c.subs.into_iter();
 		let mut next_sub = subs.next();
 		VMTrace {
-			code: c.code,
+			code: c.code.into(),
 			ops: c.operations
 				.into_iter()
 				.enumerate()
@@ -484,7 +485,7 @@ impl From<FlatTrace> for Trace {
 /// A diff of some chunk of memory.
 pub struct TraceResults {
 	/// The output of the call/create
-	pub output: Vec<u8>,
+	pub output: Bytes,
 	/// The transaction trace.
 	pub trace: Vec<Trace>,
 	/// The transaction trace.
@@ -516,13 +517,13 @@ mod tests {
 	#[test]
 	fn should_serialize_trace_results() {
 		let r = TraceResults {
-			output: vec![0x60],
+			output: vec![0x60].into(),
 			trace: vec![],
 			vm_trace: None,
 			state_diff: None,
 		};
 		let serialized = serde_json::to_string(&r).unwrap();
-		assert_eq!(serialized, r#"{"output":[96],"trace":[],"vmTrace":null,"stateDiff":null}"#);
+		assert_eq!(serialized, r#"{"output":"0x60","trace":[],"vmTrace":null,"stateDiff":null}"#);
 	}

 	#[test]
@@ -554,7 +555,7 @@ mod tests {
 	#[test]
 	fn test_vmtrace_serialize() {
 		let t = VMTrace {
-			code: vec![0, 1, 2, 3],
+			code: vec![0, 1, 2, 3].into(),
 			ops: vec![
 				VMOperation {
 					pc: 0,
@@ -572,15 +573,15 @@ mod tests {
 						store: None,
 					}),
 					sub: Some(VMTrace {
-						code: vec![0],
+						code: vec![0].into(),
 						ops: vec![
 							VMOperation {
 								pc: 0,
 								cost: 0,
 								ex: Some(VMExecutedOperation {
 									used: 10,
-									push: vec![42.into()],
-									mem: Some(MemoryDiff {off: 42, data: vec![1, 2, 3]}),
+									push: vec![42.into()].into(),
+									mem: Some(MemoryDiff {off: 42, data: vec![1, 2, 3].into()}),
 									store: Some(StorageDiff {key: 69.into(), val: 42.into()}),
 								}),
 								sub: None,
@@ -591,7 +592,7 @@ mod tests {
 			]
 		};
 		let serialized = serde_json::to_string(&t).unwrap();
-		assert_eq!(serialized, r#"{"code":[0,1,2,3],"ops":[{"pc":0,"cost":10,"ex":null,"sub":null},{"pc":1,"cost":11,"ex":{"used":10,"push":["0x45"],"mem":null,"store":null},"sub":{"code":[0],"ops":[{"pc":0,"cost":0,"ex":{"used":10,"push":["0x2a"],"mem":{"off":42,"data":[1,2,3]},"store":{"key":"0x45","val":"0x2a"}},"sub":null}]}}]}"#);
+		assert_eq!(serialized, r#"{"code":"0x00010203","ops":[{"pc":0,"cost":10,"ex":null,"sub":null},{"pc":1,"cost":11,"ex":{"used":10,"push":["0x45"],"mem":null,"store":null},"sub":{"code":"0x00","ops":[{"pc":0,"cost":0,"ex":{"used":10,"push":["0x2a"],"mem":{"off":42,"data":"0x010203"},"store":{"key":"0x45","val":"0x2a"}},"sub":null}]}}]}"#);
 	}

 	#[test]
--- 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/api.rs
+++ b/sync/src/api.rs
@@ -15,9 +15,10 @@
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.

 use std::sync::Arc;
+use std::collections::HashMap;
 use network::{NetworkProtocolHandler, NetworkService, NetworkContext, PeerId,
 	NetworkConfiguration as BasicNetworkConfiguration, NonReservedPeerMode, NetworkError};
-use util::{U256, H256, Secret, Populatable};
+use util::{U256, H256, Secret, Populatable, Bytes};
 use io::{TimerToken};
 use ethcore::client::{BlockChainClient, ChainNotify};
 use ethcore::header::BlockNumber;
@@ -78,7 +79,11 @@ impl EthSync {
 		let service = try!(NetworkService::new(try!(network_config.into_basic())));
 		let sync = Arc::new(EthSync{
 			network: service,
-			handler: Arc::new(SyncProtocolHandler { sync: RwLock::new(chain_sync), chain: chain }),
+			handler: Arc::new(SyncProtocolHandler {
+				sync: RwLock::new(chain_sync),
+				chain: chain,
+				overlay: RwLock::new(HashMap::new()),
+			}),
 		});

 		Ok(sync)
@@ -99,6 +104,8 @@ struct SyncProtocolHandler {
 	chain: Arc<BlockChainClient>,
 	/// Sync strategy
 	sync: RwLock<ChainSync>,
+	/// Chain overlay used to cache data such as fork block.
+	overlay: RwLock<HashMap<BlockNumber, Bytes>>,
 }

 impl NetworkProtocolHandler for SyncProtocolHandler {
@@ -107,20 +114,20 @@ impl NetworkProtocolHandler for SyncProtocolHandler {
 	}

 	fn read(&self, io: &NetworkContext, peer: &PeerId, packet_id: u8, data: &[u8]) {
-		ChainSync::dispatch_packet(&self.sync, &mut NetSyncIo::new(io, &*self.chain), *peer, packet_id, data);
+		ChainSync::dispatch_packet(&self.sync, &mut NetSyncIo::new(io, &*self.chain, &self.overlay), *peer, packet_id, data);
 	}

 	fn connected(&self, io: &NetworkContext, peer: &PeerId) {
-		self.sync.write().on_peer_connected(&mut NetSyncIo::new(io, &*self.chain), *peer);
+		self.sync.write().on_peer_connected(&mut NetSyncIo::new(io, &*self.chain, &self.overlay), *peer);
 	}

 	fn disconnected(&self, io: &NetworkContext, peer: &PeerId) {
-		self.sync.write().on_peer_aborting(&mut NetSyncIo::new(io, &*self.chain), *peer);
+		self.sync.write().on_peer_aborting(&mut NetSyncIo::new(io, &*self.chain, &self.overlay), *peer);
 	}

 	fn timeout(&self, io: &NetworkContext, _timer: TimerToken) {
-		self.sync.write().maintain_peers(&mut NetSyncIo::new(io, &*self.chain));
-		self.sync.write().maintain_sync(&mut NetSyncIo::new(io, &*self.chain));
+		self.sync.write().maintain_peers(&mut NetSyncIo::new(io, &*self.chain, &self.overlay));
+		self.sync.write().maintain_sync(&mut NetSyncIo::new(io, &*self.chain, &self.overlay));
 	}
 }

@@ -134,7 +141,7 @@ impl ChainNotify for EthSync {
 		_duration: u64)
 	{
 		self.network.with_context(ETH_PROTOCOL, |context| {
-			let mut sync_io = NetSyncIo::new(context, &*self.handler.chain);
+			let mut sync_io = NetSyncIo::new(context, &*self.handler.chain, &self.handler.overlay);
 			self.handler.sync.write().chain_new_blocks(
 				&mut sync_io,
 				&imported,
@@ -203,7 +210,7 @@ impl ManageNetwork for EthSync {

 	fn stop_network(&self) {
 		self.network.with_context(ETH_PROTOCOL, |context| {
-			let mut sync_io = NetSyncIo::new(context, &*self.handler.chain);
+			let mut sync_io = NetSyncIo::new(context, &*self.handler.chain, &self.handler.overlay);
 			self.handler.sync.write().abort(&mut sync_io);
 		});
 		self.stop();
--- a/sync/src/blocks.rs
+++ b/sync/src/blocks.rs
@@ -18,7 +18,7 @@ use util::*;
 use network::NetworkError;
 use ethcore::header::{ Header as BlockHeader};

-known_heap_size!(0, HeaderId, SyncBlock);
+known_heap_size!(0, HeaderId);

 /// Block data with optional body.
 struct SyncBlock {
@@ -26,6 +26,12 @@ struct SyncBlock {
 	body: Option<Bytes>,
 }

+impl HeapSizeOf for SyncBlock {
+	fn heap_size_of_children(&self) -> usize {
+		self.header.heap_size_of_children() + self.body.heap_size_of_children()
+	}
+}
+
 /// Used to identify header by transactions and uncles hashes
 #[derive(Eq, PartialEq, Hash)]
 struct HeaderId {
@@ -218,10 +224,14 @@ impl BlockCollection {
 		self.blocks.contains_key(hash)
 	}

-	/// Return heap size.
+	/// Return used heap size.
 	pub fn heap_size(&self) -> usize {
-		//TODO: other collections
-		self.blocks.heap_size_of_children()
+		self.heads.heap_size_of_children()
+			+ self.blocks.heap_size_of_children()
+			+ self.parents.heap_size_of_children()
+			+ self.header_ids.heap_size_of_children()
+			+ self.downloading_headers.heap_size_of_children()
+			+ self.downloading_bodies.heap_size_of_children()
 	}

 	/// Check if given block hash is marked as being downloaded.
--- a/sync/src/chain.rs
+++ b/sync/src/chain.rs
@@ -449,7 +449,9 @@ impl ChainSync {
 		let confirmed = match self.peers.get_mut(&peer_id) {
 			Some(ref mut peer) if peer.asking == PeerAsking::ForkHeader => {
 				let item_count = r.item_count();
-				if item_count == 0 || (item_count == 1 && try!(r.at(0)).as_raw().sha3() == self.fork_block.unwrap().1) {
+				let (fork_number, fork_hash) = self.fork_block.expect("ForkHeader request is sent only fork block is Some; qed").clone();
+				let header = try!(r.at(0)).as_raw();
+				if item_count == 0 || (item_count == 1 && header.sha3() == fork_hash) {
 					peer.asking = PeerAsking::Nothing;
 					if item_count == 0 {
 						trace!(target: "sync", "{}: Chain is too short to confirm the block", peer_id);
@@ -457,6 +459,9 @@ impl ChainSync {
 					} else {
 						trace!(target: "sync", "{}: Confirmed peer", peer_id);
 						peer.confirmation = ForkConfirmation::Confirmed;
+						if !io.chain_overlay().read().contains_key(&fork_number) {
+							io.chain_overlay().write().insert(fork_number, header.to_vec());
+						}
 					}
 					true
 				} else {
@@ -1135,8 +1140,13 @@ impl ChainSync {
 		let mut count = 0;
 		let mut data = Bytes::new();
 		let inc = (skip + 1) as BlockNumber;
+		let overlay = io.chain_overlay().read();
 		while number <= last && count < max_count {
-			if let Some(mut hdr) = io.chain().block_header(BlockID::Number(number)) {
+			if let Some(hdr) = overlay.get(&number) {
+				trace!(target: "sync", "{}: Returning cached fork header", peer_id);
+				data.extend(hdr);
+				count += 1;
+			} else if let Some(mut hdr) = io.chain().block_header(BlockID::Number(number)) {
 				data.append(&mut hdr);
 				count += 1;
 			}
@@ -1336,8 +1346,10 @@ impl ChainSync {
 						let mut rlp_stream = RlpStream::new_list(blocks.len());
 						for block_hash in  blocks {
 							let mut hash_rlp = RlpStream::new_list(2);
-							let number = HeaderView::new(&chain.block_header(BlockID::Hash(block_hash.clone()))
-								.expect("chain.tree_route and chain.find_uncles only return hahses of blocks that are in the blockchain. qed.")).number();
+							let number = match chain.block_header(BlockID::Hash(block_hash.clone())) {
+								Some(header) => HeaderView::new(&header).number(),
+								_ => return None,
+							};
 							hash_rlp.append(&block_hash);
 							hash_rlp.append(&number);
 							rlp_stream.append_raw(hash_rlp.as_raw(), 1);
--- a/sync/src/sync_io.rs
+++ b/sync/src/sync_io.rs
@@ -14,8 +14,11 @@
 // 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::HashMap;
+use ethcore::header::BlockNumber;
 use network::{NetworkContext, PeerId, PacketId, NetworkError};
 use ethcore::client::BlockChainClient;
+use util::{RwLock, Bytes};

 /// IO interface for the syning handler.
 /// Provides peer connection management and an interface to the blockchain client.
@@ -41,20 +44,24 @@ pub trait SyncIo {
 	}
 	/// Check if the session is expired
 	fn is_expired(&self) -> bool;
+	/// Return sync overlay
+	fn chain_overlay(&self) -> &RwLock<HashMap<BlockNumber, Bytes>>;
 }

 /// Wraps `NetworkContext` and the blockchain client
 pub struct NetSyncIo<'s, 'h> where 'h: 's {
 	network: &'s NetworkContext<'h>,
-	chain: &'s BlockChainClient
+	chain: &'s BlockChainClient,
+	chain_overlay: &'s RwLock<HashMap<BlockNumber, Bytes>>,
 }

 impl<'s, 'h> NetSyncIo<'s, 'h> {
 	/// Creates a new instance from the `NetworkContext` and the blockchain client reference.
-	pub fn new(network: &'s NetworkContext<'h>, chain: &'s BlockChainClient) -> NetSyncIo<'s, 'h> {
+	pub fn new(network: &'s NetworkContext<'h>, chain: &'s BlockChainClient, chain_overlay: &'s RwLock<HashMap<BlockNumber, Bytes>>) -> NetSyncIo<'s, 'h> {
 		NetSyncIo {
 			network: network,
 			chain: chain,
+			chain_overlay: chain_overlay,
 		}
 	}
 }
@@ -80,6 +87,10 @@ impl<'s, 'h> SyncIo for NetSyncIo<'s, 'h> {
 		self.chain
 	}

+	fn chain_overlay(&self) -> &RwLock<HashMap<BlockNumber, Bytes>> {
+		self.chain_overlay
+	}
+
 	fn peer_info(&self, peer_id: PeerId) -> String {
 		self.network.peer_info(peer_id)
 	}
--- 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>,
+	overlay: RwLock<HashMap<BlockNumber, Bytes>>,
 }

 impl<'p> TestIo<'p> {
@@ -33,7 +34,8 @@ impl<'p> TestIo<'p> {
 		TestIo {
 			chain: chain,
 			queue: queue,
-			sender: sender
+			sender: sender,
+			overlay: RwLock::new(HashMap::new()),
 		}
 	}
 }
@@ -70,6 +72,10 @@ impl<'p> SyncIo for TestIo<'p> {
 	fn chain(&self) -> &BlockChainClient {
 		self.chain
 	}
+
+	fn chain_overlay(&self) -> &RwLock<HashMap<BlockNumber, Bytes>> {
+		&self.overlay
+	}
 }

 pub struct TestPacket {
--- 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.0"
+version = "1.3.3"
 authors = ["Ethcore <admin@ethcore.io>"]
 build = "build.rs"

--- a/util/network/src/connection.rs
+++ b/util/network/src/connection.rs
@@ -110,8 +110,8 @@ impl<Socket: GenericSocket> GenericConnection<Socket> {
 		}
 		if !self.interest.is_writable() {
 			self.interest.insert(EventSet::writable());
-			io.update_registration(self.token).ok();
 		}
+		io.update_registration(self.token).ok();
 	}

 	/// Check if this connection has data to be sent.
--- a/util/network/src/discovery.rs
+++ b/util/network/src/discovery.rs
@@ -59,7 +59,7 @@ pub struct BucketEntry {
 	pub timeout: Option<u64>,
 }

-struct NodeBucket {
+pub struct NodeBucket {
 	nodes: VecDeque<BucketEntry>, //sorted by last active
 }

@@ -281,12 +281,12 @@ impl Discovery {
 				if count == BUCKET_SIZE {
 					// delete the most distant element
 					let remove = {
-						let (_, last) = found.iter_mut().next_back().unwrap();
+						let (key, last) = found.iter_mut().next_back().unwrap();
 						last.pop();
-						last.is_empty()
+						if last.is_empty() { Some(key.clone()) } else { None }
 					};
-					if remove {
-						found.remove(&distance);
+					if let Some(remove) = remove {
+						found.remove(&remove);
 					}
 				}
 				else {
@@ -605,6 +605,21 @@ mod tests {
 		assert!(removed > 0);
 	}

+	#[test]
+	fn find_nearest_saturated() {
+		use super::*;
+		let mut buckets: Vec<_> = (0..256).map(|_| NodeBucket::new()).collect();
+		let ep = NodeEndpoint { address: SocketAddr::from_str("127.0.0.1:40447").unwrap(), udp_port: 40447 };
+		for _ in 0..(16 + 10) {
+			buckets[0].nodes.push_back(BucketEntry {
+				address: NodeEntry { id: NodeId::new(), endpoint: ep.clone() },
+				timeout: None
+			});
+		}
+		let nearest = Discovery::nearest_node_entries(&NodeId::new(), &buckets);
+		assert_eq!(nearest.len(), 16)
+	}
+
 	#[test]
 	fn packets() {
 		let key = KeyPair::create().unwrap();
--- a/util/src/crypto.rs
+++ b/util/src/crypto.rs
@@ -287,6 +287,7 @@ pub mod ecies {
 	use hash::*;
 	use bytes::*;
 	use crypto::*;
+	use sha3::Hashable;

 	/// Encrypt a message with a public key
 	pub fn encrypt(public: &Public, shared_mac: &[u8], plain: &[u8]) -> Result<Bytes, CryptoError> {
@@ -310,9 +311,11 @@ pub mod ecies {
 		{
 			let msgd = &mut msg[1..];
 			r.public().copy_to(&mut msgd[0..64]);
+			let iv = H128::random();
+			iv.copy_to(&mut msgd[64..(64+16)]);
 			{
 				let cipher = &mut msgd[(64 + 16)..(64 + 16 + plain.len())];
-				aes::encrypt(ekey, &H128::new(), plain, cipher);
+				aes::encrypt(ekey, &iv, plain, cipher);
 			}
 			let mut hmac = Hmac::new(Sha256::new(), &mkey);
 			{
@@ -325,6 +328,33 @@ pub mod ecies {
 		Ok(msg)
 	}

+	/// Encrypt a message with a public key
+	pub fn encrypt_single_message(public: &Public, plain: &[u8]) -> Result<Bytes, CryptoError> {
+		use ::rcrypto::digest::Digest;
+		use ::rcrypto::sha2::Sha256;
+		let r = try!(KeyPair::create());
+		let z = try!(ecdh::agree(r.secret(), public));
+		let mut key = [0u8; 32];
+		let mut mkey = [0u8; 32];
+		kdf(&z, &[0u8; 0], &mut key);
+		let mut hasher = Sha256::new();
+		let mkey_material = &key[16..32];
+		hasher.input(mkey_material);
+		hasher.result(&mut mkey);
+		let ekey = &key[0..16];
+
+		let mut msgd = vec![0u8; (64 + plain.len())];
+		{
+			r.public().copy_to(&mut msgd[0..64]);
+			let iv = H128::from_slice(&z.sha3()[0..16]);
+			{
+				let cipher = &mut msgd[64..(64 + plain.len())];
+				aes::encrypt(ekey, &iv, plain, cipher);
+			}
+		}
+		Ok(msgd)
+	}
+
 	/// Decrypt a message with a secret key
 	pub fn decrypt(secret: &Secret, shared_mac: &[u8], encrypted: &[u8]) -> Result<Bytes, CryptoError> {
 		use ::rcrypto::digest::Digest;
@@ -370,6 +400,36 @@ pub mod ecies {
 		Ok(msg)
 	}

+	/// Decrypt single message with a secret key
+	pub fn decrypt_single_message(secret: &Secret, encrypted: &[u8]) -> Result<Bytes, CryptoError> {
+		use ::rcrypto::digest::Digest;
+		use ::rcrypto::sha2::Sha256;
+
+		let meta_len = 64;
+		if encrypted.len() < meta_len {
+			return Err(CryptoError::InvalidMessage); //invalid message: publickey
+		}
+
+		let e = encrypted;
+		let p = Public::from_slice(&e[0..64]);
+		let z = try!(ecdh::agree(secret, &p));
+		let mut key = [0u8; 32];
+		kdf(&z, &[0u8; 0], &mut key);
+		let ekey = &key[0..16];
+		let mkey_material = &key[16..32];
+		let mut hasher = Sha256::new();
+		let mut mkey = [0u8; 32];
+		hasher.input(mkey_material);
+		hasher.result(&mut mkey);
+
+		let clen = encrypted.len() - meta_len;
+		let cipher = &e[64..(64+clen)];
+		let mut msg = vec![0u8; clen];
+		let iv = H128::from_slice(&z.sha3()[0..16]);
+		aes::decrypt(ekey, &iv, cipher, &mut msg[..]);
+		Ok(msg)
+	}
+
 	fn kdf(secret: &Secret, s1: &[u8], dest: &mut [u8]) {
 		use ::rcrypto::digest::Digest;
 		use ::rcrypto::sha2::Sha256;
@@ -458,4 +518,14 @@ mod tests {
 		let decrypted = ecies::decrypt(kp.secret(), shared, &encrypted).unwrap();
 		assert_eq!(decrypted[..message.len()], message[..]);
 	}
+
+	#[test]
+	fn ecies_shared_single() {
+		let kp = KeyPair::create().unwrap();
+		let message = b"So many books, so little time";
+		let encrypted = ecies::encrypt_single_message(kp.public(), message).unwrap();
+		assert!(encrypted[..] != message[..]);
+		let decrypted = ecies::decrypt_single_message(kp.secret(), &encrypted).unwrap();
+		assert_eq!(decrypted[..message.len()], message[..]);
+	}
 }
--- a/util/src/hash.rs
+++ b/util/src/hash.rs
@@ -77,11 +77,11 @@ pub fn clean_0x(s: &str) -> &str {

 macro_rules! impl_hash {
 	($from: ident, $size: expr) => {
-		#[derive(Eq)]
 		#[repr(C)]
 		/// Unformatted binary data of fixed length.
 		pub struct $from (pub [u8; $size]);

+
 		impl From<[u8; $size]> for $from {
 			fn from(bytes: [u8; $size]) -> Self {
 				$from(bytes)
@@ -263,6 +263,8 @@ macro_rules! impl_hash {
 			}
 		}

+		impl Eq for $from {}
+
 		impl PartialEq for $from {
 			fn eq(&self, other: &Self) -> bool {
 				for i in 0..$size {
--- a/util/src/journaldb/archivedb.rs
+++ b/util/src/journaldb/archivedb.rs
@@ -163,7 +163,6 @@ impl JournalDB for ArchiveDB {
 		for i in self.overlay.drain().into_iter() {
 			let (key, (value, rc)) = i;
 			if rc > 0 {
-				assert!(rc == 1);
 				batch.put(self.column, &key, &value).expect("Low-level database error. Some issue with your hard disk?");
 				inserts += 1;
 			}
@@ -192,7 +191,6 @@ impl JournalDB for ArchiveDB {
 		for i in self.overlay.drain().into_iter() {
 			let (key, (value, rc)) = i;
 			if rc > 0 {
-				assert!(rc == 1);
 				if try!(self.backing.get(self.column, &key)).is_some() {
 					return Err(BaseDataError::AlreadyExists(key).into());
 				}
--- a/util/src/kvdb.rs
+++ b/util/src/kvdb.rs
@@ -213,23 +213,33 @@ impl Database {
 		if let Some(rate_limit) = config.compaction.write_rate_limit {
 			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)));
 		opts.set_max_open_files(config.max_open_files);
 		opts.create_if_missing(true);
 		opts.set_use_fsync(false);

+		opts.set_max_background_flushes(DB_BACKGROUND_FLUSHES);
+		opts.set_max_background_compactions(DB_BACKGROUND_COMPACTIONS);
+
 		// compaction settings
 		opts.set_compaction_style(DBCompactionStyle::DBUniversalCompaction);
 		opts.set_target_file_size_base(config.compaction.initial_file_size);
 		opts.set_target_file_size_multiplier(config.compaction.file_size_multiplier);

-		opts.set_max_background_flushes(DB_BACKGROUND_FLUSHES);
-		opts.set_max_background_compactions(DB_BACKGROUND_COMPACTIONS);
+		let mut cf_options = Vec::with_capacity(config.columns.unwrap_or(0) as usize);

-		if let Some(cache_size) = config.cache_size {
-			let mut block_opts = BlockBasedOptions::new();
-			// all goes to read cache
-			block_opts.set_cache(Cache::new(cache_size * 1024 * 1024));
-			opts.set_block_based_table_factory(&block_opts);
+		for _ in 0 .. config.columns.unwrap_or(0) {
+			let mut opts = Options::new();
+			opts.set_compaction_style(DBCompactionStyle::DBUniversalCompaction);
+			opts.set_target_file_size_base(config.compaction.initial_file_size);
+			opts.set_target_file_size_multiplier(config.compaction.file_size_multiplier);
+			if let Some(cache_size) = config.cache_size {
+				let mut block_opts = BlockBasedOptions::new();
+				// all goes to read cache
+				block_opts.set_cache(Cache::new(cache_size * 1024 * 1024));
+				opts.set_block_based_table_factory(&block_opts);
+			}
+			cf_options.push(opts);
 		}

 		let mut write_opts = WriteOptions::new();
@@ -242,7 +252,7 @@ impl Database {
 			Some(columns) => {
 				let cfnames: Vec<_> = (0..columns).map(|c| format!("col{}", c)).collect();
 				let cfnames: Vec<&str> = cfnames.iter().map(|n| n as &str).collect();
-				match DB::open_cf(&opts, path, &cfnames) {
+				match DB::open_cf(&opts, path, &cfnames, &cf_options) {
 					Ok(db) => {
 						cfs = cfnames.iter().map(|n| db.cf_handle(n).unwrap()).collect();
 						assert!(cfs.len() == columns as usize);
@@ -250,9 +260,9 @@ impl Database {
 					}
 					Err(_) => {
 						// retry and create CFs
-						match DB::open_cf(&opts, path, &[]) {
+						match DB::open_cf(&opts, path, &[], &[]) {
 							Ok(mut db) => {
-								cfs = cfnames.iter().map(|n| db.create_cf(n, &opts).unwrap()).collect();
+								cfs = cfnames.iter().enumerate().map(|(i, n)| db.create_cf(n, &cf_options[i]).unwrap()).collect();
 								Ok(db)
 							},
 							err @ Err(_) => err,
--- a/util/src/migration/mod.rs
+++ b/util/src/migration/mod.rs
@@ -102,6 +102,12 @@ impl From<::std::io::Error> for Error {
 	}
 }

+impl From<String> for Error {
+	fn from(e: String) -> Self {
+		Error::Custom(e)
+	}
+}
+
 /// A generalized migration from the given db to a destination db.
 pub trait Migration: 'static {
 	/// Number of columns in database after the migration.
--- 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/rlp/bytes.rs
+++ b/util/src/rlp/bytes.rs
@@ -174,6 +174,8 @@ pub enum FromBytesError {
 	DataIsTooLong,
 	/// Integer-representation is non-canonically prefixed with zero byte(s).
 	ZeroPrefixedInt,
+	/// String representation is not utf-8
+	InvalidUtf8,
 }

 impl StdError for FromBytesError {
@@ -199,7 +201,7 @@ pub trait FromBytes: Sized {

 impl FromBytes for String {
 	fn from_bytes(bytes: &[u8]) -> FromBytesResult<String> {
-		Ok(::std::str::from_utf8(bytes).unwrap().to_owned())
+		::std::str::from_utf8(bytes).map(|s| s.to_owned()).map_err(|_| FromBytesError::InvalidUtf8)
 	}
 }

--- 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};
--- a/util/src/trie/triedbmut.rs
+++ b/util/src/trie/triedbmut.rs
@@ -56,11 +56,11 @@ impl From<H256> for NodeHandle {
 	}
 }

-fn empty_children() -> [Option<NodeHandle>; 16] {
-	[
+fn empty_children() -> Box<[Option<NodeHandle>; 16]> {
+	Box::new([
 		None, None, None, None, None, None, None, None,
 		None, None, None, None, None, None, None, None,
-	]
+	])
 }

 /// Node types in the Trie.
@@ -78,7 +78,7 @@ enum Node {
 	/// The child node is always a branch.
 	Extension(Bytes, NodeHandle),
 	/// A branch has up to 16 children and an optional value.
-	Branch([Option<NodeHandle>; 16], Option<Bytes>)
+	Branch(Box<[Option<NodeHandle>; 16]>, Option<Bytes>)
 }

 impl Node {
@@ -820,19 +820,19 @@ impl<'a> TrieDBMut<'a> {
 	/// Commit the in-memory changes to disk, freeing their storage and
 	/// updating the state root.
 	pub fn commit(&mut self) {
-		let handle = match self.root_handle() {
-			NodeHandle::Hash(_) => return, // no changes necessary.
-			NodeHandle::InMemory(h) => h,
-		};
-
 		trace!(target: "trie", "Committing trie changes to db.");

-		// kill all the nodes on death row.
+		// always kill all the nodes on death row.
 		trace!(target: "trie", "{:?} nodes to remove from db", self.death_row.len());
 		for hash in self.death_row.drain() {
 			self.db.remove(&hash);
 		}

+		let handle = match self.root_handle() {
+			NodeHandle::Hash(_) => return, // no changes necessary.
+			NodeHandle::InMemory(h) => h,
+		};
+
 		match self.storage.destroy(handle) {
 			Stored::New(node) => {
 				let root_rlp = node.into_rlp(|child, stream| self.commit_node(child, stream));
@@ -906,21 +906,29 @@ impl<'a> TrieMut for TrieDBMut<'a> {
 			return self.remove(key);
 		}

+		trace!(target: "trie", "insert: key={:?}, value={:?}", key.pretty(), value.pretty());
+
 		let root_handle = self.root_handle();
-		let (new_handle, _) = try!(self.insert_at(root_handle, NibbleSlice::new(key), value.to_owned()));
+		let (new_handle, changed) = try!(self.insert_at(root_handle, NibbleSlice::new(key), value.to_owned()));
+
+		trace!(target: "trie", "insert: altered trie={}", changed);
 		self.root_handle = NodeHandle::InMemory(new_handle);

 		Ok(())
 	}

 	fn remove(&mut self, key: &[u8]) -> super::Result<()> {
+		trace!(target: "trie", "remove: key={:?}", key.pretty());
+
 		let root_handle = self.root_handle();
 		let key = NibbleSlice::new(key);
 		match try!(self.remove_at(root_handle, key)) {
-			Some((handle, _)) => {
+			Some((handle, changed)) => {
+				trace!(target: "trie", "remove: altered trie={}", changed);
 				self.root_handle = NodeHandle::InMemory(handle);
 			}
 			None => {
+				trace!(target: "trie", "remove: obliterated trie");
 				self.root_handle = NodeHandle::Hash(SHA3_NULL_RLP);
 				*self.root = SHA3_NULL_RLP;
 			}
Author	SHA1	Message	Date
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
Arkadiy Paronyan	e298ab30e4	Quick fix for missing tree route blocks (#2400 )	2016-09-29 14:47:13 +02:00
Tomasz Drwięga	63d3a4dd59	Beta Backports (#2396 ) * Removing extras data from retracted blocks. (#2375) * Removing extras data from retracted blocks. * Adding a test case Conflicts: ethcore/src/blockchain/blockchain.rs * Fixing transaction queue Conflicts: ethcore/src/miner/transaction_queue.rs * Prioritizing re-imported transactions (#2372) * Prioritizing re-imported transactions * Fixing compilation on beta Conflicts: Cargo.lock ethcore/src/client/client.rs ethcore/src/miner/transaction_queue.rs * Post-merge fixes	2016-09-29 13:19:53 +02:00
Arkadiy Paronyan	0e55b6c6c9	Cache the fork block header after snapshot restoration (#2391 )	2016-09-29 12:34:40 +02:00
Nikolay Volf	4d115987cb	Accounts bloom (#2357 ) * proper bloom * incremental bloom updates * crate update * return of the column * fix n^2 byteorder write * add notes to funs * working bloom commits * Optimizations * bloom diag * migration basic * migration ongoing * migration finalizing * mingration api workarounds * fix test_client setups * snapshot bloom update * review fixes * just forward keys in the migration * migration extra tracing * fix migration path * remove close pray * review issues	2016-09-29 11:27:41 +02:00
Tomasz Drwięga	2d623f14db	Disable colors for signer token in beta (#2379 )	2016-09-28 23:33:50 +02:00
Robert Habermeier	1d1a3b9d02	correct sync memory usage calculation (#2386 )	2016-09-28 23:00:27 +02:00
Arkadiy Paronyan	1d69b0e124	Fixing jit feature compilation (#2376 ) * Fixing jit feature compilation * Fixing jit feature compilation (#2310) Conflicts: Cargo.lock * Delegatecall support	2016-09-28 17:25:32 +02:00
Arkadiy Paronyan	3c59475be6	Clear state cache on sealed block import (#2377 )	2016-09-28 17:24:47 +02:00
Denis S. Soldatov aka General-Beck	facab31551	Update gitlab-ci add RUST_BACKTRACE=1 in test stage	2016-09-28 01:52:17 +07:00
Arkadiy Paronyan	c9cfcd2728	Canonical state cache (#2308 ) * State cache * Reduced copying data between caches Whitespace and optional symbols * Set a limit on storage cache * Style and docs	2016-09-27 16:44:32 +02:00
Arkadiy Paronyan	557dbb73b8	DIV optimization (#2353 )	2016-09-27 14:04:08 +02:00
Gav Wood	6f772a28e2	Reorder transaction_by_hash to favour canon search (#2331 ) * Reorder transaction_by_hash to favour canon search * Fix test.	2016-09-27 12:16:42 +02:00
Tomasz Drwięga	16f3119547	Lenient bytes deserialization (#2340 ) * Lenient bytes deserialization * Error when deserializing invalid hex * Error when deserializing invalid hex Conflicts: rpc/src/v1/types/bytes.rs	2016-09-27 11:24:27 +02:00
Tomasz Drwięga	c3741640f7	Penalize transactions with gas above gas limit (#2271 ) * Handle RLP to string UTF-8 decoding errors (#2217) * Penalize transactions with gas above gas limit * Avoid penalizing legit transactions * saturating not overflowing * Remove crufty code * Introduce gas price ordering. * Gas before gas-price, as long as the minimum price is met. * saturating add	2016-09-25 12:14:39 +02:00
Denis S. Soldatov aka General-Beck	decca7f698	Update gitlab-ci deploy fix	2016-09-24 05:01:48 +07:00
Denis S. Soldatov aka General-Beck	fc53726c7f	Update gitlab-ci fix armv7 path	2016-09-24 03:00:22 +07:00
Denis S. Soldatov aka General-Beck	e2b81bc08d	Update gitlab-ci [ci skip] rename x86_64-unknown-centos-gnu	2016-09-24 00:11:23 +07:00
Denis S. Soldatov aka General-Beck	4d2d1eac1f	Update gitlab-ci fix path in arm	2016-09-23 23:45:57 +07:00
Denis S. Soldatov aka General-Beck	5572e3dd1d	Update gitlab-ci fix windows deploy to S3 add ubuntu 14.04 build	2016-09-23 23:40:25 +07:00
Tomasz Drwięga	0db1c0d336	Peek transaction queue via RPC (#2270 ) * Handle RLP to string UTF-8 decoding errors (#2217) * pending transactions	2016-09-23 18:13:03 +02:00
Denis S. Soldatov aka General-Beck	905f04dc9d	Update Ubuntu arm Dockerfile [ci skip] remove CC and CXX env backport to beta https://github.com/ethcore/parity/pull/2064	2016-09-23 21:35:04 +07:00
Denis S. Soldatov aka General-Beck	f560cf360c	Update Dockerfile ubuntu-aarch64 [ci skip] remove CC and CXX env backport to beta https://github.com/ethcore/parity/pull/2064	2016-09-23 21:34:16 +07:00
Tomasz Drwięga	f5d48cbf2a	Handle RLP to string UTF-8 decoding errors (#2217 ) (#2226 )	2016-09-22 14:48:54 +02:00
Denis S. Soldatov aka General-Beck	d59e2ecbc6	Update gitlab-ci fix x86_64-pc-windows-msvc	2016-09-21 22:36:54 +07:00
Denis S. Soldatov aka General-Beck	a97ca5aaf4	Update gitlab-ci remove -export	2016-09-21 22:25:51 +07:00
Tomasz Drwięga	df61b1b328	Fixing compilation without ui feature (#2207 )	2016-09-21 11:51:49 +01:00
Tomasz Drwięga	52a69d19e6	Avoid cloning clean stuff (#2173 )	2016-09-20 23:10:26 +08:00
Arkadiy Paronyan	33084aaa07	v1.3.2 (#2200 )	2016-09-20 14:21:17 +08:00
Arkadiy Paronyan	2a82fa0a47	Backports to beta (#2068 ) * Fix several RPCs (#1926) * Fix up pending receipts details. * Add support for additional params and registry over RPC. * Fix tests. * Add test, additional fix. Fixes #1932. * Fix up tests. * Fix test. * Fix test. * DB WAL size limit (#1935) * Limit WAL size * Check pruning by db modification date (#1924) * Cache address hash (#1943) * ECIES without MAC (#1948) * Use random IV for ECIES AES * ECIES encrypt/decrypt for a single message * Derive IV from shared secret * Apply settings to column families * fixed #1933 (#1979) * Fixed neighbours collection (#1996) * dapps-hosts configuration * Disabled counter check * always process trie death row on commit, add more tracing * fixed transaction addresses mapping, fixes #1971 * simplified iterator * v1.3.1 * v1.3.1	2016-09-11 14:04:17 +02:00
Denis S. Soldatov aka General-Beck	1ccc90108c	Update gitlab-ci	2016-09-10 00:59:40 +07:00
Marek Kotewicz	e60c5b59a6	Fixing serde overflow error (#1977 ) (#2030 )	2016-09-01 12:23:05 +02:00
Denis S. Soldatov aka General-Beck	b199fbb6c6	Update gitlab-ci clone from master	2016-08-27 02:59:47 +07:00
Denis S. Soldatov aka General-Beck	d9d506db57	Update gitlab-ci remove CC&CXX env from beta branch	2016-08-19 12:18:37 +07:00