[beta] Backports (#8785 )

* Fix light sync with initial validator-set contract (#8528) * Fix #8468 * Use U256::max_value() instead * Fix again * Also change initial transaction gas * Resumable warp-sync / Seed downloaded snapshots (#8544) * Start dividing sync chain : first supplier method * WIP - updated chain sync supplier * Finish refactoring the Chain Sync Supplier * Create Chain Sync Requester * Add Propagator for Chain Sync * Add the Chain Sync Handler * Move tests from mod -> handler * Move tests to propagator * Refactor SyncRequester arguments * Refactoring peer fork header handler * Fix wrong highest block number in snapshot sync * Small refactor... * Resume warp-sync downloaded chunks * Add comments * Refactoring the previous chunks import * Fix tests * Address PR grumbles * Fix not seeding current snapshot * Address PR Grumbles * Address PR grumble * Retry failed CI job * Update SnapshotService readiness check Fix restoration locking issue for previous chunks restoration * Fix tests * Fix tests * Fix test * Early abort importing previous chunks * PR Grumbles * Update Gitlab CI config * SyncState back to Waiting when Manifest peers disconnect * Move fix * Better fix * Revert GitLab CI changes * Fix Warning * Refactor resuming snapshots * Fix string construction * Revert "Refactor resuming snapshots" This reverts commit 75fd4b553a38e4a49dc5d6a878c70e830ff382eb. * Update informant log * Fix string construction * Refactor resuming snapshots * Fix informant * PR Grumbles * Update informant message : show chunks done * PR Grumbles * Fix * Fix Warning * PR Grumbles * Don't open Browser post-install on Mac (#8641) Since we start parity with the UI disabled per default now, opening the browser post installation will show an annoying error message, confusing the user. This patch removes opening the browser to prevent that annoyance. fixes #8194 * Fix not downloading old blocks (#8642) * Fix PoW blockchains sealing notifications in chain_new_blocks (#8656) * Shutdown the Snapshot Service early (#8658) * Shutdown the Snapshot Service when shutting down the runner * Rename `service` to `client_service` * Fix tests * Fix cli signer (#8682) * Update ethereum-types so `{:#x}` applies 0x prefix * Set the request index to that of the current request (#8683) * Set the request index to that of the current request When setting up the chain of (two) requests to look up a block by hash, the second need to refer to the first. This fixes an issue where the back ref was set to the subsequent request, not the current one. When the requests are executed we loop through them in order and ensure the requests that should produce headers all match up. We do this by index so they better be right. In other words: off by one. * network-devp2p: handle UselessPeer disconnect (#8686) * Fix local transactions policy. (#8691) * CI: Fixes for Android Pipeline (#8745) * ci: Remove check for shared libraries in gitlab script * ci: allow android arm build to fail * Custom Error Messages on ENFILE and EMFILE IO Errors (#8744) * Custom Error Messages on ENFILE and EMFILE IO Errors Add custom mapping of ENFILE and EMFILE IO Errors (Failure because of missing system resource) right when chaining ioError into ::util::Network::Error to improve Error Messages given to user Note: Adds libc as a dependency to util/network * Use assert-matches for more readable tests * Fix Wording and consistency * ethcore-sync: fix connection to peers behind chain fork block (#8710)
parity-version: bump beta to 1.11.2 (#8750 )
2018-06-04 22:29:20 +02:00 · 2018-06-01 14:28:01 +02:00 · 2018-05-15 07:41:30 +02:00 · 2018-05-14 15:53:12 +02:00 · 2018-05-07 20:17:52 +02:00 · 2018-04-26 09:46:06 +02:00
137 changed files with 10655 additions and 4000 deletions
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@ -180,6 +180,23 @@ windows:
    paths:
    - parity.zip
    name: "x86_64-pc-windows-msvc_parity"
+android-armv7:
+  stage: build
+  image: parity/parity-android:latest
+  only:
+    - beta
+    - tags
+    - stable
+    - triggers
+  script:
+    - cargo build --target=armv7-linux-androideabi
+  tags:
+    - rust-arm
+  allow_failure: true
+  artifacts:
+    paths:
+    - parity.zip
+    name: "armv7-linux-androideabi_parity"
 docker-build:
  stage: build
  only:
@ -188,7 +205,7 @@ docker-build:
  before_script:
    - docker info
  script:
-    - if [ "$CI_BUILD_REF_NAME" == "beta-release" ]; then DOCKER_TAG="latest"; else DOCKER_TAG=$CI_BUILD_REF_NAME; fi
+    - if [ "$CI_BUILD_REF_NAME" == "master" ]; then DOCKER_TAG="latest"; else DOCKER_TAG=$CI_BUILD_REF_NAME; fi
    - echo "Tag:" $DOCKER_TAG
    - docker login -u $Docker_Hub_User_Parity -p $Docker_Hub_Pass_Parity
    - scripts/docker-build.sh $DOCKER_TAG
--- a/Cargo.lock
+++ b/Cargo.lock
@ -35,6 +35,11 @@ dependencies = [
 "nodrop 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
 ]

+[[package]]
+name = "assert_matches"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
 [[package]]
 name = "aster"
 version = "0.41.0"
@ -70,7 +75,7 @@ name = "backtrace-sys"
 version = "0.1.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
- "cc 1.0.9 (registry+https://github.com/rust-lang/crates.io-index)",
+ "cc 1.0.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.36 (registry+https://github.com/rust-lang/crates.io-index)",
 ]

@ -104,12 +109,11 @@ dependencies = [

 [[package]]
 name = "bigint"
-version = "4.2.0"
+version = "4.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
 "byteorder 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "crunchy 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
- "rustc_version 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
 ]

 [[package]]
@ -194,7 +198,7 @@ dependencies = [

 [[package]]
 name = "cc"
-version = "1.0.9"
+version = "1.0.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
 "rayon 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
@ -243,7 +247,7 @@ name = "common-types"
 version = "0.1.0"
 dependencies = [
 "ethcore-bytes 0.1.0",
- "ethereum-types 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "ethereum-types 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "ethjson 0.1.0",
 "heapsize 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "keccak-hash 0.1.0",
@ -380,7 +384,7 @@ name = "dir"
 version = "0.1.0"
 dependencies = [
 "app_dirs 1.2.1 (git+https://github.com/paritytech/app-dirs-rs)",
- "ethereum-types 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "ethereum-types 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "journaldb 0.1.0",
 ]

@ -442,7 +446,7 @@ version = "0.5.7"
 source = "git+https://github.com/paritytech/rust-secp256k1#db81cfea59014b4d176f10f86ed52e1a130b6822"
 dependencies = [
 "arrayvec 0.4.7 (registry+https://github.com/rust-lang/crates.io-index)",
- "cc 1.0.9 (registry+https://github.com/rust-lang/crates.io-index)",
+ "cc 1.0.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
 ]

@ -452,12 +456,12 @@ version = "5.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
 "error-chain 0.11.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "ethereum-types 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "ethereum-types 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc-hex 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.37 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_derive 1.0.37 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_json 1.0.9 (registry+https://github.com/rust-lang/crates.io-index)",
- "tiny-keccak 1.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "tiny-keccak 1.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
 ]

 [[package]]
@ -499,7 +503,7 @@ dependencies = [
 "ethereum-types-serialize 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "fixed-hash 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.37 (registry+https://github.com/rust-lang/crates.io-index)",
- "tiny-keccak 1.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "tiny-keccak 1.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
 ]

 [[package]]
@ -524,7 +528,7 @@ dependencies = [
 "ethcore-miner 1.11.0",
 "ethcore-stratum 1.11.0",
 "ethcore-transaction 0.1.0",
- "ethereum-types 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "ethereum-types 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "ethjson 0.1.0",
 "ethkey 0.3.0",
 "ethstore 0.2.0",
@ -546,7 +550,7 @@ dependencies = [
 "memory-cache 0.1.0",
 "memorydb 0.1.1",
 "num 0.1.42 (registry+https://github.com/rust-lang/crates.io-index)",
- "num_cpus 1.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "num_cpus 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "parity-machine 0.1.0",
 "parking_lot 0.5.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "patricia-trie 0.1.0",
@ -587,11 +591,11 @@ name = "ethcore-crypto"
 version = "0.1.0"
 dependencies = [
 "eth-secp256k1 0.5.7 (git+https://github.com/paritytech/rust-secp256k1)",
- "ethereum-types 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "ethereum-types 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "ethkey 0.3.0",
 "rust-crypto 0.2.36 (registry+https://github.com/rust-lang/crates.io-index)",
 "subtle 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)",
- "tiny-keccak 1.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "tiny-keccak 1.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
 ]

 [[package]]
@ -620,7 +624,7 @@ dependencies = [
 "ethcore-io 1.11.0",
 "ethcore-network 1.11.0",
 "ethcore-transaction 0.1.0",
- "ethereum-types 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "ethereum-types 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.21 (registry+https://github.com/rust-lang/crates.io-index)",
 "hashdb 0.1.1",
 "heapsize 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
@ -670,7 +674,7 @@ dependencies = [
 "error-chain 0.11.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "ethash 1.11.0",
 "ethcore-transaction 0.1.0",
- "ethereum-types 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "ethereum-types 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "ethkey 0.3.0",
 "fetch 0.1.0",
 "futures 0.1.21 (registry+https://github.com/rust-lang/crates.io-index)",
@ -684,6 +688,7 @@ dependencies = [
 "parking_lot 0.5.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "price-info 1.11.0",
 "rayon 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rlp 0.2.1",
 "rustc-hex 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "trace-time 0.1.0",
 "transaction-pool 1.11.0",
@ -694,12 +699,14 @@ dependencies = [
 name = "ethcore-network"
 version = "1.11.0"
 dependencies = [
+ "assert_matches 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "error-chain 0.11.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "ethcore-crypto 0.1.0",
 "ethcore-io 1.11.0",
- "ethereum-types 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "ethereum-types 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "ethkey 0.3.0",
 "ipnetwork 0.12.7 (registry+https://github.com/rust-lang/crates.io-index)",
+ "libc 0.2.36 (registry+https://github.com/rust-lang/crates.io-index)",
 "rlp 0.2.1",
 "snappy 0.1.0 (git+https://github.com/paritytech/rust-snappy)",
 ]
@ -709,6 +716,7 @@ name = "ethcore-network-devp2p"
 version = "1.11.0"
 dependencies = [
 "ansi_term 0.10.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "assert_matches 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "error-chain 0.11.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "ethcore-bytes 0.1.0",
@ -716,7 +724,7 @@ dependencies = [
 "ethcore-io 1.11.0",
 "ethcore-logger 1.11.0",
 "ethcore-network 1.11.0",
- "ethereum-types 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "ethereum-types 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "ethkey 0.3.0",
 "igd 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "ipnetwork 0.12.7 (registry+https://github.com/rust-lang/crates.io-index)",
@ -736,7 +744,7 @@ dependencies = [
 "slab 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "snappy 0.1.0 (git+https://github.com/paritytech/rust-snappy)",
 "tempdir 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
- "tiny-keccak 1.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "tiny-keccak 1.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
 ]

 [[package]]
@ -754,7 +762,7 @@ dependencies = [
 "ethcore-logger 1.11.0",
 "ethcore-miner 1.11.0",
 "ethcore-transaction 0.1.0",
- "ethereum-types 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "ethereum-types 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "ethjson 0.1.0",
 "ethkey 0.3.0",
 "fetch 0.1.0",
@ -770,7 +778,7 @@ dependencies = [
 "serde 1.0.37 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_derive 1.0.37 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_json 1.0.9 (registry+https://github.com/rust-lang/crates.io-index)",
- "tiny-keccak 1.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "tiny-keccak 1.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "url 1.5.1 (registry+https://github.com/rust-lang/crates.io-index)",
 ]

@ -788,7 +796,7 @@ dependencies = [
 "ethcore-logger 1.11.0",
 "ethcore-sync 1.11.0",
 "ethcore-transaction 0.1.0",
- "ethereum-types 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "ethereum-types 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "ethkey 0.3.0",
 "futures 0.1.21 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures-cpupool 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
@ -804,7 +812,7 @@ dependencies = [
 "serde_derive 1.0.37 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_json 1.0.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "tempdir 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
- "tiny-keccak 1.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "tiny-keccak 1.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-core 0.1.17 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
@ -828,6 +836,7 @@ dependencies = [
 "log 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "stop-guard 0.1.0",
 "tempdir 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
+ "trace-time 0.1.0",
 ]

 [[package]]
@ -836,7 +845,7 @@ version = "1.11.0"
 dependencies = [
 "env_logger 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "ethcore-logger 1.11.0",
- "ethereum-types 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "ethereum-types 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "jsonrpc-core 8.0.1 (git+https://github.com/paritytech/jsonrpc.git?branch=parity-1.11)",
 "jsonrpc-macros 8.0.0 (git+https://github.com/paritytech/jsonrpc.git?branch=parity-1.11)",
 "jsonrpc-tcp-server 8.0.0 (git+https://github.com/paritytech/jsonrpc.git?branch=parity-1.11)",
@ -860,7 +869,7 @@ dependencies = [
 "ethcore-network-devp2p 1.11.0",
 "ethcore-private-tx 1.0.0",
 "ethcore-transaction 0.1.0",
- "ethereum-types 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "ethereum-types 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "ethkey 0.3.0",
 "heapsize 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "ipnetwork 0.12.7 (registry+https://github.com/rust-lang/crates.io-index)",
@ -876,6 +885,7 @@ dependencies = [
 "rustc-hex 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "semver 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)",
+ "trace-time 0.1.0",
 "triehash 0.1.0",
 ]

@ -883,7 +893,7 @@ dependencies = [
 name = "ethcore-transaction"
 version = "0.1.0"
 dependencies = [
- "ethereum-types 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "ethereum-types 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "ethjson 0.1.0",
 "ethkey 0.3.0",
 "evm 0.1.0",
@ -896,7 +906,7 @@ dependencies = [

 [[package]]
 name = "ethereum-types"
-version = "0.3.1"
+version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
 "crunchy 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
@ -905,7 +915,7 @@ dependencies = [
 "fixed-hash 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc_version 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.37 (registry+https://github.com/rust-lang/crates.io-index)",
- "uint 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "uint 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
 ]

 [[package]]
@ -920,7 +930,7 @@ dependencies = [
 name = "ethjson"
 version = "0.1.0"
 dependencies = [
- "ethereum-types 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "ethereum-types 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc-hex 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.37 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_derive 1.0.37 (registry+https://github.com/rust-lang/crates.io-index)",
@ -934,7 +944,7 @@ dependencies = [
 "byteorder 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "edit-distance 2.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "eth-secp256k1 0.5.7 (git+https://github.com/paritytech/rust-secp256k1)",
- "ethereum-types 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "ethereum-types 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "mem 0.1.0",
@ -942,7 +952,7 @@ dependencies = [
 "rand 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-hex 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "tiny-keccak 1.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "tiny-keccak 1.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
 ]

 [[package]]
@ -966,7 +976,7 @@ version = "0.2.0"
 dependencies = [
 "dir 0.1.0",
 "ethcore-crypto 0.1.0",
- "ethereum-types 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "ethereum-types 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "ethkey 0.3.0",
 "itertools 0.5.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.36 (registry+https://github.com/rust-lang/crates.io-index)",
@ -984,7 +994,7 @@ dependencies = [
 "subtle 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "tempdir 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "time 0.1.38 (registry+https://github.com/rust-lang/crates.io-index)",
- "tiny-keccak 1.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "tiny-keccak 1.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
 ]

 [[package]]
@ -994,7 +1004,7 @@ dependencies = [
 "dir 0.1.0",
 "docopt 0.8.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "ethstore 0.2.0",
- "num_cpus 1.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "num_cpus 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "panic_hook 0.1.0",
 "parking_lot 0.5.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc-hex 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
@ -1008,7 +1018,7 @@ name = "evm"
 version = "0.1.0"
 dependencies = [
 "bit-set 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "ethereum-types 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "ethereum-types 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "heapsize 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "keccak-hash 0.1.0",
 "lazy_static 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
@ -1027,7 +1037,7 @@ dependencies = [
 "ethcore 1.11.0",
 "ethcore-bytes 0.1.0",
 "ethcore-transaction 0.1.0",
- "ethereum-types 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "ethereum-types 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "ethjson 0.1.0",
 "evm 0.1.0",
 "panic_hook 0.1.0",
@ -1120,7 +1130,7 @@ version = "0.1.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
 "futures 0.1.21 (registry+https://github.com/rust-lang/crates.io-index)",
- "num_cpus 1.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "num_cpus 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 ]

 [[package]]
@ -1167,7 +1177,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 name = "hardware-wallet"
 version = "1.11.0"
 dependencies = [
- "ethereum-types 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "ethereum-types 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "ethkey 0.3.0",
 "hidapi 0.3.1 (git+https://github.com/paritytech/hidapi-rs)",
 "libusb 0.3.0 (git+https://github.com/paritytech/libusb-rs)",
@ -1183,7 +1193,7 @@ name = "hashdb"
 version = "0.1.1"
 dependencies = [
 "elastic-array 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "ethereum-types 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "ethereum-types 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
 ]

 [[package]]
@ -1212,7 +1222,7 @@ name = "hidapi"
 version = "0.3.1"
 source = "git+https://github.com/paritytech/hidapi-rs#70ec4bd1b755ec5dd32ad2be0c8345864147c8bc"
 dependencies = [
- "cc 1.0.9 (registry+https://github.com/rust-lang/crates.io-index)",
+ "cc 1.0.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.36 (registry+https://github.com/rust-lang/crates.io-index)",
 ]

@ -1331,7 +1341,7 @@ version = "0.1.0"
 dependencies = [
 "ethcore-bytes 0.1.0",
 "ethcore-logger 1.11.0",
- "ethereum-types 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "ethereum-types 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "hashdb 0.1.1",
 "heapsize 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "keccak-hash 0.1.0",
@ -1445,10 +1455,10 @@ dependencies = [
 name = "keccak-hash"
 version = "0.1.0"
 dependencies = [
- "cc 1.0.9 (registry+https://github.com/rust-lang/crates.io-index)",
- "ethereum-types 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "cc 1.0.10 (registry+https://github.com/rust-lang/crates.io-index)",
+ "ethereum-types 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "tempdir 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
- "tiny-keccak 1.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "tiny-keccak 1.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
 ]

 [[package]]
@ -1482,11 +1492,11 @@ name = "kvdb-rocksdb"
 version = "0.1.0"
 dependencies = [
 "elastic-array 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "ethereum-types 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "ethereum-types 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "interleaved-ordered 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "kvdb 0.1.0",
 "log 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
- "num_cpus 1.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "num_cpus 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "parking_lot 0.5.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "regex 0.2.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "rocksdb 0.4.5 (git+https://github.com/paritytech/rust-rocksdb)",
@ -1533,7 +1543,7 @@ name = "libusb-sys"
 version = "0.2.4"
 source = "git+https://github.com/paritytech/libusb-sys#14bdb698003731b6344a79e1d814704e44363e7c"
 dependencies = [
- "cc 1.0.9 (registry+https://github.com/rust-lang/crates.io-index)",
+ "cc 1.0.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.36 (registry+https://github.com/rust-lang/crates.io-index)",
 ]

@ -1633,9 +1643,9 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 name = "memorydb"
 version = "0.1.1"
 dependencies = [
- "bigint 4.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "bigint 4.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "elastic-array 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "ethereum-types 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "ethereum-types 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "hashdb 0.1.1",
 "heapsize 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "keccak-hash 0.1.0",
@ -1688,7 +1698,7 @@ name = "miniz_oxide_c_api"
 version = "0.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
- "cc 1.0.9 (registry+https://github.com/rust-lang/crates.io-index)",
+ "cc 1.0.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "crc 1.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.36 (registry+https://github.com/rust-lang/crates.io-index)",
 "miniz_oxide 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
@ -1767,9 +1777,14 @@ version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
 "ring 0.12.1 (git+https://github.com/paritytech/ring)",
- "tiny-keccak 1.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "tiny-keccak 1.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
 ]

+[[package]]
+name = "nan-preserving-float"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
 [[package]]
 name = "net2"
 version = "0.2.31"
@ -1792,7 +1807,7 @@ dependencies = [
 "ethcore 1.11.0",
 "ethcore-io 1.11.0",
 "ethcore-network-devp2p 1.11.0",
- "ethereum-types 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "ethereum-types 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "kvdb-memorydb 0.1.0",
 "log 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "lru-cache 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
@ -1851,7 +1866,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
 "num-integer 0.1.36 (registry+https://github.com/rust-lang/crates.io-index)",
 "num-traits 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
- "rand 0.3.20 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rand 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc-serialize 0.3.24 (registry+https://github.com/rust-lang/crates.io-index)",
 ]

@ -1887,7 +1902,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"

 [[package]]
 name = "num_cpus"
-version = "1.7.0"
+version = "1.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
 "libc 0.2.36 (registry+https://github.com/rust-lang/crates.io-index)",
@ -1941,7 +1956,7 @@ dependencies = [

 [[package]]
 name = "parity"
-version = "1.11.0"
+version = "1.11.2"
 dependencies = [
 "ansi_term 0.10.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "atty 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
@ -1964,7 +1979,7 @@ dependencies = [
 "ethcore-stratum 1.11.0",
 "ethcore-sync 1.11.0",
 "ethcore-transaction 0.1.0",
- "ethereum-types 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "ethereum-types 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "ethkey 0.3.0",
 "fake-fetch 0.0.1",
 "fdlimit 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
@ -1981,7 +1996,7 @@ dependencies = [
 "migration-rocksdb 0.1.0",
 "node-filter 1.11.0",
 "node-health 0.1.0",
- "num_cpus 1.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "num_cpus 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "number_prefix 0.2.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "panic_hook 0.1.0",
 "parity-dapps 1.11.0",
@ -1992,7 +2007,7 @@ dependencies = [
 "parity-rpc 1.11.0",
 "parity-rpc-client 1.4.0",
 "parity-updater 1.11.0",
- "parity-version 1.11.0",
+ "parity-version 1.11.2",
 "parity-whisper 0.1.0",
 "parking_lot 0.5.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "path 0.1.0",
@ -2023,7 +2038,7 @@ dependencies = [
 "env_logger 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "ethcore-bytes 0.1.0",
 "ethcore-devtools 1.11.0",
- "ethereum-types 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "ethereum-types 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "fetch 0.1.0",
 "futures 0.1.21 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures-cpupool 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
@ -2040,7 +2055,7 @@ dependencies = [
 "parity-reactor 0.1.0",
 "parity-ui 1.11.0",
 "parity-ui-deprecation 1.10.0",
- "parity-version 1.11.0",
+ "parity-version 1.11.2",
 "parking_lot 0.5.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "registrar 0.0.1",
@ -2088,7 +2103,7 @@ dependencies = [
 "ethabi-contract 5.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "ethabi-derive 5.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "ethcore-bytes 0.1.0",
- "ethereum-types 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "ethereum-types 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "fake-fetch 0.0.1",
 "fetch 0.1.0",
 "futures 0.1.21 (registry+https://github.com/rust-lang/crates.io-index)",
@ -2112,7 +2127,7 @@ dependencies = [
 "cid 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "ethcore 1.11.0",
 "ethcore-bytes 0.1.0",
- "ethereum-types 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "ethereum-types 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "jsonrpc-core 8.0.1 (git+https://github.com/paritytech/jsonrpc.git?branch=parity-1.11)",
 "jsonrpc-http-server 8.0.0 (git+https://github.com/paritytech/jsonrpc.git?branch=parity-1.11)",
 "multihash 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
@ -2141,7 +2156,7 @@ dependencies = [
 name = "parity-machine"
 version = "0.1.0"
 dependencies = [
- "ethereum-types 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "ethereum-types 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
 ]

 [[package]]
@ -2171,7 +2186,7 @@ dependencies = [
 "ethcore-private-tx 1.0.0",
 "ethcore-sync 1.11.0",
 "ethcore-transaction 0.1.0",
- "ethereum-types 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "ethereum-types 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "ethjson 0.1.0",
 "ethkey 0.3.0",
 "ethstore 0.2.0",
@ -2196,7 +2211,7 @@ dependencies = [
 "order-stat 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "parity-reactor 0.1.0",
 "parity-updater 1.11.0",
- "parity-version 1.11.0",
+ "parity-version 1.11.2",
 "parking_lot 0.5.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "patricia-trie 0.1.0",
 "pretty_assertions 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
@ -2210,7 +2225,7 @@ dependencies = [
 "serde_json 1.0.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "stats 0.1.0",
 "tempdir 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
- "tiny-keccak 1.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "tiny-keccak 1.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-timer 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "transaction-pool 1.11.0",
 "transient-hashmap 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
@ -2311,13 +2326,13 @@ dependencies = [
 "ethcore 1.11.0",
 "ethcore-bytes 0.1.0",
 "ethcore-sync 1.11.0",
- "ethereum-types 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "ethereum-types 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "keccak-hash 0.1.0",
 "lazy_static 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "matches 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "parity-hash-fetch 1.11.0",
- "parity-version 1.11.0",
+ "parity-version 1.11.2",
 "parking_lot 0.5.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "path 0.1.0",
 "rand 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
@ -2328,7 +2343,7 @@ dependencies = [

 [[package]]
 name = "parity-version"
-version = "1.11.0"
+version = "1.11.2"
 dependencies = [
 "ethcore-bytes 0.1.0",
 "rlp 0.2.1",
@ -2356,7 +2371,7 @@ dependencies = [
 "byteorder 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "ethcore-crypto 0.1.0",
 "ethcore-network 1.11.0",
- "ethereum-types 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "ethereum-types 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "ethkey 0.3.0",
 "hex 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "jsonrpc-core 8.0.1 (git+https://github.com/paritytech/jsonrpc.git?branch=parity-1.11)",
@ -2374,7 +2389,7 @@ dependencies = [
 "serde_json 1.0.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "slab 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)",
- "tiny-keccak 1.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "tiny-keccak 1.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
 ]

 [[package]]
@ -2419,7 +2434,7 @@ dependencies = [
 "elastic-array 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "ethcore-bytes 0.1.0",
 "ethcore-logger 1.11.0",
- "ethereum-types 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "ethereum-types 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "hashdb 0.1.1",
 "keccak-hash 0.1.0",
 "log 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
@ -2475,7 +2490,7 @@ name = "plain_hasher"
 version = "0.1.0"
 dependencies = [
 "crunchy 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
- "ethereum-types 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "ethereum-types 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
 ]

 [[package]]
@ -2574,7 +2589,7 @@ version = "0.1.0"
 dependencies = [
 "clap 2.29.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "ethcore-logger 1.11.0",
- "ethereum-types 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "ethereum-types 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "ethjson 0.1.0",
 "rustc-hex 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.37 (registry+https://github.com/rust-lang/crates.io-index)",
@ -2586,7 +2601,7 @@ dependencies = [

 [[package]]
 name = "pwasm-utils"
-version = "0.1.3"
+version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
 "byteorder 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
@ -2670,7 +2685,7 @@ dependencies = [
 "crossbeam-deque 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.36 (registry+https://github.com/rust-lang/crates.io-index)",
- "num_cpus 1.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "num_cpus 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
 ]

@ -2728,7 +2743,7 @@ name = "ring"
 version = "0.12.1"
 source = "git+https://github.com/paritytech/ring#b98d7f586c0467d68e9946a5f47b4a04b9a86b4a"
 dependencies = [
- "cc 1.0.9 (registry+https://github.com/rust-lang/crates.io-index)",
+ "cc 1.0.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.36 (registry+https://github.com/rust-lang/crates.io-index)",
 "rayon 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
@ -2742,7 +2757,7 @@ version = "0.2.1"
 dependencies = [
 "byteorder 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "elastic-array 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "ethereum-types 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "ethereum-types 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc-hex 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
 ]

@ -2779,7 +2794,7 @@ name = "rocksdb-sys"
 version = "0.3.0"
 source = "git+https://github.com/paritytech/rust-rocksdb#ecf06adf3148ab10f6f7686b724498382ff4f36e"
 dependencies = [
- "cc 1.0.9 (registry+https://github.com/rust-lang/crates.io-index)",
+ "cc 1.0.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.36 (registry+https://github.com/rust-lang/crates.io-index)",
 "local-encoding 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "snappy-sys 0.1.0 (git+https://github.com/paritytech/rust-snappy)",
@ -2800,7 +2815,7 @@ dependencies = [
 name = "rpc-cli"
 version = "1.4.0"
 dependencies = [
- "bigint 4.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "bigint 4.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.21 (registry+https://github.com/rust-lang/crates.io-index)",
 "parity-rpc 1.11.0",
 "parity-rpc-client 1.4.0",
@ -2951,7 +2966,7 @@ name = "shell32-sys"
 version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
- "winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
+ "winapi 0.3.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi-build 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 ]

@ -3016,7 +3031,7 @@ name = "snappy-sys"
 version = "0.1.0"
 source = "git+https://github.com/paritytech/rust-snappy#40ac9a0d9fd613e7f38df800a11a589b7296da73"
 dependencies = [
- "cc 1.0.9 (registry+https://github.com/rust-lang/crates.io-index)",
+ "cc 1.0.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.36 (registry+https://github.com/rust-lang/crates.io-index)",
 ]

@ -3179,7 +3194,7 @@ name = "threadpool"
 version = "1.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
- "num_cpus 1.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "num_cpus 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 ]

 [[package]]
@ -3195,7 +3210,7 @@ dependencies = [

 [[package]]
 name = "tiny-keccak"
-version = "1.4.1"
+version = "1.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
 "crunchy 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
@ -3346,7 +3361,7 @@ dependencies = [
 "crossbeam-deque 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.21 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
- "num_cpus 1.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "num_cpus 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
@ -3418,7 +3433,7 @@ name = "transaction-pool"
 version = "1.11.0"
 dependencies = [
 "error-chain 0.11.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "ethereum-types 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "ethereum-types 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "trace-time 0.1.0",
@ -3445,7 +3460,7 @@ name = "trie-standardmap"
 version = "0.1.0"
 dependencies = [
 "ethcore-bytes 0.1.0",
- "ethereum-types 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "ethereum-types 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "keccak-hash 0.1.0",
 "rlp 0.2.1",
 ]
@ -3455,7 +3470,7 @@ name = "triehash"
 version = "0.1.0"
 dependencies = [
 "elastic-array 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "ethereum-types 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "ethereum-types 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "keccak-hash 0.1.0",
 "rlp 0.2.1",
 "trie-standardmap 0.1.0",
@ -3463,7 +3478,7 @@ dependencies = [

 [[package]]
 name = "uint"
-version = "0.2.0"
+version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
 "byteorder 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
@ -3570,7 +3585,7 @@ name = "util-error"
 version = "0.1.0"
 dependencies = [
 "error-chain 0.11.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "ethereum-types 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "ethereum-types 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "kvdb 0.1.0",
 "rlp 0.2.1",
 "rustc-hex 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
@ -3602,7 +3617,7 @@ dependencies = [
 "byteorder 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "common-types 0.1.0",
 "ethcore-bytes 0.1.0",
- "ethereum-types 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "ethereum-types 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "ethjson 0.1.0",
 "keccak-hash 0.1.0",
 "log 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
@ -3621,22 +3636,23 @@ version = "0.1.0"
 dependencies = [
 "byteorder 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "ethcore-logger 1.11.0",
- "ethereum-types 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "ethereum-types 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.36 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "parity-wasm 0.27.5 (registry+https://github.com/rust-lang/crates.io-index)",
- "pwasm-utils 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
+ "pwasm-utils 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "vm 0.1.0",
- "wasmi 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
+ "wasmi 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 ]

 [[package]]
 name = "wasmi"
-version = "0.1.3"
+version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
 "byteorder 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "memory_units 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "nan-preserving-float 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "parity-wasm 0.27.5 (registry+https://github.com/rust-lang/crates.io-index)",
 ]

@ -3768,6 +3784,7 @@ dependencies = [
 "checksum ansi_term 0.10.2 (registry+https://github.com/rust-lang/crates.io-index)" = "6b3568b48b7cefa6b8ce125f9bb4989e52fbcc29ebea88df04cc7c5f12f70455"
 "checksum app_dirs 1.2.1 (git+https://github.com/paritytech/app-dirs-rs)" = "<none>"
 "checksum arrayvec 0.4.7 (registry+https://github.com/rust-lang/crates.io-index)" = "a1e964f9e24d588183fcb43503abda40d288c8657dfc27311516ce2f05675aef"
+"checksum assert_matches 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "664470abf00fae0f31c0eb6e1ca12d82961b2a2541ef898bc9dd51a9254d218b"
 "checksum aster 0.41.0 (registry+https://github.com/rust-lang/crates.io-index)" = "4ccfdf7355d9db158df68f976ed030ab0f6578af811f5a7bb6dcf221ec24e0e0"
 "checksum atty 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)" = "af80143d6f7608d746df1520709e5d141c96f240b0e62b0aa41bdfb53374d9d4"
 "checksum backtrace 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)" = "ebbbf59b1c43eefa8c3ede390fcc36820b4999f7914104015be25025e0d62af2"
@ -3776,7 +3793,7 @@ dependencies = [
 "checksum base32 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "1b9605ba46d61df0410d8ac686b0007add8172eba90e8e909c347856fe794d8c"
 "checksum base64 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)" = "96434f987501f0ed4eb336a411e0631ecd1afa11574fe148587adc4ff96143c9"
 "checksum base64 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)" = "229d032f1a99302697f10b27167ae6d03d49d032e6a8e2550e8d3fc13356d2b4"
-"checksum bigint 4.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "5442186ef6560f30f1ee4b9c1e4c87a35a6879d3644550cc248ec2b955eb5fcd"
+"checksum bigint 4.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "b4a6d961f23ce43ce7391b994c78174691e41274a5c48a1cda69caf04af173e1"
 "checksum bincode 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "e103c8b299b28a9c6990458b7013dc4a8356a9b854c51b9883241f5866fac36e"
 "checksum bit-set 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "d9bf6104718e80d7b26a68fdbacff3481cfc05df670821affc7e9cbc1884400c"
 "checksum bit-vec 0.4.4 (registry+https://github.com/rust-lang/crates.io-index)" = "02b4ff8b16e6076c3e14220b39fbc1fabb6737522281a388998046859400895f"
@ -3788,7 +3805,7 @@ dependencies = [
 "checksum build_const 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "39092a32794787acd8525ee150305ff051b0aa6cc2abaf193924f5ab05425f39"
 "checksum byteorder 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "652805b7e73fada9d85e9a6682a4abd490cb52d96aeecc12e33a0de34dfd0d23"
 "checksum bytes 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)" = "1b7db437d718977f6dc9b2e3fd6fc343c02ac6b899b73fdd2179163447bd9ce9"
-"checksum cc 1.0.9 (registry+https://github.com/rust-lang/crates.io-index)" = "2b4911e4bdcb4100c7680e7e854ff38e23f1b34d4d9e079efae3da2801341ffc"
+"checksum cc 1.0.10 (registry+https://github.com/rust-lang/crates.io-index)" = "8b9d2900f78631a5876dc5d6c9033ede027253efcd33dd36b1309fc6cab97ee0"
 "checksum cfg-if 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "d4c819a1287eb618df47cc647173c5c4c66ba19d888a6e50d605672aed3140de"
 "checksum cid 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)" = "d85ee025368e69063c420cbb2ed9f852cb03a5e69b73be021e65726ce03585b6"
 "checksum clap 2.29.1 (registry+https://github.com/rust-lang/crates.io-index)" = "8f4a2b3bb7ef3c672d7c13d15613211d5a6976b6892c598b0fcb5d40765f19c2"
@ -3819,7 +3836,7 @@ dependencies = [
 "checksum ethabi-contract 5.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "210c9e21d164c15b6ef64fe601e0e12a3c84a031d5ef558e38463e53edbd22ed"
 "checksum ethabi-derive 5.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "d2bc7099baa147187aedaecd9fe04a6c0541c82bc43ff317cb6900fe2b983d74"
 "checksum ethbloom 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)" = "1a93a43ce2e9f09071449da36bfa7a1b20b950ee344b6904ff23de493b03b386"
-"checksum ethereum-types 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "3a3ae691a36ce5d25b433e63128ce5579f4a18457b6a9c849832b2c9e0fec92a"
+"checksum ethereum-types 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)" = "9c48729b8aea8aedb12cf4cb2e5cef439fdfe2dda4a89e47eeebd15778ef53b6"
 "checksum ethereum-types-serialize 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "4ac59a21a9ce98e188f3dace9eb67a6c4a3c67ec7fbc7218cb827852679dc002"
 "checksum fdlimit 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "b1ee15a7050e5580b3712877157068ea713b245b080ff302ae2ca973cfcd9baa"
 "checksum fixed-hash 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "b18d6fd718fb4396e7a9c93ac59ba7143501467ca7a143c145b5555a571d5576"
@ -3888,6 +3905,7 @@ dependencies = [
 "checksum msdos_time 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)" = "aad9dfe950c057b1bfe9c1f2aa51583a8468ef2a5baba2ebbe06d775efeb7729"
 "checksum multibase 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)" = "b9c35dac080fd6e16a99924c8dfdef0af89d797dd851adab25feaffacf7850d6"
 "checksum multihash 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "7d49add5f49eb08bfc4d01ff286b84a48f53d45314f165c2d6efe477222d24f3"
+"checksum nan-preserving-float 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "34d4f00fcc2f4c9efa8cc971db0da9e28290e28e97af47585e48691ef10ff31f"
 "checksum net2 0.2.31 (registry+https://github.com/rust-lang/crates.io-index)" = "3a80f842784ef6c9a958b68b7516bc7e35883c614004dd94959a4dca1b716c09"
 "checksum nodrop 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)" = "9a2228dca57108069a5262f2ed8bd2e82496d2e074a06d1ccc7ce1687b6ae0a2"
 "checksum ntp 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "143149743832c6543b60a8ef2a26cd9122dfecec2b767158e852a7beecf6d7a0"
@ -3897,7 +3915,7 @@ dependencies = [
 "checksum num-iter 0.1.35 (registry+https://github.com/rust-lang/crates.io-index)" = "4b226df12c5a59b63569dd57fafb926d91b385dfce33d8074a412411b689d593"
 "checksum num-traits 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)" = "92e5113e9fd4cc14ded8e499429f396a20f98c772a47cc8622a736e1ec843c31"
 "checksum num-traits 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "dee092fcdf725aee04dd7da1d21debff559237d49ef1cb3e69bcb8ece44c7364"
-"checksum num_cpus 1.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "514f0d73e64be53ff320680ca671b64fe3fb91da01e1ae2ddc99eb51d453b20d"
+"checksum num_cpus 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "c51a3322e4bca9d212ad9a158a02abc6934d005490c054a2778df73a70aa0a30"
 "checksum number_prefix 0.2.7 (registry+https://github.com/rust-lang/crates.io-index)" = "59a14be9c211cb9c602bad35ac99f41e9a84b44d71b8cbd3040e3bd02a214902"
 "checksum ole32-sys 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "5d2c49021782e5233cd243168edfa8037574afed4eba4bbaf538b3d8d1789d8c"
 "checksum order-stat 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "efa535d5117d3661134dbf1719b6f0ffe06f2375843b13935db186cd094105eb"
@ -3928,7 +3946,7 @@ dependencies = [
 "checksum proc-macro2 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "388d7ea47318c5ccdeb9ba6312cee7d3f65dd2804be8580a170fce410d50b786"
 "checksum protobuf 1.5.1 (registry+https://github.com/rust-lang/crates.io-index)" = "40e2484e639dcae0985fc483ad76ce7ad78ee5aa092751d7d538f0b20d76486b"
 "checksum pulldown-cmark 0.0.3 (registry+https://github.com/rust-lang/crates.io-index)" = "8361e81576d2e02643b04950e487ec172b687180da65c731c03cf336784e6c07"
-"checksum pwasm-utils 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "54d440c3b56eee028aa5d4f18cbed8c6e0c9ae23563b93f344beb7e73854ea02"
+"checksum pwasm-utils 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "d51e9954a77aab7b4b606dc315a49cbed187924f163b6750cdf6d5677dbf0839"
 "checksum quasi 0.32.0 (registry+https://github.com/rust-lang/crates.io-index)" = "18c45c4854d6d1cf5d531db97c75880feb91c958b0720f4ec1057135fec358b3"
 "checksum quasi_codegen 0.32.0 (registry+https://github.com/rust-lang/crates.io-index)" = "51b9e25fa23c044c1803f43ca59c98dac608976dd04ce799411edd58ece776d4"
 "checksum quasi_macros 0.32.0 (registry+https://github.com/rust-lang/crates.io-index)" = "29cec87bc2816766d7e4168302d505dd06b0a825aed41b00633d296e922e02dd"
@ -3995,7 +4013,7 @@ dependencies = [
 "checksum thread_local 0.3.4 (registry+https://github.com/rust-lang/crates.io-index)" = "1697c4b57aeeb7a536b647165a2825faddffb1d3bad386d507709bd51a90bb14"
 "checksum threadpool 1.7.1 (registry+https://github.com/rust-lang/crates.io-index)" = "e2f0c90a5f3459330ac8bc0d2f879c693bb7a2f59689c1083fc4ef83834da865"
 "checksum time 0.1.38 (registry+https://github.com/rust-lang/crates.io-index)" = "d5d788d3aa77bc0ef3e9621256885555368b47bd495c13dd2e7413c89f845520"
-"checksum tiny-keccak 1.4.1 (registry+https://github.com/rust-lang/crates.io-index)" = "58911ed5eb275a8fd2f1f0418ed360a42f59329864b64e1e95377a9024498c01"
+"checksum tiny-keccak 1.4.2 (registry+https://github.com/rust-lang/crates.io-index)" = "e9175261fbdb60781fcd388a4d6cc7e14764a2b629a7ad94abb439aed223a44f"
 "checksum tokio 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "be15ef40f675c9fe66e354d74c73f3ed012ca1aa14d65846a33ee48f1ae8d922"
 "checksum tokio-core 0.1.17 (registry+https://github.com/rust-lang/crates.io-index)" = "aeeffbbb94209023feaef3c196a41cbcdafa06b4a6f893f68779bb5e53796f71"
 "checksum tokio-executor 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "8cac2a7883ff3567e9d66bb09100d09b33d90311feca0206c7ca034bc0c55113"
@ -4015,7 +4033,7 @@ dependencies = [
 "checksum toml 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)" = "a7540f4ffc193e0d3c94121edb19b055670d369f77d5804db11ae053a45b6e7e"
 "checksum transient-hashmap 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "715254c8f0811be1a79ad3ea5e6fa3c8eddec2b03d7f5ba78cf093e56d79c24f"
 "checksum trezor-sys 1.0.0 (git+https://github.com/paritytech/trezor-sys)" = "<none>"
-"checksum uint 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "6477b2716357758c176c36719023e1f9726974d762150e4fc0a9c8c75488c343"
+"checksum uint 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "38051a96565903d81c9a9210ce11076b2218f3b352926baa1f5f6abbdfce8273"
 "checksum unicase 1.4.2 (registry+https://github.com/rust-lang/crates.io-index)" = "7f4765f83163b74f957c797ad9253caf97f103fb064d3999aea9568d09fc8a33"
 "checksum unicase 2.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "284b6d3db520d67fbe88fd778c21510d1b0ba4a551e5d0fbb023d33405f6de8a"
 "checksum unicode-bidi 0.3.4 (registry+https://github.com/rust-lang/crates.io-index)" = "49f2bd0c6468a8230e1db229cff8029217cf623c767ea5d60bfbd42729ea54d5"
@ -4033,7 +4051,7 @@ dependencies = [
 "checksum vergen 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "8c3365f36c57e5df714a34be40902b27a992eeddb9996eca52d0584611cf885d"
 "checksum version_check 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "6b772017e347561807c1aa192438c5fd74242a670a6cffacc40f2defd1dc069d"
 "checksum void 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)" = "6a02e4885ed3bc0f2de90ea6dd45ebcbb66dacffe03547fadbb0eeae2770887d"
-"checksum wasmi 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "d19da510b59247935ad5f598357b3cc739912666d75d3d28318026478d95bbdb"
+"checksum wasmi 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "46df76793c28cd8f590d5667f540a81c1c245440a17b03560e381226e27cf348"
 "checksum webpki 0.17.0 (registry+https://github.com/rust-lang/crates.io-index)" = "9e1622384bcb5458c6a3e3fa572f53ea8fef1cc85e535a2983dea87e9154fac2"
 "checksum webpki-roots 0.13.0 (registry+https://github.com/rust-lang/crates.io-index)" = "155d4060e5befdf3a6076bd28c22513473d9900b763c9e4521acc6f78a75415c"
 "checksum winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)" = "167dc9d6949a9b857f3451275e911c3f44255842c1f7a76f33c55103a909087a"
--- a/Cargo.toml
+++ b/Cargo.toml
@ -2,7 +2,7 @@
 description = "Parity Ethereum client"
 name = "parity"
 # NOTE Make sure to update util/version/Cargo.toml as well
-version = "1.11.0"
+version = "1.11.2"
 license = "GPL-3.0"
 authors = ["Parity Technologies <admin@parity.io>"]

--- a/ethcore/light/src/client/header_chain.rs
+++ b/ethcore/light/src/client/header_chain.rs
@ -228,7 +228,7 @@ impl HeaderChain {
 		let decoded_header = spec.genesis_header();

 		let chain = if let Some(current) = db.get(col, CURRENT_KEY)? {
-			let curr : BestAndLatest = ::rlp::decode(&current);
+			let curr : BestAndLatest = ::rlp::decode(&current).expect("decoding db value failed");

 			let mut cur_number = curr.latest_num;
 			let mut candidates = BTreeMap::new();
@ -236,7 +236,7 @@ impl HeaderChain {
 			// load all era entries, referenced headers within them,
 			// and live epoch proofs.
 			while let Some(entry) = db.get(col, era_key(cur_number).as_bytes())? {
-				let entry: Entry = ::rlp::decode(&entry);
+				let entry: Entry = ::rlp::decode(&entry).expect("decoding db value failed");
 				trace!(target: "chain", "loaded header chain entry for era {} with {} candidates",
 					cur_number, entry.candidates.len());

@ -305,7 +305,7 @@ impl HeaderChain {
 					batch.put(col, cht_key(cht_num as u64).as_bytes(), &::rlp::encode(cht_root));
 				}

-				let decoded_header = hardcoded_sync.header.decode();
+				let decoded_header = hardcoded_sync.header.decode()?;
 				let decoded_header_num = decoded_header.number();

 				// write the block in the DB.
@ -524,7 +524,10 @@ impl HeaderChain {
 											None
 										}
 										Ok(None) => panic!("stored candidates always have corresponding headers; qed"),
-										Ok(Some(header)) => Some((epoch_transition, ::rlp::decode(&header))),
+										Ok(Some(header)) => Some((
+											epoch_transition,
+											::rlp::decode(&header).expect("decoding value from db failed")
+										)),
 									};
 								}
 							}
@ -582,7 +585,7 @@ impl HeaderChain {
 						bail!(ErrorKind::Database(msg.into()));
 					};

-					let decoded = header.decode();
+					let decoded = header.decode().expect("decoding db value failed");

 					let entry: Entry = {
 						let bytes = self.db.get(self.col, era_key(h_num).as_bytes())?
@ -591,7 +594,7 @@ impl HeaderChain {
 													in an inconsistent state", h_num);
 								ErrorKind::Database(msg.into())
 							})?;
-						::rlp::decode(&bytes)
+						::rlp::decode(&bytes).expect("decoding db value failed")
 					};

 					let total_difficulty = entry.candidates.iter()
@ -604,9 +607,9 @@ impl HeaderChain {
 						.total_difficulty;

 					break Ok(Some(SpecHardcodedSync {
-						header: header,
-						total_difficulty: total_difficulty,
-						chts: chts,
+						header,
+						total_difficulty,
+						chts,
 					}));
 				},
 				None => {
@ -742,7 +745,7 @@ impl HeaderChain {
 	/// so including it within a CHT would be redundant.
 	pub fn cht_root(&self, n: usize) -> Option<H256> {
 		match self.db.get(self.col, cht_key(n as u64).as_bytes()) {
-			Ok(val) => val.map(|x| ::rlp::decode(&x)),
+			Ok(db_fetch) => db_fetch.map(|bytes| ::rlp::decode(&bytes).expect("decoding value from db failed")),
 			Err(e) => {
 				warn!(target: "chain", "Error reading from database: {}", e);
 				None
@ -793,7 +796,7 @@ impl HeaderChain {
 	pub fn pending_transition(&self, hash: H256) -> Option<PendingEpochTransition> {
 		let key = pending_transition_key(hash);
 		match self.db.get(self.col, &*key) {
-			Ok(val) => val.map(|x| ::rlp::decode(&x)),
+			Ok(db_fetch) => db_fetch.map(|bytes| ::rlp::decode(&bytes).expect("decoding value from db failed")),
 			Err(e) => {
 				warn!(target: "chain", "Error reading from database: {}", e);
 				None
@ -812,7 +815,9 @@ impl HeaderChain {

 		for hdr in self.ancestry_iter(BlockId::Hash(parent_hash)) {
 			if let Some(transition) = live_proofs.get(&hdr.hash()).cloned() {
-				return Some((hdr.decode(), transition.proof))
+				return hdr.decode().map(|decoded_hdr| {
+					(decoded_hdr, transition.proof)
+				}).ok();
 			}
 		}

@ -1192,7 +1197,7 @@ mod tests {

 		let cache = Arc::new(Mutex::new(Cache::new(Default::default(), Duration::from_secs(6 * 3600))));

-		let chain = HeaderChain::new(db.clone(), None, &spec, cache, HardcodedSync::Allow).unwrap();
+		let chain = HeaderChain::new(db.clone(), None, &spec, cache, HardcodedSync::Allow).expect("failed to instantiate a new HeaderChain");

 		let mut parent_hash = genesis_header.hash();
 		let mut rolling_timestamp = genesis_header.timestamp();
@ -1211,17 +1216,17 @@ mod tests {
 			parent_hash = header.hash();

 			let mut tx = db.transaction();
-			let pending = chain.insert(&mut tx, header, None).unwrap();
+			let pending = chain.insert(&mut tx, header, None).expect("failed inserting a transaction");
 			db.write(tx).unwrap();
 			chain.apply_pending(pending);

 			rolling_timestamp += 10;
 		}

-		let hardcoded_sync = chain.read_hardcoded_sync().unwrap().unwrap();
+		let hardcoded_sync = chain.read_hardcoded_sync().expect("failed reading hardcoded sync").expect("failed unwrapping hardcoded sync");
 		assert_eq!(hardcoded_sync.chts.len(), 3);
 		assert_eq!(hardcoded_sync.total_difficulty, total_difficulty);
-		let decoded: Header = hardcoded_sync.header.decode();
+		let decoded: Header = hardcoded_sync.header.decode().expect("decoding failed");
 		assert_eq!(decoded.number(), h_num);
 	}
 }
--- a/ethcore/light/src/client/mod.rs
+++ b/ethcore/light/src/client/mod.rs
@ -318,7 +318,7 @@ impl<T: ChainDataFetcher> Client<T> {

 			let epoch_proof =  self.engine.is_epoch_end(
 				&verified_header,
-				&|h| self.chain.block_header(BlockId::Hash(h)).map(|hdr| hdr.decode()),
+				&|h| self.chain.block_header(BlockId::Hash(h)).and_then(|hdr| hdr.decode().ok()),
 				&|h| self.chain.pending_transition(h),
 			);

@ -426,7 +426,15 @@ impl<T: ChainDataFetcher> Client<T> {
 		};

 		// Verify Block Family
-		let verify_family_result = self.engine.verify_block_family(&verified_header, &parent_header.decode());
+
+		let verify_family_result = {
+			parent_header.decode()
+				.map_err(|dec_err| dec_err.into())
+				.and_then(|decoded| {
+					self.engine.verify_block_family(&verified_header, &decoded)
+				})
+
+		};
 		if let Err(e) = verify_family_result {
 			warn!(target: "client", "Stage 3 block verification failed for #{} ({})\nError: {:?}",
 				verified_header.number(), verified_header.hash(), e);
--- a/ethcore/light/src/client/service.rs
+++ b/ethcore/light/src/client/service.rs
@ -30,7 +30,7 @@ use kvdb::KeyValueDB;
 use cache::Cache;
 use parking_lot::Mutex;

-use super::{ChainDataFetcher, Client, Config as ClientConfig};
+use super::{ChainDataFetcher, LightChainNotify, Client, Config as ClientConfig};

 /// Errors on service initialization.
 #[derive(Debug)]
@ -86,6 +86,11 @@ impl<T: ChainDataFetcher> Service<T> {
 		})
 	}

+	/// Set the actor to be notified on certain chain events
+	pub fn add_notify(&self, notify: Arc<LightChainNotify>) {
+		self.client.add_listener(Arc::downgrade(&notify));
+	}
+
 	/// Register an I/O handler on the service.
 	pub fn register_handler(&self, handler: Arc<IoHandler<ClientIoMessage> + Send>) -> Result<(), IoError> {
 		self.io_service.register_handler(handler)
--- a/ethcore/light/src/net/mod.rs
+++ b/ethcore/light/src/net/mod.rs
@ -75,14 +75,17 @@ const RECALCULATE_COSTS_INTERVAL: Duration = Duration::from_secs(60 * 60);
 // minimum interval between updates.
 const UPDATE_INTERVAL: Duration = Duration::from_millis(5000);

+/// Packet count for PIP.
+const PACKET_COUNT_V1: u8 = 9;
+
 /// Supported protocol versions.
-pub const PROTOCOL_VERSIONS: &'static [u8] = &[1];
+pub const PROTOCOL_VERSIONS: &'static [(u8, u8)] = &[
+	(1, PACKET_COUNT_V1),
+];

 /// Max protocol version.
 pub const MAX_PROTOCOL_VERSION: u8 = 1;

-/// Packet count for PIP.
-pub const PACKET_COUNT: u8 = 9;

 // packet ID definitions.
 mod packet {
@ -111,9 +114,9 @@ mod packet {
 mod timeout {
 	use std::time::Duration;

-	pub const HANDSHAKE: Duration =  Duration::from_millis(2500);
-	pub const ACKNOWLEDGE_UPDATE: Duration = Duration::from_millis(5000);
-	pub const BASE: u64 = 1500; // base timeout for packet.
+	pub const HANDSHAKE: Duration = Duration::from_millis(4_000);
+	pub const ACKNOWLEDGE_UPDATE: Duration = Duration::from_millis(5_000);
+	pub const BASE: u64 = 2_500; // base timeout for packet.

 	// timeouts per request within packet.
 	pub const HEADERS: u64 = 250; // per header?
@ -688,7 +691,7 @@ impl LightProtocol {
 			Err(e) => { punish(*peer, io, e); return }
 		};

-		if PROTOCOL_VERSIONS.iter().find(|x| **x == proto_version).is_none() {
+		if PROTOCOL_VERSIONS.iter().find(|x| x.0 == proto_version).is_none() {
 			punish(*peer, io, Error::UnsupportedProtocolVersion(proto_version));
 			return;
 		}
--- a/ethcore/light/src/net/request_credits.rs
+++ b/ethcore/light/src/net/request_credits.rs
@ -407,7 +407,7 @@ mod tests {
 		let costs = CostTable::default();
 		let serialized = ::rlp::encode(&costs);

-		let new_costs: CostTable = ::rlp::decode(&*serialized);
+		let new_costs: CostTable = ::rlp::decode(&*serialized).unwrap();

 		assert_eq!(costs, new_costs);
 	}
--- a/ethcore/light/src/types/request/mod.rs
+++ b/ethcore/light/src/types/request/mod.rs
@ -1642,7 +1642,7 @@ mod tests {
 	{
 		// check as single value.
 		let bytes = ::rlp::encode(&val);
-		let new_val: T = ::rlp::decode(&bytes);
+		let new_val: T = ::rlp::decode(&bytes).unwrap();
 		assert_eq!(val, new_val);

 		// check as list containing single value.
--- a/ethcore/private-tx/src/lib.rs
+++ b/ethcore/private-tx/src/lib.rs
@ -148,8 +148,8 @@ impl Provider where {
 		encryptor: Box<Encryptor>,
 		config: ProviderConfig,
 		channel: IoChannel<ClientIoMessage>,
-	) -> Result<Self, Error> {
-		Ok(Provider {
+	) -> Self {
+		Provider {
 			encryptor,
 			validator_accounts: config.validator_accounts.into_iter().collect(),
 			signer_account: config.signer_account,
@ -161,7 +161,7 @@ impl Provider where {
 			miner,
 			accounts,
 			channel,
-		})
+		}
 	}

 	// TODO [ToDr] Don't use `ChainNotify` here!
@ -242,50 +242,6 @@ impl Provider where {
 		Ok(original_transaction)
 	}

-	/// Process received private transaction
-	pub fn import_private_transaction(&self, rlp: &[u8]) -> Result<(), Error> {
-		trace!("Private transaction received");
-		let private_tx: PrivateTransaction = Rlp::new(rlp).as_val()?;
-		let contract = private_tx.contract;
-		let contract_validators = self.get_validators(BlockId::Latest, &contract)?;
-
-		let validation_account = contract_validators
-			.iter()
-			.find(|address| self.validator_accounts.contains(address));
-
-		match validation_account {
-			None => {
-				// TODO [ToDr] This still seems a bit invalid, imho we should still import the transaction to the pool.
-				// Importing to pool verifies correctness and nonce; here we are just blindly forwarding.
-				//
-				// Not for verification, broadcast further to peers
-				self.broadcast_private_transaction(rlp.into());
-				return Ok(());
-			},
-			Some(&validation_account) => {
-				let hash = private_tx.hash();
-				trace!("Private transaction taken for verification");
-				let original_tx = self.extract_original_transaction(private_tx, &contract)?;
-				trace!("Validating transaction: {:?}", original_tx);
-				// Verify with the first account available
-				trace!("The following account will be used for verification: {:?}", validation_account);
-				let nonce_cache = Default::default();
-				self.transactions_for_verification.lock().add_transaction(
-					original_tx,
-					contract,
-					validation_account,
-					hash,
-					self.pool_client(&nonce_cache),
-				)?;
-				// NOTE This will just fire `on_private_transaction_queued` but from a client thread.
-				// It seems that a lot of heavy work (verification) is done in this thread anyway
-				// it might actually make sense to decouple it from clientService and just use dedicated thread
-				// for both verification and execution.
-				self.channel.send(ClientIoMessage::NewPrivateTransaction).map_err(|_| ErrorKind::ClientIsMalformed.into())
-			}
-		}
-	}
-
 	fn pool_client<'a>(&'a self, nonce_cache: &'a RwLock<HashMap<Address, U256>>) -> miner::pool_client::PoolClient<'a, Client> {
 		let engine = self.client.engine();
 		let refuse_service_transactions = true;
@ -298,11 +254,6 @@ impl Provider where {
 		)
 	}

-	/// Private transaction for validation added into queue
-	pub fn on_private_transaction_queued(&self) -> Result<(), Error> {
-		self.process_queue()
-	}
-
 	/// Retrieve and verify the first available private transaction for every sender
 	///
 	/// TODO [ToDr] It seems that:
@ -346,73 +297,6 @@ impl Provider where {
 		Ok(())
 	}

-	/// Add signed private transaction into the store
-	/// Creates corresponding public transaction if last required singature collected and sends it to the chain
-	pub fn import_signed_private_transaction(&self, rlp: &[u8]) -> Result<(), Error> {
-		let tx: SignedPrivateTransaction = Rlp::new(rlp).as_val()?;
-		trace!("Signature for private transaction received: {:?}", tx);
-		let private_hash = tx.private_transaction_hash();
-		let desc = match self.transactions_for_signing.lock().get(&private_hash) {
-			None => {
-				// TODO [ToDr] Verification (we can't just blindly forward every transaction)
-
-				// Not our transaction, broadcast further to peers
-				self.broadcast_signed_private_transaction(rlp.into());
-				return Ok(());
-			},
-			Some(desc) => desc,
-		};
-
-		let last = self.last_required_signature(&desc, tx.signature())?;
-
-		if last {
-			let mut signatures = desc.received_signatures.clone();
-			signatures.push(tx.signature());
-			let rsv: Vec<Signature> = signatures.into_iter().map(|sign| sign.into_electrum().into()).collect();
-			//Create public transaction
-			let public_tx = self.public_transaction(
-				desc.state.clone(),
-				&desc.original_transaction,
-				&rsv,
-				desc.original_transaction.nonce,
-				desc.original_transaction.gas_price
-			)?;
-			trace!("Last required signature received, public transaction created: {:?}", public_tx);
-			//Sign and add it to the queue
-			let chain_id = desc.original_transaction.chain_id();
-			let hash = public_tx.hash(chain_id);
-			let signer_account = self.signer_account.ok_or_else(|| ErrorKind::SignerAccountNotSet)?;
-			let password = find_account_password(&self.passwords, &*self.accounts, &signer_account);
-			let signature = self.accounts.sign(signer_account, password, hash)?;
-			let signed = SignedTransaction::new(public_tx.with_signature(signature, chain_id))?;
-			match self.miner.import_own_transaction(&*self.client, signed.into()) {
-				Ok(_) => trace!("Public transaction added to queue"),
-				Err(err) => {
-					trace!("Failed to add transaction to queue, error: {:?}", err);
-					bail!(err);
-				}
-			}
-			//Remove from store for signing
-			match self.transactions_for_signing.lock().remove(&private_hash) {
-				Ok(_) => {}
-				Err(err) => {
-					trace!("Failed to remove transaction from signing store, error: {:?}", err);
-					bail!(err);
-				}
-			}
-		} else {
-			//Add signature to the store
-			match self.transactions_for_signing.lock().add_signature(&private_hash, tx.signature()) {
-				Ok(_) => trace!("Signature stored for private transaction"),
-				Err(err) => {
-					trace!("Failed to add signature to signing store, error: {:?}", err);
-					bail!(err);
-				}
-			}
-		}
-		Ok(())
-	}
-
 	fn last_required_signature(&self, desc: &PrivateTransactionSigningDesc, sign: Signature) -> Result<bool, Error>  {
 		if desc.received_signatures.contains(&sign) {
 			return Ok(false);
@ -656,6 +540,134 @@ impl Provider where {
 	}
 }

+pub trait Importer {
+	/// Process received private transaction
+	fn import_private_transaction(&self, _rlp: &[u8]) -> Result<(), Error>;
+
+	/// Add signed private transaction into the store
+	///
+	/// Creates corresponding public transaction if last required signature collected and sends it to the chain
+	fn import_signed_private_transaction(&self, _rlp: &[u8]) -> Result<(), Error>;
+}
+
+// TODO [ToDr] Offload more heavy stuff to the IoService thread.
+// It seems that a lot of heavy work (verification) is done in this thread anyway
+// it might actually make sense to decouple it from clientService and just use dedicated thread
+// for both verification and execution.
+
+impl Importer for Arc<Provider> {
+	fn import_private_transaction(&self, rlp: &[u8]) -> Result<(), Error> {
+		trace!("Private transaction received");
+		let private_tx: PrivateTransaction = Rlp::new(rlp).as_val()?;
+		let contract = private_tx.contract;
+		let contract_validators = self.get_validators(BlockId::Latest, &contract)?;
+
+		let validation_account = contract_validators
+			.iter()
+			.find(|address| self.validator_accounts.contains(address));
+
+		match validation_account {
+			None => {
+				// TODO [ToDr] This still seems a bit invalid, imho we should still import the transaction to the pool.
+				// Importing to pool verifies correctness and nonce; here we are just blindly forwarding.
+				//
+				// Not for verification, broadcast further to peers
+				self.broadcast_private_transaction(rlp.into());
+				return Ok(());
+			},
+			Some(&validation_account) => {
+				let hash = private_tx.hash();
+				trace!("Private transaction taken for verification");
+				let original_tx = self.extract_original_transaction(private_tx, &contract)?;
+				trace!("Validating transaction: {:?}", original_tx);
+				// Verify with the first account available
+				trace!("The following account will be used for verification: {:?}", validation_account);
+				let nonce_cache = Default::default();
+				self.transactions_for_verification.lock().add_transaction(
+					original_tx,
+					contract,
+					validation_account,
+					hash,
+					self.pool_client(&nonce_cache),
+				)?;
+				let provider = Arc::downgrade(self);
+				self.channel.send(ClientIoMessage::execute(move |_| {
+					if let Some(provider) = provider.upgrade() {
+						if let Err(e) = provider.process_queue() {
+							debug!("Unable to process the queue: {}", e);
+						}
+					}
+				})).map_err(|_| ErrorKind::ClientIsMalformed.into())
+			}
+		}
+	}
+
+	fn import_signed_private_transaction(&self, rlp: &[u8]) -> Result<(), Error> {
+		let tx: SignedPrivateTransaction = Rlp::new(rlp).as_val()?;
+		trace!("Signature for private transaction received: {:?}", tx);
+		let private_hash = tx.private_transaction_hash();
+		let desc = match self.transactions_for_signing.lock().get(&private_hash) {
+			None => {
+				// TODO [ToDr] Verification (we can't just blindly forward every transaction)
+
+				// Not our transaction, broadcast further to peers
+				self.broadcast_signed_private_transaction(rlp.into());
+				return Ok(());
+			},
+			Some(desc) => desc,
+		};
+
+		let last = self.last_required_signature(&desc, tx.signature())?;
+
+		if last {
+			let mut signatures = desc.received_signatures.clone();
+			signatures.push(tx.signature());
+			let rsv: Vec<Signature> = signatures.into_iter().map(|sign| sign.into_electrum().into()).collect();
+			//Create public transaction
+			let public_tx = self.public_transaction(
+				desc.state.clone(),
+				&desc.original_transaction,
+				&rsv,
+				desc.original_transaction.nonce,
+				desc.original_transaction.gas_price
+			)?;
+			trace!("Last required signature received, public transaction created: {:?}", public_tx);
+			//Sign and add it to the queue
+			let chain_id = desc.original_transaction.chain_id();
+			let hash = public_tx.hash(chain_id);
+			let signer_account = self.signer_account.ok_or_else(|| ErrorKind::SignerAccountNotSet)?;
+			let password = find_account_password(&self.passwords, &*self.accounts, &signer_account);
+			let signature = self.accounts.sign(signer_account, password, hash)?;
+			let signed = SignedTransaction::new(public_tx.with_signature(signature, chain_id))?;
+			match self.miner.import_own_transaction(&*self.client, signed.into()) {
+				Ok(_) => trace!("Public transaction added to queue"),
+				Err(err) => {
+					trace!("Failed to add transaction to queue, error: {:?}", err);
+					bail!(err);
+				}
+			}
+			//Remove from store for signing
+			match self.transactions_for_signing.lock().remove(&private_hash) {
+				Ok(_) => {}
+				Err(err) => {
+					trace!("Failed to remove transaction from signing store, error: {:?}", err);
+					bail!(err);
+				}
+			}
+		} else {
+			//Add signature to the store
+			match self.transactions_for_signing.lock().add_signature(&private_hash, tx.signature()) {
+				Ok(_) => trace!("Signature stored for private transaction"),
+				Err(err) => {
+					trace!("Failed to add signature to signing store, error: {:?}", err);
+					bail!(err);
+				}
+			}
+		}
+		Ok(())
+	}
+}
+
 /// Try to unlock account using stored password, return found password if any
 fn find_account_password(passwords: &Vec<String>, account_provider: &AccountProvider, account: &Address) -> Option<String> {
 	for password in passwords {
--- a/ethcore/private-tx/tests/private_contract.rs
+++ b/ethcore/private-tx/tests/private_contract.rs
@ -74,7 +74,7 @@ fn private_contract() {
 			Box::new(NoopEncryptor::default()),
 			config,
 			io,
-	).unwrap());
+	));

 	let (address, _) = contract_address(CreateContractAddress::FromSenderAndNonce, &key1.address(), &0.into(), &[]);

--- a/ethcore/res/ethereum/ellaism.json
+++ b/ethcore/res/ethereum/ellaism.json
@ -13,9 +13,9 @@
        "eip150Transition": "0x0",
        "eip160Transition": "0x0",
        "ecip1017EraRounds": 10000000,
-
        "eip161abcTransition": "0x7fffffffffffffff",
-        "eip161dTransition": "0x7fffffffffffffff"
+        "eip161dTransition": "0x7fffffffffffffff",
+        "eip100bTransition": 2000000
      }
    }
  },
@ -29,7 +29,12 @@
    "chainID": "0x40",
    "eip155Transition": "0x0",
    "eip98Transition": "0x7fffffffffffff",
-    "eip86Transition": "0x7fffffffffffff"
+    "eip86Transition": "0x7fffffffffffff",
+    "wasmActivationTransition": 2000000,
+    "eip140Transition": 2000000,
+    "eip211Transition": 2000000,
+    "eip214Transition": 2000000,
+    "eip658Transition": 2000000
  },
  "genesis": {
    "seal": {
@ -60,6 +65,10 @@
    "0000000000000000000000000000000000000001": { "builtin": { "name": "ecrecover", "pricing": { "linear": { "base": 3000, "word": 0 } } } },
    "0000000000000000000000000000000000000002": { "builtin": { "name": "sha256", "pricing": { "linear": { "base": 60, "word": 12 } } } },
    "0000000000000000000000000000000000000003": { "builtin": { "name": "ripemd160", "pricing": { "linear": { "base": 600, "word": 120 } } } },
-    "0000000000000000000000000000000000000004": { "builtin": { "name": "identity", "pricing": { "linear": { "base": 15, "word": 3 } } } }
+    "0000000000000000000000000000000000000004": { "builtin": { "name": "identity", "pricing": { "linear": { "base": 15, "word": 3 } } } },
+    "0000000000000000000000000000000000000005": { "builtin": { "name": "modexp", "activate_at": 2000000, "pricing": { "modexp": { "divisor": 20 } } } },
+    "0000000000000000000000000000000000000006": { "builtin": { "name": "alt_bn128_add", "activate_at": 2000000, "pricing": { "linear": { "base": 500, "word": 0 } } } },
+    "0000000000000000000000000000000000000007": { "builtin": { "name": "alt_bn128_mul", "activate_at": 2000000, "pricing": { "linear": { "base": 40000, "word": 0 } } } },
+    "0000000000000000000000000000000000000008": { "builtin": { "name": "alt_bn128_pairing", "activate_at": 2000000, "pricing": { "alt_bn128_pairing": { "base": 100000, "pair": 80000 } } } }
  }
 }
--- a/ethcore/res/ethereum/foundation.json
+++ b/ethcore/res/ethereum/foundation.json
@ -174,8 +174,8 @@
 		"stateRoot": "0xd7f8974fb5ac78d9ac099b9ad5018bedc2ce0a72dad1827a1709da30580f0544"
 	},
 	"hardcodedSync": {
-		"header": "f90219a061d694007fbaca6e23e73e29c8c6a60099abc740ab7e27ae3cd1b9c6a47efef7a01dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347945a0b54d5dc17e0aadc383d2db43b0a0d3e029c4ca0a2f1bdabc1a72737de1c22a76cacc8fc162366904f759a99db7d6d19efee3090a0ac5f5b236e8977928a2ce43c7569ea5a74919643cb0b06d7540407b1ea1298f0a04356ddc5d77c83923a6541260308be167386e0969a608a017770c9e38091cfcab90100a00010002001009080011010141088000004000080081100000a002023000002204204801204084000c000010008000000000880080020c0000440200460000290005010c01c80800080004800100406003380000400402040000028084002a80087000008090a00200100544020019580022000000306100a0080100084020006809000e80000010000254810002000000a240050014200002002c10809202030006422022000203012000241089300080400000009001021020200012410348500028290230408100302000000058c0000020c08c20480081040020260004008481000080000800010010060020000e00020002140100a8988000004400201870b9af4a66df8038350a8018379d54483799eba845ab0426d984554482e45544846414e532e4f52472d3231323134313232a05eeccc80302d8fecca48a47be03654b5a41b5e5f296f271f910ebae631124f518890074810024c6c2b",
-		"totalDifficulty": "3144406426008470895785",
+		"header": "f90216a03b798fd7d7c51f61fdbe7a08d6d2257eea4501c12dfc5442146b85837c0da51fa01dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d4934794ea674fdde714fd979de3edf0f56aa9716b898ec8a0a2df7c321f2a532f63cdaf4e234227dd067f3782787db2ac892e875a8cb6842fa0c3a3f2c96c938633c7a99531a3876d544dbb8d5fac06879bea8e3cc5b6ece09da0221863f4a4fa6ca8dc7b6eed0eaefea36a5069f06ba9a61e78b87b634b5e4409b9010000a02080204012000000004100800000c0a08040041160000000740200200148000000000104011040800081808000102001180000000a80000011401020002c14008402000000100014400e20082080400000aa004100000000d10e8a0026180020882008200400a548000000201010088080000c0020800000001004046200600000052004020001800400800400420001800084002c1200040088028840004604020820400000264000005808500400410451c0808020140380c02014000440000002010422080800000240000000048a80072140000400409020020220810010020018008021800280a05008020000400000000044178000008000044410870b075e7ebe9d268353f001837a11f88379cd17845adfefa59565746865726d696e652d6177732d61736961312d32a0c92755fe5da24ea52d89783e387d88e1c2e24ac202641dd9906fc704a88979d28818d4dcc0009d0541",
+		"totalDifficulty": "3828700463149109414955",
 		"CHTs": [
 			"0x0eb474b7721727204978e92e27d31cddff56471911e424a4c8271c35f9c982cc",
 			"0xe10e94515fb5ffb7ffa9bf50db4a959b3f50c2ff75e0b8bd5f5e038749e52a11",
@ -2757,7 +2757,112 @@
 			"0x568f44291c13efc908db42d2473bc91ebb16e062e9b4368bcb770a3033d67741",
 			"0xe5ecad510448855ff0aafb92a8c7aa54aca0fb390bec3c14ad5d2ba200380aec",
 			"0xa40aa7655c1458b76c04ea5934ae171fb01c72c8c375bb61a0c27b0ebd70f21f",
-			"0x770ad5107ac47fd983979b016553ca8f340a13e2647b9140e65c980dcf349cff"
+			"0x770ad5107ac47fd983979b016553ca8f340a13e2647b9140e65c980dcf349cff",
+			"0xfd074cacab08d2d5f113669672632ab0e94e03bfbbe17fc3de27a30e9f0e8327",
+			"0x2063bf5ce8eed483242157113534b314296deb123cb33083cb0cce04db610c9a",
+			"0x9dfb8274e842fd3cb7d73506e64adacc39eb12ebd8a972b7101385ac4eb5b12c",
+			"0x8294c3d4892cb0bcba9acdd31d53af5bfc97daf124f08d903297da8bbb28cdfe",
+			"0x9dc2d04fe197009f24ebd4a0c95a0b91d4ff0093387b61569af993fa91edb3fa",
+			"0xe88e256abdc6447b1f141c2fcf2c46721d9717a9fcb302513c93ed6e31b7c11c",
+			"0xd2ad4ca6091f6ae6c323b6565522c208a839e36958a1675e5e9b48b13068e7c8",
+			"0xb168169f2643b8cdbec58f3f94d7889af37117a35389726563ac770f5205faab",
+			"0x09f32b423ca728b8fd04f9872325c0e2a4c9b1eb36fab49b31ae51254c69ebab",
+			"0x0b47f8f28a3242c9ca705fd11949e648f190053de023366f98e6c736eb2f0de1",
+			"0x870a8067623b35b5f0146ec95047869357617fe3773a8285a622c18d44963f9f",
+			"0xd14e05d8f3238294ffd8885c1f1710f64f2d8eb3d3b4e8a921f7f5c94a0a6288",
+			"0xf9cdef6ffacbea7692e9fef3de1b778bd11399492486dca0209b27bd474eb04a",
+			"0x5dc41201eaa00957d070c68bb289fc00eb31b7e5fff52f0603d52d27a40abf81",
+			"0xae3a53054ff4e3e5562795b45777e1e3e82abeed84e2fab748af50aace8bc8e2",
+			"0x93fd6f9af3b1efd27487477edccd690b19902300a4eebd34cb0d9b2e60b3cccf",
+			"0xbe475a9dc045e70ac8218e5a65450edf026d70f3f814162251f83a88098245c2",
+			"0x20566435d247cc1e7d0d81e143c01b6649fa1fd3cd5a9f97738e6045b29460c5",
+			"0xb37273228fe8b0c1679bb2dab7176ee1282400daddaaeb0db415c716f5dd1f71",
+			"0x494bb2cea59fc43629b0f8be3fba9ee5b52948c72fd1f1c94d31600756bfb675",
+			"0xc690eb3d8e65d5efc211def8fe8f198e42c0321000b8998a6ab218d897d593a5",
+			"0x26821d73690b9d1bdd9594c92b086291474cd365bd41f7de5edc49dfc29c26df",
+			"0x026a57937338c9e168d254f99dc9dbe3fb41508049ac1a5b6d7df868e2935e6c",
+			"0x50dc451812556bd69244f3728c6a17e958b2fa125248103942ac94142610bcc7",
+			"0x0ffe7ea32c3ef43049d8041a16bd3381ba89b1439dc5329e839546aa01a64726",
+			"0xab1e06f13dbaed341fc9e33ef387ebbe187787ccd8961a47560f7e02617a06db",
+			"0x8b72166b0d16ebfd9c3156f5972e3778e16b3d7edf3decd4b6efbc779990ca3c",
+			"0x149de0dcdbe03bf6d0ae9ccc989a074a4cf2e78311ce8cb6dee3856c2a374caa",
+			"0x42147f5960814dc31cc38b692089e6d1d53b85cc85a69e4cc01954dc61c268a6",
+			"0x1460ceccff1ac00f3e126383c3102c424b75c2abeb973d0baa8bec8e7bdda692",
+			"0xdbbbf28a5d25c832c5f625868dea79a481dce880d5145f4119d3e9eb32356a6b",
+			"0xd8e5b32a88bdb502fbd62888b9906a0c7955ccaaad1ead31636572a07fe7419b",
+			"0xdbc42abbec7d223666da11767d9862cd1458f91b5bf2f6499da4ae5bff281888",
+			"0xc3138499753f545de139238bdc8cd4cbad254c6b87bf0eb37dc1fe7a85168e79",
+			"0x42be700f627bb081543ab289fcd01235bedea5e33a9779d6d14744685f5a652a",
+			"0x8660e4130c98f6a8024c1b587dd24ebe402126d4d9a2adf610c62bf033b749c5",
+			"0xdab926bab8c4ff9e492f992b5696e8f7e3ba3ce77e49fe0e2ca36d3efc8791b6",
+			"0x0e3911bcf379fd57014bee6a1f796b884c62f2392cf6e8ac5a145126e4622b88",
+			"0xbd52346714664eeb7b4034bc6a54804824bdd40d9e5bdbae9375a302926babe6",
+			"0x641e58eaeb404f7a40b9c4be686c26721563b310f7624a654185a60374c1512e",
+			"0xfa07b0f7b970413ae5085f042224861bb1bc5f2f6ad72a44c3681d47a817c0a9",
+			"0x70cf3fffa7e27f03d5cbb1664bbd0e1315dfc43df76f1b0e3dce494255e54752",
+			"0x1d5b0118939994aa8be89dc365f909309df84e7c92530aef25d62118b09e0572",
+			"0x8b34c5a5cd5a42a58bbc60166f3f2a4be7d79057691c708e7a9639c21b6f57c7",
+			"0x7b149005e7f8378189c70c33c073d897cb07f62ba5ae319088b3be204beea8e4",
+			"0xf2a41e8feb5d294faca47dd1f7a90f66b7b616addcd179ae60c5f173cd44a85d",
+			"0xa2875c8e5a226f2cf69f07e19b13a628ef6a8662f3a5de4c9d666ca5ebddb001",
+			"0x4231ca8bdccd59526900a487608912a4fc0918a6c693250bd67787bc61a9d09b",
+			"0x2b06301a6372e0fca0da8a15d4e31a08522ecb91efbda58c3e495e2ab7f4fceb",
+			"0xd0e19f62b07275097b56e7f409cd52826a1dbc0be26eeaae20562420559153dc",
+			"0xa4ecf1ef04bcc95ba0ed9214e9118129ae5497c37db94dda284dd536b4dd75c9",
+			"0x3dc87ba482aaac6b59678c899bfb1da9b768e1385e0f8e8574852efeee2db8c0",
+			"0x07f8df3f6ec63d926c3a76b17ad1750a9ac6c62a8cdffa549440e651f6087178",
+			"0x96952f8ba7c83d640119868a030cb7397624ef322b2d153aa3843259da5f468c",
+			"0x08eca2fb4295f069f3fa62849b354a9e10b8a8e9b771cb8d2790b28b7b09d70c",
+			"0xfd5832f531c8819c0ce9d031434c33eb442578e81cf711e8ba23e9b21d096e13",
+			"0xfee9a8bae124565c963b65fa47dcf7f0c9b5ef7e778c2d99539b8a04efd04522",
+			"0xead692739a0723a73dd38b3aa02f93d72b3b6922c2520ea0b74981eaafe7f6a1",
+			"0x890dd8befeee6c7c7b4942b02a3bf1a9d1b9e1140ecd1c07de570f38b6c323b6",
+			"0x690343489ed214b9195db6181c42237b7a62fc935a18ca1a5dc883a2045ceae7",
+			"0x4bdfdc1bef8c19b89344230c0f48841abfeea788a4973c34afff4d2039ce4417",
+			"0x6ef6a94338d794400f95f8c0b6d5a40df8b56c31e9bd0037bdd7e41234bb32a1",
+			"0x00b7568bfdf2d4780b8650a49f707752a12fe9a88302622e68f264622877acdc",
+			"0x83e96e0b864df30b53ae08075acc83f785e9b8b2bc80e8976b1a954f995df012",
+			"0x664305b610d0b3167dd25210acba7eea291a37a224546a6f6d59aa7b71d16e5f",
+			"0x3d3a6401ab83eabc2af15a23b9c0e6d123f661b3599c6131d5923a106f562ac8",
+			"0x7a11833fbc8ce3d9883088649b930238625e6f6136dfa06a00daf8e646cd020c",
+			"0x112c33932097c4ec4e18f6308b2a6502cbf746605f1e404555dd07703d60ba2d",
+			"0x9e77cd028749d69caf352a95f75dee842c0d9323e3618afa2927b2aaaf7fc4a8",
+			"0x7fe0a62bfd04e263b4c67c5808f6231ad6faca7ff0f5bc0c02177034608d6991",
+			"0xea820d62b423b68da2f8ce345dbb56e2205fdfae1fce261d64acc959fb30cccd",
+			"0xd8f6367448dec55e8e2e26b5d304d92969abde131d402de313b1705c0bfd528f",
+			"0x4b97f3b4e0bff7cfe322e4f50176f6bfb379a706d42308ae75b2a46735762a95",
+			"0x7425ff9cea5e4869332ce12ef727fbcb004add827eb567424fd4c17717def390",
+			"0xc7dcd4fd005ae8d4d9e125727b54a64e900b3fee9cdc82fb5057c012178c8483",
+			"0x8ba88bfba201db1db716f762b5517369d3ae232ca045d2932fc27f6c47b15806",
+			"0xad2f63fa4fddd0cfc7f6cb01116d285e8aad4b0c51fa9445d39a4cb4949ed020",
+			"0x366874aec4ea26ece424f5402604ec7df9f40fc4cb9087cd3f45e764b1e36ebf",
+			"0x7f27eb75010b0d5da72794c129042511e24794b6c8491c1ff2e257dadcc7052d",
+			"0x27eadc596f6eaeb9247704c3339f7fe4e649f683fd815f9d71270caf5d9e38cd",
+			"0xba3f72ce8f45b1575554bd0c64feda3959c2a68f0300f021b67880b56f7152e2",
+			"0x50833c82dc63533f7ec918cd6d58ffbef4e2d597f354589b8eb66c9de0fc9697",
+			"0x30fc354a8893f683ef03bb024254574b550710f3c05496976cd39166a29e1c98",
+			"0x1b6b8d13fca6583d358b173c1a255c3db9efed8ad72084eadf10e29868a26fdc",
+			"0xb1b2a80122d1210160d8649d31422a1edc26b23e8499aa3a88b047dc52b42222",
+			"0x4e6c85a13cc0c739fbdf844a4f52c78979a84a86db728e4a5d2043ee3b2fcb3e",
+			"0xe98c28b49aa690aecfa43527acd3e5a010c8f90faf79ef5b4b479a715fe66a99",
+			"0x5b56e2b50ec96f7bda3f529ed71321650d688e2ee5c16723f6199256532ee660",
+			"0x1c9b8f5106a23096f2f57dfdb2a7a82876f4374be97b6a818fdc3c742b216b09",
+			"0xcb6973f775356ec7596ed6f9a036258e98677c7c5b2358da75af28f553327506",
+			"0x26b42a54252893f59e8eca923a0d2f2c0fe507a680e8907e2904702791c42aea",
+			"0x25fec26921bb5b6cd9657588b09813270cad72947abc6cb2726764db44181ff2",
+			"0xdfbd186df632b63f4cf74db660c59e658e0b4b725fe244a563c6698dd94adaf4",
+			"0xd1e00635e2399f6fa625f5c204e4c1643a7b619271394141433d26d902479bbe",
+			"0x3d3323fea45851eb0bc0b6c80a79cc0d0582abd8032aba957e719c31bb7901e6",
+			"0xe7d7b4c68d4f55ea8b71b43ad20bdd86402d36b6360ed0ca18082942736a7e41",
+			"0x1436749eca0a72b74bf8d596e3499414d412fbea0b936ee3564c4f83de907092",
+			"0xa828c16af52bd4adcb64928fada82a02d0a49fd3f53c5083ca9acfd998f8af1d",
+			"0x0fe559ad45cde755dd41876c5a65a690d32fc3d294fafeaa43e3fe133ae48da8",
+			"0x8f91d2082e5a1e6c1c905936515ab5f03889ac67261ef1d892fd909a9379a8ba",
+			"0x3881a9fe4ba6a24dcfa86351be2ca741dc9b2078409b2e7e0140569f19733505",
+			"0x4a3295525bfdda29bb9a552d8dc5c992649699f5694f96ff5bb0647910386db2",
+			"0x337389b3e800bae87fdbe5271f2167f169ffeb4710ecdcea30f08b2cefba57b1",
+			"0x2978e1e3c2b5dfe0b41ceb5c9c4029f42d346a2123a199c52ba6efdbf1d5fb68",
+			"0x8abbdb4f1f88fe8900afdfe15f3d03244435d4fb871606a689c11f6420145b45"
 		]
 	},
 	"nodes": [
--- a/ethcore/res/ethereum/kovan.json
+++ b/ethcore/res/ethereum/kovan.json
--- a/ethcore/res/ethereum/ropsten.json
+++ b/ethcore/res/ethereum/ropsten.json
--- a/ethcore/service/Cargo.toml
+++ b/ethcore/service/Cargo.toml
@ -13,6 +13,7 @@ ethcore-sync = { path = "../sync" }
 kvdb = { path = "../../util/kvdb" }
 log = "0.3"
 stop-guard = { path = "../../util/stop-guard" }
+trace-time = { path = "../../util/trace-time" }

 [dev-dependencies]
 tempdir = "0.3"
--- a/ethcore/service/src/lib.rs
+++ b/ethcore/service/src/lib.rs
@ -28,6 +28,9 @@ extern crate error_chain;
 #[macro_use]
 extern crate log;

+#[macro_use]
+extern crate trace_time;
+
 #[cfg(test)]
 extern crate tempdir;

--- a/ethcore/service/src/service.rs
+++ b/ethcore/service/src/service.rs
@ -29,11 +29,11 @@ use sync::PrivateTxHandler;
 use ethcore::client::{Client, ClientConfig, ChainNotify, ClientIoMessage};
 use ethcore::miner::Miner;
 use ethcore::snapshot::service::{Service as SnapshotService, ServiceParams as SnapServiceParams};
-use ethcore::snapshot::{RestorationStatus};
+use ethcore::snapshot::{SnapshotService as _SnapshotService, RestorationStatus};
 use ethcore::spec::Spec;
 use ethcore::account_provider::AccountProvider;

-use ethcore_private_tx;
+use ethcore_private_tx::{self, Importer};
 use Error;

 pub struct PrivateTxService {
@ -112,14 +112,13 @@ impl ClientService {
 				account_provider,
 				encryptor,
 				private_tx_conf,
-				io_service.channel())?,
-		);
+				io_service.channel(),
+		));
 		let private_tx = Arc::new(PrivateTxService::new(provider));

 		let client_io = Arc::new(ClientIoHandler {
 			client: client.clone(),
 			snapshot: snapshot.clone(),
-			private_tx: private_tx.clone(),
 		});
 		io_service.register_handler(client_io)?;

@ -169,13 +168,17 @@ impl ClientService {

 	/// Get a handle to the database.
 	pub fn db(&self) -> Arc<KeyValueDB> { self.database.clone() }
+
+	/// Shutdown the Client Service
+	pub fn shutdown(&self) {
+		self.snapshot.shutdown();
+	}
 }

 /// IO interface for the Client handler
 struct ClientIoHandler {
 	client: Arc<Client>,
 	snapshot: Arc<SnapshotService>,
-	private_tx: Arc<PrivateTxService>,
 }

 const CLIENT_TICK_TIMER: TimerToken = 0;
@ -191,6 +194,7 @@ impl IoHandler<ClientIoMessage> for ClientIoHandler {
 	}

 	fn timeout(&self, _io: &IoContext<ClientIoMessage>, timer: TimerToken) {
+		trace_time!("service::read");
 		match timer {
 			CLIENT_TICK_TIMER => {
 				use ethcore::snapshot::SnapshotService;
@ -203,20 +207,24 @@ impl IoHandler<ClientIoMessage> for ClientIoHandler {
 	}

 	fn message(&self, _io: &IoContext<ClientIoMessage>, net_message: &ClientIoMessage) {
+		trace_time!("service::message");
 		use std::thread;

 		match *net_message {
-			ClientIoMessage::BlockVerified => { self.client.import_verified_blocks(); }
-			ClientIoMessage::NewTransactions(ref transactions, peer_id) => {
-				self.client.import_queued_transactions(transactions, peer_id);
+			ClientIoMessage::BlockVerified => {
+				self.client.import_verified_blocks();
 			}
 			ClientIoMessage::BeginRestoration(ref manifest) => {
 				if let Err(e) = self.snapshot.init_restore(manifest.clone(), true) {
 					warn!("Failed to initialize snapshot restoration: {}", e);
 				}
 			}
-			ClientIoMessage::FeedStateChunk(ref hash, ref chunk) => self.snapshot.feed_state_chunk(*hash, chunk),
-			ClientIoMessage::FeedBlockChunk(ref hash, ref chunk) => self.snapshot.feed_block_chunk(*hash, chunk),
+			ClientIoMessage::FeedStateChunk(ref hash, ref chunk) => {
+				self.snapshot.feed_state_chunk(*hash, chunk)
+			}
+			ClientIoMessage::FeedBlockChunk(ref hash, ref chunk) => {
+				self.snapshot.feed_block_chunk(*hash, chunk)
+			}
 			ClientIoMessage::TakeSnapshot(num) => {
 				let client = self.client.clone();
 				let snapshot = self.snapshot.clone();
@ -231,12 +239,9 @@ impl IoHandler<ClientIoMessage> for ClientIoHandler {
 					debug!(target: "snapshot", "Failed to initialize periodic snapshot thread: {:?}", e);
 				}
 			},
-			ClientIoMessage::NewMessage(ref message) => if let Err(e) = self.client.engine().handle_message(message) {
-				trace!(target: "poa", "Invalid message received: {}", e);
-			},
-			ClientIoMessage::NewPrivateTransaction => if let Err(e) = self.private_tx.provider.on_private_transaction_queued() {
-				warn!("Failed to handle private transaction {:?}", e);
-			},
+			ClientIoMessage::Execute(ref exec) => {
+				(*exec.0)(&self.client);
+			}
 			_ => {} // ignore other messages
 		}
 	}
--- a/ethcore/src/blockchain/blockchain.rs
+++ b/ethcore/src/blockchain/blockchain.rs
@ -57,6 +57,12 @@ pub trait BlockProvider {
 	/// (though not necessarily a part of the canon chain).
 	fn is_known(&self, hash: &H256) -> bool;

+	/// Returns true if the given block is known and in the canon chain.
+	fn is_canon(&self, hash: &H256) -> bool {
+		let is_canon = || Some(hash == &self.block_hash(self.block_number(hash)?)?);
+		is_canon().unwrap_or(false)
+	}
+
 	/// Get the first block of the best part of the chain.
 	/// Return `None` if there is no gap and the first block is the genesis.
 	/// Any queries of blocks which precede this one are not guaranteed to
@ -148,7 +154,7 @@ pub trait BlockProvider {
 	fn blocks_with_bloom(&self, bloom: &Bloom, from_block: BlockNumber, to_block: BlockNumber) -> Vec<BlockNumber>;

 	/// Returns logs matching given filter.
-	fn logs<F>(&self, blocks: Vec<BlockNumber>, matches: F, limit: Option<usize>) -> Vec<LocalizedLogEntry>
+	fn logs<F>(&self, blocks: Vec<H256>, matches: F, limit: Option<usize>) -> Vec<LocalizedLogEntry>
 		where F: Fn(&LogEntry) -> bool + Send + Sync, Self: Sized;
 }

@ -332,16 +338,18 @@ impl BlockProvider for BlockChain {
 			.collect()
 	}

-	fn logs<F>(&self, mut blocks: Vec<BlockNumber>, matches: F, limit: Option<usize>) -> Vec<LocalizedLogEntry>
+	/// Returns logs matching given filter. The order of logs returned will be the same as the order of the blocks
+	/// provided. And it's the callers responsibility to sort blocks provided in advance.
+	fn logs<F>(&self, mut blocks: Vec<H256>, matches: F, limit: Option<usize>) -> Vec<LocalizedLogEntry>
 		where F: Fn(&LogEntry) -> bool + Send + Sync, Self: Sized {
 		// sort in reverse order
-		blocks.sort_by(|a, b| b.cmp(a));
+		blocks.reverse();

 		let mut logs = blocks
 			.chunks(128)
 			.flat_map(move |blocks_chunk| {
 				blocks_chunk.into_par_iter()
-					.filter_map(|number| self.block_hash(*number).map(|hash| (*number, hash)))
+					.filter_map(|hash| self.block_number(&hash).map(|r| (r, hash)))
 					.filter_map(|(number, hash)| self.block_receipts(&hash).map(|r| (number, hash, r.receipts)))
 					.filter_map(|(number, hash, receipts)| self.block_body(&hash).map(|ref b| (number, hash, receipts, b.transaction_hashes())))
 					.flat_map(|(number, hash, mut receipts, mut hashes)| {
@ -368,7 +376,7 @@ impl BlockProvider for BlockChain {
 									.enumerate()
 									.map(move |(i, log)| LocalizedLogEntry {
 										entry: log,
-										block_hash: hash,
+										block_hash: *hash,
 										block_number: number,
 										transaction_hash: tx_hash,
 										// iterating in reverse order
@ -430,7 +438,7 @@ impl<'a> Iterator for EpochTransitionIter<'a> {
 				return None
 			}

-			let transitions: EpochTransitions = ::rlp::decode(&val[..]);
+			let transitions: EpochTransitions = ::rlp::decode(&val[..]).expect("decode error: the db is corrupted or the data structure has changed");

 			// if there are multiple candidates, at most one will be on the
 			// canon chain.
@ -454,7 +462,7 @@ impl<'a> Iterator for EpochTransitionIter<'a> {
 impl BlockChain {
 	/// Create new instance of blockchain from given Genesis.
 	pub fn new(config: Config, genesis: &[u8], db: Arc<KeyValueDB>) -> BlockChain {
-		// 400 is the avarage size of the key
+		// 400 is the average size of the key
 		let cache_man = CacheManager::new(config.pref_cache_size, config.max_cache_size, 400);

 		let mut bc = BlockChain {
@ -1933,17 +1941,33 @@ mod tests {
 			value: 103.into(),
 			data: "601080600c6000396000f3006000355415600957005b60203560003555".from_hex().unwrap(),
 		}.sign(&secret(), None);
+		let t4 = Transaction {
+			nonce: 0.into(),
+			gas_price: 0.into(),
+			gas: 100_000.into(),
+			action: Action::Create,
+			value: 104.into(),
+			data: "601080600c6000396000f3006000355415600957005b60203560003555".from_hex().unwrap(),
+		}.sign(&secret(), None);
 		let tx_hash1 = t1.hash();
 		let tx_hash2 = t2.hash();
 		let tx_hash3 = t3.hash();
+		let tx_hash4 = t4.hash();

 		let genesis = BlockBuilder::genesis();
 		let b1 = genesis.add_block_with_transactions(vec![t1, t2]);
 		let b2 = b1.add_block_with_transactions(iter::once(t3));
+		let b3 = genesis.add_block_with(|| BlockOptions {
+			transactions: vec![t4.clone()],
+			difficulty: U256::from(9),
+			..Default::default()
+		}); // Branch block
 		let b1_hash = b1.last().hash();
 		let b1_number = b1.last().number();
 		let b2_hash = b2.last().hash();
 		let b2_number = b2.last().number();
+		let b3_hash = b3.last().hash();
+		let b3_number = b3.last().number();

 		let db = new_db();
 		let bc = new_chain(&genesis.last().encoded(), db.clone());
@ -1974,10 +1998,21 @@ mod tests {
 				],
 			}
 		]);
+		insert_block(&db, &bc, &b3.last().encoded(), vec![
+			Receipt {
+				outcome: TransactionOutcome::StateRoot(H256::default()),
+				gas_used: 10_000.into(),
+				log_bloom: Default::default(),
+				logs: vec![
+					LogEntry { address: Default::default(), topics: vec![], data: vec![5], },
+				],
+			}
+		]);

 		// when
-		let logs1 = bc.logs(vec![1, 2], |_| true, None);
-		let logs2 = bc.logs(vec![1, 2], |_| true, Some(1));
+		let logs1 = bc.logs(vec![b1_hash, b2_hash], |_| true, None);
+		let logs2 = bc.logs(vec![b1_hash, b2_hash], |_| true, Some(1));
+		let logs3 = bc.logs(vec![b3_hash], |_| true, None);

 		// then
 		assert_eq!(logs1, vec![
@ -2029,6 +2064,17 @@ mod tests {
 				log_index: 0,
 			}
 		]);
+		assert_eq!(logs3, vec![
+			LocalizedLogEntry {
+				entry: LogEntry { address: Default::default(), topics: vec![], data: vec![5] },
+				block_hash: b3_hash,
+				block_number: b3_number,
+				transaction_hash: tx_hash4,
+				transaction_index: 0,
+				transaction_log_index: 0,
+				log_index: 0,
+			}
+		]);
 	}

 	#[test]
--- a/ethcore/src/client/ancient_import.rs
+++ b/ethcore/src/client/ancient_import.rs
@ -32,16 +32,16 @@ const HEAVY_VERIFY_RATE: f32 = 0.02;
 /// Ancient block verifier: import an ancient sequence of blocks in order from a starting
 /// epoch.
 pub struct AncientVerifier {
-	cur_verifier: RwLock<Box<EpochVerifier<EthereumMachine>>>,
+	cur_verifier: RwLock<Option<Box<EpochVerifier<EthereumMachine>>>>,
 	engine: Arc<EthEngine>,
 }

 impl AncientVerifier {
-	/// Create a new ancient block verifier with the given engine and initial verifier.
-	pub fn new(engine: Arc<EthEngine>, start_verifier: Box<EpochVerifier<EthereumMachine>>) -> Self {
+	/// Create a new ancient block verifier with the given engine.
+	pub fn new(engine: Arc<EthEngine>) -> Self {
 		AncientVerifier {
-			cur_verifier: RwLock::new(start_verifier),
-			engine: engine,
+			cur_verifier: RwLock::new(None),
+			engine,
 		}
 	}

@ -53,17 +53,49 @@ impl AncientVerifier {
 		header: &Header,
 		chain: &BlockChain,
 	) -> Result<(), ::error::Error> {
-		match rng.gen::<f32>() <= HEAVY_VERIFY_RATE {
-			true => self.cur_verifier.read().verify_heavy(header)?,
-			false => self.cur_verifier.read().verify_light(header)?,
+		// perform verification
+		let verified = if let Some(ref cur_verifier) = *self.cur_verifier.read() {
+			match rng.gen::<f32>() <= HEAVY_VERIFY_RATE {
+				true => cur_verifier.verify_heavy(header)?,
+				false => cur_verifier.verify_light(header)?,
+			}
+			true
+		} else {
+			false
+		};
+
+		// when there is no verifier initialize it.
+		// We use a bool flag to avoid double locking in the happy case
+		if !verified {
+			{
+				let mut cur_verifier = self.cur_verifier.write();
+				if cur_verifier.is_none() {
+					*cur_verifier = Some(self.initial_verifier(header, chain)?);
+				}
+			}
+			// Call again to verify.
+			return self.verify(rng, header, chain);
 		}

 		// ancient import will only use transitions obtained from the snapshot.
 		if let Some(transition) = chain.epoch_transition(header.number(), header.hash()) {
 			let v = self.engine.epoch_verifier(&header, &transition.proof).known_confirmed()?;
-			*self.cur_verifier.write() = v;
+			*self.cur_verifier.write() = Some(v);
 		}

 		Ok(())
 	}
+
+	fn initial_verifier(&self, header: &Header, chain: &BlockChain)
+		-> Result<Box<EpochVerifier<EthereumMachine>>, ::error::Error>
+	{
+		trace!(target: "client", "Initializing ancient block restoration.");
+		let current_epoch_data = chain.epoch_transitions()
+			.take_while(|&(_, ref t)| t.block_number < header.number())
+			.last()
+			.map(|(_, t)| t.proof)
+			.expect("At least one epoch entry (genesis) always stored; qed");
+
+		self.engine.epoch_verifier(&header, &current_epoch_data).known_confirmed()
+	}
 }
--- a/ethcore/src/client/client.rs
+++ b/ethcore/src/client/client.rs
@ -14,16 +14,17 @@
 // 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, BTreeMap, VecDeque};
+use std::collections::{HashSet, HashMap, BTreeMap, BTreeSet, VecDeque};
+use std::fmt;
 use std::str::FromStr;
 use std::sync::{Arc, Weak};
-use std::sync::atomic::{AtomicUsize, AtomicBool, Ordering as AtomicOrdering};
+use std::sync::atomic::{AtomicBool, Ordering as AtomicOrdering};
 use std::time::{Instant};
-use itertools::Itertools;

 // util
 use hash::keccak;
 use bytes::Bytes;
+use itertools::Itertools;
 use journaldb;
 use trie::{TrieSpec, TrieFactory, Trie};
 use kvdb::{DBValue, KeyValueDB, DBTransaction};
@ -45,7 +46,8 @@ use client::{
 use client::{
 	BlockId, TransactionId, UncleId, TraceId, ClientConfig, BlockChainClient,
 	TraceFilter, CallAnalytics, BlockImportError, Mode,
-	ChainNotify, PruningInfo, ProvingBlockChainClient, EngineInfo, ChainMessageType
+	ChainNotify, PruningInfo, ProvingBlockChainClient, EngineInfo, ChainMessageType,
+	IoClient,
 };
 use encoded;
 use engines::{EthEngine, EpochTransition};
@ -55,14 +57,13 @@ use evm::Schedule;
 use executive::{Executive, Executed, TransactOptions, contract_address};
 use factory::{Factories, VmFactory};
 use header::{BlockNumber, Header};
-use io::IoChannel;
+use io::{IoChannel, IoError};
 use log_entry::LocalizedLogEntry;
 use miner::{Miner, MinerService};
 use ethcore_miner::pool::VerifiedTransaction;
 use parking_lot::{Mutex, RwLock};
 use rand::OsRng;
 use receipt::{Receipt, LocalizedReceipt};
-use rlp::Rlp;
 use snapshot::{self, io as snapshot_io};
 use spec::Spec;
 use state_db::StateDB;
@ -86,6 +87,7 @@ pub use verification::queue::QueueInfo as BlockQueueInfo;
 use_contract!(registry, "Registry", "res/contracts/registrar.json");

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

@ -155,10 +157,7 @@ struct Importer {
 	pub miner: Arc<Miner>,

 	/// Ancient block verifier: import an ancient sequence of blocks in order from a starting epoch
-	pub ancient_verifier: Mutex<Option<AncientVerifier>>,
-
-	/// Random number generator used by `AncientVerifier`
-	pub rng: Mutex<OsRng>,
+	pub ancient_verifier: AncientVerifier,

 	/// Ethereum engine to be used during import
 	pub engine: Arc<EthEngine>,
@ -205,8 +204,15 @@ pub struct Client {
 	/// List of actors to be notified on certain chain events
 	notify: RwLock<Vec<Weak<ChainNotify>>>,

-	/// Count of pending transactions in the queue
-	queue_transactions: AtomicUsize,
+	/// Queued transactions from IO
+	queue_transactions: IoChannelQueue,
+	/// Ancient blocks import queue
+	queue_ancient_blocks: IoChannelQueue,
+	/// Hashes of pending ancient block wainting to be included
+	pending_ancient_blocks: RwLock<HashSet<H256>>,
+	/// Consensus messages import queue
+	queue_consensus_message: IoChannelQueue,
+
 	last_hashes: RwLock<VecDeque<H256>>,
 	factories: Factories,

@ -240,8 +246,7 @@ impl Importer {
 			verifier: verification::new(config.verifier_type.clone()),
 			block_queue,
 			miner,
-			ancient_verifier: Mutex::new(None),
-			rng: Mutex::new(OsRng::new()?),
+			ancient_verifier: AncientVerifier::new(engine.clone()),
 			engine,
 		})
 	}
@ -448,57 +453,26 @@ impl Importer {
 		Ok(locked_block)
 	}

+
 	/// Import a block with transaction receipts.
 	///
 	/// The block is guaranteed to be the next best blocks in the
 	/// first block sequence. Does no sealing or transaction validation.
-	fn import_old_block(&self, block_bytes: Bytes, receipts_bytes: Bytes, db: &KeyValueDB, chain: &BlockChain) -> Result<H256, ::error::Error> {
-		let block = view!(BlockView, &block_bytes);
-		let header = block.header();
-		let receipts = ::rlp::decode_list(&receipts_bytes);
+	fn import_old_block(&self, header: &Header, block_bytes: &[u8], receipts_bytes: &[u8], db: &KeyValueDB, chain: &BlockChain) -> Result<H256, ::error::Error> {
+		let receipts = ::rlp::decode_list(receipts_bytes);
 		let hash = header.hash();
 		let _import_lock = self.import_lock.lock();

+		trace!(target: "client", "Trying to import old block #{}", header.number());
 		{
 			trace_time!("import_old_block");
-			let mut ancient_verifier = self.ancient_verifier.lock();
-
-			{
-				// closure for verifying a block.
-				let verify_with = |verifier: &AncientVerifier| -> Result<(), ::error::Error> {
-					// verify the block, passing the chain for updating the epoch
-					// verifier.
-					let mut rng = OsRng::new().map_err(UtilError::from)?;
-					verifier.verify(&mut rng, &header, &chain)
-				};
-
-				// initialize the ancient block verifier if we don't have one already.
-				match &mut *ancient_verifier {
-					&mut Some(ref verifier) => {
-						verify_with(verifier)?
-					}
-					x @ &mut None => {
-						// load most recent epoch.
-						trace!(target: "client", "Initializing ancient block restoration.");
-						let current_epoch_data = chain.epoch_transitions()
-							.take_while(|&(_, ref t)| t.block_number < header.number())
-							.last()
-							.map(|(_, t)| t.proof)
-							.expect("At least one epoch entry (genesis) always stored; qed");
-
-						let current_verifier = self.engine.epoch_verifier(&header, &current_epoch_data)
-							.known_confirmed()?;
-						let current_verifier = AncientVerifier::new(self.engine.clone(), current_verifier);
-
-						verify_with(&current_verifier)?;
-						*x = Some(current_verifier);
-					}
-				}
-			}
+			// verify the block, passing the chain for updating the epoch verifier.
+			let mut rng = OsRng::new().map_err(UtilError::from)?;
+			self.ancient_verifier.verify(&mut rng, &header, &chain)?;

 			// Commit results
 			let mut batch = DBTransaction::new();
-			chain.insert_unordered_block(&mut batch, &block_bytes, receipts, None, false, true);
+			chain.insert_unordered_block(&mut batch, block_bytes, receipts, None, false, true);
 			// Final commit to the DB
 			db.write_buffered(batch);
 			chain.commit();
@ -768,7 +742,10 @@ impl Client {
 			report: RwLock::new(Default::default()),
 			io_channel: Mutex::new(message_channel),
 			notify: RwLock::new(Vec::new()),
-			queue_transactions: AtomicUsize::new(0),
+			queue_transactions: IoChannelQueue::new(MAX_TX_QUEUE_SIZE),
+			queue_ancient_blocks: IoChannelQueue::new(MAX_ANCIENT_BLOCKS_QUEUE_SIZE),
+			pending_ancient_blocks: RwLock::new(HashSet::new()),
+			queue_consensus_message: IoChannelQueue::new(usize::max_value()),
 			last_hashes: RwLock::new(VecDeque::new()),
 			factories: factories,
 			history: history,
@ -854,7 +831,7 @@ impl Client {
 	}

 	fn notify<F>(&self, f: F) where F: Fn(&ChainNotify) {
-		for np in self.notify.read().iter() {
+		for np in &*self.notify.read() {
 			if let Some(n) = np.upgrade() {
 				f(&*n);
 			}
@ -988,24 +965,6 @@ impl Client {
 		}
 	}

-	/// Import transactions from the IO queue
-	pub fn import_queued_transactions(&self, transactions: &[Bytes], peer_id: usize) -> usize {
-		trace_time!("import_queued_transactions");
-		self.queue_transactions.fetch_sub(transactions.len(), AtomicOrdering::SeqCst);
-
-		let txs: Vec<UnverifiedTransaction> = transactions
-			.iter()
-			.filter_map(|bytes| Rlp::new(bytes).as_val().ok())
-			.collect();
-
-		self.notify(|notify| {
-			notify.transactions_received(&txs, peer_id);
-		});
-
-		let results = self.importer.miner.import_external_transactions(self, txs);
-		results.len()
-	}
-
 	/// Get shared miner reference.
 	#[cfg(test)]
 	pub fn miner(&self) -> Arc<Miner> {
@ -1295,8 +1254,7 @@ impl Client {
 				=> Some(self.chain.read().best_block_header()),
 			BlockId::Number(number) if number == self.chain.read().best_block_number()
 				=> Some(self.chain.read().best_block_header()),
-			_
-				=> self.block_header(id).map(|h| h.decode()),
+			_   => self.block_header(id).and_then(|h| h.decode().ok())
 		}
 	}
 }
@ -1413,7 +1371,7 @@ impl ImportBlock for Client {
 		use verification::queue::kind::blocks::Unverified;

 		// create unverified block here so the `keccak` calculation can be cached.
-		let unverified = Unverified::new(bytes);
+		let unverified = Unverified::from_rlp(bytes)?;

 		{
 			if self.chain.read().is_known(&unverified.hash()) {
@ -1426,22 +1384,6 @@ impl ImportBlock for Client {
 		}
 		Ok(self.importer.block_queue.import(unverified)?)
 	}
-
-	fn import_block_with_receipts(&self, block_bytes: Bytes, receipts_bytes: Bytes) -> Result<H256, BlockImportError> {
-		{
-			// check block order
-			let header = view!(BlockView, &block_bytes).header_view();
-			if self.chain.read().is_known(&header.hash()) {
-				bail!(BlockImportErrorKind::Import(ImportErrorKind::AlreadyInChain));
-			}
-			let status = self.block_status(BlockId::Hash(header.parent_hash()));
-			if  status == BlockStatus::Unknown || status == BlockStatus::Pending {
-				bail!(BlockImportErrorKind::Block(BlockError::UnknownParent(header.parent_hash())));
-			}
-		}
-
-		self.importer.import_old_block(block_bytes, receipts_bytes, &**self.db.read(), &*self.chain.read()).map_err(Into::into)
-	}
 }

 impl StateClient for Client {
@ -1853,23 +1795,82 @@ impl BlockChainClient for Client {
 	}

 	fn logs(&self, filter: Filter) -> Vec<LocalizedLogEntry> {
-		let (from, to) = match (self.block_number_ref(&filter.from_block), self.block_number_ref(&filter.to_block)) {
-			(Some(from), Some(to)) => (from, to),
-			_ => return Vec::new(),
+		// Wrap the logic inside a closure so that we can take advantage of question mark syntax.
+		let fetch_logs = || {
+			let chain = self.chain.read();
+
+			// First, check whether `filter.from_block` and `filter.to_block` is on the canon chain. If so, we can use the
+			// optimized version.
+			let is_canon = |id| {
+				match id {
+					// If it is referred by number, then it is always on the canon chain.
+					&BlockId::Earliest | &BlockId::Latest | &BlockId::Number(_) => true,
+					// If it is referred by hash, we see whether a hash -> number -> hash conversion gives us the same
+					// result.
+					&BlockId::Hash(ref hash) => chain.is_canon(hash),
+				}
+			};
+
+			let blocks = if is_canon(&filter.from_block) && is_canon(&filter.to_block) {
+				// If we are on the canon chain, use bloom filter to fetch required hashes.
+				let from = self.block_number_ref(&filter.from_block)?;
+				let to = self.block_number_ref(&filter.to_block)?;
+
+				filter.bloom_possibilities().iter()
+					.map(|bloom| {
+						chain.blocks_with_bloom(bloom, from, to)
+					})
+					.flat_map(|m| m)
+					// remove duplicate elements
+					.collect::<BTreeSet<u64>>()
+					.into_iter()
+					.filter_map(|n| chain.block_hash(n))
+					.collect::<Vec<H256>>()
+
+			} else {
+				// Otherwise, we use a slower version that finds a link between from_block and to_block.
+				let from_hash = Self::block_hash(&chain, filter.from_block)?;
+				let from_number = chain.block_number(&from_hash)?;
+				let to_hash = Self::block_hash(&chain, filter.from_block)?;
+
+				let blooms = filter.bloom_possibilities();
+				let bloom_match = |header: &encoded::Header| {
+					blooms.iter().any(|bloom| header.log_bloom().contains_bloom(bloom))
+				};
+
+				let (blocks, last_hash) = {
+					let mut blocks = Vec::new();
+					let mut current_hash = to_hash;
+
+					loop {
+						let header = chain.block_header_data(&current_hash)?;
+						if bloom_match(&header) {
+							blocks.push(current_hash);
+						}
+
+						// Stop if `from` block is reached.
+						if header.number() <= from_number {
+							break;
+						}
+						current_hash = header.parent_hash();
+					}
+
+					blocks.reverse();
+					(blocks, current_hash)
+				};
+
+				// Check if we've actually reached the expected `from` block.
+				if last_hash != from_hash || blocks.is_empty() {
+					return None;
+				}
+
+				blocks
+			};
+
+			Some(self.chain.read().logs(blocks, |entry| filter.matches(entry), filter.limit))
 		};

-		let chain = self.chain.read();
-		let blocks = filter.bloom_possibilities().iter()
-			.map(move |bloom| {
-				chain.blocks_with_bloom(bloom, from, to)
-			})
-			.flat_map(|m| m)
-			// remove duplicate elements
-			.collect::<HashSet<u64>>()
-			.into_iter()
-			.collect::<Vec<u64>>();
-
-		self.chain.read().logs(blocks, |entry| filter.matches(entry), filter.limit)
+		fetch_logs().unwrap_or_default()
 	}

 	fn filter_traces(&self, filter: TraceFilter) -> Option<Vec<LocalizedTrace>> {
@ -1917,35 +1918,10 @@ impl BlockChainClient for Client {
 		(*self.build_last_hashes(&self.chain.read().best_block_hash())).clone()
 	}

-	fn queue_transactions(&self, transactions: Vec<Bytes>, peer_id: usize) {
-		let queue_size = self.queue_transactions.load(AtomicOrdering::Relaxed);
-		trace!(target: "external_tx", "Queue size: {}", queue_size);
-		if queue_size > MAX_TX_QUEUE_SIZE {
-			debug!("Ignoring {} transactions: queue is full", transactions.len());
-		} else {
-			let len = transactions.len();
-			match self.io_channel.lock().send(ClientIoMessage::NewTransactions(transactions, peer_id)) {
-				Ok(_) => {
-					self.queue_transactions.fetch_add(len, AtomicOrdering::SeqCst);
-				}
-				Err(e) => {
-					debug!("Ignoring {} transactions: error queueing: {}", len, e);
-				}
-			}
-		}
-	}
-
 	fn ready_transactions(&self) -> Vec<Arc<VerifiedTransaction>> {
 		self.importer.miner.ready_transactions(self)
 	}

-	fn queue_consensus_message(&self, message: Bytes) {
-		let channel = self.io_channel.lock().clone();
-		if let Err(e) = channel.send(ClientIoMessage::NewMessage(message)) {
-			debug!("Ignoring the message, error queueing: {}", e);
-		}
-	}
-
 	fn signing_chain_id(&self) -> Option<u64> {
 		self.engine.signing_chain_id(&self.latest_env_info())
 	}
@ -1957,7 +1933,11 @@ impl BlockChainClient for Client {

 	fn uncle_extra_info(&self, id: UncleId) -> Option<BTreeMap<String, String>> {
 		self.uncle(id)
-			.map(|header| self.engine.extra_info(&header.decode()))
+			.and_then(|h| {
+				h.decode().map(|dh| {
+					self.engine.extra_info(&dh)
+				}).ok()
+			})
 	}

 	fn pruning_info(&self) -> PruningInfo {
@ -1993,6 +1973,81 @@ impl BlockChainClient for Client {
 	}
 }

+impl IoClient for Client {
+	fn queue_transactions(&self, transactions: Vec<Bytes>, peer_id: usize) {
+		let len = transactions.len();
+		self.queue_transactions.queue(&mut self.io_channel.lock(), move |client| {
+			trace_time!("import_queued_transactions");
+
+			let txs: Vec<UnverifiedTransaction> = transactions
+				.iter()
+				.filter_map(|bytes| client.engine.decode_transaction(bytes).ok())
+				.collect();
+
+			client.notify(|notify| {
+				notify.transactions_received(&txs, peer_id);
+			});
+
+			client.importer.miner.import_external_transactions(client, txs);
+		}).unwrap_or_else(|e| {
+			debug!(target: "client", "Ignoring {} transactions: {}", len, e);
+		});
+	}
+
+	fn queue_ancient_block(&self, block_bytes: Bytes, receipts_bytes: Bytes) -> Result<H256, BlockImportError> {
+		let header: Header = ::rlp::Rlp::new(&block_bytes).val_at(0)?;
+		let hash = header.hash();
+
+		{
+			// check block order
+			if self.chain.read().is_known(&hash) {
+				bail!(BlockImportErrorKind::Import(ImportErrorKind::AlreadyInChain));
+			}
+
+			let parent_hash = *header.parent_hash();
+			let parent_pending = self.pending_ancient_blocks.read().contains(&parent_hash);
+			let status = self.block_status(BlockId::Hash(parent_hash));
+			if !parent_pending && (status == BlockStatus::Unknown || status == BlockStatus::Pending) {
+				bail!(BlockImportErrorKind::Block(BlockError::UnknownParent(parent_hash)));
+			}
+		}
+
+		self.pending_ancient_blocks.write().insert(hash);
+
+		trace!(target: "client", "Queuing old block #{}", header.number());
+		match self.queue_ancient_blocks.queue(&mut self.io_channel.lock(), move |client| {
+			let result = client.importer.import_old_block(
+				&header,
+				&block_bytes,
+				&receipts_bytes,
+				&**client.db.read(),
+				&*client.chain.read()
+			);
+
+			client.pending_ancient_blocks.write().remove(&hash);
+			result.map(|_| ()).unwrap_or_else(|e| {
+				error!(target: "client", "Error importing ancient block: {}", e);
+			});
+		}) {
+			Ok(_) => Ok(hash),
+			Err(e) => bail!(BlockImportErrorKind::Other(format!("{}", e))),
+		}
+	}
+
+	fn queue_consensus_message(&self, message: Bytes) {
+		match self.queue_consensus_message.queue(&mut self.io_channel.lock(), move |client| {
+			if let Err(e) = client.engine().handle_message(&message) {
+				debug!(target: "poa", "Invalid message received: {}", e);
+			}
+		}) {
+			Ok(_) => (),
+			Err(e) => {
+				debug!(target: "poa", "Ignoring the message, error queueing: {}", e);
+			}
+		}
+	}
+}
+
 impl ReopenBlock for Client {
 	fn reopen_block(&self, block: ClosedBlock) -> OpenBlock {
 		let engine = &*self.engine;
@ -2009,7 +2064,8 @@ impl ReopenBlock for Client {
 			for h in uncles {
 				if !block.uncles().iter().any(|header| header.hash() == h) {
 					let uncle = chain.block_header_data(&h).expect("find_uncle_hashes only returns hashes for existing headers; qed");
-					block.push_uncle(uncle.decode()).expect("pushing up to maximum_uncle_count;
+					let uncle = uncle.decode().expect("decoding failure");
+					block.push_uncle(uncle).expect("pushing up to maximum_uncle_count;
 												push_uncle is not ok only if more than maximum_uncle_count is pushed;
 												so all push_uncle are Ok;
 												qed");
@ -2050,7 +2106,7 @@ impl PrepareOpenBlock for Client {
 			.into_iter()
 			.take(engine.maximum_uncle_count(open_block.header().number()))
 			.foreach(|h| {
-				open_block.push_uncle(h.decode()).expect("pushing maximum_uncle_count;
+				open_block.push_uncle(h.decode().expect("decoding failure")).expect("pushing maximum_uncle_count;
 												open_block was just created;
 												push_uncle is not ok only if more than maximum_uncle_count is pushed;
 												so all push_uncle are Ok;
@ -2088,7 +2144,7 @@ impl ImportSealedBlock for Client {
 			route
 		};
 		let (enacted, retracted) = self.importer.calculate_enacted_retracted(&[route]);
-		self.importer.miner.chain_new_blocks(self, &[h.clone()], &[], &enacted, &retracted, true);
+		self.importer.miner.chain_new_blocks(self, &[h.clone()], &[], &enacted, &retracted, self.engine.seals_internally().is_some());
 		self.notify(|notify| {
 			notify.new_blocks(
 				vec![h.clone()],
@ -2372,3 +2428,57 @@ mod tests {
 		});
 	}
 }
+
+#[derive(Debug)]
+enum QueueError {
+	Channel(IoError),
+	Full(usize),
+}
+
+impl fmt::Display for QueueError {
+	fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+		match *self {
+			QueueError::Channel(ref c) => fmt::Display::fmt(c, fmt),
+			QueueError::Full(limit) => write!(fmt, "The queue is full ({})", limit),
+		}
+	}
+}
+
+/// Queue some items to be processed by IO client.
+struct IoChannelQueue {
+	queue: Arc<Mutex<VecDeque<Box<Fn(&Client) + Send>>>>,
+	limit: usize,
+}
+
+impl IoChannelQueue {
+	pub fn new(limit: usize) -> Self {
+		IoChannelQueue {
+			queue: Default::default(),
+			limit,
+		}
+	}
+
+	pub fn queue<F>(&self, channel: &mut IoChannel<ClientIoMessage>, fun: F) -> Result<(), QueueError>
+		where F: Fn(&Client) + Send + Sync + 'static
+	{
+		{
+			let mut queue = self.queue.lock();
+			let queue_size = queue.len();
+			ensure!(queue_size < self.limit, QueueError::Full(self.limit));
+
+			queue.push_back(Box::new(fun));
+		}
+
+		let queue = self.queue.clone();
+		let result = channel.send(ClientIoMessage::execute(move |client| {
+			while let Some(fun) = queue.lock().pop_front() {
+				fun(client);
+			}
+		}));
+
+		match result {
+			Ok(_) => Ok(()),
+			Err(e) => Err(QueueError::Channel(e)),
+		}
+	}
+}
--- a/ethcore/src/client/io_message.rs
+++ b/ethcore/src/client/io_message.rs
@ -14,19 +14,19 @@
 // You should have received a copy of the GNU General Public License
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.

-use ethereum_types::H256;
+use std::fmt;
 use bytes::Bytes;
+use client::Client;
+use ethereum_types::H256;
 use snapshot::ManifestData;

 /// Message type for external and internal events
-#[derive(Clone, PartialEq, Eq, Debug)]
+#[derive(Debug)]
 pub enum ClientIoMessage {
 	/// Best Block Hash in chain has been changed
 	NewChainHead,
 	/// A block is ready
 	BlockVerified,
-	/// New transaction RLPs are ready to be imported
-	NewTransactions(Vec<Bytes>, usize),
 	/// Begin snapshot restoration
 	BeginRestoration(ManifestData),
 	/// Feed a state chunk to the snapshot service
@ -35,9 +35,23 @@ pub enum ClientIoMessage {
 	FeedBlockChunk(H256, Bytes),
 	/// Take a snapshot for the block with given number.
 	TakeSnapshot(u64),
-	/// New consensus message received.
-	NewMessage(Bytes),
-	/// New private transaction arrived
-	NewPrivateTransaction,
+	/// Execute wrapped closure
+	Execute(Callback),
+}
+
+impl ClientIoMessage {
+	/// Create new `ClientIoMessage` that executes given procedure.
+	pub fn execute<F: Fn(&Client) + Send + Sync + 'static>(fun: F) -> Self {
+		ClientIoMessage::Execute(Callback(Box::new(fun)))
+	}
+}
+
+/// A function to invoke in the client thread.
+pub struct Callback(pub Box<Fn(&Client) + Send + Sync>);
+
+impl fmt::Debug for Callback {
+	fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+		write!(fmt, "<callback>")
+	}
 }

--- a/ethcore/src/client/mod.rs
+++ b/ethcore/src/client/mod.rs
@ -36,9 +36,8 @@ pub use self::traits::{
    Nonce, Balance, ChainInfo, BlockInfo, ReopenBlock, PrepareOpenBlock, CallContract, TransactionInfo, RegistryInfo, ScheduleInfo, ImportSealedBlock, BroadcastProposalBlock, ImportBlock,
    StateOrBlock, StateClient, Call, EngineInfo, AccountData, BlockChain, BlockProducer, SealedBlockImporter
 };
-//pub use self::private_notify::PrivateNotify;
 pub use state::StateInfo;
-pub use self::traits::{BlockChainClient, EngineClient, ProvingBlockChainClient};
+pub use self::traits::{BlockChainClient, EngineClient, ProvingBlockChainClient, IoClient};

 pub use types::ids::*;
 pub use types::trace_filter::Filter as TraceFilter;
--- a/ethcore/src/client/test_client.rs
+++ b/ethcore/src/client/test_client.rs
@ -39,7 +39,7 @@ use client::{
 	PrepareOpenBlock, BlockChainClient, BlockChainInfo, BlockStatus, BlockId,
 	TransactionId, UncleId, TraceId, TraceFilter, LastHashes, CallAnalytics, BlockImportError,
 	ProvingBlockChainClient, ScheduleInfo, ImportSealedBlock, BroadcastProposalBlock, ImportBlock, StateOrBlock,
-	Call, StateClient, EngineInfo, AccountData, BlockChain, BlockProducer, SealedBlockImporter
+	Call, StateClient, EngineInfo, AccountData, BlockChain, BlockProducer, SealedBlockImporter, IoClient
 };
 use db::{NUM_COLUMNS, COL_STATE};
 use header::{Header as BlockHeader, BlockNumber};
@ -289,7 +289,7 @@ impl TestBlockChainClient {
 	/// Make a bad block by setting invalid extra data.
 	pub fn corrupt_block(&self, n: BlockNumber) {
 		let hash = self.block_hash(BlockId::Number(n)).unwrap();
-		let mut header: BlockHeader = self.block_header(BlockId::Number(n)).unwrap().decode();
+		let mut header: BlockHeader = self.block_header(BlockId::Number(n)).unwrap().decode().expect("decoding failed");
 		header.set_extra_data(b"This extra data is way too long to be considered valid".to_vec());
 		let mut rlp = RlpStream::new_list(3);
 		rlp.append(&header);
@ -301,7 +301,7 @@ impl TestBlockChainClient {
 	/// Make a bad block by setting invalid parent hash.
 	pub fn corrupt_block_parent(&self, n: BlockNumber) {
 		let hash = self.block_hash(BlockId::Number(n)).unwrap();
-		let mut header: BlockHeader = self.block_header(BlockId::Number(n)).unwrap().decode();
+		let mut header: BlockHeader = self.block_header(BlockId::Number(n)).unwrap().decode().expect("decoding failed");
 		header.set_parent_hash(H256::from(42));
 		let mut rlp = RlpStream::new_list(3);
 		rlp.append(&header);
@ -479,6 +479,7 @@ impl BlockInfo for TestBlockChainClient {
 		self.block_header(BlockId::Hash(self.chain_info().best_block_hash))
 			.expect("Best block always has header.")
 			.decode()
+			.expect("decoding failed")
 	}

 	fn block(&self, id: BlockId) -> Option<encoded::Block> {
@ -556,10 +557,6 @@ impl ImportBlock for TestBlockChainClient {
 		}
 		Ok(h)
 	}
-
-	fn import_block_with_receipts(&self, b: Bytes, _r: Bytes) -> Result<H256, BlockImportError> {
-		self.import_block(b)
-	}
 }

 impl Call for TestBlockChainClient {
@ -809,16 +806,6 @@ impl BlockChainClient for TestBlockChainClient {
 		self.traces.read().clone()
 	}

-	fn queue_transactions(&self, transactions: Vec<Bytes>, _peer_id: usize) {
-		// import right here
-		let txs = transactions.into_iter().filter_map(|bytes| Rlp::new(&bytes).as_val().ok()).collect();
-		self.miner.import_external_transactions(self, txs);
-	}
-
-	fn queue_consensus_message(&self, message: Bytes) {
-		self.spec.engine.handle_message(&message).unwrap();
-	}
-
 	fn ready_transactions(&self) -> Vec<Arc<VerifiedTransaction>> {
 		self.miner.ready_transactions(self)
 	}
@ -863,6 +850,22 @@ impl BlockChainClient for TestBlockChainClient {
 	fn eip86_transition(&self) -> u64 { u64::max_value() }
 }

+impl IoClient for TestBlockChainClient {
+	fn queue_transactions(&self, transactions: Vec<Bytes>, _peer_id: usize) {
+		// import right here
+		let txs = transactions.into_iter().filter_map(|bytes| Rlp::new(&bytes).as_val().ok()).collect();
+		self.miner.import_external_transactions(self, txs);
+	}
+
+	fn queue_ancient_block(&self, b: Bytes, _r: Bytes) -> Result<H256, BlockImportError> {
+		self.import_block(b)
+	}
+
+	fn queue_consensus_message(&self, message: Bytes) {
+		self.spec.engine.handle_message(&message).unwrap();
+	}
+}
+
 impl ProvingBlockChainClient for TestBlockChainClient {
 	fn prove_storage(&self, _: H256, _: H256, _: BlockId) -> Option<(Vec<Bytes>, H256)> {
 		None
--- a/ethcore/src/client/traits.rs
+++ b/ethcore/src/client/traits.rs
@ -168,9 +168,6 @@ pub trait RegistryInfo {
 pub trait ImportBlock {
 	/// Import a block into the blockchain.
 	fn import_block(&self, bytes: Bytes) -> Result<H256, BlockImportError>;
-
-	/// Import a block with transaction receipts. Does no sealing and transaction validation.
-	fn import_block_with_receipts(&self, block_bytes: Bytes, receipts_bytes: Bytes) -> Result<H256, BlockImportError>;
 }

 /// Provides `call_contract` method
@ -201,8 +198,21 @@ pub trait EngineInfo {
 	fn engine(&self) -> &EthEngine;
 }

+/// IO operations that should off-load heavy work to another thread.
+pub trait IoClient: Sync + Send {
+	/// Queue transactions for importing.
+	fn queue_transactions(&self, transactions: Vec<Bytes>, peer_id: usize);
+
+	/// Queue block import with transaction receipts. Does no sealing and transaction validation.
+	fn queue_ancient_block(&self, block_bytes: Bytes, receipts_bytes: Bytes) -> Result<H256, BlockImportError>;
+
+	/// Queue conensus engine message.
+	fn queue_consensus_message(&self, message: Bytes);
+}
+
 /// Blockchain database client. Owns and manages a blockchain and a block queue.
-pub trait BlockChainClient : Sync + Send + AccountData + BlockChain + CallContract + RegistryInfo + ImportBlock {
+pub trait BlockChainClient : Sync + Send + AccountData + BlockChain + CallContract + RegistryInfo + ImportBlock
+ IoClient {
 	/// Look up the block number for the given block ID.
 	fn block_number(&self, id: BlockId) -> Option<BlockNumber>;

@ -310,12 +320,6 @@ pub trait BlockChainClient : Sync + Send + AccountData + BlockChain + CallContra
 	/// Get last hashes starting from best block.
 	fn last_hashes(&self) -> LastHashes;

-	/// Queue transactions for importing.
-	fn queue_transactions(&self, transactions: Vec<Bytes>, peer_id: usize);
-
-	/// Queue conensus engine message.
-	fn queue_consensus_message(&self, message: Bytes);
-
 	/// List all transactions that are allowed into the next block.
 	fn ready_transactions(&self) -> Vec<Arc<VerifiedTransaction>>;

--- a/ethcore/src/db.rs
+++ b/ethcore/src/db.rs
@ -218,15 +218,12 @@ impl Writable for DBTransaction {
 }

 impl<KVDB: KeyValueDB + ?Sized> Readable for KVDB {
-	fn read<T, R>(&self, col: Option<u32>, key: &Key<T, Target = R>) -> Option<T> where T: rlp::Decodable, R: Deref<Target = [u8]> {
-		let result = self.get(col, &key.key());
+	fn read<T, R>(&self, col: Option<u32>, key: &Key<T, Target = R>) -> Option<T>
+		where T: rlp::Decodable, R: Deref<Target = [u8]> {
+		self.get(col, &key.key())
+			.expect(&format!("db get failed, key: {:?}", &key.key() as &[u8]))
+			.map(|v| rlp::decode(&v).expect("decode db value failed") )

-		match result {
-			Ok(option) => option.map(|v| rlp::decode(&v)),
-			Err(err) => {
-				panic!("db get failed, key: {:?}, err: {:?}", &key.key() as &[u8], err);
-			}
-		}
 	}

 	fn exists<T, R>(&self, col: Option<u32>, key: &Key<T, Target = R>) -> bool where R: Deref<Target = [u8]> {
--- a/ethcore/src/encoded.rs
+++ b/ethcore/src/encoded.rs
@ -24,13 +24,12 @@
 //! decoded object where parts like the hash can be saved.

 use block::Block as FullBlock;
-use header::{BlockNumber, Header as FullHeader};
-use transaction::UnverifiedTransaction;
-
-use hash::keccak;
-use heapsize::HeapSizeOf;
 use ethereum_types::{H256, Bloom, U256, Address};
-use rlp::{Rlp, RlpStream};
+use hash::keccak;
+use header::{BlockNumber, Header as FullHeader};
+use heapsize::HeapSizeOf;
+use rlp::{self, Rlp, RlpStream};
+use transaction::UnverifiedTransaction;
 use views::{self, BlockView, HeaderView, BodyView};

 /// Owning header view.
@ -48,7 +47,9 @@ impl Header {
 	pub fn new(encoded: Vec<u8>) -> Self { Header(encoded) }

 	/// Upgrade this encoded view to a fully owned `Header` object.
-	pub fn decode(&self) -> FullHeader { ::rlp::decode(&self.0) }
+	pub fn decode(&self) -> Result<FullHeader, rlp::DecoderError> {
+		rlp::decode(&self.0)
+	}

 	/// Get a borrowed header view onto the data.
 	#[inline]
@ -205,7 +206,7 @@ impl Block {
 	pub fn header_view(&self) -> HeaderView { self.view().header_view() }

 	/// Decode to a full block.
-	pub fn decode(&self) -> FullBlock { ::rlp::decode(&self.0) }
+	pub fn decode(&self) -> Result<FullBlock, rlp::DecoderError> { rlp::decode(&self.0) }

 	/// Decode the header.
 	pub fn decode_header(&self) -> FullHeader { self.view().rlp().val_at(0) }
--- a/ethcore/src/engines/authority_round/mod.rs
+++ b/ethcore/src/engines/authority_round/mod.rs
@ -996,7 +996,7 @@ impl Engine<EthereumMachine> for AuthorityRound {

 				let parent = client.block_header(::client::BlockId::Hash(*block.header().parent_hash()))
 					.expect("hash is from parent; parent header must exist; qed")
-					.decode();
+					.decode()?;

 				let parent_step = header_step(&parent, self.empty_steps_transition)?;
 				let current_step = self.step.load();
--- a/ethcore/src/engines/mod.rs
+++ b/ethcore/src/engines/mod.rs
@ -426,6 +426,11 @@ pub trait EthEngine: Engine<::machine::EthereumMachine> {
 	fn additional_params(&self) -> HashMap<String, String> {
 		self.machine().additional_params()
 	}
+
+	/// Performs pre-validation of RLP decoded transaction before other processing
+	fn decode_transaction(&self, transaction: &[u8]) -> Result<UnverifiedTransaction, transaction::Error> {
+		self.machine().decode_transaction(transaction)
+	}
 }

 // convenience wrappers for existing functions.
--- a/ethcore/src/engines/tendermint/mod.rs
+++ b/ethcore/src/engines/tendermint/mod.rs
@ -142,8 +142,10 @@ impl <F> super::EpochVerifier<EthereumMachine> for EpochVerifier<F>
 	}

 	fn check_finality_proof(&self, proof: &[u8]) -> Option<Vec<H256>> {
-		let header: Header = ::rlp::decode(proof);
-		self.verify_light(&header).ok().map(|_| vec![header.hash()])
+		match ::rlp::decode(proof) {
+			Ok(header) => self.verify_light(&header).ok().map(|_| vec![header.hash()]),
+			Err(_) => None // REVIEW: log perhaps? Not sure what the policy is.
+		}
 	}
 }

--- a/ethcore/src/error.rs
+++ b/ethcore/src/error.rs
@ -190,6 +190,7 @@ error_chain! {

 	foreign_links {
 		Block(BlockError) #[doc = "Block error"];
+		Decoder(::rlp::DecoderError) #[doc = "Rlp decoding error"];
 	}

 	errors {
@ -206,6 +207,7 @@ impl From<Error> for BlockImportError {
 		match e {
 			Error(ErrorKind::Block(block_error), _) => BlockImportErrorKind::Block(block_error).into(),
 			Error(ErrorKind::Import(import_error), _) => BlockImportErrorKind::Import(import_error.into()).into(),
+			Error(ErrorKind::Util(util_error::ErrorKind::Decoder(decoder_err)), _) => BlockImportErrorKind::Decoder(decoder_err).into(),
 			_ => BlockImportErrorKind::Other(format!("other block import error: {:?}", e)).into(),
 		}
 	}
@ -288,6 +290,12 @@ error_chain! {
 			description("Unknown engine name")
 			display("Unknown engine name ({})", name)
 		}
+
+		#[doc = "RLP decoding errors"]
+		Decoder(err: ::rlp::DecoderError) {
+			description("decoding value failed")
+			display("decoding value failed with error: {}", err)
+		}
 	}
 }

@ -308,11 +316,11 @@ impl From<AccountsError> for Error {
 	fn from(err: AccountsError) -> Error { 
 		ErrorKind::AccountProvider(err).into()
 	} 
-} 
+}

 impl From<::rlp::DecoderError> for Error {
 	fn from(err: ::rlp::DecoderError) -> Error {
-		UtilError::from(err).into()
+		ErrorKind::Decoder(err).into()
 	}
 }

--- a/ethcore/src/executive.rs
+++ b/ethcore/src/executive.rs
@ -428,8 +428,14 @@ impl<'a, B: 'a + StateBackend> Executive<'a, B> {
 					self.state.discard_checkpoint();
 					output.write(0, &builtin_out_buffer);

-					// trace only top level calls to builtins to avoid DDoS attacks
-					if self.depth == 0 {
+					// Trace only top level calls and calls with balance transfer to builtins. The reason why we don't
+					// trace all internal calls to builtin contracts is that memcpy (IDENTITY) is a heavily used
+					// function.
+					let is_transferred = match params.value {
+						ActionValue::Transfer(value) => value != U256::zero(),
+						ActionValue::Apparent(_) => false,
+					};
+					if self.depth == 0 || is_transferred {
 						let mut trace_output = tracer.prepare_trace_output();
 						if let Some(out) = trace_output.as_mut() {
 							*out = output.to_owned();
@ -722,6 +728,12 @@ mod tests {
 		machine
 	}

+	fn make_byzantium_machine(max_depth: usize) -> EthereumMachine {
+		let mut machine = ::ethereum::new_byzantium_test_machine();
+		machine.set_schedule_creation_rules(Box::new(move |s, _| s.max_depth = max_depth));
+		machine
+	}
+
 	#[test]
 	fn test_contract_address() {
 		let address = Address::from_str("0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6").unwrap();
@ -813,6 +825,76 @@ mod tests {
 		assert_eq!(substate.contracts_created.len(), 0);
 	}

+	#[test]
+	fn test_call_to_precompiled_tracing() {
+		// code:
+		//
+		// 60 00 - push 00 out size
+		// 60 00 - push 00 out offset
+		// 60 00 - push 00 in size
+		// 60 00 - push 00 in offset
+		// 60 01 - push 01 value
+		// 60 03 - push 03 to
+		// 61 ffff - push fff gas
+		// f1 - CALL
+
+		let code = "60006000600060006001600361fffff1".from_hex().unwrap();
+		let sender = Address::from_str("4444444444444444444444444444444444444444").unwrap();
+		let address = Address::from_str("5555555555555555555555555555555555555555").unwrap();
+
+		let mut params = ActionParams::default();
+		params.address = address.clone();
+		params.code_address = address.clone();
+		params.sender = sender.clone();
+		params.origin = sender.clone();
+		params.gas = U256::from(100_000);
+		params.code = Some(Arc::new(code));
+		params.value = ActionValue::Transfer(U256::from(100));
+		params.call_type = CallType::Call;
+		let mut state = get_temp_state();
+		state.add_balance(&sender, &U256::from(100), CleanupMode::NoEmpty).unwrap();
+		let info = EnvInfo::default();
+		let machine = make_byzantium_machine(5);
+		let mut substate = Substate::new();
+		let mut tracer = ExecutiveTracer::default();
+		let mut vm_tracer = ExecutiveVMTracer::toplevel();
+
+		let mut ex = Executive::new(&mut state, &info, &machine);
+		let output = BytesRef::Fixed(&mut[0u8;0]);
+		ex.call(params, &mut substate, output, &mut tracer, &mut vm_tracer).unwrap();
+
+		assert_eq!(tracer.drain(), vec![FlatTrace {
+			action: trace::Action::Call(trace::Call {
+				from: "4444444444444444444444444444444444444444".into(),
+				to: "5555555555555555555555555555555555555555".into(),
+				value: 100.into(),
+				gas: 100_000.into(),
+				input: vec![],
+				call_type: CallType::Call
+			}),
+			result: trace::Res::Call(trace::CallResult {
+				gas_used: 33021.into(),
+				output: vec![]
+			}),
+			subtraces: 1,
+			trace_address: Default::default()
+		}, FlatTrace {
+			action: trace::Action::Call(trace::Call {
+				from: "5555555555555555555555555555555555555555".into(),
+				to: "0000000000000000000000000000000000000003".into(),
+				value: 1.into(),
+				gas: 66560.into(),
+				input: vec![],
+				call_type: CallType::Call
+			}), result: trace::Res::Call(trace::CallResult {
+				gas_used: 600.into(),
+				output: vec![]
+			}),
+			subtraces: 0,
+			trace_address: vec![0].into_iter().collect(),
+		}]);
+	}
+
 	#[test]
 	// Tracing is not suported in JIT
 	fn test_call_to_create() {
--- a/ethcore/src/header.rs
+++ b/ethcore/src/header.rs
@ -398,7 +398,7 @@ mod tests {
 		let nonce = "88ab4e252a7e8c2a23".from_hex().unwrap();
 		let nonce_decoded = "ab4e252a7e8c2a23".from_hex().unwrap();

-		let header: Header = rlp::decode(&header_rlp);
+		let header: Header = rlp::decode(&header_rlp).expect("error decoding header");
 		let seal_fields = header.seal.clone();
 		assert_eq!(seal_fields.len(), 2);
 		assert_eq!(seal_fields[0], mix_hash);
@ -415,7 +415,7 @@ mod tests {
 		// that's rlp of block header created with ethash engine.
 		let header_rlp = "f901f9a0d405da4e66f1445d455195229624e133f5baafe72b5cf7b3c36c12c8146e98b7a01dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347948888f1f195afa192cfee860698584c030f4c9db1a05fb2b4bfdef7b314451cb138a534d225c922fc0e5fbe25e451142732c3e25c25a088d2ec6b9860aae1a2c3b299f72b6a5d70d7f7ba4722c78f2c49ba96273c2158a007c6fdfa8eea7e86b81f5b0fc0f78f90cc19f4aa60d323151e0cac660199e9a1b90100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008302008003832fefba82524d84568e932a80a0a0349d8c3df71f1a48a9df7d03fd5f14aeee7d91332c009ecaff0a71ead405bd88ab4e252a7e8c2a23".from_hex().unwrap();

-		let header: Header = rlp::decode(&header_rlp);
+		let header: Header = rlp::decode(&header_rlp).expect("error decoding header");
 		let encoded_header = rlp::encode(&header).into_vec();

 		assert_eq!(header_rlp, encoded_header);
--- a/ethcore/src/machine.rs
+++ b/ethcore/src/machine.rs
@ -34,6 +34,7 @@ use tx_filter::TransactionFilter;

 use ethereum_types::{U256, Address};
 use bytes::BytesRef;
+use rlp::Rlp;
 use vm::{CallType, ActionParams, ActionValue, ParamsType};
 use vm::{EnvInfo, Schedule, CreateContractAddress};

@ -121,7 +122,13 @@ impl EthereumMachine {
 }

 impl EthereumMachine {
-	/// Execute a call as the system address.
+	/// Execute a call as the system address. Block environment information passed to the
+	/// VM is modified to have its gas limit bounded at the upper limit of possible used
+	/// gases including this system call, capped at the maximum value able to be
+	/// represented by U256. This system call modifies the block state, but discards other
+	/// information. If suicides, logs or refunds happen within the system call, they
+	/// will not be executed or recorded. Gas used by this system call will not be counted
+	/// on the block.
 	pub fn execute_as_system(
 		&self,
 		block: &mut ExecutedBlock,
@ -131,7 +138,7 @@ impl EthereumMachine {
 	) -> Result<Vec<u8>, Error> {
 		let env_info = {
 			let mut env_info = block.env_info();
-			env_info.gas_limit = env_info.gas_used + gas;
+			env_info.gas_limit = env_info.gas_used.saturating_add(gas);
 			env_info
 		};

@ -376,6 +383,16 @@ impl EthereumMachine {
 			"registrar".to_owned() => format!("{:x}", self.params.registrar)
 		]
 	}
+
+	/// Performs pre-validation of RLP decoded transaction before other processing
+	pub fn decode_transaction(&self, transaction: &[u8]) -> Result<UnverifiedTransaction, transaction::Error> {
+		let rlp = Rlp::new(&transaction);
+		if rlp.as_raw().len() > self.params().max_transaction_size {
+			debug!("Rejected oversized transaction of {} bytes", rlp.as_raw().len());
+			return Err(transaction::Error::TooBig)
+		}
+		rlp.as_val().map_err(|e| transaction::Error::InvalidRlp(e.to_string()))
+	}
 }

 /// Auxiliary data fetcher for an Ethereum machine. In Ethereum-like machines
--- a/ethcore/src/miner/miner.rs
+++ b/ethcore/src/miner/miner.rs
@ -528,8 +528,8 @@ impl Miner {
 	}

 	/// Attempts to perform internal sealing (one that does not require work) and handles the result depending on the type of Seal.
-	fn seal_and_import_block_internally<C>(&self, chain: &C, block: ClosedBlock) -> bool where
-		C: BlockChain + SealedBlockImporter,
+	fn seal_and_import_block_internally<C>(&self, chain: &C, block: ClosedBlock) -> bool
+		where C: BlockChain + SealedBlockImporter,
 	{
 		{
 			let sealing = self.sealing.lock();
@ -544,7 +544,12 @@ impl Miner {
 		trace!(target: "miner", "seal_block_internally: attempting internal seal.");

 		let parent_header = match chain.block_header(BlockId::Hash(*block.header().parent_hash())) {
-			Some(hdr) => hdr.decode(),
+			Some(h) => {
+				match h.decode() {
+					Ok(decoded_hdr) => decoded_hdr,
+					Err(_) => return false
+				}
+			}
 			None => return false,
 		};

--- a/ethcore/src/miner/pool_client.rs
+++ b/ethcore/src/miner/pool_client.rs
@ -145,6 +145,10 @@ impl<'a, C: 'a> pool::client::Client for PoolClient<'a, C> where
 			}
 		}
 	}
+
+	fn decode_transaction(&self, transaction: &[u8]) -> Result<UnverifiedTransaction, transaction::Error> {
+		self.engine.decode_transaction(transaction)
+	}
 }

 impl<'a, C: 'a> NonceClient for PoolClient<'a, C> where
--- a/ethcore/src/snapshot/account.rs
+++ b/ethcore/src/snapshot/account.rs
@ -236,7 +236,7 @@ mod tests {
 		};

 		let thin_rlp = ::rlp::encode(&account);
-		assert_eq!(::rlp::decode::<BasicAccount>(&thin_rlp), account);
+		assert_eq!(::rlp::decode::<BasicAccount>(&thin_rlp).unwrap(), account);

 		let fat_rlps = to_fat_rlps(&keccak(&addr), &account, &AccountDB::new(db.as_hashdb(), &addr), &mut Default::default(), usize::max_value(), usize::max_value()).unwrap();
 		let fat_rlp = Rlp::new(&fat_rlps[0]).at(1).unwrap();
@ -261,7 +261,7 @@ mod tests {
 		};

 		let thin_rlp = ::rlp::encode(&account);
-		assert_eq!(::rlp::decode::<BasicAccount>(&thin_rlp), account);
+		assert_eq!(::rlp::decode::<BasicAccount>(&thin_rlp).unwrap(), account);

 		let fat_rlp = to_fat_rlps(&keccak(&addr), &account, &AccountDB::new(db.as_hashdb(), &addr), &mut Default::default(), usize::max_value(), usize::max_value()).unwrap();
 		let fat_rlp = Rlp::new(&fat_rlp[0]).at(1).unwrap();
@ -286,7 +286,7 @@ mod tests {
 		};

 		let thin_rlp = ::rlp::encode(&account);
-		assert_eq!(::rlp::decode::<BasicAccount>(&thin_rlp), account);
+		assert_eq!(::rlp::decode::<BasicAccount>(&thin_rlp).unwrap(), account);

 		let fat_rlps = to_fat_rlps(&keccak(addr), &account, &AccountDB::new(db.as_hashdb(), &addr), &mut Default::default(), 500, 1000).unwrap();
 		let mut root = KECCAK_NULL_RLP;
--- a/ethcore/src/snapshot/consensus/authority.rs
+++ b/ethcore/src/snapshot/consensus/authority.rs
@ -100,7 +100,7 @@ impl SnapshotComponents for PoaSnapshot {
 		let (block, receipts) = chain.block(&block_at)
 			.and_then(|b| chain.block_receipts(&block_at).map(|r| (b, r)))
 			.ok_or(Error::BlockNotFound(block_at))?;
-		let block = block.decode();
+		let block = block.decode()?;

 		let parent_td = chain.block_details(block.header.parent_hash())
 			.map(|d| d.total_difficulty)
--- a/ethcore/src/snapshot/mod.rs
+++ b/ethcore/src/snapshot/mod.rs
@ -281,7 +281,7 @@ pub fn chunk_state<'a>(db: &HashDB, root: &H256, writer: &Mutex<SnapshotWriter +
 	// account_key here is the address' hash.
 	for item in account_trie.iter()? {
 		let (account_key, account_data) = item?;
-		let account = ::rlp::decode(&*account_data);
+		let account = ::rlp::decode(&*account_data)?;
 		let account_key_hash = H256::from_slice(&account_key);

 		let account_db = AccountDB::from_hash(db, account_key_hash);
@ -467,10 +467,10 @@ fn rebuild_accounts(
 		*out = (hash, thin_rlp);
 	}
 	if let Some(&(ref hash, ref rlp)) = out_chunk.iter().last() {
-		known_storage_roots.insert(*hash, ::rlp::decode::<BasicAccount>(rlp).storage_root);
+		known_storage_roots.insert(*hash, ::rlp::decode::<BasicAccount>(rlp)?.storage_root);
 	}
 	if let Some(&(ref hash, ref rlp)) = out_chunk.iter().next() {
-		known_storage_roots.insert(*hash, ::rlp::decode::<BasicAccount>(rlp).storage_root);
+		known_storage_roots.insert(*hash, ::rlp::decode::<BasicAccount>(rlp)?.storage_root);
 	}
 	Ok(status)
 }
@ -487,7 +487,7 @@ pub fn verify_old_block(rng: &mut OsRng, header: &Header, engine: &EthEngine, ch
 	if always || rng.gen::<f32>() <= POW_VERIFY_RATE {
 		engine.verify_block_unordered(header)?;
 		match chain.block_header_data(header.parent_hash()) {
-			Some(parent) => engine.verify_block_family(header, &parent.decode()),
+			Some(parent) => engine.verify_block_family(header, &parent.decode()?),
 			None => Ok(()),
 		}
 	} else {
--- a/ethcore/src/snapshot/service.rs
+++ b/ethcore/src/snapshot/service.rs
@ -17,8 +17,8 @@
 //! Snapshot network service implementation.

 use std::collections::HashSet;
-use std::io::ErrorKind;
-use std::fs;
+use std::io::{self, Read, ErrorKind};
+use std::fs::{self, File};
 use std::path::PathBuf;
 use std::sync::Arc;
 use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
@ -30,6 +30,7 @@ use blockchain::BlockChain;
 use client::{Client, ChainInfo, ClientIoMessage};
 use engines::EthEngine;
 use error::Error;
+use hash::keccak;
 use ids::BlockId;

 use io::IoChannel;
@ -270,8 +271,8 @@ impl Service {
 			}
 		}

-		// delete the temporary restoration dir if it does exist.
-		if let Err(e) = fs::remove_dir_all(service.restoration_dir()) {
+		// delete the temporary restoration DB dir if it does exist.
+		if let Err(e) = fs::remove_dir_all(service.restoration_db()) {
 			if e.kind() != ErrorKind::NotFound {
 				return Err(e.into())
 			}
@ -325,6 +326,13 @@ impl Service {
 		dir
 	}

+	// previous snapshot chunks path.
+	fn prev_chunks_dir(&self) -> PathBuf {
+		let mut dir = self.snapshot_root.clone();
+		dir.push("prev_chunks");
+		dir
+	}
+
 	// replace one the client's database with our own.
 	fn replace_client_db(&self) -> Result<(), Error> {
 		let our_db = self.restoration_db();
@ -406,10 +414,27 @@ impl Service {
 	/// Initialize the restoration synchronously.
 	/// The recover flag indicates whether to recover the restored snapshot.
 	pub fn init_restore(&self, manifest: ManifestData, recover: bool) -> Result<(), Error> {
-		let rest_dir = self.restoration_dir();
-
 		let mut res = self.restoration.lock();

+		let rest_dir = self.restoration_dir();
+		let rest_db = self.restoration_db();
+		let recovery_temp = self.temp_recovery_dir();
+		let prev_chunks = self.prev_chunks_dir();
+
+		// delete and restore the restoration dir.
+		if let Err(e) = fs::remove_dir_all(&prev_chunks) {
+			match e.kind() {
+				ErrorKind::NotFound => {},
+				_ => return Err(e.into()),
+			}
+		}
+
+		// Move the previous recovery temp directory
+		// to `prev_chunks` to be able to restart restoring
+		// with previously downloaded blocks
+		// This step is optional, so don't fail on error
+		fs::rename(&recovery_temp, &prev_chunks).ok();
+
 		self.state_chunks.store(0, Ordering::SeqCst);
 		self.block_chunks.store(0, Ordering::SeqCst);

@ -424,29 +449,38 @@ impl Service {
 			}
 		}

+		*self.status.lock() = RestorationStatus::Initializing {
+			chunks_done: 0,
+		};
+
 		fs::create_dir_all(&rest_dir)?;

 		// make new restoration.
 		let writer = match recover {
-			true => Some(LooseWriter::new(self.temp_recovery_dir())?),
+			true => Some(LooseWriter::new(recovery_temp)?),
 			false => None
 		};

 		let params = RestorationParams {
-			manifest: manifest,
+			manifest: manifest.clone(),
 			pruning: self.pruning,
-			db: self.restoration_db_handler.open(&self.restoration_db())?,
+			db: self.restoration_db_handler.open(&rest_db)?,
 			writer: writer,
 			genesis: &self.genesis_block,
-			guard: Guard::new(rest_dir),
+			guard: Guard::new(rest_db),
 			engine: &*self.engine,
 		};

-		let state_chunks = params.manifest.state_hashes.len();
-		let block_chunks = params.manifest.block_hashes.len();
+		let state_chunks = manifest.state_hashes.len();
+		let block_chunks = manifest.block_hashes.len();

 		*res = Some(Restoration::new(params)?);

+		self.restoring_snapshot.store(true, Ordering::SeqCst);
+
+		// Import previous chunks, continue if it fails
+		self.import_prev_chunks(&mut res, manifest).ok();
+
 		*self.status.lock() = RestorationStatus::Ongoing {
 			state_chunks: state_chunks as u32,
 			block_chunks: block_chunks as u32,
@ -454,10 +488,65 @@ impl Service {
 			block_chunks_done: self.block_chunks.load(Ordering::SeqCst) as u32,
 		};

-		self.restoring_snapshot.store(true, Ordering::SeqCst);
 		Ok(())
 	}

+	/// Import the previous chunks into the current restoration
+	fn import_prev_chunks(&self, restoration: &mut Option<Restoration>, manifest: ManifestData) -> Result<(), Error> {
+		let prev_chunks = self.prev_chunks_dir();
+
+		// Restore previous snapshot chunks
+		let files = fs::read_dir(prev_chunks.as_path())?;
+		let mut num_temp_chunks = 0;
+
+		for prev_chunk_file in files {
+			// Don't go over all the files if the restoration has been aborted
+			if !self.restoring_snapshot.load(Ordering::SeqCst) {
+				trace!(target:"snapshot", "Aborting importing previous chunks");
+				return Ok(());
+			}
+			// Import the chunk, don't fail and continue if one fails
+			match self.import_prev_chunk(restoration, &manifest, prev_chunk_file) {
+				Ok(true) => num_temp_chunks += 1,
+				Err(e) => trace!(target: "snapshot", "Error importing chunk: {:?}", e),
+				_ => (),
+			}
+		}
+
+		trace!(target:"snapshot", "Imported {} previous chunks", num_temp_chunks);
+
+		// Remove the prev temp directory
+		fs::remove_dir_all(&prev_chunks)?;
+
+		Ok(())
+	}
+
+	/// Import a previous chunk at the given path. Returns whether the block was imported or not
+	fn import_prev_chunk(&self, restoration: &mut Option<Restoration>, manifest: &ManifestData, file: io::Result<fs::DirEntry>) -> Result<bool, Error> {
+		let file = file?;
+		let path = file.path();
+
+		let mut file = File::open(path.clone())?;
+		let mut buffer = Vec::new();
+		file.read_to_end(&mut buffer)?;
+
+		let hash = keccak(&buffer);
+
+		let is_state = if manifest.block_hashes.contains(&hash) {
+			false
+		} else if manifest.state_hashes.contains(&hash) {
+			true
+		} else {
+			return Ok(false);
+		};
+
+		self.feed_chunk_with_restoration(restoration, hash, &buffer, is_state)?;
+
+		trace!(target: "snapshot", "Fed chunk {:?}", hash);
+
+		Ok(true)
+	}
+
 	// finalize the restoration. this accepts an already-locked
 	// restoration as an argument -- so acquiring it again _will_
 	// lead to deadlock.
@ -499,12 +588,19 @@ impl Service {
 	/// Feed a chunk of either kind. no-op if no restoration or status is wrong.
 	fn feed_chunk(&self, hash: H256, chunk: &[u8], is_state: bool) -> Result<(), Error> {
 		// TODO: be able to process block chunks and state chunks at same time?
-		let (result, db) = {
-			let mut restoration = self.restoration.lock();
+		let mut restoration = self.restoration.lock();
+		self.feed_chunk_with_restoration(&mut restoration, hash, chunk, is_state)
+	}

+	/// Feed a chunk with the Restoration
+	fn feed_chunk_with_restoration(&self, restoration: &mut Option<Restoration>, hash: H256, chunk: &[u8], is_state: bool) -> Result<(), Error> {
+		let (result, db) = {
 			match self.status() {
-				RestorationStatus::Inactive | RestorationStatus::Failed => return Ok(()),
-				RestorationStatus::Ongoing { .. } => {
+				RestorationStatus::Inactive | RestorationStatus::Failed => {
+					trace!(target: "snapshot", "Tried to restore chunk {:x} while inactive or failed", hash);
+					return Ok(());
+				},
+				RestorationStatus::Ongoing { .. } | RestorationStatus::Initializing { .. } => {
 					let (res, db) = {
 						let rest = match *restoration {
 							Some(ref mut r) => r,
@ -583,11 +679,41 @@ impl SnapshotService for Service {
 		self.reader.read().as_ref().and_then(|r| r.chunk(hash).ok())
 	}

+	fn completed_chunks(&self) -> Option<Vec<H256>> {
+		let restoration = self.restoration.lock();
+
+		match *restoration {
+			Some(ref restoration) => {
+				let completed_chunks = restoration.manifest.block_hashes
+					.iter()
+					.filter(|h| !restoration.block_chunks_left.contains(h))
+					.chain(
+						restoration.manifest.state_hashes
+							.iter()
+							.filter(|h| !restoration.state_chunks_left.contains(h))
+					)
+					.map(|h| *h)
+					.collect();
+
+				Some(completed_chunks)
+			},
+			None => None,
+		}
+	}
+
 	fn status(&self) -> RestorationStatus {
 		let mut cur_status = self.status.lock();
-		if let RestorationStatus::Ongoing { ref mut state_chunks_done, ref mut block_chunks_done, .. } = *cur_status {
-			*state_chunks_done = self.state_chunks.load(Ordering::SeqCst) as u32;
-			*block_chunks_done = self.block_chunks.load(Ordering::SeqCst) as u32;
+
+		match *cur_status {
+			RestorationStatus::Initializing { ref mut chunks_done } => {
+				*chunks_done = self.state_chunks.load(Ordering::SeqCst) as u32 +
+					self.block_chunks.load(Ordering::SeqCst) as u32;
+			}
+			RestorationStatus::Ongoing { ref mut state_chunks_done, ref mut block_chunks_done, .. } => {
+				*state_chunks_done = self.state_chunks.load(Ordering::SeqCst) as u32;
+				*block_chunks_done = self.block_chunks.load(Ordering::SeqCst) as u32;
+			},
+			_ => (),
 		}

 		cur_status.clone()
@ -600,6 +726,7 @@ impl SnapshotService for Service {
 	}

 	fn abort_restore(&self) {
+		trace!(target: "snapshot", "Aborting restore");
 		self.restoring_snapshot.store(false, Ordering::SeqCst);
 		*self.restoration.lock() = None;
 		*self.status.lock() = RestorationStatus::Inactive;
@ -616,6 +743,10 @@ impl SnapshotService for Service {
 			trace!("Error sending snapshot service message: {:?}", e);
 		}
 	}
+
+	fn shutdown(&self) {
+		self.abort_restore();
+	}
 }

 impl Drop for Service {
--- a/ethcore/src/snapshot/tests/helpers.rs
+++ b/ethcore/src/snapshot/tests/helpers.rs
@ -75,7 +75,7 @@ impl StateProducer {

 		// sweep once to alter storage tries.
 		for &mut (ref mut address_hash, ref mut account_data) in &mut accounts_to_modify {
-			let mut account: BasicAccount = ::rlp::decode(&*account_data);
+			let mut account: BasicAccount = ::rlp::decode(&*account_data).expect("error decoding basic account");
 			let acct_db = AccountDBMut::from_hash(db, *address_hash);
 			fill_storage(acct_db, &mut account.storage_root, &mut self.storage_seed);
 			*account_data = DBValue::from_vec(::rlp::encode(&account).into_vec());
--- a/ethcore/src/snapshot/tests/service.rs
+++ b/ethcore/src/snapshot/tests/service.rs
@ -130,12 +130,16 @@ fn guards_delete_folders() {
 	service.init_restore(manifest.clone(), true).unwrap();
 	assert!(path.exists());

+	// The `db` folder should have been deleted,
+	// while the `temp` one kept
 	service.abort_restore();
-	assert!(!path.exists());
+	assert!(!path.join("db").exists());
+	assert!(path.join("temp").exists());

 	service.init_restore(manifest.clone(), true).unwrap();
 	assert!(path.exists());

 	drop(service);
-	assert!(!path.exists());
+	assert!(!path.join("db").exists());
+	assert!(path.join("temp").exists());
 }
--- a/ethcore/src/snapshot/tests/state.rs
+++ b/ethcore/src/snapshot/tests/state.rs
@ -114,7 +114,7 @@ fn get_code_from_prev_chunk() {
 	// first one will have code inlined,
 	// second will just have its hash.
 	let thin_rlp = acc_stream.out();
-	let acc: BasicAccount = ::rlp::decode(&thin_rlp);
+	let acc: BasicAccount = ::rlp::decode(&thin_rlp).expect("error decoding basic account");

 	let mut make_chunk = |acc, hash| {
 		let mut db = MemoryDB::new();
--- a/ethcore/src/snapshot/traits.rs
+++ b/ethcore/src/snapshot/traits.rs
@ -30,6 +30,9 @@ pub trait SnapshotService : Sync + Send {
 	/// `None` indicates warp sync isn't supported by the consensus engine.
 	fn supported_versions(&self) -> Option<(u64, u64)>;

+	/// Returns a list of the completed chunks
+	fn completed_chunks(&self) -> Option<Vec<H256>>;
+
 	/// Get raw chunk for a given hash.
 	fn chunk(&self, hash: H256) -> Option<Bytes>;

@ -51,4 +54,7 @@ pub trait SnapshotService : Sync + Send {
 	/// Feed a raw block chunk to the service to be processed asynchronously.
 	/// no-op if currently restoring.
 	fn restore_block_chunk(&self, hash: H256, chunk: Bytes);
+
+	/// Shutdown the Snapshot Service by aborting any ongoing restore
+	fn shutdown(&self);
 }
--- a/ethcore/src/spec/spec.rs
+++ b/ethcore/src/spec/spec.rs
@ -48,6 +48,8 @@ use trace::{NoopTracer, NoopVMTracer};

 pub use ethash::OptimizeFor;

+const MAX_TRANSACTION_SIZE: usize = 300 * 1024;
+
 // helper for formatting errors.
 fn fmt_err<F: ::std::fmt::Display>(f: F) -> String {
 	format!("Spec json is invalid: {}", f)
@ -123,6 +125,8 @@ pub struct CommonParams {
 	pub max_code_size_transition: BlockNumber,
 	/// Transaction permission managing contract address.
 	pub transaction_permission_contract: Option<Address>,
+	/// Maximum size of transaction's RLP payload
+	pub max_transaction_size: usize,
 }

 impl CommonParams {
@ -238,6 +242,7 @@ impl From<ethjson::spec::Params> for CommonParams {
 			registrar: p.registrar.map_or_else(Address::new, Into::into),
 			node_permission_contract: p.node_permission_contract.map(Into::into),
 			max_code_size: p.max_code_size.map_or(u64::max_value(), Into::into),
+			max_transaction_size: p.max_transaction_size.map_or(MAX_TRANSACTION_SIZE, Into::into),
 			max_code_size_transition: p.max_code_size_transition.map_or(0, Into::into),
 			transaction_permission_contract: p.transaction_permission_contract.map(Into::into),
 			wasm_activation_transition: p.wasm_activation_transition.map_or(
@ -771,7 +776,7 @@ impl Spec {
 				author: *genesis.author(),
 				timestamp: genesis.timestamp(),
 				difficulty: *genesis.difficulty(),
-				gas_limit: *genesis.gas_limit(),
+				gas_limit: U256::max_value(),
 				last_hashes: Arc::new(Vec::new()),
 				gas_used: 0.into(),
 			};
@ -780,7 +785,7 @@ impl Spec {
 			let tx = Transaction {
 				nonce: self.engine.account_start_nonce(0),
 				action: Action::Call(a),
-				gas: U256::from(50_000_000), // TODO: share with client.
+				gas: U256::max_value(),
 				gas_price: U256::default(),
 				value: U256::default(),
 				data: d,
--- a/ethcore/src/state/account.rs
+++ b/ethcore/src/state/account.rs
@ -21,6 +21,7 @@ use std::sync::Arc;
 use std::collections::{HashMap, BTreeMap};
 use hash::{KECCAK_EMPTY, KECCAK_NULL_RLP, keccak};
 use ethereum_types::{H256, U256, Address};
+use error::Error;
 use hashdb::HashDB;
 use kvdb::DBValue;
 use bytes::{Bytes, ToPretty};
@ -144,9 +145,10 @@ impl Account {
 	}

 	/// Create a new account from RLP.
-	pub fn from_rlp(rlp: &[u8]) -> Account {
-		let basic: BasicAccount = ::rlp::decode(rlp);
-		basic.into()
+	pub fn from_rlp(rlp: &[u8]) -> Result<Account, Error> {
+		::rlp::decode::<BasicAccount>(rlp)
+			.map(|ba| ba.into())
+			.map_err(|e| e.into())
 	}

 	/// Create a new contract account.
@ -202,8 +204,8 @@ impl Account {
 			return Ok(value);
 		}
 		let db = SecTrieDB::new(db, &self.storage_root)?;
-
-		let item: U256 = db.get_with(key, ::rlp::decode)?.unwrap_or_else(U256::zero);
+		let panicky_decoder = |bytes:&[u8]| ::rlp::decode(&bytes).expect("decoding db value failed");
+		let item: U256 = db.get_with(key, panicky_decoder)?.unwrap_or_else(U256::zero);
 		let value: H256 = item.into();
 		self.storage_cache.borrow_mut().insert(key.clone(), value.clone());
 		Ok(value)
@ -478,7 +480,8 @@ impl Account {

 		let trie = TrieDB::new(db, &self.storage_root)?;
 		let item: U256 = {
-			let query = (&mut recorder, ::rlp::decode);
+			let panicky_decoder = |bytes:&[u8]| ::rlp::decode(bytes).expect("decoding db value failed");
+			let query = (&mut recorder, panicky_decoder);
 			trie.get_with(&storage_key, query)?.unwrap_or_else(U256::zero)
 		};

@ -528,7 +531,7 @@ mod tests {
 			a.rlp()
 		};

-		let a = Account::from_rlp(&rlp);
+		let a = Account::from_rlp(&rlp).expect("decoding db value failed");
 		assert_eq!(*a.storage_root().unwrap(), "c57e1afb758b07f8d2c8f13a3b6e44fa5ff94ab266facc5a4fd3f062426e50b2".into());
 		assert_eq!(a.storage_at(&db.immutable(), &0x00u64.into()).unwrap(), 0x1234u64.into());
 		assert_eq!(a.storage_at(&db.immutable(), &0x01u64.into()).unwrap(), H256::default());
@ -546,10 +549,10 @@ mod tests {
 			a.rlp()
 		};

-		let mut a = Account::from_rlp(&rlp);
+		let mut a = Account::from_rlp(&rlp).expect("decoding db value failed");
 		assert!(a.cache_code(&db.immutable()).is_some());

-		let mut a = Account::from_rlp(&rlp);
+		let mut a = Account::from_rlp(&rlp).expect("decoding db value failed");
 		assert_eq!(a.note_code(vec![0x55, 0x44, 0xffu8]), Ok(()));
 	}

@ -609,7 +612,7 @@ mod tests {
 	#[test]
 	fn rlpio() {
 		let a = Account::new(69u8.into(), 0u8.into(), HashMap::new(), Bytes::new());
-		let b = Account::from_rlp(&a.rlp());
+		let b = Account::from_rlp(&a.rlp()).unwrap();
 		assert_eq!(a.balance(), b.balance());
 		assert_eq!(a.nonce(), b.nonce());
 		assert_eq!(a.code_hash(), b.code_hash());
--- a/ethcore/src/state/mod.rs
+++ b/ethcore/src/state/mod.rs
@ -21,7 +21,7 @@

 use std::cell::{RefCell, RefMut};
 use std::collections::hash_map::Entry;
-use std::collections::{HashMap, BTreeMap, HashSet};
+use std::collections::{HashMap, BTreeMap, BTreeSet, HashSet};
 use std::fmt;
 use std::sync::Arc;
 use hash::{KECCAK_NULL_RLP, KECCAK_EMPTY};
@ -605,7 +605,8 @@ impl<B: Backend> State<B> {

 		// account is not found in the global cache, get from the DB and insert into local
 		let db = self.factories.trie.readonly(self.db.as_hashdb(), &self.root).expect(SEC_TRIE_DB_UNWRAP_STR);
-		let maybe_acc = db.get_with(address, Account::from_rlp)?;
+		let from_rlp = |b: &[u8]| Account::from_rlp(b).expect("decoding db value failed");
+		let maybe_acc = db.get_with(address, from_rlp)?;
 		let r = maybe_acc.as_ref().map_or(Ok(H256::new()), |a| {
 			let account_db = self.factories.accountdb.readonly(self.db.as_hashdb(), a.address_hash(address));
 			a.storage_at(account_db.as_hashdb(), key)
@ -862,40 +863,65 @@ impl<B: Backend> State<B> {
 		}))
 	}

-	// Return a list of all touched addresses in cache.
-	fn touched_addresses(&self) -> Vec<Address> {
+	/// Populate a PodAccount map from this state, with another state as the account and storage query.
+	pub fn to_pod_diff<X: Backend>(&mut self, query: &State<X>) -> trie::Result<PodState> {
 		assert!(self.checkpoints.borrow().is_empty());
-		self.cache.borrow().iter().map(|(add, _)| *add).collect()
-	}

-	fn query_pod(&mut self, query: &PodState, touched_addresses: &[Address]) -> trie::Result<()> {
-		let pod = query.get();
+		// Merge PodAccount::to_pod for cache of self and `query`.
+		let all_addresses = self.cache.borrow().keys().cloned()
+			.chain(query.cache.borrow().keys().cloned())
+			.collect::<BTreeSet<_>>();

-		for address in touched_addresses {
-			if !self.ensure_cached(address, RequireCache::Code, true, |a| a.is_some())? {
-				continue
+		Ok(PodState::from(all_addresses.into_iter().fold(Ok(BTreeMap::new()), |m: trie::Result<_>, address| {
+			let mut m = m?;
+
+			let account = self.ensure_cached(&address, RequireCache::Code, true, |acc| {
+				acc.map(|acc| {
+					// Merge all modified storage keys.
+					let all_keys = {
+						let self_keys = acc.storage_changes().keys().cloned()
+							.collect::<BTreeSet<_>>();
+
+						if let Some(ref query_storage) = query.cache.borrow().get(&address)
+							.and_then(|opt| {
+								Some(opt.account.as_ref()?.storage_changes().keys().cloned()
+									 .collect::<BTreeSet<_>>())
+							})
+						{
+							self_keys.union(&query_storage).cloned().collect::<Vec<_>>()
+						} else {
+							self_keys.into_iter().collect::<Vec<_>>()
+						}
+					};
+
+					// Storage must be fetched after ensure_cached to avoid borrow problem.
+					(*acc.balance(), *acc.nonce(), all_keys, acc.code().map(|x| x.to_vec()))
+				})
+			})?;
+
+			if let Some((balance, nonce, storage_keys, code)) = account {
+				let storage = storage_keys.into_iter().fold(Ok(BTreeMap::new()), |s: trie::Result<_>, key| {
+					let mut s = s?;
+
+					s.insert(key, self.storage_at(&address, &key)?);
+					Ok(s)
+				})?;
+
+				m.insert(address, PodAccount {
+					balance, nonce, storage, code
+				});
 			}

-			if let Some(pod_account) = pod.get(address) {
-				// needs to be split into two parts for the refcell code here
-				// to work.
-				for key in pod_account.storage.keys() {
-					self.storage_at(address, key)?;
-				}
-			}
-		}
-
-		Ok(())
+			Ok(m)
+		})?))
 	}

 	/// Returns a `StateDiff` describing the difference from `orig` to `self`.
 	/// Consumes self.
-	pub fn diff_from<X: Backend>(&self, orig: State<X>) -> trie::Result<StateDiff> {
-		let addresses_post = self.touched_addresses();
+	pub fn diff_from<X: Backend>(&self, mut orig: State<X>) -> trie::Result<StateDiff> {
 		let pod_state_post = self.to_pod();
-		let mut state_pre = orig;
-		state_pre.query_pod(&pod_state_post, &addresses_post)?;
-		Ok(pod_state::diff_pod(&state_pre.to_pod(), &pod_state_post))
+		let pod_state_pre = orig.to_pod_diff(self)?;
+		Ok(pod_state::diff_pod(&pod_state_pre, &pod_state_post))
 	}

 	// load required account data from the databases.
@ -958,7 +984,8 @@ impl<B: Backend> State<B> {

 				// not found in the global cache, get from the DB and insert into local
 				let db = self.factories.trie.readonly(self.db.as_hashdb(), &self.root)?;
-				let mut maybe_acc = db.get_with(a, Account::from_rlp)?;
+				let from_rlp = |b: &[u8]| Account::from_rlp(b).expect("decoding db value failed");
+				let mut maybe_acc = db.get_with(a, from_rlp)?;
 				if let Some(ref mut account) = maybe_acc.as_mut() {
 					let accountdb = self.factories.accountdb.readonly(self.db.as_hashdb(), account.address_hash(a));
 					Self::update_account_cache(require, account, &self.db, accountdb.as_hashdb());
@ -987,7 +1014,8 @@ impl<B: Backend> State<B> {
 				None => {
 					let maybe_acc = if !self.db.is_known_null(a) {
 						let db = self.factories.trie.readonly(self.db.as_hashdb(), &self.root)?;
-						AccountEntry::new_clean(db.get_with(a, Account::from_rlp)?)
+						let from_rlp = |b:&[u8]| { Account::from_rlp(b).expect("decoding db value failed") };
+						AccountEntry::new_clean(db.get_with(a, from_rlp)?)
 					} else {
 						AccountEntry::new_clean(None)
 					};
@ -1039,7 +1067,10 @@ impl<B: Backend> State<B> {
 		let mut recorder = Recorder::new();
 		let trie = TrieDB::new(self.db.as_hashdb(), &self.root)?;
 		let maybe_account: Option<BasicAccount> = {
-			let query = (&mut recorder, ::rlp::decode);
+			let panicky_decoder = |bytes: &[u8]| {
+				::rlp::decode(bytes).expect(&format!("prove_account, could not query trie for account key={}", &account_key))
+			};
+			let query = (&mut recorder, panicky_decoder);
 			trie.get_with(&account_key, query)?
 		};
 		let account = maybe_account.unwrap_or_else(|| BasicAccount {
@ -1061,7 +1092,8 @@ impl<B: Backend> State<B> {
 		// TODO: probably could look into cache somehow but it's keyed by
 		// address, not keccak(address).
 		let trie = TrieDB::new(self.db.as_hashdb(), &self.root)?;
-		let acc = match trie.get_with(&account_key, Account::from_rlp)? {
+		let from_rlp = |b: &[u8]| Account::from_rlp(b).expect("decoding db value failed");
+		let acc = match trie.get_with(&account_key, from_rlp)? {
 			Some(acc) => acc,
 			None => return Ok((Vec::new(), H256::new())),
 		};
@ -2243,9 +2275,6 @@ mod tests {
 		let original = state.clone();
 		state.kill_account(&a);

-		assert_eq!(original.touched_addresses(), vec![]);
-		assert_eq!(state.touched_addresses(), vec![a]);
-
 		let diff = state.diff_from(original).unwrap();
 		let diff_map = diff.get();
 		assert_eq!(diff_map.len(), 1);
@ -2258,4 +2287,42 @@ mod tests {
 					   storage: Default::default()
 				   }), None).as_ref());
 	}
+
+	#[test]
+	fn should_trace_diff_unmodified_storage() {
+		use pod_account;
+
+		let a = 10.into();
+		let db = get_temp_state_db();
+
+		let (root, db) = {
+			let mut state = State::new(db, U256::from(0), Default::default());
+			state.set_storage(&a, H256::from(&U256::from(1u64)), H256::from(&U256::from(20u64))).unwrap();
+			state.commit().unwrap();
+			state.drop()
+		};
+
+		let mut state = State::from_existing(db, root, U256::from(0u8), Default::default()).unwrap();
+		let original = state.clone();
+		state.set_storage(&a, H256::from(&U256::from(1u64)), H256::from(&U256::from(100u64))).unwrap();
+
+		let diff = state.diff_from(original).unwrap();
+		let diff_map = diff.get();
+		assert_eq!(diff_map.len(), 1);
+		assert!(diff_map.get(&a).is_some());
+		assert_eq!(diff_map.get(&a),
+				   pod_account::diff_pod(Some(&PodAccount {
+					   balance: U256::zero(),
+					   nonce: U256::zero(),
+					   code: Some(Default::default()),
+					   storage: vec![(H256::from(&U256::from(1u64)), H256::from(&U256::from(20u64)))]
+						   .into_iter().collect(),
+				   }), Some(&PodAccount {
+					   balance: U256::zero(),
+					   nonce: U256::zero(),
+					   code: Some(Default::default()),
+					   storage: vec![(H256::from(&U256::from(1u64)), H256::from(&U256::from(100u64)))]
+						   .into_iter().collect(),
+				   })).as_ref());
+	}
 }
--- a/ethcore/src/tests/client.rs
+++ b/ethcore/src/tests/client.rs
@ -36,6 +36,7 @@ use views::BlockView;
 use ethkey::KeyPair;
 use transaction::{PendingTransaction, Transaction, Action, Condition};
 use miner::MinerService;
+use rlp::{RlpStream, EMPTY_LIST_RLP};
 use tempdir::TempDir;

 #[test]
@ -111,6 +112,25 @@ fn imports_good_block() {
 	assert!(!block.into_inner().is_empty());
 }

+#[test]
+fn fails_to_import_block_with_invalid_rlp() {
+	use error::{BlockImportError, BlockImportErrorKind};
+
+	let client = generate_dummy_client(6);
+	let mut rlp = RlpStream::new_list(3);
+	rlp.append_raw(&EMPTY_LIST_RLP, 1); // empty header
+	rlp.append_raw(&EMPTY_LIST_RLP, 1);
+	rlp.append_raw(&EMPTY_LIST_RLP, 1);
+	let invalid_header_block = rlp.out();
+
+	match client.import_block(invalid_header_block) {
+		Err(BlockImportError(BlockImportErrorKind::Decoder(_), _)) => (), // all good
+		Err(_) => panic!("Should fail with a decoder error"),
+		Ok(_) => panic!("Should not import block with invalid header"),
+	}
+}
+
+
 #[test]
 fn query_none_block() {
 	let tempdir = TempDir::new("").unwrap();
--- a/ethcore/src/trace/types/flat.rs
+++ b/ethcore/src/trace/types/flat.rs
@ -244,7 +244,7 @@ mod tests {
 		]);

 		let encoded = ::rlp::encode(&block_traces);
-		let decoded = ::rlp::decode(&encoded);
+		let decoded = ::rlp::decode(&encoded).expect("error decoding block traces");
 		assert_eq!(block_traces, decoded);
 	}
 }
--- a/ethcore/src/verification/queue/kind.rs
+++ b/ethcore/src/verification/queue/kind.rs
@ -119,14 +119,13 @@ pub mod blocks {

 	impl Unverified {
 		/// Create an `Unverified` from raw bytes.
-		pub fn new(bytes: Bytes) -> Self {
-			use views::BlockView;
+		pub fn from_rlp(bytes: Bytes) -> Result<Self, ::rlp::DecoderError> {

-			let header = view!(BlockView, &bytes).header();
-			Unverified {
+			let header = ::rlp::Rlp::new(&bytes).val_at(0)?; 
+			Ok(Unverified {
 				header: header,
 				bytes: bytes,
-			}
+			})
 		}
 	}

--- a/ethcore/src/verification/queue/mod.rs
+++ b/ethcore/src/verification/queue/mod.rs
@ -734,6 +734,7 @@ mod tests {
 	use test_helpers::{get_good_dummy_block_seq, get_good_dummy_block};
 	use error::*;
 	use views::BlockView;
+	use bytes::Bytes;

 	// create a test block queue.
 	// auto_scaling enables verifier adjustment.
@ -746,6 +747,10 @@ mod tests {
 		BlockQueue::new(config, engine, IoChannel::disconnected(), true)
 	}

+	fn new_unverified(bytes: Bytes) -> Unverified {
+		Unverified::from_rlp(bytes).expect("Should be valid rlp")
+	}
+
 	#[test]
 	fn can_be_created() {
 		// TODO better test
@ -757,7 +762,7 @@ mod tests {
 	#[test]
 	fn can_import_blocks() {
 		let queue = get_test_queue(false);
-		if let Err(e) = queue.import(Unverified::new(get_good_dummy_block())) {
+		if let Err(e) = queue.import(new_unverified(get_good_dummy_block())) {
 			panic!("error importing block that is valid by definition({:?})", e);
 		}
 	}
@ -765,11 +770,11 @@ mod tests {
 	#[test]
 	fn returns_error_for_duplicates() {
 		let queue = get_test_queue(false);
-		if let Err(e) = queue.import(Unverified::new(get_good_dummy_block())) {
+		if let Err(e) = queue.import(new_unverified(get_good_dummy_block())) {
 			panic!("error importing block that is valid by definition({:?})", e);
 		}

-		let duplicate_import = queue.import(Unverified::new(get_good_dummy_block()));
+		let duplicate_import = queue.import(new_unverified(get_good_dummy_block()));
 		match duplicate_import {
 			Err(e) => {
 				match e {
@ -786,7 +791,7 @@ mod tests {
 		let queue = get_test_queue(false);
 		let block = get_good_dummy_block();
 		let hash = view!(BlockView, &block).header().hash().clone();
-		if let Err(e) = queue.import(Unverified::new(block)) {
+		if let Err(e) = queue.import(new_unverified(block)) {
 			panic!("error importing block that is valid by definition({:?})", e);
 		}
 		queue.flush();
@ -802,14 +807,14 @@ mod tests {
 		let queue = get_test_queue(false);
 		let block = get_good_dummy_block();
 		let hash = view!(BlockView, &block).header().hash().clone();
-		if let Err(e) = queue.import(Unverified::new(block)) {
+		if let Err(e) = queue.import(new_unverified(block)) {
 			panic!("error importing block that is valid by definition({:?})", e);
 		}
 		queue.flush();
 		queue.drain(10);
 		queue.mark_as_good(&[ hash ]);

-		if let Err(e) = queue.import(Unverified::new(get_good_dummy_block())) {
+		if let Err(e) = queue.import(new_unverified(get_good_dummy_block())) {
 			panic!("error importing block that has already been drained ({:?})", e);
 		}
 	}
@ -817,7 +822,7 @@ mod tests {
 	#[test]
 	fn returns_empty_once_finished() {
 		let queue = get_test_queue(false);
-		queue.import(Unverified::new(get_good_dummy_block()))
+		queue.import(new_unverified(get_good_dummy_block()))
 			.expect("error importing block that is valid by definition");
 		queue.flush();
 		queue.drain(1);
@ -835,7 +840,7 @@ mod tests {
 		assert!(!queue.queue_info().is_full());
 		let mut blocks = get_good_dummy_block_seq(50);
 		for b in blocks.drain(..) {
-			queue.import(Unverified::new(b)).unwrap();
+			queue.import(new_unverified(b)).unwrap();
 		}
 		assert!(queue.queue_info().is_full());
 	}
@ -863,7 +868,7 @@ mod tests {
 		*queue.state.0.lock() = State::Work(0);

 		for block in get_good_dummy_block_seq(5000) {
-			queue.import(Unverified::new(block)).expect("Block good by definition; qed");
+			queue.import(new_unverified(block)).expect("Block good by definition; qed");
 		}

 		// almost all unverified == bump verifier count.
--- a/ethcore/src/verification/verification.rs
+++ b/ethcore/src/verification/verification.rs
@ -224,7 +224,7 @@ fn verify_uncles(header: &Header, bytes: &[u8], bc: &BlockProvider, engine: &Eth
 				return Err(From::from(BlockError::UncleParentNotInChain(uncle_parent.hash())));
 			}

-			let uncle_parent = uncle_parent.decode();
+			let uncle_parent = uncle_parent.decode()?;
 			verify_parent(&uncle, &uncle_parent, engine)?;
 			engine.verify_block_family(&uncle, &uncle_parent)?;
 			verified.insert(uncle.hash());
@ -476,7 +476,7 @@ mod tests {
 			unimplemented!()
 		}

-		fn logs<F>(&self, _blocks: Vec<BlockNumber>, _matches: F, _limit: Option<usize>) -> Vec<LocalizedLogEntry>
+		fn logs<F>(&self, _blocks: Vec<H256>, _matches: F, _limit: Option<usize>) -> Vec<LocalizedLogEntry>
 			where F: Fn(&LogEntry) -> bool, Self: Sized {
 			unimplemented!()
 		}
@ -500,10 +500,9 @@ mod tests {
 		// no existing tests need access to test, so having this not function
 		// is fine.
 		let client = ::client::TestBlockChainClient::default();
-
 		let parent = bc.block_header_data(header.parent_hash())
 			.ok_or(BlockError::UnknownParent(header.parent_hash().clone()))?
-			.decode();
+			.decode()?;

 		let full_params = FullFamilyParams {
 			block_bytes: bytes,
--- a/ethcore/src/views/block.rs
+++ b/ethcore/src/views/block.rs
@ -29,7 +29,6 @@ pub struct BlockView<'a> {
 	rlp: ViewRlp<'a>
 }

-
 impl<'a> BlockView<'a> {
 	/// Creates new view onto block from rlp.
 	/// Use the `view!` macro to create this view in order to capture debugging info.
@ -39,9 +38,9 @@ impl<'a> BlockView<'a> {
 	/// ```
 	/// #[macro_use]
 	/// extern crate ethcore;
-	/// 
+	///
 	/// use ethcore::views::{BlockView};
-	/// 
+	///
 	/// fn main() {
 	/// let bytes : &[u8] = &[];
 	/// let block_view = view!(BlockView, bytes);
--- a/ethcore/sync/Cargo.toml
+++ b/ethcore/sync/Cargo.toml
@ -30,6 +30,7 @@ heapsize = "0.4"
 semver = "0.9"
 smallvec = { version = "0.4", features = ["heapsizeof"] }
 parking_lot = "0.5"
+trace-time = { path = "../../util/trace-time" }
 ipnetwork = "0.12.6"

 [dev-dependencies]
--- a/ethcore/sync/src/api.rs
+++ b/ethcore/sync/src/api.rs
@ -33,7 +33,7 @@ use chain::{ChainSync, SyncStatus as EthSyncStatus};
 use std::net::{SocketAddr, AddrParseError};
 use std::str::FromStr;
 use parking_lot::RwLock;
-use chain::{ETH_PACKET_COUNT, SNAPSHOT_SYNC_PACKET_COUNT, ETH_PROTOCOL_VERSION_63, ETH_PROTOCOL_VERSION_62,
+use chain::{ETH_PROTOCOL_VERSION_63, ETH_PROTOCOL_VERSION_62,
 	PAR_PROTOCOL_VERSION_1, PAR_PROTOCOL_VERSION_2, PAR_PROTOCOL_VERSION_3};
 use light::client::AsLightClient;
 use light::Provider;
@ -202,10 +202,8 @@ pub struct AttachedProtocol {
 	pub handler: Arc<NetworkProtocolHandler + Send + Sync>,
 	/// 3-character ID for the protocol.
 	pub protocol_id: ProtocolId,
-	/// Packet count.
-	pub packet_count: u8,
-	/// Supported versions.
-	pub versions: &'static [u8],
+	/// Supported versions and their packet counts.
+	pub versions: &'static [(u8, u8)],
 }

 impl AttachedProtocol {
@ -213,7 +211,6 @@ impl AttachedProtocol {
 		let res = network.register_protocol(
 			self.handler.clone(),
 			self.protocol_id,
-			self.packet_count,
 			self.versions
 		);

@ -379,10 +376,12 @@ impl NetworkProtocolHandler for SyncProtocolHandler {
 	}

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

 	fn connected(&self, io: &NetworkContext, peer: &PeerId) {
+		trace_time!("sync::connected");
 		// If warp protocol is supported only allow warp handshake
 		let warp_protocol = io.protocol_version(WARP_SYNC_PROTOCOL_ID, *peer).unwrap_or(0) != 0;
 		let warp_context = io.subprotocol_name() == WARP_SYNC_PROTOCOL_ID;
@ -392,12 +391,14 @@ impl NetworkProtocolHandler for SyncProtocolHandler {
 	}

 	fn disconnected(&self, io: &NetworkContext, peer: &PeerId) {
+		trace_time!("sync::disconnected");
 		if io.subprotocol_name() != WARP_SYNC_PROTOCOL_ID {
 			self.sync.write().on_peer_aborting(&mut NetSyncIo::new(io, &*self.chain, &*self.snapshot_service, &self.overlay), *peer);
 		}
 	}

 	fn timeout(&self, io: &NetworkContext, _timer: TimerToken) {
+		trace_time!("sync::timeout");
 		let mut io = NetSyncIo::new(io, &*self.chain, &*self.snapshot_service, &self.overlay);
 		self.sync.write().maintain_peers(&mut io);
 		self.sync.write().maintain_sync(&mut io);
@ -456,15 +457,15 @@ impl ChainNotify for EthSync {
 			Err(err) => warn!("Error starting network: {}", err),
 			_ => {},
 		}
-		self.network.register_protocol(self.eth_handler.clone(), self.subprotocol_name, ETH_PACKET_COUNT, &[ETH_PROTOCOL_VERSION_62, ETH_PROTOCOL_VERSION_63])
+		self.network.register_protocol(self.eth_handler.clone(), self.subprotocol_name, &[ETH_PROTOCOL_VERSION_62, ETH_PROTOCOL_VERSION_63])
 			.unwrap_or_else(|e| warn!("Error registering ethereum protocol: {:?}", e));
 		// register the warp sync subprotocol
-		self.network.register_protocol(self.eth_handler.clone(), WARP_SYNC_PROTOCOL_ID, SNAPSHOT_SYNC_PACKET_COUNT, &[PAR_PROTOCOL_VERSION_1, PAR_PROTOCOL_VERSION_2, PAR_PROTOCOL_VERSION_3])
+		self.network.register_protocol(self.eth_handler.clone(), WARP_SYNC_PROTOCOL_ID, &[PAR_PROTOCOL_VERSION_1, PAR_PROTOCOL_VERSION_2, PAR_PROTOCOL_VERSION_3])
 			.unwrap_or_else(|e| warn!("Error registering snapshot sync protocol: {:?}", e));

 		// register the light protocol.
 		if let Some(light_proto) = self.light_proto.as_ref().map(|x| x.clone()) {
-			self.network.register_protocol(light_proto, self.light_subprotocol_name, ::light::net::PACKET_COUNT, ::light::net::PROTOCOL_VERSIONS)
+			self.network.register_protocol(light_proto, self.light_subprotocol_name, ::light::net::PROTOCOL_VERSIONS)
 				.unwrap_or_else(|e| warn!("Error registering light client protocol: {:?}", e));
 		}

@ -824,7 +825,7 @@ impl ManageNetwork for LightSync {

 		let light_proto = self.proto.clone();

-		self.network.register_protocol(light_proto, self.subprotocol_name, ::light::net::PACKET_COUNT, ::light::net::PROTOCOL_VERSIONS)
+		self.network.register_protocol(light_proto, self.subprotocol_name, ::light::net::PROTOCOL_VERSIONS)
 			.unwrap_or_else(|e| warn!("Error registering light client protocol: {:?}", e));

 		for proto in &self.attached_protos { proto.register(&self.network) }
--- a/ethcore/sync/src/block_sync.rs
+++ b/ethcore/sync/src/block_sync.rs
@ -496,7 +496,7 @@ impl BlockDownloader {
 			}

 			let result = if let Some(receipts) = receipts {
-				io.chain().import_block_with_receipts(block, receipts)
+				io.chain().queue_ancient_block(block, receipts)
 			} else {
 				io.chain().import_block(block)
 			};
--- a/ethcore/sync/src/blocks.rs
+++ b/ethcore/sync/src/blocks.rs
@ -266,7 +266,7 @@ impl BlockCollection {
 		}
 	}

-	/// Get a valid chain of blocks ordered in descending order and ready for importing into blockchain.
+	/// Get a valid chain of blocks ordered in ascending order and ready for importing into blockchain.
 	pub fn drain(&mut self) -> Vec<BlockAndReceipts> {
 		if self.blocks.is_empty() || self.head.is_none() {
 			return Vec::new();
--- a/ethcore/sync/src/chain.rs
+++ b/ethcore/sync/src/chain.rs
--- a/ethcore/sync/src/chain/handler.rs
+++ b/ethcore/sync/src/chain/handler.rs
@ -0,0 +1,853 @@
+// Copyright 2015-2018 Parity Technologies (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+use api::WARP_SYNC_PROTOCOL_ID;
+use block_sync::{BlockDownloaderImportError as DownloaderImportError, DownloadAction};
+use bytes::Bytes;
+use ethcore::client::{BlockStatus, BlockId, BlockImportError, BlockImportErrorKind};
+use ethcore::error::*;
+use ethcore::header::{BlockNumber, Header as BlockHeader};
+use ethcore::snapshot::{ManifestData, RestorationStatus};
+use ethereum_types::{H256, U256};
+use hash::keccak;
+use network::PeerId;
+use rlp::Rlp;
+use snapshot::ChunkType;
+use std::cmp;
+use std::collections::HashSet;
+use std::time::Instant;
+use sync_io::SyncIo;
+
+use super::{
+	BlockSet,
+	ChainSync,
+	ForkConfirmation,
+	PacketDecodeError,
+	PeerAsking,
+	PeerInfo,
+	SyncRequester,
+	SyncState,
+	ETH_PROTOCOL_VERSION_62,
+	ETH_PROTOCOL_VERSION_63,
+	MAX_NEW_BLOCK_AGE,
+	MAX_NEW_HASHES,
+	PAR_PROTOCOL_VERSION_1,
+	PAR_PROTOCOL_VERSION_3,
+	BLOCK_BODIES_PACKET,
+	BLOCK_HEADERS_PACKET,
+	NEW_BLOCK_HASHES_PACKET,
+	NEW_BLOCK_PACKET,
+	PRIVATE_TRANSACTION_PACKET,
+	RECEIPTS_PACKET,
+	SIGNED_PRIVATE_TRANSACTION_PACKET,
+	SNAPSHOT_DATA_PACKET,
+	SNAPSHOT_MANIFEST_PACKET,
+	STATUS_PACKET,
+	TRANSACTIONS_PACKET,
+};
+
+/// The Chain Sync Handler: handles responses from peers
+pub struct SyncHandler;
+
+impl SyncHandler {
+	/// Handle incoming packet from peer
+	pub fn on_packet(sync: &mut ChainSync, io: &mut SyncIo, peer: PeerId, packet_id: u8, data: &[u8]) {
+		if packet_id != STATUS_PACKET && !sync.peers.contains_key(&peer) {
+			debug!(target:"sync", "Unexpected packet {} from unregistered peer: {}:{}", packet_id, peer, io.peer_info(peer));
+			return;
+		}
+		let rlp = Rlp::new(data);
+		let result = match packet_id {
+			STATUS_PACKET => SyncHandler::on_peer_status(sync, io, peer, &rlp),
+			TRANSACTIONS_PACKET => SyncHandler::on_peer_transactions(sync, io, peer, &rlp),
+			BLOCK_HEADERS_PACKET => SyncHandler::on_peer_block_headers(sync, io, peer, &rlp),
+			BLOCK_BODIES_PACKET => SyncHandler::on_peer_block_bodies(sync, io, peer, &rlp),
+			RECEIPTS_PACKET => SyncHandler::on_peer_block_receipts(sync, io, peer, &rlp),
+			NEW_BLOCK_PACKET => SyncHandler::on_peer_new_block(sync, io, peer, &rlp),
+			NEW_BLOCK_HASHES_PACKET => SyncHandler::on_peer_new_hashes(sync, io, peer, &rlp),
+			SNAPSHOT_MANIFEST_PACKET => SyncHandler::on_snapshot_manifest(sync, io, peer, &rlp),
+			SNAPSHOT_DATA_PACKET => SyncHandler::on_snapshot_data(sync, io, peer, &rlp),
+			PRIVATE_TRANSACTION_PACKET => SyncHandler::on_private_transaction(sync, io, peer, &rlp),
+			SIGNED_PRIVATE_TRANSACTION_PACKET => SyncHandler::on_signed_private_transaction(sync, io, peer, &rlp),
+			_ => {
+				debug!(target: "sync", "{}: Unknown packet {}", peer, packet_id);
+				Ok(())
+			}
+		};
+		result.unwrap_or_else(|e| {
+			debug!(target:"sync", "{} -> Malformed packet {} : {}", peer, packet_id, e);
+		})
+	}
+
+	/// Called when peer sends us new consensus packet
+	pub fn on_consensus_packet(io: &mut SyncIo, peer_id: PeerId, r: &Rlp) -> Result<(), PacketDecodeError> {
+		trace!(target: "sync", "Received consensus packet from {:?}", peer_id);
+		io.chain().queue_consensus_message(r.as_raw().to_vec());
+		Ok(())
+	}
+
+	/// Called by peer when it is disconnecting
+	pub fn on_peer_aborting(sync: &mut ChainSync, io: &mut SyncIo, peer_id: PeerId) {
+		trace!(target: "sync", "== Disconnecting {}: {}", peer_id, io.peer_info(peer_id));
+		sync.handshaking_peers.remove(&peer_id);
+		if sync.peers.contains_key(&peer_id) {
+			debug!(target: "sync", "Disconnected {}", peer_id);
+			sync.clear_peer_download(peer_id);
+			sync.peers.remove(&peer_id);
+			sync.active_peers.remove(&peer_id);
+
+			if sync.state == SyncState::SnapshotManifest {
+				// Check if we are asking other peers for
+				// the snapshot manifest as well.
+				// If not, return to initial state
+				let still_asking_manifest = sync.peers.iter()
+					.filter(|&(id, p)| sync.active_peers.contains(id) && p.asking == PeerAsking::SnapshotManifest)
+					.next().is_none();
+
+				if still_asking_manifest {
+					sync.state = ChainSync::get_init_state(sync.warp_sync, io.chain());
+				}
+			}
+			sync.continue_sync(io);
+		}
+	}
+
+	/// Called when a new peer is connected
+	pub fn on_peer_connected(sync: &mut ChainSync, io: &mut SyncIo, peer: PeerId) {
+		trace!(target: "sync", "== Connected {}: {}", peer, io.peer_info(peer));
+		if let Err(e) = sync.send_status(io, peer) {
+			debug!(target:"sync", "Error sending status request: {:?}", e);
+			io.disconnect_peer(peer);
+		} else {
+			sync.handshaking_peers.insert(peer, Instant::now());
+		}
+	}
+
+	/// Called by peer once it has new block bodies
+	pub fn on_peer_new_block(sync: &mut ChainSync, io: &mut SyncIo, peer_id: PeerId, r: &Rlp) -> Result<(), PacketDecodeError> {
+		if !sync.peers.get(&peer_id).map_or(false, |p| p.can_sync()) {
+			trace!(target: "sync", "Ignoring new block from unconfirmed peer {}", peer_id);
+			return Ok(());
+		}
+		let difficulty: U256 = r.val_at(1)?;
+		if let Some(ref mut peer) = sync.peers.get_mut(&peer_id) {
+			if peer.difficulty.map_or(true, |pd| difficulty > pd) {
+				peer.difficulty = Some(difficulty);
+			}
+		}
+		let block_rlp = r.at(0)?;
+		let header_rlp = block_rlp.at(0)?;
+		let h = keccak(&header_rlp.as_raw());
+		trace!(target: "sync", "{} -> NewBlock ({})", peer_id, h);
+		let header: BlockHeader = header_rlp.as_val()?;
+		if header.number() > sync.highest_block.unwrap_or(0) {
+			sync.highest_block = Some(header.number());
+		}
+		let mut unknown = false;
+		{
+			if let Some(ref mut peer) = sync.peers.get_mut(&peer_id) {
+				peer.latest_hash = header.hash();
+			}
+		}
+		let last_imported_number = sync.new_blocks.last_imported_block_number();
+		if last_imported_number > header.number() && last_imported_number - header.number() > MAX_NEW_BLOCK_AGE {
+			trace!(target: "sync", "Ignored ancient new block {:?}", h);
+			io.disable_peer(peer_id);
+			return Ok(());
+		}
+		match io.chain().import_block(block_rlp.as_raw().to_vec()) {
+			Err(BlockImportError(BlockImportErrorKind::Import(ImportErrorKind::AlreadyInChain), _)) => {
+				trace!(target: "sync", "New block already in chain {:?}", h);
+			},
+			Err(BlockImportError(BlockImportErrorKind::Import(ImportErrorKind::AlreadyQueued), _)) => {
+				trace!(target: "sync", "New block already queued {:?}", h);
+			},
+			Ok(_) => {
+				// abort current download of the same block
+				sync.complete_sync(io);
+				sync.new_blocks.mark_as_known(&header.hash(), header.number());
+				trace!(target: "sync", "New block queued {:?} ({})", h, header.number());
+			},
+			Err(BlockImportError(BlockImportErrorKind::Block(BlockError::UnknownParent(p)), _)) => {
+				unknown = true;
+				trace!(target: "sync", "New block with unknown parent ({:?}) {:?}", p, h);
+			},
+			Err(e) => {
+				debug!(target: "sync", "Bad new block {:?} : {:?}", h, e);
+				io.disable_peer(peer_id);
+			}
+		};
+		if unknown {
+			if sync.state != SyncState::Idle {
+				trace!(target: "sync", "NewBlock ignored while seeking");
+			} else {
+				trace!(target: "sync", "New unknown block {:?}", h);
+				//TODO: handle too many unknown blocks
+				sync.sync_peer(io, peer_id, true);
+			}
+		}
+		sync.continue_sync(io);
+		Ok(())
+	}
+
+	/// Handles `NewHashes` packet. Initiates headers download for any unknown hashes.
+	pub fn on_peer_new_hashes(sync: &mut ChainSync, io: &mut SyncIo, peer_id: PeerId, r: &Rlp) -> Result<(), PacketDecodeError> {
+		if !sync.peers.get(&peer_id).map_or(false, |p| p.can_sync()) {
+			trace!(target: "sync", "Ignoring new hashes from unconfirmed peer {}", peer_id);
+			return Ok(());
+		}
+		let hashes: Vec<_> = r.iter().take(MAX_NEW_HASHES).map(|item| (item.val_at::<H256>(0), item.val_at::<BlockNumber>(1))).collect();
+		if let Some(ref mut peer) = sync.peers.get_mut(&peer_id) {
+			// Peer has new blocks with unknown difficulty
+			peer.difficulty = None;
+			if let Some(&(Ok(ref h), _)) = hashes.last() {
+				peer.latest_hash = h.clone();
+			}
+		}
+		if sync.state != SyncState::Idle {
+			trace!(target: "sync", "Ignoring new hashes since we're already downloading.");
+			let max = r.iter().take(MAX_NEW_HASHES).map(|item| item.val_at::<BlockNumber>(1).unwrap_or(0)).fold(0u64, cmp::max);
+			if max > sync.highest_block.unwrap_or(0) {
+				sync.highest_block = Some(max);
+			}
+			sync.continue_sync(io);
+			return Ok(());
+		}
+		trace!(target: "sync", "{} -> NewHashes ({} entries)", peer_id, r.item_count()?);
+		let mut max_height: BlockNumber = 0;
+		let mut new_hashes = Vec::new();
+		let last_imported_number = sync.new_blocks.last_imported_block_number();
+		for (rh, rn) in hashes {
+			let hash = rh?;
+			let number = rn?;
+			if number > sync.highest_block.unwrap_or(0) {
+				sync.highest_block = Some(number);
+			}
+			if sync.new_blocks.is_downloading(&hash) {
+				continue;
+			}
+			if last_imported_number > number && last_imported_number - number > MAX_NEW_BLOCK_AGE {
+				trace!(target: "sync", "Ignored ancient new block hash {:?}", hash);
+				io.disable_peer(peer_id);
+				continue;
+			}
+			match io.chain().block_status(BlockId::Hash(hash.clone())) {
+				BlockStatus::InChain  => {
+					trace!(target: "sync", "New block hash already in chain {:?}", hash);
+				},
+				BlockStatus::Queued => {
+					trace!(target: "sync", "New hash block already queued {:?}", hash);
+				},
+				BlockStatus::Unknown | BlockStatus::Pending => {
+					new_hashes.push(hash.clone());
+					if number > max_height {
+						trace!(target: "sync", "New unknown block hash {:?}", hash);
+						if let Some(ref mut peer) = sync.peers.get_mut(&peer_id) {
+							peer.latest_hash = hash.clone();
+						}
+						max_height = number;
+					}
+				},
+				BlockStatus::Bad => {
+					debug!(target: "sync", "Bad new block hash {:?}", hash);
+					io.disable_peer(peer_id);
+					return Ok(());
+				}
+			}
+		};
+		if max_height != 0 {
+			trace!(target: "sync", "Downloading blocks for new hashes");
+			sync.new_blocks.reset_to(new_hashes);
+			sync.state = SyncState::NewBlocks;
+			sync.sync_peer(io, peer_id, true);
+		}
+		sync.continue_sync(io);
+		Ok(())
+	}
+
+	/// Called by peer once it has new block bodies
+	fn on_peer_block_bodies(sync: &mut ChainSync, io: &mut SyncIo, peer_id: PeerId, r: &Rlp) -> Result<(), PacketDecodeError> {
+		sync.clear_peer_download(peer_id);
+		let block_set = sync.peers.get(&peer_id).and_then(|p| p.block_set).unwrap_or(BlockSet::NewBlocks);
+		if !sync.reset_peer_asking(peer_id, PeerAsking::BlockBodies) {
+			trace!(target: "sync", "{}: Ignored unexpected bodies", peer_id);
+			sync.continue_sync(io);
+			return Ok(());
+		}
+		let item_count = r.item_count()?;
+		trace!(target: "sync", "{} -> BlockBodies ({} entries), set = {:?}", peer_id, item_count, block_set);
+		if item_count == 0 {
+			sync.deactivate_peer(io, peer_id);
+		}
+		else if sync.state == SyncState::Waiting {
+			trace!(target: "sync", "Ignored block bodies while waiting");
+		}
+		else
+		{
+			let result = {
+				let downloader = match block_set {
+					BlockSet::NewBlocks => &mut sync.new_blocks,
+					BlockSet::OldBlocks => match sync.old_blocks {
+						None => {
+							trace!(target: "sync", "Ignored block headers while block download is inactive");
+							sync.continue_sync(io);
+							return Ok(());
+						},
+						Some(ref mut blocks) => blocks,
+					}
+				};
+				downloader.import_bodies(io, r)
+			};
+
+			match result {
+				Err(DownloaderImportError::Invalid) => {
+					io.disable_peer(peer_id);
+					sync.deactivate_peer(io, peer_id);
+					sync.continue_sync(io);
+					return Ok(());
+				},
+				Err(DownloaderImportError::Useless) => {
+					sync.deactivate_peer(io, peer_id);
+				},
+				Ok(()) => (),
+			}
+
+			sync.collect_blocks(io, block_set);
+			sync.sync_peer(io, peer_id, false);
+		}
+		sync.continue_sync(io);
+		Ok(())
+	}
+
+	fn on_peer_fork_header(sync: &mut ChainSync, io: &mut SyncIo, peer_id: PeerId, r: &Rlp) -> Result<(), PacketDecodeError> {
+		{
+			let peer = sync.peers.get_mut(&peer_id).expect("Is only called when peer is present in peers");
+			peer.asking = PeerAsking::Nothing;
+			let item_count = r.item_count()?;
+			let (fork_number, fork_hash) = sync.fork_block.expect("ForkHeader request is sent only fork block is Some; qed").clone();
+
+			if item_count == 0 || item_count != 1 {
+				trace!(target: "sync", "{}: Chain is too short to confirm the block", peer_id);
+				peer.confirmation = ForkConfirmation::TooShort;
+
+			} else {
+				let header = r.at(0)?.as_raw();
+				if keccak(&header) != fork_hash {
+					trace!(target: "sync", "{}: Fork mismatch", peer_id);
+					io.disable_peer(peer_id);
+					return Ok(());
+				}
+
+				trace!(target: "sync", "{}: Confirmed peer", peer_id);
+				peer.confirmation = ForkConfirmation::Confirmed;
+
+				if !io.chain_overlay().read().contains_key(&fork_number) {
+					trace!(target: "sync", "Inserting (fork) block {} header", fork_number);
+					io.chain_overlay().write().insert(fork_number, header.to_vec());
+				}
+			}
+		}
+
+		sync.sync_peer(io, peer_id, false);
+		return Ok(());
+	}
+
+	/// Called by peer once it has new block headers during sync
+	fn on_peer_block_headers(sync: &mut ChainSync, io: &mut SyncIo, peer_id: PeerId, r: &Rlp) -> Result<(), PacketDecodeError> {
+		let is_fork_header_request = match sync.peers.get(&peer_id) {
+			Some(peer) if peer.asking == PeerAsking::ForkHeader => true,
+			_ => false,
+		};
+
+		if is_fork_header_request {
+			return SyncHandler::on_peer_fork_header(sync, io, peer_id, r);
+		}
+
+		sync.clear_peer_download(peer_id);
+		let expected_hash = sync.peers.get(&peer_id).and_then(|p| p.asking_hash);
+		let allowed = sync.peers.get(&peer_id).map(|p| p.is_allowed()).unwrap_or(false);
+		let block_set = sync.peers.get(&peer_id).and_then(|p| p.block_set).unwrap_or(BlockSet::NewBlocks);
+		if !sync.reset_peer_asking(peer_id, PeerAsking::BlockHeaders) || expected_hash.is_none() || !allowed {
+			trace!(target: "sync", "{}: Ignored unexpected headers, expected_hash = {:?}", peer_id, expected_hash);
+			sync.continue_sync(io);
+			return Ok(());
+		}
+		let item_count = r.item_count()?;
+		trace!(target: "sync", "{} -> BlockHeaders ({} entries), state = {:?}, set = {:?}", peer_id, item_count, sync.state, block_set);
+		if (sync.state == SyncState::Idle || sync.state == SyncState::WaitingPeers) && sync.old_blocks.is_none() {
+			trace!(target: "sync", "Ignored unexpected block headers");
+			sync.continue_sync(io);
+			return Ok(());
+		}
+		if sync.state == SyncState::Waiting {
+			trace!(target: "sync", "Ignored block headers while waiting");
+			sync.continue_sync(io);
+			return Ok(());
+		}
+
+		let result =  {
+			let downloader = match block_set {
+				BlockSet::NewBlocks => &mut sync.new_blocks,
+				BlockSet::OldBlocks => {
+					match sync.old_blocks {
+						None => {
+							trace!(target: "sync", "Ignored block headers while block download is inactive");
+							sync.continue_sync(io);
+							return Ok(());
+						},
+						Some(ref mut blocks) => blocks,
+					}
+				}
+			};
+			downloader.import_headers(io, r, expected_hash)
+		};
+
+		match result {
+			Err(DownloaderImportError::Useless) => {
+				sync.deactivate_peer(io, peer_id);
+			},
+			Err(DownloaderImportError::Invalid) => {
+				io.disable_peer(peer_id);
+				sync.deactivate_peer(io, peer_id);
+				sync.continue_sync(io);
+				return Ok(());
+			},
+			Ok(DownloadAction::Reset) => {
+				// mark all outstanding requests as expired
+				trace!("Resetting downloads for {:?}", block_set);
+				for (_, ref mut p) in sync.peers.iter_mut().filter(|&(_, ref p)| p.block_set == Some(block_set)) {
+					p.reset_asking();
+				}
+
+			}
+			Ok(DownloadAction::None) => {},
+		}
+
+		sync.collect_blocks(io, block_set);
+		// give a task to the same peer first if received valuable headers.
+		sync.sync_peer(io, peer_id, false);
+		// give tasks to other peers
+		sync.continue_sync(io);
+		Ok(())
+	}
+
+	/// Called by peer once it has new block receipts
+	fn on_peer_block_receipts(sync: &mut ChainSync, io: &mut SyncIo, peer_id: PeerId, r: &Rlp) -> Result<(), PacketDecodeError> {
+		sync.clear_peer_download(peer_id);
+		let block_set = sync.peers.get(&peer_id).and_then(|p| p.block_set).unwrap_or(BlockSet::NewBlocks);
+		if !sync.reset_peer_asking(peer_id, PeerAsking::BlockReceipts) {
+			trace!(target: "sync", "{}: Ignored unexpected receipts", peer_id);
+			sync.continue_sync(io);
+			return Ok(());
+		}
+		let item_count = r.item_count()?;
+		trace!(target: "sync", "{} -> BlockReceipts ({} entries)", peer_id, item_count);
+		if item_count == 0 {
+			sync.deactivate_peer(io, peer_id);
+		}
+		else if sync.state == SyncState::Waiting {
+			trace!(target: "sync", "Ignored block receipts while waiting");
+		}
+		else
+		{
+			let result = {
+				let downloader = match block_set {
+					BlockSet::NewBlocks => &mut sync.new_blocks,
+					BlockSet::OldBlocks => match sync.old_blocks {
+						None => {
+							trace!(target: "sync", "Ignored block headers while block download is inactive");
+							sync.continue_sync(io);
+							return Ok(());
+						},
+						Some(ref mut blocks) => blocks,
+					}
+				};
+				downloader.import_receipts(io, r)
+			};
+
+			match result {
+				Err(DownloaderImportError::Invalid) => {
+					io.disable_peer(peer_id);
+					sync.deactivate_peer(io, peer_id);
+					sync.continue_sync(io);
+					return Ok(());
+				},
+				Err(DownloaderImportError::Useless) => {
+					sync.deactivate_peer(io, peer_id);
+				},
+				Ok(()) => (),
+			}
+
+			sync.collect_blocks(io, block_set);
+			sync.sync_peer(io, peer_id, false);
+		}
+		sync.continue_sync(io);
+		Ok(())
+	}
+
+	/// Called when snapshot manifest is downloaded from a peer.
+	fn on_snapshot_manifest(sync: &mut ChainSync, io: &mut SyncIo, peer_id: PeerId, r: &Rlp) -> Result<(), PacketDecodeError> {
+		if !sync.peers.get(&peer_id).map_or(false, |p| p.can_sync()) {
+			trace!(target: "sync", "Ignoring snapshot manifest from unconfirmed peer {}", peer_id);
+			return Ok(());
+		}
+		sync.clear_peer_download(peer_id);
+		if !sync.reset_peer_asking(peer_id, PeerAsking::SnapshotManifest) || sync.state != SyncState::SnapshotManifest {
+			trace!(target: "sync", "{}: Ignored unexpected/expired manifest", peer_id);
+			sync.continue_sync(io);
+			return Ok(());
+		}
+
+		let manifest_rlp = r.at(0)?;
+		let manifest = match ManifestData::from_rlp(manifest_rlp.as_raw()) {
+			Err(e) => {
+				trace!(target: "sync", "{}: Ignored bad manifest: {:?}", peer_id, e);
+				io.disable_peer(peer_id);
+				sync.continue_sync(io);
+				return Ok(());
+			}
+			Ok(manifest) => manifest,
+		};
+
+		let is_supported_version = io.snapshot_service().supported_versions()
+			.map_or(false, |(l, h)| manifest.version >= l && manifest.version <= h);
+
+		if !is_supported_version {
+			trace!(target: "sync", "{}: Snapshot manifest version not supported: {}", peer_id, manifest.version);
+			io.disable_peer(peer_id);
+			sync.continue_sync(io);
+			return Ok(());
+		}
+		sync.snapshot.reset_to(&manifest, &keccak(manifest_rlp.as_raw()));
+		io.snapshot_service().begin_restore(manifest);
+		sync.state = SyncState::SnapshotData;
+
+		// give a task to the same peer first.
+		sync.sync_peer(io, peer_id, false);
+		// give tasks to other peers
+		sync.continue_sync(io);
+		Ok(())
+	}
+
+	/// Called when snapshot data is downloaded from a peer.
+	fn on_snapshot_data(sync: &mut ChainSync, io: &mut SyncIo, peer_id: PeerId, r: &Rlp) -> Result<(), PacketDecodeError> {
+		if !sync.peers.get(&peer_id).map_or(false, |p| p.can_sync()) {
+			trace!(target: "sync", "Ignoring snapshot data from unconfirmed peer {}", peer_id);
+			return Ok(());
+		}
+		sync.clear_peer_download(peer_id);
+		if !sync.reset_peer_asking(peer_id, PeerAsking::SnapshotData) || (sync.state != SyncState::SnapshotData && sync.state != SyncState::SnapshotWaiting) {
+			trace!(target: "sync", "{}: Ignored unexpected snapshot data", peer_id);
+			sync.continue_sync(io);
+			return Ok(());
+		}
+
+		// check service status
+		let status = io.snapshot_service().status();
+		match status {
+			RestorationStatus::Inactive | RestorationStatus::Failed => {
+				trace!(target: "sync", "{}: Snapshot restoration aborted", peer_id);
+				sync.state = SyncState::WaitingPeers;
+
+				// only note bad if restoration failed.
+				if let (Some(hash), RestorationStatus::Failed) = (sync.snapshot.snapshot_hash(), status) {
+					trace!(target: "sync", "Noting snapshot hash {} as bad", hash);
+					sync.snapshot.note_bad(hash);
+				}
+
+				sync.snapshot.clear();
+				sync.continue_sync(io);
+				return Ok(());
+			},
+			RestorationStatus::Initializing  { .. } => {
+				trace!(target: "warp", "{}: Snapshot restoration is initializing", peer_id);
+				return Ok(());
+			}
+			RestorationStatus::Ongoing { .. } => {
+				trace!(target: "sync", "{}: Snapshot restoration is ongoing", peer_id);
+			},
+		}
+
+		let snapshot_data: Bytes = r.val_at(0)?;
+		match sync.snapshot.validate_chunk(&snapshot_data) {
+			Ok(ChunkType::Block(hash)) => {
+				trace!(target: "sync", "{}: Processing block chunk", peer_id);
+				io.snapshot_service().restore_block_chunk(hash, snapshot_data);
+			}
+			Ok(ChunkType::State(hash)) => {
+				trace!(target: "sync", "{}: Processing state chunk", peer_id);
+				io.snapshot_service().restore_state_chunk(hash, snapshot_data);
+			}
+			Err(()) => {
+				trace!(target: "sync", "{}: Got bad snapshot chunk", peer_id);
+				io.disconnect_peer(peer_id);
+				sync.continue_sync(io);
+				return Ok(());
+			}
+		}
+
+		if sync.snapshot.is_complete() {
+			// wait for snapshot restoration process to complete
+			sync.state = SyncState::SnapshotWaiting;
+		}
+		// give a task to the same peer first.
+		sync.sync_peer(io, peer_id, false);
+		// give tasks to other peers
+		sync.continue_sync(io);
+		Ok(())
+	}
+
+	/// Called by peer to report status
+	fn on_peer_status(sync: &mut ChainSync, io: &mut SyncIo, peer_id: PeerId, r: &Rlp) -> Result<(), PacketDecodeError> {
+		sync.handshaking_peers.remove(&peer_id);
+		let protocol_version: u8 = r.val_at(0)?;
+		let warp_protocol = io.protocol_version(&WARP_SYNC_PROTOCOL_ID, peer_id) != 0;
+		let peer = PeerInfo {
+			protocol_version: protocol_version,
+			network_id: r.val_at(1)?,
+			difficulty: Some(r.val_at(2)?),
+			latest_hash: r.val_at(3)?,
+			genesis: r.val_at(4)?,
+			asking: PeerAsking::Nothing,
+			asking_blocks: Vec::new(),
+			asking_hash: None,
+			ask_time: Instant::now(),
+			last_sent_transactions: HashSet::new(),
+			expired: false,
+			confirmation: if sync.fork_block.is_none() { ForkConfirmation::Confirmed } else { ForkConfirmation::Unconfirmed },
+			asking_snapshot_data: None,
+			snapshot_hash: if warp_protocol { Some(r.val_at(5)?) } else { None },
+			snapshot_number: if warp_protocol { Some(r.val_at(6)?) } else { None },
+			block_set: None,
+		};
+
+		trace!(target: "sync", "New peer {} (protocol: {}, network: {:?}, difficulty: {:?}, latest:{}, genesis:{}, snapshot:{:?})",
+			peer_id, peer.protocol_version, peer.network_id, peer.difficulty, peer.latest_hash, peer.genesis, peer.snapshot_number);
+		if io.is_expired() {
+			trace!(target: "sync", "Status packet from expired session {}:{}", peer_id, io.peer_info(peer_id));
+			return Ok(());
+		}
+
+		if sync.peers.contains_key(&peer_id) {
+			debug!(target: "sync", "Unexpected status packet from {}:{}", peer_id, io.peer_info(peer_id));
+			return Ok(());
+		}
+		let chain_info = io.chain().chain_info();
+		if peer.genesis != chain_info.genesis_hash {
+			io.disable_peer(peer_id);
+			trace!(target: "sync", "Peer {} genesis hash mismatch (ours: {}, theirs: {})", peer_id, chain_info.genesis_hash, peer.genesis);
+			return Ok(());
+		}
+		if peer.network_id != sync.network_id {
+			io.disable_peer(peer_id);
+			trace!(target: "sync", "Peer {} network id mismatch (ours: {}, theirs: {})", peer_id, sync.network_id, peer.network_id);
+			return Ok(());
+		}
+
+		if false
+			|| (warp_protocol && (peer.protocol_version < PAR_PROTOCOL_VERSION_1.0 || peer.protocol_version > PAR_PROTOCOL_VERSION_3.0))
+			|| (!warp_protocol && (peer.protocol_version < ETH_PROTOCOL_VERSION_62.0 || peer.protocol_version > ETH_PROTOCOL_VERSION_63.0))
+		{
+			io.disable_peer(peer_id);
+			trace!(target: "sync", "Peer {} unsupported eth protocol ({})", peer_id, peer.protocol_version);
+			return Ok(());
+		}
+
+		if sync.sync_start_time.is_none() {
+			sync.sync_start_time = Some(Instant::now());
+		}
+
+		sync.peers.insert(peer_id.clone(), peer);
+		// Don't activate peer immediatelly when searching for common block.
+		// Let the current sync round complete first.
+		sync.active_peers.insert(peer_id.clone());
+		debug!(target: "sync", "Connected {}:{}", peer_id, io.peer_info(peer_id));
+
+		match sync.fork_block {
+			Some((fork_block, _)) => {
+				SyncRequester::request_fork_header(sync, io, peer_id, fork_block);
+			},
+			_ => {
+				// when there's no `fork_block` defined we initialize the peer with
+				// `confirmation: ForkConfirmation::Confirmed`.
+				sync.sync_peer(io, peer_id, false);
+			}
+		}
+
+		Ok(())
+	}
+
+	/// Called when peer sends us new transactions
+	fn on_peer_transactions(sync: &mut ChainSync, io: &mut SyncIo, peer_id: PeerId, r: &Rlp) -> Result<(), PacketDecodeError> {
+		// Accept transactions only when fully synced
+		if !io.is_chain_queue_empty() || (sync.state != SyncState::Idle && sync.state != SyncState::NewBlocks) {
+			trace!(target: "sync", "{} Ignoring transactions while syncing", peer_id);
+			return Ok(());
+		}
+		if !sync.peers.get(&peer_id).map_or(false, |p| p.can_sync()) {
+			trace!(target: "sync", "{} Ignoring transactions from unconfirmed/unknown peer", peer_id);
+			return Ok(());
+		}
+
+		let item_count = r.item_count()?;
+		trace!(target: "sync", "{:02} -> Transactions ({} entries)", peer_id, item_count);
+		let mut transactions = Vec::with_capacity(item_count);
+		for i in 0 .. item_count {
+			let rlp = r.at(i)?;
+			let tx = rlp.as_raw().to_vec();
+			transactions.push(tx);
+		}
+		io.chain().queue_transactions(transactions, peer_id);
+		Ok(())
+	}
+
+	/// Called when peer sends us signed private transaction packet
+	fn on_signed_private_transaction(sync: &ChainSync, _io: &mut SyncIo, peer_id: PeerId, r: &Rlp) -> Result<(), PacketDecodeError> {
+		if !sync.peers.get(&peer_id).map_or(false, |p| p.can_sync()) {
+			trace!(target: "sync", "{} Ignoring packet from unconfirmed/unknown peer", peer_id);
+			return Ok(());
+		}
+
+		trace!(target: "sync", "Received signed private transaction packet from {:?}", peer_id);
+		if let Err(e) = sync.private_tx_handler.import_signed_private_transaction(r.as_raw()) {
+			trace!(target: "sync", "Ignoring the message, error queueing: {}", e);
+		}
+		Ok(())
+	}
+
+	/// Called when peer sends us new private transaction packet
+	fn on_private_transaction(sync: &ChainSync, _io: &mut SyncIo, peer_id: PeerId, r: &Rlp) -> Result<(), PacketDecodeError> {
+		if !sync.peers.get(&peer_id).map_or(false, |p| p.can_sync()) {
+			trace!(target: "sync", "{} Ignoring packet from unconfirmed/unknown peer", peer_id);
+			return Ok(());
+		}
+
+		trace!(target: "sync", "Received private transaction packet from {:?}", peer_id);
+
+		if let Err(e) = sync.private_tx_handler.import_private_transaction(r.as_raw()) {
+			trace!(target: "sync", "Ignoring the message, error queueing: {}", e);
+		}
+		Ok(())
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use ethcore::client::{ChainInfo, EachBlockWith, TestBlockChainClient};
+	use parking_lot::RwLock;
+	use rlp::{Rlp};
+	use std::collections::{VecDeque};
+	use tests::helpers::{TestIo};
+	use tests::snapshot::TestSnapshotService;
+
+	use super::*;
+	use super::super::tests::{
+		dummy_sync_with_peer,
+		get_dummy_block,
+		get_dummy_blocks,
+		get_dummy_hashes,
+	};
+
+	#[test]
+	fn handles_peer_new_hashes() {
+		let mut client = TestBlockChainClient::new();
+		client.add_blocks(10, EachBlockWith::Uncle);
+		let queue = RwLock::new(VecDeque::new());
+		let mut sync = dummy_sync_with_peer(client.block_hash_delta_minus(5), &client);
+		let ss = TestSnapshotService::new();
+		let mut io = TestIo::new(&mut client, &ss, &queue, None);
+
+		let hashes_data = get_dummy_hashes();
+		let hashes_rlp = Rlp::new(&hashes_data);
+
+		let result = SyncHandler::on_peer_new_hashes(&mut sync, &mut io, 0, &hashes_rlp);
+
+		assert!(result.is_ok());
+	}
+
+	#[test]
+	fn handles_peer_new_block_malformed() {
+		let mut client = TestBlockChainClient::new();
+		client.add_blocks(10, EachBlockWith::Uncle);
+
+		let block_data = get_dummy_block(11, client.chain_info().best_block_hash);
+
+		let queue = RwLock::new(VecDeque::new());
+		let mut sync = dummy_sync_with_peer(client.block_hash_delta_minus(5), &client);
+		//sync.have_common_block = true;
+		let ss = TestSnapshotService::new();
+		let mut io = TestIo::new(&mut client, &ss, &queue, None);
+
+		let block = Rlp::new(&block_data);
+
+		let result = SyncHandler::on_peer_new_block(&mut sync, &mut io, 0, &block);
+
+		assert!(result.is_err());
+	}
+
+	#[test]
+	fn handles_peer_new_block() {
+		let mut client = TestBlockChainClient::new();
+		client.add_blocks(10, EachBlockWith::Uncle);
+
+		let block_data = get_dummy_blocks(11, client.chain_info().best_block_hash);
+
+		let queue = RwLock::new(VecDeque::new());
+		let mut sync = dummy_sync_with_peer(client.block_hash_delta_minus(5), &client);
+		let ss = TestSnapshotService::new();
+		let mut io = TestIo::new(&mut client, &ss, &queue, None);
+
+		let block = Rlp::new(&block_data);
+
+		let result = SyncHandler::on_peer_new_block(&mut sync, &mut io, 0, &block);
+
+		assert!(result.is_ok());
+	}
+
+	#[test]
+	fn handles_peer_new_block_empty() {
+		let mut client = TestBlockChainClient::new();
+		client.add_blocks(10, EachBlockWith::Uncle);
+		let queue = RwLock::new(VecDeque::new());
+		let mut sync = dummy_sync_with_peer(client.block_hash_delta_minus(5), &client);
+		let ss = TestSnapshotService::new();
+		let mut io = TestIo::new(&mut client, &ss, &queue, None);
+
+		let empty_data = vec![];
+		let block = Rlp::new(&empty_data);
+
+		let result = SyncHandler::on_peer_new_block(&mut sync, &mut io, 0, &block);
+
+		assert!(result.is_err());
+	}
+
+	#[test]
+	fn handles_peer_new_hashes_empty() {
+		let mut client = TestBlockChainClient::new();
+		client.add_blocks(10, EachBlockWith::Uncle);
+		let queue = RwLock::new(VecDeque::new());
+		let mut sync = dummy_sync_with_peer(client.block_hash_delta_minus(5), &client);
+		let ss = TestSnapshotService::new();
+		let mut io = TestIo::new(&mut client, &ss, &queue, None);
+
+		let empty_hashes_data = vec![];
+		let hashes_rlp = Rlp::new(&empty_hashes_data);
+
+		let result = SyncHandler::on_peer_new_hashes(&mut sync, &mut io, 0, &hashes_rlp);
+
+		assert!(result.is_ok());
+	}
+}
--- a/ethcore/sync/src/chain/mod.rs
+++ b/ethcore/sync/src/chain/mod.rs
--- a/ethcore/sync/src/chain/propagator.rs
+++ b/ethcore/sync/src/chain/propagator.rs
@ -0,0 +1,636 @@
+// Copyright 2015-2018 Parity Technologies (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+use bytes::Bytes;
+use ethereum_types::H256;
+use ethcore::client::BlockChainInfo;
+use ethcore::header::BlockNumber;
+use network::{PeerId, PacketId};
+use rand::Rng;
+use rlp::{Encodable, RlpStream};
+use sync_io::SyncIo;
+use std::cmp;
+use std::collections::HashSet;
+use transaction::SignedTransaction;
+
+use super::{
+	random,
+	ChainSync,
+	MAX_PEER_LAG_PROPAGATION,
+	MAX_PEERS_PROPAGATION,
+	MAX_TRANSACTION_PACKET_SIZE,
+	MAX_TRANSACTIONS_TO_PROPAGATE,
+	MIN_PEERS_PROPAGATION,
+	CONSENSUS_DATA_PACKET,
+	NEW_BLOCK_HASHES_PACKET,
+	NEW_BLOCK_PACKET,
+	PRIVATE_TRANSACTION_PACKET,
+	SIGNED_PRIVATE_TRANSACTION_PACKET,
+	TRANSACTIONS_PACKET,
+};
+
+/// Checks if peer is able to process service transactions
+fn accepts_service_transaction(client_id: &str) -> bool {
+	// Parity versions starting from this will accept service-transactions
+	const SERVICE_TRANSACTIONS_VERSION: (u32, u32) = (1u32, 6u32);
+	// Parity client string prefix
+	const PARITY_CLIENT_ID_PREFIX: &'static str = "Parity/v";
+
+	if !client_id.starts_with(PARITY_CLIENT_ID_PREFIX) {
+		return false;
+	}
+	let ver: Vec<u32> = client_id[PARITY_CLIENT_ID_PREFIX.len()..].split('.')
+		.take(2)
+		.filter_map(|s| s.parse().ok())
+		.collect();
+	ver.len() == 2 && (ver[0] > SERVICE_TRANSACTIONS_VERSION.0 || (ver[0] == SERVICE_TRANSACTIONS_VERSION.0 && ver[1] >= SERVICE_TRANSACTIONS_VERSION.1))
+}
+
+/// The Chain Sync Propagator: propagates data to peers
+pub struct SyncPropagator;
+
+impl SyncPropagator {
+	/// propagates latest block to a set of peers
+	pub fn propagate_blocks(sync: &mut ChainSync, chain_info: &BlockChainInfo, io: &mut SyncIo, blocks: &[H256], peers: &[PeerId]) -> usize {
+		trace!(target: "sync", "Sending NewBlocks to {:?}", peers);
+		let mut sent = 0;
+		for peer_id in peers {
+			if blocks.is_empty() {
+				let rlp =  ChainSync::create_latest_block_rlp(io.chain());
+				SyncPropagator::send_packet(io, *peer_id, NEW_BLOCK_PACKET, rlp);
+			} else {
+				for h in blocks {
+					let rlp =  ChainSync::create_new_block_rlp(io.chain(), h);
+					SyncPropagator::send_packet(io, *peer_id, NEW_BLOCK_PACKET, rlp);
+				}
+			}
+			if let Some(ref mut peer) = sync.peers.get_mut(peer_id) {
+				peer.latest_hash = chain_info.best_block_hash.clone();
+			}
+			sent += 1;
+		}
+		sent
+	}
+
+	/// propagates new known hashes to all peers
+	pub fn propagate_new_hashes(sync: &mut ChainSync, chain_info: &BlockChainInfo, io: &mut SyncIo, peers: &[PeerId]) -> usize {
+		trace!(target: "sync", "Sending NewHashes to {:?}", peers);
+		let mut sent = 0;
+		let last_parent = *io.chain().best_block_header().parent_hash();
+		for peer_id in peers {
+			sent += match ChainSync::create_new_hashes_rlp(io.chain(), &last_parent, &chain_info.best_block_hash) {
+				Some(rlp) => {
+					{
+						if let Some(ref mut peer) = sync.peers.get_mut(peer_id) {
+							peer.latest_hash = chain_info.best_block_hash.clone();
+						}
+					}
+					SyncPropagator::send_packet(io, *peer_id, NEW_BLOCK_HASHES_PACKET, rlp);
+					1
+				},
+				None => 0
+			}
+		}
+		sent
+	}
+
+	/// propagates new transactions to all peers
+	pub fn propagate_new_transactions(sync: &mut ChainSync, io: &mut SyncIo) -> usize {
+		// Early out if nobody to send to.
+		if sync.peers.is_empty() {
+			return 0;
+		}
+
+		let transactions = io.chain().ready_transactions();
+		if transactions.is_empty() {
+			return 0;
+		}
+
+		let (transactions, service_transactions): (Vec<_>, Vec<_>) = transactions.iter()
+			.map(|tx| tx.signed())
+			.partition(|tx| !tx.gas_price.is_zero());
+
+		// usual transactions could be propagated to all peers
+		let mut affected_peers = HashSet::new();
+		if !transactions.is_empty() {
+			let peers = SyncPropagator::select_peers_for_transactions(sync, |_| true);
+			affected_peers = SyncPropagator::propagate_transactions_to_peers(sync, io, peers, transactions);
+		}
+
+		// most of times service_transactions will be empty
+		// => there's no need to merge packets
+		if !service_transactions.is_empty() {
+			let service_transactions_peers = SyncPropagator::select_peers_for_transactions(sync, |peer_id| accepts_service_transaction(&io.peer_info(*peer_id)));
+			let service_transactions_affected_peers = SyncPropagator::propagate_transactions_to_peers(sync, io, service_transactions_peers, service_transactions);
+			affected_peers.extend(&service_transactions_affected_peers);
+		}
+
+		affected_peers.len()
+	}
+
+	fn propagate_transactions_to_peers(sync: &mut ChainSync, io: &mut SyncIo, peers: Vec<PeerId>, transactions: Vec<&SignedTransaction>) -> HashSet<PeerId> {
+		let all_transactions_hashes = transactions.iter()
+			.map(|tx| tx.hash())
+			.collect::<HashSet<H256>>();
+		let all_transactions_rlp = {
+			let mut packet = RlpStream::new_list(transactions.len());
+			for tx in &transactions { packet.append(&**tx); }
+			packet.out()
+		};
+
+		// Clear old transactions from stats
+		sync.transactions_stats.retain(&all_transactions_hashes);
+
+		// sqrt(x)/x scaled to max u32
+		let block_number = io.chain().chain_info().best_block_number;
+
+		let lucky_peers = {
+			peers.into_iter()
+				.filter_map(|peer_id| {
+					let stats = &mut sync.transactions_stats;
+					let peer_info = sync.peers.get_mut(&peer_id)
+						.expect("peer_id is form peers; peers is result of select_peers_for_transactions; select_peers_for_transactions selects peers from self.peers; qed");
+
+					// Send all transactions
+					if peer_info.last_sent_transactions.is_empty() {
+						// update stats
+						for hash in &all_transactions_hashes {
+							let id = io.peer_session_info(peer_id).and_then(|info| info.id);
+							stats.propagated(hash, id, block_number);
+						}
+						peer_info.last_sent_transactions = all_transactions_hashes.clone();
+						return Some((peer_id, all_transactions_hashes.len(), all_transactions_rlp.clone()));
+					}
+
+					// Get hashes of all transactions to send to this peer
+					let to_send = all_transactions_hashes.difference(&peer_info.last_sent_transactions)
+						.take(MAX_TRANSACTIONS_TO_PROPAGATE)
+						.cloned()
+						.collect::<HashSet<_>>();
+					if to_send.is_empty() {
+						return None;
+					}
+
+					// Construct RLP
+					let (packet, to_send) = {
+						let mut to_send = to_send;
+						let mut packet = RlpStream::new();
+						packet.begin_unbounded_list();
+						let mut pushed = 0;
+						for tx in &transactions {
+							let hash = tx.hash();
+							if to_send.contains(&hash) {
+								let mut transaction = RlpStream::new();
+								tx.rlp_append(&mut transaction);
+								let appended = packet.append_raw_checked(&transaction.drain(), 1, MAX_TRANSACTION_PACKET_SIZE);
+								if !appended {
+									// Maximal packet size reached just proceed with sending
+									debug!("Transaction packet size limit reached. Sending incomplete set of {}/{} transactions.", pushed, to_send.len());
+									to_send = to_send.into_iter().take(pushed).collect();
+									break;
+								}
+								pushed += 1;
+							}
+						}
+						packet.complete_unbounded_list();
+						(packet, to_send)
+					};
+
+					// Update stats
+					let id = io.peer_session_info(peer_id).and_then(|info| info.id);
+					for hash in &to_send {
+						// update stats
+						stats.propagated(hash, id, block_number);
+					}
+
+					peer_info.last_sent_transactions = all_transactions_hashes
+						.intersection(&peer_info.last_sent_transactions)
+						.chain(&to_send)
+						.cloned()
+						.collect();
+					Some((peer_id, to_send.len(), packet.out()))
+				})
+				.collect::<Vec<_>>()
+		};
+
+		// Send RLPs
+		let mut peers = HashSet::new();
+		if lucky_peers.len() > 0 {
+			let mut max_sent = 0;
+			let lucky_peers_len = lucky_peers.len();
+			for (peer_id, sent, rlp) in lucky_peers {
+				peers.insert(peer_id);
+				SyncPropagator::send_packet(io, peer_id, TRANSACTIONS_PACKET, rlp);
+				trace!(target: "sync", "{:02} <- Transactions ({} entries)", peer_id, sent);
+				max_sent = cmp::max(max_sent, sent);
+			}
+			debug!(target: "sync", "Sent up to {} transactions to {} peers.", max_sent, lucky_peers_len);
+		}
+
+		peers
+	}
+
+	pub fn propagate_latest_blocks(sync: &mut ChainSync, io: &mut SyncIo, sealed: &[H256]) {
+		let chain_info = io.chain().chain_info();
+		if (((chain_info.best_block_number as i64) - (sync.last_sent_block_number as i64)).abs() as BlockNumber) < MAX_PEER_LAG_PROPAGATION {
+			let mut peers = sync.get_lagging_peers(&chain_info);
+			if sealed.is_empty() {
+				let hashes = SyncPropagator::propagate_new_hashes(sync, &chain_info, io, &peers);
+				peers = ChainSync::select_random_peers(&peers);
+				let blocks = SyncPropagator::propagate_blocks(sync, &chain_info, io, sealed, &peers);
+				if blocks != 0 || hashes != 0 {
+					trace!(target: "sync", "Sent latest {} blocks and {} hashes to peers.", blocks, hashes);
+				}
+			} else {
+				SyncPropagator::propagate_blocks(sync, &chain_info, io, sealed, &peers);
+				SyncPropagator::propagate_new_hashes(sync, &chain_info, io, &peers);
+				trace!(target: "sync", "Sent sealed block to all peers");
+			};
+		}
+		sync.last_sent_block_number = chain_info.best_block_number;
+	}
+
+	/// Distribute valid proposed blocks to subset of current peers.
+	pub fn propagate_proposed_blocks(sync: &mut ChainSync, io: &mut SyncIo, proposed: &[Bytes]) {
+		let peers = sync.get_consensus_peers();
+		trace!(target: "sync", "Sending proposed blocks to {:?}", peers);
+		for block in proposed {
+			let rlp = ChainSync::create_block_rlp(
+				block,
+				io.chain().chain_info().total_difficulty
+			);
+			for peer_id in &peers {
+				SyncPropagator::send_packet(io, *peer_id, NEW_BLOCK_PACKET, rlp.clone());
+			}
+		}
+	}
+
+	/// Broadcast consensus message to peers.
+	pub fn propagate_consensus_packet(sync: &mut ChainSync, io: &mut SyncIo, packet: Bytes) {
+		let lucky_peers = ChainSync::select_random_peers(&sync.get_consensus_peers());
+		trace!(target: "sync", "Sending consensus packet to {:?}", lucky_peers);
+		for peer_id in lucky_peers {
+			SyncPropagator::send_packet(io, peer_id, CONSENSUS_DATA_PACKET, packet.clone());
+		}
+	}
+
+	/// Broadcast private transaction message to peers.
+	pub fn propagate_private_transaction(sync: &mut ChainSync, io: &mut SyncIo, packet: Bytes) {
+		let lucky_peers = ChainSync::select_random_peers(&sync.get_private_transaction_peers());
+		trace!(target: "sync", "Sending private transaction packet to {:?}", lucky_peers);
+		for peer_id in lucky_peers {
+			SyncPropagator::send_packet(io, peer_id, PRIVATE_TRANSACTION_PACKET, packet.clone());
+		}
+	}
+
+	/// Broadcast signed private transaction message to peers.
+	pub fn propagate_signed_private_transaction(sync: &mut ChainSync, io: &mut SyncIo, packet: Bytes) {
+		let lucky_peers = ChainSync::select_random_peers(&sync.get_private_transaction_peers());
+		trace!(target: "sync", "Sending signed private transaction packet to {:?}", lucky_peers);
+		for peer_id in lucky_peers {
+			SyncPropagator::send_packet(io, peer_id, SIGNED_PRIVATE_TRANSACTION_PACKET, packet.clone());
+		}
+	}
+
+	fn select_peers_for_transactions<F>(sync: &ChainSync, filter: F) -> Vec<PeerId>
+		where F: Fn(&PeerId) -> bool {
+		// sqrt(x)/x scaled to max u32
+		let fraction = ((sync.peers.len() as f64).powf(-0.5) * (u32::max_value() as f64).round()) as u32;
+		let small = sync.peers.len() < MIN_PEERS_PROPAGATION;
+
+		let mut random = random::new();
+		sync.peers.keys()
+			.cloned()
+			.filter(filter)
+			.filter(|_| small || random.next_u32() < fraction)
+			.take(MAX_PEERS_PROPAGATION)
+			.collect()
+	}
+
+	/// Generic packet sender
+	fn send_packet(sync: &mut SyncIo, peer_id: PeerId, packet_id: PacketId, packet: Bytes) {
+		if let Err(e) = sync.send(peer_id, packet_id, packet) {
+			debug!(target:"sync", "Error sending packet: {:?}", e);
+			sync.disconnect_peer(peer_id);
+		}
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use ethcore::client::{BlockInfo, ChainInfo, EachBlockWith, TestBlockChainClient};
+	use parking_lot::RwLock;
+	use private_tx::NoopPrivateTxHandler;
+	use rlp::{Rlp};
+	use std::collections::{VecDeque};
+	use tests::helpers::{TestIo};
+	use tests::snapshot::TestSnapshotService;
+
+	use super::{*, super::{*, tests::*}};
+
+	#[test]
+	fn sends_new_hashes_to_lagging_peer() {
+		let mut client = TestBlockChainClient::new();
+		client.add_blocks(100, EachBlockWith::Uncle);
+		let queue = RwLock::new(VecDeque::new());
+		let mut sync = dummy_sync_with_peer(client.block_hash_delta_minus(5), &client);
+		let chain_info = client.chain_info();
+		let ss = TestSnapshotService::new();
+		let mut io = TestIo::new(&mut client, &ss, &queue, None);
+
+		let peers = sync.get_lagging_peers(&chain_info);
+		let peer_count = SyncPropagator::propagate_new_hashes(&mut sync, &chain_info, &mut io, &peers);
+
+		// 1 message should be send
+		assert_eq!(1, io.packets.len());
+		// 1 peer should be updated
+		assert_eq!(1, peer_count);
+		// NEW_BLOCK_HASHES_PACKET
+		assert_eq!(0x01, io.packets[0].packet_id);
+	}
+
+	#[test]
+	fn sends_latest_block_to_lagging_peer() {
+		let mut client = TestBlockChainClient::new();
+		client.add_blocks(100, EachBlockWith::Uncle);
+		let queue = RwLock::new(VecDeque::new());
+		let mut sync = dummy_sync_with_peer(client.block_hash_delta_minus(5), &client);
+		let chain_info = client.chain_info();
+		let ss = TestSnapshotService::new();
+		let mut io = TestIo::new(&mut client, &ss, &queue, None);
+		let peers = sync.get_lagging_peers(&chain_info);
+		let peer_count = SyncPropagator::propagate_blocks(&mut sync, &chain_info, &mut io, &[], &peers);
+
+		// 1 message should be send
+		assert_eq!(1, io.packets.len());
+		// 1 peer should be updated
+		assert_eq!(1, peer_count);
+		// NEW_BLOCK_PACKET
+		assert_eq!(0x07, io.packets[0].packet_id);
+	}
+
+	#[test]
+	fn sends_sealed_block() {
+		let mut client = TestBlockChainClient::new();
+		client.add_blocks(100, EachBlockWith::Uncle);
+		let queue = RwLock::new(VecDeque::new());
+		let hash = client.block_hash(BlockId::Number(99)).unwrap();
+		let mut sync = dummy_sync_with_peer(client.block_hash_delta_minus(5), &client);
+		let chain_info = client.chain_info();
+		let ss = TestSnapshotService::new();
+		let mut io = TestIo::new(&mut client, &ss, &queue, None);
+		let peers = sync.get_lagging_peers(&chain_info);
+		let peer_count = SyncPropagator::propagate_blocks(&mut sync ,&chain_info, &mut io, &[hash.clone()], &peers);
+
+		// 1 message should be send
+		assert_eq!(1, io.packets.len());
+		// 1 peer should be updated
+		assert_eq!(1, peer_count);
+		// NEW_BLOCK_PACKET
+		assert_eq!(0x07, io.packets[0].packet_id);
+	}
+
+	#[test]
+	fn sends_proposed_block() {
+		let mut client = TestBlockChainClient::new();
+		client.add_blocks(2, EachBlockWith::Uncle);
+		let queue = RwLock::new(VecDeque::new());
+		let block = client.block(BlockId::Latest).unwrap().into_inner();
+		let mut sync = ChainSync::new(SyncConfig::default(), &client, Arc::new(NoopPrivateTxHandler));
+		sync.peers.insert(0,
+			PeerInfo {
+				// Messaging protocol
+				protocol_version: 2,
+				genesis: H256::zero(),
+				network_id: 0,
+				latest_hash: client.block_hash_delta_minus(1),
+				difficulty: None,
+				asking: PeerAsking::Nothing,
+				asking_blocks: Vec::new(),
+				asking_hash: None,
+				ask_time: Instant::now(),
+				last_sent_transactions: HashSet::new(),
+				expired: false,
+				confirmation: ForkConfirmation::Confirmed,
+				snapshot_number: None,
+				snapshot_hash: None,
+				asking_snapshot_data: None,
+				block_set: None,
+			});
+		let ss = TestSnapshotService::new();
+		let mut io = TestIo::new(&mut client, &ss, &queue, None);
+		SyncPropagator::propagate_proposed_blocks(&mut sync, &mut io, &[block]);
+
+		// 1 message should be sent
+		assert_eq!(1, io.packets.len());
+		// NEW_BLOCK_PACKET
+		assert_eq!(0x07, io.packets[0].packet_id);
+	}
+
+	#[test]
+	fn propagates_transactions() {
+		let mut client = TestBlockChainClient::new();
+		client.add_blocks(100, EachBlockWith::Uncle);
+		client.insert_transaction_to_queue();
+		let mut sync = dummy_sync_with_peer(client.block_hash_delta_minus(1), &client);
+		let queue = RwLock::new(VecDeque::new());
+		let ss = TestSnapshotService::new();
+		let mut io = TestIo::new(&mut client, &ss, &queue, None);
+		let peer_count = SyncPropagator::propagate_new_transactions(&mut sync, &mut io);
+		// Try to propagate same transactions for the second time
+		let peer_count2 = SyncPropagator::propagate_new_transactions(&mut sync, &mut io);
+		// Even after new block transactions should not be propagated twice
+		sync.chain_new_blocks(&mut io, &[], &[], &[], &[], &[], &[]);
+		// Try to propagate same transactions for the third time
+		let peer_count3 = SyncPropagator::propagate_new_transactions(&mut sync, &mut io);
+
+		// 1 message should be send
+		assert_eq!(1, io.packets.len());
+		// 1 peer should be updated but only once
+		assert_eq!(1, peer_count);
+		assert_eq!(0, peer_count2);
+		assert_eq!(0, peer_count3);
+		// TRANSACTIONS_PACKET
+		assert_eq!(0x02, io.packets[0].packet_id);
+	}
+
+	#[test]
+	fn does_not_propagate_new_transactions_after_new_block() {
+		let mut client = TestBlockChainClient::new();
+		client.add_blocks(100, EachBlockWith::Uncle);
+		client.insert_transaction_to_queue();
+		let mut sync = dummy_sync_with_peer(client.block_hash_delta_minus(1), &client);
+		let queue = RwLock::new(VecDeque::new());
+		let ss = TestSnapshotService::new();
+		let mut io = TestIo::new(&mut client, &ss, &queue, None);
+		let peer_count = SyncPropagator::propagate_new_transactions(&mut sync, &mut io);
+		io.chain.insert_transaction_to_queue();
+		// New block import should not trigger propagation.
+		// (we only propagate on timeout)
+		sync.chain_new_blocks(&mut io, &[], &[], &[], &[], &[], &[]);
+
+		// 2 message should be send
+		assert_eq!(1, io.packets.len());
+		// 1 peer should receive the message
+		assert_eq!(1, peer_count);
+		// TRANSACTIONS_PACKET
+		assert_eq!(0x02, io.packets[0].packet_id);
+	}
+
+	#[test]
+	fn does_not_fail_for_no_peers() {
+		let mut client = TestBlockChainClient::new();
+		client.add_blocks(100, EachBlockWith::Uncle);
+		client.insert_transaction_to_queue();
+		// Sync with no peers
+		let mut sync = ChainSync::new(SyncConfig::default(), &client, Arc::new(NoopPrivateTxHandler));
+		let queue = RwLock::new(VecDeque::new());
+		let ss = TestSnapshotService::new();
+		let mut io = TestIo::new(&mut client, &ss, &queue, None);
+		let peer_count = SyncPropagator::propagate_new_transactions(&mut sync, &mut io);
+		sync.chain_new_blocks(&mut io, &[], &[], &[], &[], &[], &[]);
+		// Try to propagate same transactions for the second time
+		let peer_count2 = SyncPropagator::propagate_new_transactions(&mut sync, &mut io);
+
+		assert_eq!(0, io.packets.len());
+		assert_eq!(0, peer_count);
+		assert_eq!(0, peer_count2);
+	}
+
+	#[test]
+	fn propagates_transactions_without_alternating() {
+		let mut client = TestBlockChainClient::new();
+		client.add_blocks(100, EachBlockWith::Uncle);
+		client.insert_transaction_to_queue();
+		let mut sync = dummy_sync_with_peer(client.block_hash_delta_minus(1), &client);
+		let queue = RwLock::new(VecDeque::new());
+		let ss = TestSnapshotService::new();
+		// should sent some
+		{
+			let mut io = TestIo::new(&mut client, &ss, &queue, None);
+			let peer_count = SyncPropagator::propagate_new_transactions(&mut sync, &mut io);
+			assert_eq!(1, io.packets.len());
+			assert_eq!(1, peer_count);
+		}
+		// Insert some more
+		client.insert_transaction_to_queue();
+		let (peer_count2, peer_count3) = {
+			let mut io = TestIo::new(&mut client, &ss, &queue, None);
+			// Propagate new transactions
+			let peer_count2 = SyncPropagator::propagate_new_transactions(&mut sync, &mut io);
+			// And now the peer should have all transactions
+			let peer_count3 = SyncPropagator::propagate_new_transactions(&mut sync, &mut io);
+			(peer_count2, peer_count3)
+		};
+
+		// 2 message should be send (in total)
+		assert_eq!(2, queue.read().len());
+		// 1 peer should be updated but only once after inserting new transaction
+		assert_eq!(1, peer_count2);
+		assert_eq!(0, peer_count3);
+		// TRANSACTIONS_PACKET
+		assert_eq!(0x02, queue.read()[0].packet_id);
+		assert_eq!(0x02, queue.read()[1].packet_id);
+	}
+
+	#[test]
+	fn should_maintain_transations_propagation_stats() {
+		let mut client = TestBlockChainClient::new();
+		client.add_blocks(100, EachBlockWith::Uncle);
+		client.insert_transaction_to_queue();
+		let mut sync = dummy_sync_with_peer(client.block_hash_delta_minus(1), &client);
+		let queue = RwLock::new(VecDeque::new());
+		let ss = TestSnapshotService::new();
+		let mut io = TestIo::new(&mut client, &ss, &queue, None);
+		SyncPropagator::propagate_new_transactions(&mut sync, &mut io);
+
+		let stats = sync.transactions_stats();
+		assert_eq!(stats.len(), 1, "Should maintain stats for single transaction.")
+	}
+
+	#[test]
+	fn should_propagate_service_transaction_to_selected_peers_only() {
+		let mut client = TestBlockChainClient::new();
+		client.insert_transaction_with_gas_price_to_queue(U256::zero());
+		let block_hash = client.block_hash_delta_minus(1);
+		let mut sync = ChainSync::new(SyncConfig::default(), &client, Arc::new(NoopPrivateTxHandler));
+		let queue = RwLock::new(VecDeque::new());
+		let ss = TestSnapshotService::new();
+		let mut io = TestIo::new(&mut client, &ss, &queue, None);
+
+		// when peer#1 is Geth
+		insert_dummy_peer(&mut sync, 1, block_hash);
+		io.peers_info.insert(1, "Geth".to_owned());
+		// and peer#2 is Parity, accepting service transactions
+		insert_dummy_peer(&mut sync, 2, block_hash);
+		io.peers_info.insert(2, "Parity/v1.6".to_owned());
+		// and peer#3 is Parity, discarding service transactions
+		insert_dummy_peer(&mut sync, 3, block_hash);
+		io.peers_info.insert(3, "Parity/v1.5".to_owned());
+		// and peer#4 is Parity, accepting service transactions
+		insert_dummy_peer(&mut sync, 4, block_hash);
+		io.peers_info.insert(4, "Parity/v1.7.3-ABCDEFGH".to_owned());
+
+		// and new service transaction is propagated to peers
+		SyncPropagator::propagate_new_transactions(&mut sync, &mut io);
+
+		// peer#2 && peer#4 are receiving service transaction
+		assert!(io.packets.iter().any(|p| p.packet_id == 0x02 && p.recipient == 2)); // TRANSACTIONS_PACKET
+		assert!(io.packets.iter().any(|p| p.packet_id == 0x02 && p.recipient == 4)); // TRANSACTIONS_PACKET
+		assert_eq!(io.packets.len(), 2);
+	}
+
+	#[test]
+	fn should_propagate_service_transaction_is_sent_as_separate_message() {
+		let mut client = TestBlockChainClient::new();
+		let tx1_hash = client.insert_transaction_to_queue();
+		let tx2_hash = client.insert_transaction_with_gas_price_to_queue(U256::zero());
+		let block_hash = client.block_hash_delta_minus(1);
+		let mut sync = ChainSync::new(SyncConfig::default(), &client, Arc::new(NoopPrivateTxHandler));
+		let queue = RwLock::new(VecDeque::new());
+		let ss = TestSnapshotService::new();
+		let mut io = TestIo::new(&mut client, &ss, &queue, None);
+
+		// when peer#1 is Parity, accepting service transactions
+		insert_dummy_peer(&mut sync, 1, block_hash);
+		io.peers_info.insert(1, "Parity/v1.6".to_owned());
+
+		// and service + non-service transactions are propagated to peers
+		SyncPropagator::propagate_new_transactions(&mut sync, &mut io);
+
+		// two separate packets for peer are queued:
+		// 1) with non-service-transaction
+		// 2) with service transaction
+		let sent_transactions: Vec<UnverifiedTransaction> = io.packets.iter()
+			.filter_map(|p| {
+				if p.packet_id != 0x02 || p.recipient != 1 { // TRANSACTIONS_PACKET
+					return None;
+				}
+
+				let rlp = Rlp::new(&*p.data);
+				let item_count = rlp.item_count().unwrap_or(0);
+				if item_count != 1 {
+					return None;
+				}
+
+				rlp.at(0).ok().and_then(|r| r.as_val().ok())
+			})
+			.collect();
+		assert_eq!(sent_transactions.len(), 2);
+		assert!(sent_transactions.iter().any(|tx| tx.hash() == tx1_hash));
+		assert!(sent_transactions.iter().any(|tx| tx.hash() == tx2_hash));
+	}
+}
--- a/ethcore/sync/src/chain/requester.rs
+++ b/ethcore/sync/src/chain/requester.rs
@ -0,0 +1,155 @@
+// Copyright 2015-2018 Parity Technologies (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+use api::WARP_SYNC_PROTOCOL_ID;
+use block_sync::BlockRequest;
+use bytes::Bytes;
+use ethcore::header::BlockNumber;
+use ethereum_types::H256;
+use network::{PeerId, PacketId};
+use rlp::RlpStream;
+use std::time::Instant;
+use sync_io::SyncIo;
+
+use super::{
+	BlockSet,
+	ChainSync,
+	PeerAsking,
+	ETH_PROTOCOL_VERSION_63,
+	GET_BLOCK_BODIES_PACKET,
+	GET_BLOCK_HEADERS_PACKET,
+	GET_RECEIPTS_PACKET,
+	GET_SNAPSHOT_DATA_PACKET,
+	GET_SNAPSHOT_MANIFEST_PACKET,
+};
+
+/// The Chain Sync Requester: requesting data to other peers
+pub struct SyncRequester;
+
+impl SyncRequester {
+	/// Perform block download request`
+	pub fn request_blocks(sync: &mut ChainSync, io: &mut SyncIo, peer_id: PeerId, request: BlockRequest, block_set: BlockSet) {
+		match request {
+			BlockRequest::Headers { start, count, skip } => {
+				SyncRequester::request_headers_by_hash(sync, io, peer_id, &start, count, skip, false, block_set);
+			},
+			BlockRequest::Bodies { hashes } => {
+				SyncRequester::request_bodies(sync, io, peer_id, hashes, block_set);
+			},
+			BlockRequest::Receipts { hashes } => {
+				SyncRequester::request_receipts(sync, io, peer_id, hashes, block_set);
+			},
+		}
+	}
+
+	/// Request block bodies from a peer
+	fn request_bodies(sync: &mut ChainSync, io: &mut SyncIo, peer_id: PeerId, hashes: Vec<H256>, set: BlockSet) {
+		let mut rlp = RlpStream::new_list(hashes.len());
+		trace!(target: "sync", "{} <- GetBlockBodies: {} entries starting from {:?}, set = {:?}", peer_id, hashes.len(), hashes.first(), set);
+		for h in &hashes {
+			rlp.append(&h.clone());
+		}
+		SyncRequester::send_request(sync, io, peer_id, PeerAsking::BlockBodies, GET_BLOCK_BODIES_PACKET, rlp.out());
+		let peer = sync.peers.get_mut(&peer_id).expect("peer_id may originate either from on_packet, where it is already validated or from enumerating self.peers. qed");
+		peer.asking_blocks = hashes;
+		peer.block_set = Some(set);
+	}
+
+	/// Request headers from a peer by block number
+	pub fn request_fork_header(sync: &mut ChainSync, io: &mut SyncIo, peer_id: PeerId, n: BlockNumber) {
+		trace!(target: "sync", "{} <- GetForkHeader: at {}", peer_id, n);
+		let mut rlp = RlpStream::new_list(4);
+		rlp.append(&n);
+		rlp.append(&1u32);
+		rlp.append(&0u32);
+		rlp.append(&0u32);
+		SyncRequester::send_request(sync, io, peer_id, PeerAsking::ForkHeader, GET_BLOCK_HEADERS_PACKET, rlp.out());
+	}
+
+	/// Find some headers or blocks to download for a peer.
+	pub fn request_snapshot_data(sync: &mut ChainSync, io: &mut SyncIo, peer_id: PeerId) {
+		// find chunk data to download
+		if let Some(hash) = sync.snapshot.needed_chunk() {
+			if let Some(ref mut peer) = sync.peers.get_mut(&peer_id) {
+				peer.asking_snapshot_data = Some(hash.clone());
+			}
+			SyncRequester::request_snapshot_chunk(sync, io, peer_id, &hash);
+		}
+	}
+
+	/// Request snapshot manifest from a peer.
+	pub fn request_snapshot_manifest(sync: &mut ChainSync, io: &mut SyncIo, peer_id: PeerId) {
+		trace!(target: "sync", "{} <- GetSnapshotManifest", peer_id);
+		let rlp = RlpStream::new_list(0);
+		SyncRequester::send_request(sync, io, peer_id, PeerAsking::SnapshotManifest, GET_SNAPSHOT_MANIFEST_PACKET, rlp.out());
+	}
+
+	/// Request headers from a peer by block hash
+	fn request_headers_by_hash(sync: &mut ChainSync, io: &mut SyncIo, peer_id: PeerId, h: &H256, count: u64, skip: u64, reverse: bool, set: BlockSet) {
+		trace!(target: "sync", "{} <- GetBlockHeaders: {} entries starting from {}, set = {:?}", peer_id, count, h, set);
+		let mut rlp = RlpStream::new_list(4);
+		rlp.append(h);
+		rlp.append(&count);
+		rlp.append(&skip);
+		rlp.append(&if reverse {1u32} else {0u32});
+		SyncRequester::send_request(sync, io, peer_id, PeerAsking::BlockHeaders, GET_BLOCK_HEADERS_PACKET, rlp.out());
+		let peer = sync.peers.get_mut(&peer_id).expect("peer_id may originate either from on_packet, where it is already validated or from enumerating self.peers. qed");
+		peer.asking_hash = Some(h.clone());
+		peer.block_set = Some(set);
+	}
+
+	/// Request block receipts from a peer
+	fn request_receipts(sync: &mut ChainSync, io: &mut SyncIo, peer_id: PeerId, hashes: Vec<H256>, set: BlockSet) {
+		let mut rlp = RlpStream::new_list(hashes.len());
+		trace!(target: "sync", "{} <- GetBlockReceipts: {} entries starting from {:?}, set = {:?}", peer_id, hashes.len(), hashes.first(), set);
+		for h in &hashes {
+			rlp.append(&h.clone());
+		}
+		SyncRequester::send_request(sync, io, peer_id, PeerAsking::BlockReceipts, GET_RECEIPTS_PACKET, rlp.out());
+		let peer = sync.peers.get_mut(&peer_id).expect("peer_id may originate either from on_packet, where it is already validated or from enumerating self.peers. qed");
+		peer.asking_blocks = hashes;
+		peer.block_set = Some(set);
+	}
+
+	/// Request snapshot chunk from a peer.
+	fn request_snapshot_chunk(sync: &mut ChainSync, io: &mut SyncIo, peer_id: PeerId, chunk: &H256) {
+		trace!(target: "sync", "{} <- GetSnapshotData {:?}", peer_id, chunk);
+		let mut rlp = RlpStream::new_list(1);
+		rlp.append(chunk);
+		SyncRequester::send_request(sync, io, peer_id, PeerAsking::SnapshotData, GET_SNAPSHOT_DATA_PACKET, rlp.out());
+	}
+
+	/// Generic request sender
+	fn send_request(sync: &mut ChainSync, io: &mut SyncIo, peer_id: PeerId, asking: PeerAsking,  packet_id: PacketId, packet: Bytes) {
+		if let Some(ref mut peer) = sync.peers.get_mut(&peer_id) {
+			if peer.asking != PeerAsking::Nothing {
+				warn!(target:"sync", "Asking {:?} while requesting {:?}", peer.asking, asking);
+			}
+			peer.asking = asking;
+			peer.ask_time = Instant::now();
+			// TODO [ToDr] This seems quite fragile. Be careful when protocol is updated.
+			let result = if packet_id >= ETH_PROTOCOL_VERSION_63.1 {
+				io.send_protocol(WARP_SYNC_PROTOCOL_ID, peer_id, packet_id, packet)
+			} else {
+				io.send(peer_id, packet_id, packet)
+			};
+			if let Err(e) = result {
+				debug!(target:"sync", "Error sending request: {:?}", e);
+				io.disconnect_peer(peer_id);
+			}
+		}
+	}
+}
--- a/ethcore/sync/src/chain/supplier.rs
+++ b/ethcore/sync/src/chain/supplier.rs
@ -0,0 +1,450 @@
+// Copyright 2015-2018 Parity Technologies (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+use bytes::Bytes;
+use ethcore::client::BlockId;
+use ethcore::header::BlockNumber;
+use ethereum_types::H256;
+use network::{self, PeerId};
+use parking_lot::RwLock;
+use rlp::{Rlp, RlpStream};
+use std::cmp;
+use sync_io::SyncIo;
+
+use super::{
+	ChainSync,
+	RlpResponseResult,
+	PacketDecodeError,
+	BLOCK_BODIES_PACKET,
+	BLOCK_HEADERS_PACKET,
+	CONSENSUS_DATA_PACKET,
+	GET_BLOCK_BODIES_PACKET,
+	GET_BLOCK_HEADERS_PACKET,
+	GET_NODE_DATA_PACKET,
+	GET_RECEIPTS_PACKET,
+	GET_SNAPSHOT_DATA_PACKET,
+	GET_SNAPSHOT_MANIFEST_PACKET,
+	MAX_BODIES_TO_SEND,
+	MAX_HEADERS_TO_SEND,
+	MAX_NODE_DATA_TO_SEND,
+	MAX_RECEIPTS_HEADERS_TO_SEND,
+	MAX_RECEIPTS_TO_SEND,
+	NODE_DATA_PACKET,
+	RECEIPTS_PACKET,
+	SNAPSHOT_DATA_PACKET,
+	SNAPSHOT_MANIFEST_PACKET,
+};
+
+/// The Chain Sync Supplier: answers requests from peers with available data
+pub struct SyncSupplier;
+
+impl SyncSupplier {
+	/// Dispatch incoming requests and responses
+	pub fn dispatch_packet(sync: &RwLock<ChainSync>, io: &mut SyncIo, peer: PeerId, packet_id: u8, data: &[u8]) {
+		let rlp = Rlp::new(data);
+		let result = match packet_id {
+			GET_BLOCK_BODIES_PACKET => SyncSupplier::return_rlp(io, &rlp, peer,
+				SyncSupplier::return_block_bodies,
+				|e| format!("Error sending block bodies: {:?}", e)),
+
+			GET_BLOCK_HEADERS_PACKET => SyncSupplier::return_rlp(io, &rlp, peer,
+				SyncSupplier::return_block_headers,
+				|e| format!("Error sending block headers: {:?}", e)),
+
+			GET_RECEIPTS_PACKET => SyncSupplier::return_rlp(io, &rlp, peer,
+				SyncSupplier::return_receipts,
+				|e| format!("Error sending receipts: {:?}", e)),
+
+			GET_NODE_DATA_PACKET => SyncSupplier::return_rlp(io, &rlp, peer,
+				SyncSupplier::return_node_data,
+				|e| format!("Error sending nodes: {:?}", e)),
+
+			GET_SNAPSHOT_MANIFEST_PACKET => SyncSupplier::return_rlp(io, &rlp, peer,
+				SyncSupplier::return_snapshot_manifest,
+				|e| format!("Error sending snapshot manifest: {:?}", e)),
+
+			GET_SNAPSHOT_DATA_PACKET => SyncSupplier::return_rlp(io, &rlp, peer,
+				SyncSupplier::return_snapshot_data,
+				|e| format!("Error sending snapshot data: {:?}", e)),
+			CONSENSUS_DATA_PACKET => ChainSync::on_consensus_packet(io, peer, &rlp),
+			_ => {
+				sync.write().on_packet(io, peer, packet_id, data);
+				Ok(())
+			}
+		};
+		result.unwrap_or_else(|e| {
+			debug!(target:"sync", "{} -> Malformed packet {} : {}", peer, packet_id, e);
+		})
+	}
+
+	/// Respond to GetBlockHeaders request
+	fn return_block_headers(io: &SyncIo, r: &Rlp, peer_id: PeerId) -> RlpResponseResult {
+		// Packet layout:
+		// [ block: { P , B_32 }, maxHeaders: P, skip: P, reverse: P in { 0 , 1 } ]
+		let max_headers: usize = r.val_at(1)?;
+		let skip: usize = r.val_at(2)?;
+		let reverse: bool = r.val_at(3)?;
+		let last = io.chain().chain_info().best_block_number;
+		let number = if r.at(0)?.size() == 32 {
+			// id is a hash
+			let hash: H256 = r.val_at(0)?;
+			trace!(target: "sync", "{} -> GetBlockHeaders (hash: {}, max: {}, skip: {}, reverse:{})", peer_id, hash, max_headers, skip, reverse);
+			match io.chain().block_header(BlockId::Hash(hash)) {
+				Some(hdr) => {
+					let number = hdr.number().into();
+					debug_assert_eq!(hdr.hash(), hash);
+
+					if max_headers == 1 || io.chain().block_hash(BlockId::Number(number)) != Some(hash) {
+						// Non canonical header or single header requested
+						// TODO: handle single-step reverse hashchains of non-canon hashes
+						trace!(target:"sync", "Returning single header: {:?}", hash);
+						let mut rlp = RlpStream::new_list(1);
+						rlp.append_raw(&hdr.into_inner(), 1);
+						return Ok(Some((BLOCK_HEADERS_PACKET, rlp)));
+					}
+					number
+				}
+				None => return Ok(Some((BLOCK_HEADERS_PACKET, RlpStream::new_list(0)))) //no such header, return nothing
+			}
+		} else {
+			let number = r.val_at::<BlockNumber>(0)?;
+			trace!(target: "sync", "{} -> GetBlockHeaders (number: {}, max: {}, skip: {}, reverse:{})", peer_id, number, max_headers, skip, reverse);
+			number
+		};
+
+		let mut number = if reverse {
+			cmp::min(last, number)
+		} else {
+			cmp::max(0, number)
+		};
+		let max_count = cmp::min(MAX_HEADERS_TO_SEND, max_headers);
+		let mut count = 0;
+		let mut data = Bytes::new();
+		let inc = (skip + 1) as BlockNumber;
+		let overlay = io.chain_overlay().read();
+
+		// We are checking the `overlay` as well since it's where the ForkBlock
+		// header is cached : so peers can confirm we are on the right fork,
+		// even if we are not synced until the fork block
+		while (number <= last || overlay.contains_key(&number)) && count < max_count {
+			if let Some(hdr) = overlay.get(&number) {
+				trace!(target: "sync", "{}: Returning cached fork header", peer_id);
+				data.extend_from_slice(hdr);
+				count += 1;
+			} else if let Some(hdr) = io.chain().block_header(BlockId::Number(number)) {
+				data.append(&mut hdr.into_inner());
+				count += 1;
+			} else {
+				// No required block.
+				break;
+			}
+			if reverse {
+				if number <= inc || number == 0 {
+					break;
+				}
+				number -= inc;
+			} else {
+				number += inc;
+			}
+		}
+		let mut rlp = RlpStream::new_list(count as usize);
+		rlp.append_raw(&data, count as usize);
+		trace!(target: "sync", "{} -> GetBlockHeaders: returned {} entries", peer_id, count);
+		Ok(Some((BLOCK_HEADERS_PACKET, rlp)))
+	}
+
+	/// Respond to GetBlockBodies request
+	fn return_block_bodies(io: &SyncIo, r: &Rlp, peer_id: PeerId) -> RlpResponseResult {
+		let mut count = r.item_count().unwrap_or(0);
+		if count == 0 {
+			debug!(target: "sync", "Empty GetBlockBodies request, ignoring.");
+			return Ok(None);
+		}
+		count = cmp::min(count, MAX_BODIES_TO_SEND);
+		let mut added = 0usize;
+		let mut data = Bytes::new();
+		for i in 0..count {
+			if let Some(body) = io.chain().block_body(BlockId::Hash(r.val_at::<H256>(i)?)) {
+				data.append(&mut body.into_inner());
+				added += 1;
+			}
+		}
+		let mut rlp = RlpStream::new_list(added);
+		rlp.append_raw(&data, added);
+		trace!(target: "sync", "{} -> GetBlockBodies: returned {} entries", peer_id, added);
+		Ok(Some((BLOCK_BODIES_PACKET, rlp)))
+	}
+
+	/// Respond to GetNodeData request
+	fn return_node_data(io: &SyncIo, r: &Rlp, peer_id: PeerId) -> RlpResponseResult {
+		let mut count = r.item_count().unwrap_or(0);
+		trace!(target: "sync", "{} -> GetNodeData: {} entries", peer_id, count);
+		if count == 0 {
+			debug!(target: "sync", "Empty GetNodeData request, ignoring.");
+			return Ok(None);
+		}
+		count = cmp::min(count, MAX_NODE_DATA_TO_SEND);
+		let mut added = 0usize;
+		let mut data = Vec::new();
+		for i in 0..count {
+			if let Some(node) = io.chain().state_data(&r.val_at::<H256>(i)?) {
+				data.push(node);
+				added += 1;
+			}
+		}
+		trace!(target: "sync", "{} -> GetNodeData: return {} entries", peer_id, added);
+		let mut rlp = RlpStream::new_list(added);
+		for d in data {
+			rlp.append(&d);
+		}
+		Ok(Some((NODE_DATA_PACKET, rlp)))
+	}
+
+	fn return_receipts(io: &SyncIo, rlp: &Rlp, peer_id: PeerId) -> RlpResponseResult {
+		let mut count = rlp.item_count().unwrap_or(0);
+		trace!(target: "sync", "{} -> GetReceipts: {} entries", peer_id, count);
+		if count == 0 {
+			debug!(target: "sync", "Empty GetReceipts request, ignoring.");
+			return Ok(None);
+		}
+		count = cmp::min(count, MAX_RECEIPTS_HEADERS_TO_SEND);
+		let mut added_headers = 0usize;
+		let mut added_receipts = 0usize;
+		let mut data = Bytes::new();
+		for i in 0..count {
+			if let Some(mut receipts_bytes) = io.chain().block_receipts(&rlp.val_at::<H256>(i)?) {
+				data.append(&mut receipts_bytes);
+				added_receipts += receipts_bytes.len();
+				added_headers += 1;
+				if added_receipts > MAX_RECEIPTS_TO_SEND { break; }
+			}
+		}
+		let mut rlp_result = RlpStream::new_list(added_headers);
+		rlp_result.append_raw(&data, added_headers);
+		Ok(Some((RECEIPTS_PACKET, rlp_result)))
+	}
+
+	/// Respond to GetSnapshotManifest request
+	fn return_snapshot_manifest(io: &SyncIo, r: &Rlp, peer_id: PeerId) -> RlpResponseResult {
+		let count = r.item_count().unwrap_or(0);
+		trace!(target: "warp", "{} -> GetSnapshotManifest", peer_id);
+		if count != 0 {
+			debug!(target: "warp", "Invalid GetSnapshotManifest request, ignoring.");
+			return Ok(None);
+		}
+		let rlp = match io.snapshot_service().manifest() {
+			Some(manifest) => {
+				trace!(target: "warp", "{} <- SnapshotManifest", peer_id);
+				let mut rlp = RlpStream::new_list(1);
+				rlp.append_raw(&manifest.into_rlp(), 1);
+				rlp
+			},
+			None => {
+				trace!(target: "warp", "{}: No snapshot manifest to return", peer_id);
+				RlpStream::new_list(0)
+			}
+		};
+		Ok(Some((SNAPSHOT_MANIFEST_PACKET, rlp)))
+	}
+
+	/// Respond to GetSnapshotData request
+	fn return_snapshot_data(io: &SyncIo, r: &Rlp, peer_id: PeerId) -> RlpResponseResult {
+		let hash: H256 = r.val_at(0)?;
+		trace!(target: "warp", "{} -> GetSnapshotData {:?}", peer_id, hash);
+		let rlp = match io.snapshot_service().chunk(hash) {
+			Some(data) => {
+				let mut rlp = RlpStream::new_list(1);
+				trace!(target: "warp", "{} <- SnapshotData", peer_id);
+				rlp.append(&data);
+				rlp
+			},
+			None => {
+				trace!(target: "warp", "{}: No snapshot data to return", peer_id);
+				RlpStream::new_list(0)
+			}
+		};
+		Ok(Some((SNAPSHOT_DATA_PACKET, rlp)))
+	}
+
+	fn return_rlp<FRlp, FError>(io: &mut SyncIo, rlp: &Rlp, peer: PeerId, rlp_func: FRlp, error_func: FError) -> Result<(), PacketDecodeError>
+		where FRlp : Fn(&SyncIo, &Rlp, PeerId) -> RlpResponseResult,
+			FError : FnOnce(network::Error) -> String
+	{
+		let response = rlp_func(io, rlp, peer);
+		match response {
+			Err(e) => Err(e),
+			Ok(Some((packet_id, rlp_stream))) => {
+				io.respond(packet_id, rlp_stream.out()).unwrap_or_else(
+					|e| debug!(target: "sync", "{:?}", error_func(e)));
+				Ok(())
+			}
+			_ => Ok(())
+		}
+	}
+}
+
+#[cfg(test)]
+mod test {
+	use std::collections::{VecDeque};
+	use tests::helpers::{TestIo};
+	use tests::snapshot::TestSnapshotService;
+	use ethereum_types::{H256};
+	use parking_lot::RwLock;
+	use bytes::Bytes;
+	use rlp::{Rlp, RlpStream};
+	use super::{*, super::tests::*};
+	use ethcore::client::{BlockChainClient, EachBlockWith, TestBlockChainClient};
+
+	#[test]
+	fn return_block_headers() {
+		use ethcore::views::HeaderView;
+		fn make_hash_req(h: &H256, count: usize, skip: usize, reverse: bool) -> Bytes {
+			let mut rlp = RlpStream::new_list(4);
+			rlp.append(h);
+			rlp.append(&count);
+			rlp.append(&skip);
+			rlp.append(&if reverse {1u32} else {0u32});
+			rlp.out()
+		}
+
+		fn make_num_req(n: usize, count: usize, skip: usize, reverse: bool) -> Bytes {
+			let mut rlp = RlpStream::new_list(4);
+			rlp.append(&n);
+			rlp.append(&count);
+			rlp.append(&skip);
+			rlp.append(&if reverse {1u32} else {0u32});
+			rlp.out()
+		}
+		fn to_header_vec(rlp: ::chain::RlpResponseResult) -> Vec<Bytes> {
+			Rlp::new(&rlp.unwrap().unwrap().1.out()).iter().map(|r| r.as_raw().to_vec()).collect()
+		}
+
+		let mut client = TestBlockChainClient::new();
+		client.add_blocks(100, EachBlockWith::Nothing);
+		let blocks: Vec<_> = (0 .. 100)
+			.map(|i| (&client as &BlockChainClient).block(BlockId::Number(i as BlockNumber)).map(|b| b.into_inner()).unwrap()).collect();
+		let headers: Vec<_> = blocks.iter().map(|b| Rlp::new(b).at(0).unwrap().as_raw().to_vec()).collect();
+		let hashes: Vec<_> = headers.iter().map(|h| view!(HeaderView, h).hash()).collect();
+
+		let queue = RwLock::new(VecDeque::new());
+		let ss = TestSnapshotService::new();
+		let io = TestIo::new(&mut client, &ss, &queue, None);
+
+		let unknown: H256 = H256::new();
+		let result = SyncSupplier::return_block_headers(&io, &Rlp::new(&make_hash_req(&unknown, 1, 0, false)), 0);
+		assert!(to_header_vec(result).is_empty());
+		let result = SyncSupplier::return_block_headers(&io, &Rlp::new(&make_hash_req(&unknown, 1, 0, true)), 0);
+		assert!(to_header_vec(result).is_empty());
+
+		let result = SyncSupplier::return_block_headers(&io, &Rlp::new(&make_hash_req(&hashes[2], 1, 0, true)), 0);
+		assert_eq!(to_header_vec(result), vec![headers[2].clone()]);
+
+		let result = SyncSupplier::return_block_headers(&io, &Rlp::new(&make_hash_req(&hashes[2], 1, 0, false)), 0);
+		assert_eq!(to_header_vec(result), vec![headers[2].clone()]);
+
+		let result = SyncSupplier::return_block_headers(&io, &Rlp::new(&make_hash_req(&hashes[50], 3, 5, false)), 0);
+		assert_eq!(to_header_vec(result), vec![headers[50].clone(), headers[56].clone(), headers[62].clone()]);
+
+		let result = SyncSupplier::return_block_headers(&io, &Rlp::new(&make_hash_req(&hashes[50], 3, 5, true)), 0);
+		assert_eq!(to_header_vec(result), vec![headers[50].clone(), headers[44].clone(), headers[38].clone()]);
+
+		let result = SyncSupplier::return_block_headers(&io, &Rlp::new(&make_num_req(2, 1, 0, true)), 0);
+		assert_eq!(to_header_vec(result), vec![headers[2].clone()]);
+
+		let result = SyncSupplier::return_block_headers(&io, &Rlp::new(&make_num_req(2, 1, 0, false)), 0);
+		assert_eq!(to_header_vec(result), vec![headers[2].clone()]);
+
+		let result = SyncSupplier::return_block_headers(&io, &Rlp::new(&make_num_req(50, 3, 5, false)), 0);
+		assert_eq!(to_header_vec(result), vec![headers[50].clone(), headers[56].clone(), headers[62].clone()]);
+
+		let result = SyncSupplier::return_block_headers(&io, &Rlp::new(&make_num_req(50, 3, 5, true)), 0);
+		assert_eq!(to_header_vec(result), vec![headers[50].clone(), headers[44].clone(), headers[38].clone()]);
+	}
+
+	#[test]
+	fn return_nodes() {
+		let mut client = TestBlockChainClient::new();
+		let queue = RwLock::new(VecDeque::new());
+		let sync = dummy_sync_with_peer(H256::new(), &client);
+		let ss = TestSnapshotService::new();
+		let mut io = TestIo::new(&mut client, &ss, &queue, None);
+
+		let mut node_list = RlpStream::new_list(3);
+		node_list.append(&H256::from("0000000000000000000000000000000000000000000000005555555555555555"));
+		node_list.append(&H256::from("ffffffffffffffffffffffffffffffffffffffffffffaaaaaaaaaaaaaaaaaaaa"));
+		node_list.append(&H256::from("aff0000000000000000000000000000000000000000000000000000000000000"));
+
+		let node_request = node_list.out();
+		// it returns rlp ONLY for hashes started with "f"
+		let result = SyncSupplier::return_node_data(&io, &Rlp::new(&node_request.clone()), 0);
+
+		assert!(result.is_ok());
+		let rlp_result = result.unwrap();
+		assert!(rlp_result.is_some());
+
+		// the length of one rlp-encoded hashe
+		let rlp = rlp_result.unwrap().1.out();
+		let rlp = Rlp::new(&rlp);
+		assert_eq!(Ok(1), rlp.item_count());
+
+		io.sender = Some(2usize);
+
+		ChainSync::dispatch_packet(&RwLock::new(sync), &mut io, 0usize, GET_NODE_DATA_PACKET, &node_request);
+		assert_eq!(1, io.packets.len());
+	}
+
+	#[test]
+	fn return_receipts_empty() {
+		let mut client = TestBlockChainClient::new();
+		let queue = RwLock::new(VecDeque::new());
+		let ss = TestSnapshotService::new();
+		let io = TestIo::new(&mut client, &ss, &queue, None);
+
+		let result = SyncSupplier::return_receipts(&io, &Rlp::new(&[0xc0]), 0);
+
+		assert!(result.is_ok());
+	}
+
+	#[test]
+	fn return_receipts() {
+		let mut client = TestBlockChainClient::new();
+		let queue = RwLock::new(VecDeque::new());
+		let sync = dummy_sync_with_peer(H256::new(), &client);
+		let ss = TestSnapshotService::new();
+		let mut io = TestIo::new(&mut client, &ss, &queue, None);
+
+		let mut receipt_list = RlpStream::new_list(4);
+		receipt_list.append(&H256::from("0000000000000000000000000000000000000000000000005555555555555555"));
+		receipt_list.append(&H256::from("ff00000000000000000000000000000000000000000000000000000000000000"));
+		receipt_list.append(&H256::from("fff0000000000000000000000000000000000000000000000000000000000000"));
+		receipt_list.append(&H256::from("aff0000000000000000000000000000000000000000000000000000000000000"));
+
+		let receipts_request = receipt_list.out();
+		// it returns rlp ONLY for hashes started with "f"
+		let result = SyncSupplier::return_receipts(&io, &Rlp::new(&receipts_request.clone()), 0);
+
+		assert!(result.is_ok());
+		let rlp_result = result.unwrap();
+		assert!(rlp_result.is_some());
+
+		// the length of two rlp-encoded receipts
+		assert_eq!(603, rlp_result.unwrap().1.out().len());
+
+		io.sender = Some(2usize);
+		ChainSync::dispatch_packet(&RwLock::new(sync), &mut io, 0usize, GET_RECEIPTS_PACKET, &receipts_request);
+		assert_eq!(1, io.packets.len());
+	}
+}
--- a/ethcore/sync/src/lib.rs
+++ b/ethcore/sync/src/lib.rs
@ -54,6 +54,8 @@ extern crate macros;
 extern crate log;
 #[macro_use]
 extern crate heapsize;
+#[macro_use]
+extern crate trace_time;

 mod chain;
 mod blocks;
--- a/ethcore/sync/src/light_sync/response.rs
+++ b/ethcore/sync/src/light_sync/response.rs
@ -16,13 +16,11 @@

 //! Helpers for decoding and verifying responses for headers.

-use std::fmt;
-
-use ethcore::encoded;
-use ethcore::header::Header;
+use ethcore::{encoded, header::Header};
+use ethereum_types::H256;
 use light::request::{HashOrNumber, CompleteHeadersRequest as HeadersRequest};
 use rlp::DecoderError;
-use ethereum_types::H256;
+use std::fmt;

 /// Errors found when decoding headers and verifying with basic constraints.
 #[derive(Debug, PartialEq)]
@ -74,19 +72,23 @@ pub trait Constraint {

 /// Do basic verification of provided headers against a request.
 pub fn verify(headers: &[encoded::Header], request: &HeadersRequest) -> Result<Vec<Header>, BasicError> {
-	let headers: Vec<_> = headers.iter().map(|h| h.decode()).collect();
+	let headers: Result<Vec<_>, _> = headers.iter().map(|h| h.decode() ).collect();
+	match headers {
+		Ok(headers) => {
+			let reverse = request.reverse;

-	let reverse = request.reverse;
+			Max(request.max as usize).verify(&headers, reverse)?;
+			match request.start {
+				HashOrNumber::Number(ref num) => StartsAtNumber(*num).verify(&headers, reverse)?,
+				HashOrNumber::Hash(ref hash) => StartsAtHash(*hash).verify(&headers, reverse)?,
+			}

-	Max(request.max as usize).verify(&headers, reverse)?;
-	match request.start {
-		HashOrNumber::Number(ref num) => StartsAtNumber(*num).verify(&headers, reverse)?,
-		HashOrNumber::Hash(ref hash) => StartsAtHash(*hash).verify(&headers, reverse)?,
+			SkipsBetween(request.skip).verify(&headers, reverse)?;
+
+			Ok(headers)
+		},
+		Err(e) => Err(e.into())
 	}
-
-	SkipsBetween(request.skip).verify(&headers, reverse)?;
-
-	Ok(headers)
 }

 struct StartsAtNumber(u64);
--- a/ethcore/sync/src/light_sync/tests/mod.rs
+++ b/ethcore/sync/src/light_sync/tests/mod.rs
@ -45,7 +45,7 @@ fn fork_post_cht() {
 	for id in (0..CHAIN_LENGTH).map(|x| x + 1).map(BlockId::Number) {
 		let (light_peer, full_peer) = (net.peer(0), net.peer(1));
 		let light_chain = light_peer.light_chain();
-		let header = full_peer.chain().block_header(id).unwrap().decode();
+		let header = full_peer.chain().block_header(id).unwrap().decode().expect("decoding failure");
 		let _  = light_chain.import_header(header);
 		light_chain.flush_queue();
 		light_chain.import_verified();
--- a/ethcore/sync/src/snapshot.rs
+++ b/ethcore/sync/src/snapshot.rs
@ -14,10 +14,13 @@
 // You should have received a copy of the GNU General Public License
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.

-use hash::keccak;
+use ethcore::snapshot::{ManifestData, SnapshotService};
 use ethereum_types::H256;
+use hash::keccak;
+use rand::{thread_rng, Rng};
+
 use std::collections::HashSet;
-use ethcore::snapshot::ManifestData;
+use std::iter::FromIterator;

 #[derive(PartialEq, Eq, Debug)]
 pub enum ChunkType {
@ -32,6 +35,7 @@ pub struct Snapshot {
 	completed_chunks: HashSet<H256>,
 	snapshot_hash: Option<H256>,
 	bad_hashes: HashSet<H256>,
+	initialized: bool,
 }

 impl Snapshot {
@ -44,9 +48,29 @@ impl Snapshot {
 			completed_chunks: HashSet::new(),
 			snapshot_hash: None,
 			bad_hashes: HashSet::new(),
+			initialized: false,
 		}
 	}

+	/// Sync the Snapshot completed chunks with the Snapshot Service
+	pub fn initialize(&mut self, snapshot_service: &SnapshotService) {
+		if self.initialized {
+			return;
+		}
+
+		if let Some(completed_chunks) = snapshot_service.completed_chunks() {
+			self.completed_chunks = HashSet::from_iter(completed_chunks);
+		}
+
+		trace!(
+			target: "snapshot",
+			"Snapshot is now initialized with {} completed chunks.",
+			self.completed_chunks.len(),
+		);
+
+		self.initialized = true;
+	}
+
 	/// Clear everything.
 	pub fn clear(&mut self) {
 		self.pending_state_chunks.clear();
@ -54,6 +78,7 @@ impl Snapshot {
 		self.downloading_chunks.clear();
 		self.completed_chunks.clear();
 		self.snapshot_hash = None;
+		self.initialized = false;
 	}

 	/// Check if currently downloading a snapshot.
@ -89,18 +114,35 @@ impl Snapshot {
 		Err(())
 	}

-	/// Find a chunk to download
+	/// Find a random chunk to download
 	pub fn needed_chunk(&mut self) -> Option<H256> {
-		// check state chunks first
-		let chunk = self.pending_state_chunks.iter()
-			.chain(self.pending_block_chunks.iter())
-			.find(|&h| !self.downloading_chunks.contains(h) && !self.completed_chunks.contains(h))
-			.cloned();
+		// Find all random chunks: first blocks, then state
+		let needed_chunks = {
+			let chunk_filter = |h| !self.downloading_chunks.contains(h) && !self.completed_chunks.contains(h);
+
+			let needed_block_chunks = self.pending_block_chunks.iter()
+				.filter(|&h| chunk_filter(h))
+				.map(|h| *h)
+				.collect::<Vec<H256>>();
+
+			// If no block chunks to download, get the state chunks
+			if needed_block_chunks.len() == 0 {
+				self.pending_state_chunks.iter()
+					.filter(|&h| chunk_filter(h))
+					.map(|h| *h)
+					.collect::<Vec<H256>>()
+			} else {
+				needed_block_chunks
+			}
+		};
+
+		// Get a random chunk
+		let chunk = thread_rng().choose(&needed_chunks);

 		if let Some(hash) = chunk {
 			self.downloading_chunks.insert(hash.clone());
 		}
-		chunk
+		chunk.map(|h| *h)
 	}

 	pub fn clear_chunk_download(&mut self, hash: &H256) {
@ -185,8 +227,15 @@ mod test {

 		let requested: Vec<H256> = (0..40).map(|_| snapshot.needed_chunk().unwrap()).collect();
 		assert!(snapshot.needed_chunk().is_none());
-		assert_eq!(&requested[0..20], &manifest.state_hashes[..]);
-		assert_eq!(&requested[20..40], &manifest.block_hashes[..]);
+
+		let requested_all_block_chunks = manifest.block_hashes.iter()
+			.all(|h| requested.iter().any(|rh| rh == h));
+		assert!(requested_all_block_chunks);
+
+		let requested_all_state_chunks = manifest.state_hashes.iter()
+			.all(|h| requested.iter().any(|rh| rh == h));
+		assert!(requested_all_state_chunks);
+
 		assert_eq!(snapshot.downloading_chunks.len(), 40);

 		assert_eq!(snapshot.validate_chunk(&state_chunks[4]), Ok(ChunkType::State(manifest.state_hashes[4].clone())));
--- a/ethcore/sync/src/tests/helpers.rs
+++ b/ethcore/sync/src/tests/helpers.rs
@ -133,11 +133,11 @@ impl<'p, C> SyncIo for TestIo<'p, C> where C: FlushingBlockChainClient, C: 'p {
 	}

 	fn eth_protocol_version(&self, _peer: PeerId) -> u8 {
-		ETH_PROTOCOL_VERSION_63
+		ETH_PROTOCOL_VERSION_63.0
 	}

 	fn protocol_version(&self, protocol: &ProtocolId, peer_id: PeerId) -> u8 {
-		if protocol == &WARP_SYNC_PROTOCOL_ID { PAR_PROTOCOL_VERSION_3 } else { self.eth_protocol_version(peer_id) }
+		if protocol == &WARP_SYNC_PROTOCOL_ID { PAR_PROTOCOL_VERSION_3.0 } else { self.eth_protocol_version(peer_id) }
 	}

 	fn chain_overlay(&self) -> &RwLock<HashMap<BlockNumber, Bytes>> {
@ -519,11 +519,9 @@ impl TestIoHandler {
 impl IoHandler<ClientIoMessage> for TestIoHandler {
 	fn message(&self, _io: &IoContext<ClientIoMessage>, net_message: &ClientIoMessage) {
 		match *net_message {
-			ClientIoMessage::NewMessage(ref message) => if let Err(e) = self.client.engine().handle_message(message) {
-				panic!("Invalid message received: {}", e);
-			},
-			ClientIoMessage::NewPrivateTransaction => {
+			ClientIoMessage::Execute(ref exec) => {
 				*self.private_tx_queued.lock() += 1;
+				(*exec.0)(&self.client);
 			},
 			_ => {} // ignore other messages
 		}
--- a/ethcore/sync/src/tests/private.rs
+++ b/ethcore/sync/src/tests/private.rs
@ -24,7 +24,7 @@ use ethcore::CreateContractAddress;
 use transaction::{Transaction, Action};
 use ethcore::executive::{contract_address};
 use ethcore::test_helpers::{push_block_with_transactions};
-use ethcore_private_tx::{Provider, ProviderConfig, NoopEncryptor};
+use ethcore_private_tx::{Provider, ProviderConfig, NoopEncryptor, Importer};
 use ethcore::account_provider::AccountProvider;
 use ethkey::{KeyPair};
 use tests::helpers::{TestNet, TestIoHandler};
@ -84,7 +84,7 @@ fn send_private_transaction() {
 			Box::new(NoopEncryptor::default()),
 			signer_config,
 			IoChannel::to_handler(Arc::downgrade(&io_handler0)),
-	).unwrap());
+	));
 	pm0.add_notify(net.peers[0].clone());

 	let pm1 = Arc::new(Provider::new(
@ -94,7 +94,7 @@ fn send_private_transaction() {
 			Box::new(NoopEncryptor::default()),
 			validator_config,
 			IoChannel::to_handler(Arc::downgrade(&io_handler1)),
-	).unwrap());
+	));
 	pm1.add_notify(net.peers[1].clone());

 	// Create and deploy contract
@ -133,7 +133,6 @@ fn send_private_transaction() {
 	//process received private transaction message
 	let private_transaction = received_private_transactions[0].clone();
 	assert!(pm1.import_private_transaction(&private_transaction).is_ok());
-	assert!(pm1.on_private_transaction_queued().is_ok());

 	//send signed response
 	net.sync();
@ -147,4 +146,4 @@ fn send_private_transaction() {
 	assert!(pm0.import_signed_private_transaction(&signed_private_transaction).is_ok());
 	let local_transactions = net.peer(0).miner.local_transactions();
 	assert_eq!(local_transactions.len(), 1);
-}
+}
--- a/ethcore/sync/src/tests/snapshot.rs
+++ b/ethcore/sync/src/tests/snapshot.rs
@ -22,7 +22,7 @@ use parking_lot::Mutex;
 use bytes::Bytes;
 use ethcore::snapshot::{SnapshotService, ManifestData, RestorationStatus};
 use ethcore::header::BlockNumber;
-use ethcore::client::{EachBlockWith};
+use ethcore::client::EachBlockWith;
 use super::helpers::*;
 use {SyncConfig, WarpSync};

@ -80,6 +80,10 @@ impl SnapshotService for TestSnapshotService {
 		Some((1, 2))
 	}

+	fn completed_chunks(&self) -> Option<Vec<H256>> {
+		Some(vec![])
+	}
+
 	fn chunk(&self, hash: H256) -> Option<Bytes> {
 		self.chunks.get(&hash).cloned()
 	}
@ -99,7 +103,15 @@ impl SnapshotService for TestSnapshotService {
 	}

 	fn begin_restore(&self, manifest: ManifestData) {
-		*self.restoration_manifest.lock() = Some(manifest);
+		let mut restoration_manifest = self.restoration_manifest.lock();
+
+		if let Some(ref c_manifest) = *restoration_manifest {
+			if c_manifest.state_root == manifest.state_root {
+				return;
+			}
+		}
+
+		*restoration_manifest = Some(manifest);
 		self.state_restoration_chunks.lock().clear();
 		self.block_restoration_chunks.lock().clear();
 	}
@ -121,6 +133,10 @@ impl SnapshotService for TestSnapshotService {
 			self.block_restoration_chunks.lock().insert(hash, chunk);
 		}
 	}
+
+	fn shutdown(&self) {
+		self.abort_restore();
+	}
 }

 #[test]
--- a/ethcore/transaction/src/error.rs
+++ b/ethcore/transaction/src/error.rs
@ -18,6 +18,7 @@ use std::{fmt, error};

 use ethereum_types::U256;
 use ethkey;
+use rlp;
 use unexpected::OutOfBounds;

 #[derive(Debug, PartialEq, Clone)]
@ -74,6 +75,10 @@ pub enum Error {
 	NotAllowed,
 	/// Signature error
 	InvalidSignature(String),
+	/// Transaction too big
+	TooBig,
+	/// Invalid RLP encoding
+	InvalidRlp(String),
 }

 impl From<ethkey::Error> for Error {
@ -82,6 +87,12 @@ impl From<ethkey::Error> for Error {
 	}
 }

+impl From<rlp::DecoderError> for Error {
+	fn from(err: rlp::DecoderError) -> Self {
+		Error::InvalidRlp(format!("{}", err))
+	}
+}
+
 impl fmt::Display for Error {
 	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 		use self::Error::*;
@ -106,6 +117,8 @@ impl fmt::Display for Error {
 			InvalidChainId => "Transaction of this chain ID is not allowed on this chain.".into(),
 			InvalidSignature(ref err) => format!("Transaction has invalid signature: {}.", err),
 			NotAllowed => "Sender does not have permissions to execute this type of transction".into(),
+			TooBig => "Transaction too big".into(),
+			InvalidRlp(ref err) => format!("Transaction has invalid RLP structure: {}.", err),
 		};

 		f.write_fmt(format_args!("Transaction error ({})", msg))
--- a/ethcore/transaction/src/transaction.rs
+++ b/ethcore/transaction/src/transaction.rs
@ -576,7 +576,8 @@ mod tests {

 	#[test]
 	fn sender_test() {
-		let t: UnverifiedTransaction = rlp::decode(&::rustc_hex::FromHex::from_hex("f85f800182520894095e7baea6a6c7c4c2dfeb977efac326af552d870a801ba048b55bfa915ac795c431978d8a6a992b628d557da5ff759b307d495a36649353a0efffd310ac743f371de3b9f7f9cb56c0b28ad43601b4ab949f53faa07bd2c804").unwrap());
+		let bytes = ::rustc_hex::FromHex::from_hex("f85f800182520894095e7baea6a6c7c4c2dfeb977efac326af552d870a801ba048b55bfa915ac795c431978d8a6a992b628d557da5ff759b307d495a36649353a0efffd310ac743f371de3b9f7f9cb56c0b28ad43601b4ab949f53faa07bd2c804").unwrap();
+		let t: UnverifiedTransaction = rlp::decode(&bytes).expect("decoding UnverifiedTransaction failed");
 		assert_eq!(t.data, b"");
 		assert_eq!(t.gas, U256::from(0x5208u64));
 		assert_eq!(t.gas_price, U256::from(0x01u64));
@ -645,7 +646,7 @@ mod tests {
 		use rustc_hex::FromHex;

 		let test_vector = |tx_data: &str, address: &'static str| {
-			let signed = rlp::decode(&FromHex::from_hex(tx_data).unwrap());
+			let signed = rlp::decode(&FromHex::from_hex(tx_data).unwrap()).expect("decoding tx data failed");
 			let signed = SignedTransaction::new(signed).unwrap();
 			assert_eq!(signed.sender(), address.into());
 			println!("chainid: {:?}", signed.chain_id());
--- a/ethcore/types/src/receipt.rs
+++ b/ethcore/types/src/receipt.rs
@ -193,7 +193,7 @@ mod tests {
 		);
 		let encoded = ::rlp::encode(&r);
 		assert_eq!(&encoded[..], &expected[..]);
-		let decoded: Receipt = ::rlp::decode(&encoded);
+		let decoded: Receipt = ::rlp::decode(&encoded).expect("decoding receipt failed");
 		assert_eq!(decoded, r);
 	}

@ -211,7 +211,7 @@ mod tests {
 		);
 		let encoded = ::rlp::encode(&r);
 		assert_eq!(&encoded[..], &expected[..]);
-		let decoded: Receipt = ::rlp::decode(&encoded);
+		let decoded: Receipt = ::rlp::decode(&encoded).expect("decoding receipt failed");
 		assert_eq!(decoded, r);
 	}
 }
--- a/ethcore/types/src/restoration_status.rs
+++ b/ethcore/types/src/restoration_status.rs
@ -21,6 +21,11 @@
 pub enum RestorationStatus {
 	///	No restoration.
 	Inactive,
+	/// Restoration is initalizing
+	Initializing {
+		/// Number of chunks done/imported
+		chunks_done: u32,
+	},
 	/// Ongoing restoration.
 	Ongoing {
 		/// Total number of state chunks.
--- a/ethcore/vm/src/call_type.rs
+++ b/ethcore/vm/src/call_type.rs
@ -64,7 +64,7 @@ mod tests {
 	fn should_encode_and_decode_call_type() {
 		let original = CallType::Call;
 		let encoded = encode(&original);
-		let decoded = decode(&encoded);
+		let decoded = decode(&encoded).expect("failure decoding CallType");
 		assert_eq!(original, decoded);
 	}
 }
--- a/ethcore/wasm/Cargo.toml
+++ b/ethcore/wasm/Cargo.toml
@ -12,4 +12,4 @@ libc = "0.2"
 pwasm-utils = "0.1"
 vm = { path = "../vm" }
 ethcore-logger = { path = "../../logger" }
-wasmi = { version = "0.1.3", features = ["opt-in-32bit"] }
+wasmi = { version = "0.2" }
--- a/json/src/spec/params.rs
+++ b/json/src/spec/params.rs
@ -113,6 +113,9 @@ pub struct Params {
 	/// See main EthashParams docs.
 	#[serde(rename="maxCodeSize")]
 	pub max_code_size: Option<Uint>,
+	/// Maximum size of transaction RLP payload.
+	#[serde(rename="maxTransactionSize")]
+	pub max_transaction_size: Option<Uint>,
 	/// See main EthashParams docs.
 	#[serde(rename="maxCodeSizeTransition")]
 	pub max_code_size_transition: Option<Uint>,
--- a/mac/Parity.pkgproj
+++ b/mac/Parity.pkgproj
@ -462,7 +462,7 @@
 				<key>OVERWRITE_PERMISSIONS</key>
 				<false/>
 				<key>VERSION</key>
-				<string>1.11.0</string>
+				<string>1.11.2</string>
 			</dict>
 			<key>UUID</key>
 			<string>2DCD5B81-7BAF-4DA1-9251-6274B089FD36</string>
--- a/mac/post-install.sh
+++ b/mac/post-install.sh
@ -3,6 +3,4 @@
 test -f /usr/local/libexec/uninstall-parity.sh && /usr/local/libexec/uninstall-parity.sh || true
 killall -9 parity && sleep 5
 su $USER -c "open /Applications/Parity\ Ethereum.app"
-sleep 5
-su $USER -c "open http://127.0.0.1:8180/"
 exit 0
--- a/miner/Cargo.toml
+++ b/miner/Cargo.toml
@ -28,6 +28,7 @@ log = "0.3"
 parking_lot = "0.5"
 price-info = { path = "../price-info" }
 rayon = "1.0"
+rlp = { path = "../util/rlp" }
 trace-time = { path = "../util/trace-time" }
 transaction-pool = { path = "../transaction-pool" }

--- a/miner/src/lib.rs
+++ b/miner/src/lib.rs
@ -30,6 +30,7 @@ extern crate linked_hash_map;
 extern crate parking_lot;
 extern crate price_info;
 extern crate rayon;
+extern crate rlp;
 extern crate trace_time;
 extern crate transaction_pool as txpool;

--- a/miner/src/pool/client.rs
+++ b/miner/src/pool/client.rs
@ -62,6 +62,10 @@ pub trait Client: fmt::Debug + Sync {

 	/// Classify transaction (check if transaction is filtered by some contracts).
 	fn transaction_type(&self, tx: &transaction::SignedTransaction) -> TransactionType;
+
+	/// Performs pre-validation of RLP decoded transaction
+	fn decode_transaction(&self, transaction: &[u8])
+		-> Result<transaction::UnverifiedTransaction, transaction::Error>;
 }

 /// State nonce client
--- a/miner/src/pool/res/big_transaction.data
+++ b/miner/src/pool/res/big_transaction.data
--- a/miner/src/pool/scoring.rs
+++ b/miner/src/pool/scoring.rs
@ -108,6 +108,15 @@ impl txpool::Scoring<VerifiedTransaction> for NonceAndGasPrice {
 			}
 		}

+		// Always kick out non-local transactions in favour of local ones.
+		if new.priority().is_local() && !old.priority().is_local() {
+			return true;
+		}
+		// And never kick out local transactions in favour of external ones.
+		if !new.priority().is_local() && old.priority.is_local() {
+			return false;
+		}
+
 		self.choose(old, new) == txpool::scoring::Choice::ReplaceOld
 	}
 }
@ -119,6 +128,21 @@ mod tests {
 	use pool::tests::tx::{Tx, TxExt};
 	use txpool::Scoring;

+	#[test]
+	fn should_replace_non_local_transaction_with_local_one() {
+		// given
+		let scoring = NonceAndGasPrice(PrioritizationStrategy::GasPriceOnly);
+		let tx1 = Tx::default().signed().verified();
+		let tx2 = {
+			let mut tx = Tx::default().signed().verified();
+			tx.priority = ::pool::Priority::Local;
+			tx
+		};
+
+		assert!(scoring.should_replace(&tx1, &tx2));
+		assert!(!scoring.should_replace(&tx2, &tx1));
+	}
+
 	#[test]
 	fn should_calculate_score_correctly() {
 		// given
--- a/miner/src/pool/tests/client.rs
+++ b/miner/src/pool/tests/client.rs
@ -15,17 +15,21 @@
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.

 use ethereum_types::{U256, H256, Address};
+use rlp::Rlp;
 use transaction::{self, Transaction, SignedTransaction, UnverifiedTransaction};

 use pool;
 use pool::client::AccountDetails;

+const MAX_TRANSACTION_SIZE: usize = 15 * 1024;
+
 #[derive(Debug, Clone)]
 pub struct TestClient {
 	account_details: AccountDetails,
 	gas_required: U256,
 	is_service_transaction: bool,
 	local_address: Address,
+	max_transaction_size: usize,
 }

 impl Default for TestClient {
@ -39,6 +43,7 @@ impl Default for TestClient {
 			gas_required: 21_000.into(),
 			is_service_transaction: false,
 			local_address: Default::default(),
+			max_transaction_size: MAX_TRANSACTION_SIZE,
 		}
 	}
 }
@ -116,6 +121,15 @@ impl pool::client::Client for TestClient {
 			pool::client::TransactionType::Regular
 		}
 	}
+
+	fn decode_transaction(&self, transaction: &[u8]) -> Result<UnverifiedTransaction, transaction::Error> {
+		let rlp = Rlp::new(&transaction);
+		if rlp.as_raw().len() > self.max_transaction_size {
+			return Err(transaction::Error::TooBig)
+		}
+		rlp.as_val().map_err(|e| transaction::Error::InvalidRlp(e.to_string()))
+	}
+
 }

 impl pool::client::NonceClient for TestClient {
--- a/miner/src/pool/tests/mod.rs
+++ b/miner/src/pool/tests/mod.rs
@ -63,8 +63,10 @@ fn should_return_correct_nonces_when_dropped_because_of_limit() {
 	let nonce = tx1.nonce;

 	// when
-	let result = txq.import(TestClient::new(), vec![tx1, tx2].local());
-	assert_eq!(result, vec![Ok(()), Err(transaction::Error::LimitReached)]);
+	let r1= txq.import(TestClient::new(), vec![tx1].local());
+	let r2= txq.import(TestClient::new(), vec![tx2].local());
+	assert_eq!(r1, vec![Ok(())]);
+	assert_eq!(r2, vec![Err(transaction::Error::LimitReached)]);
 	assert_eq!(txq.status().status.transaction_count, 1);

 	// then
@ -755,3 +757,44 @@ fn should_clear_cache_after_timeout_for_local() {
 	// then
 	assert_eq!(txq.pending(TestClient::new(), 0, 1002, None).len(), 2);
 }
+
+#[test]
+fn should_reject_big_transaction() {
+	let txq = new_queue();
+	let big_tx = Tx::default().big_one();
+	let res = txq.import(TestClient::new(), vec![
+		verifier::Transaction::Local(PendingTransaction::new(big_tx, transaction::Condition::Timestamp(1000).into()))
+	]);
+	assert_eq!(res, vec![Err(transaction::Error::TooBig)]);
+}
+
+#[test]
+fn should_include_local_transaction_to_a_full_pool() {
+	// given
+	let txq = TransactionQueue::new(
+		txpool::Options {
+			max_count: 1,
+			max_per_sender: 2,
+			max_mem_usage: 50
+		},
+		verifier::Options {
+			minimal_gas_price: 1.into(),
+			block_gas_limit: 1_000_000.into(),
+			tx_gas_limit: 1_000_000.into(),
+		},
+		PrioritizationStrategy::GasPriceOnly,
+	);
+	let tx1 = Tx::gas_price(10_000).signed().unverified();
+	let tx2 = Tx::gas_price(1).signed().local();
+
+	let res = txq.import(TestClient::new().with_balance(1_000_000_000), vec![tx1]);
+	assert_eq!(res, vec![Ok(())]);
+	assert_eq!(txq.status().status.transaction_count, 1);
+
+	// when
+	let res = txq.import(TestClient::new(), vec![tx2]);
+	assert_eq!(res, vec![Ok(())]);
+
+	// then
+	assert_eq!(txq.status().status.transaction_count, 1);
+}
--- a/miner/src/pool/tests/tx.rs
+++ b/miner/src/pool/tests/tx.rs
@ -87,6 +87,19 @@ impl Tx {
 			nonce: self.nonce.into()
 		}
 	}
+
+	pub fn big_one(self) -> SignedTransaction {
+		let keypair = Random.generate().unwrap();
+		let tx = Transaction {
+			action: transaction::Action::Create,
+			value: U256::from(100),
+			data: include_str!("../res/big_transaction.data").from_hex().unwrap(),
+			gas: self.gas.into(),
+			gas_price: self.gas_price.into(),
+			nonce: self.nonce.into()
+		};
+		tx.sign(keypair.secret(), None)
+	}
 }
 pub trait TxExt: Sized {
 	type Out;
--- a/miner/src/pool/verifier.rs
+++ b/miner/src/pool/verifier.rs
@ -27,6 +27,7 @@ use std::sync::Arc;
 use std::sync::atomic::{self, AtomicUsize};

 use ethereum_types::{U256, H256};
+use rlp::Encodable;
 use transaction;
 use txpool;

@ -222,6 +223,12 @@ impl<C: Client> txpool::Verifier<Transaction> for Verifier<C> {
 			Transaction::Local(tx) => tx,
 		};

+		// Verify RLP payload
+		if let Err(err) = self.client.decode_transaction(&transaction.rlp_bytes()) {
+			debug!(target: "txqueue", "[{:?}] Rejected transaction's rlp payload", err);
+			bail!(err)
+		}
+
 		let sender = transaction.sender();
 		let account_details = self.client.account_details(&sender);

--- a/nsis/installer.nsi
+++ b/nsis/installer.nsi
@ -10,7 +10,7 @@
 !define DESCRIPTION "Fast, light, robust Ethereum implementation"
 !define VERSIONMAJOR 1
 !define VERSIONMINOR 11
-!define VERSIONBUILD 0
+!define VERSIONBUILD 2
 !define ARGS ""
 !define FIRST_START_ARGS "--mode=passive ui"

--- a/parity/account.rs
+++ b/parity/account.rs
@ -94,7 +94,7 @@ fn new(n: NewAccount) -> Result<String, String> {
 	let secret_store = Box::new(secret_store(dir, Some(n.iterations))?);
 	let acc_provider = AccountProvider::new(secret_store, AccountProviderSettings::default());
 	let new_account = acc_provider.new_account(&password).map_err(|e| format!("Could not create new account: {}", e))?;
-	Ok(format!("0x{:?}", new_account))
+	Ok(format!("0x{:x}", new_account))
 }

 fn list(list_cmd: ListAccounts) -> Result<String, String> {
@ -103,7 +103,7 @@ fn list(list_cmd: ListAccounts) -> Result<String, String> {
 	let acc_provider = AccountProvider::new(secret_store, AccountProviderSettings::default());
 	let accounts = acc_provider.accounts().map_err(|e| format!("{}", e))?;
 	let result = accounts.into_iter()
-		.map(|a| format!("0x{:?}", a))
+		.map(|a| format!("0x{:x}", a))
 		.collect::<Vec<String>>()
 		.join("\n");

--- a/parity/informant.rs
+++ b/parity/informant.rs
@ -33,7 +33,7 @@ use ethcore::snapshot::service::Service as SnapshotService;
 use sync::{LightSyncProvider, LightSync, SyncProvider, ManageNetwork};
 use io::{TimerToken, IoContext, IoHandler};
 use light::Cache as LightDataCache;
-use light::client::LightChainClient;
+use light::client::{LightChainClient, LightChainNotify};
 use number_prefix::{binary_prefix, Standalone, Prefixed};
 use parity_rpc::{is_major_importing};
 use parity_rpc::informant::RpcStats;
@ -278,15 +278,12 @@ impl<T: InformantData> Informant<T> {
 		} = full_report;

 		let rpc_stats = self.rpc_stats.as_ref();
-
-		let (snapshot_sync, snapshot_current, snapshot_total) = self.snapshot.as_ref().map_or((false, 0, 0), |s|
+		let snapshot_sync = sync_info.as_ref().map_or(false, |s| s.snapshot_sync) && self.snapshot.as_ref().map_or(false, |s|
 			match s.status() {
-				RestorationStatus::Ongoing { state_chunks, block_chunks, state_chunks_done, block_chunks_done } =>
-					(true, state_chunks_done + block_chunks_done, state_chunks + block_chunks),
-				_ => (false, 0, 0),
+				RestorationStatus::Ongoing { .. } | RestorationStatus::Initializing { .. } => true,
+				_ => false,
 			}
 		);
-		let snapshot_sync = snapshot_sync && sync_info.as_ref().map_or(false, |s| s.snapshot_sync);
 		if !importing && !snapshot_sync && elapsed < Duration::from_secs(30) {
 			return;
 		}
@ -318,7 +315,19 @@ impl<T: InformantData> Informant<T> {
 						paint(Green.bold(), format!("{:5}", queue_info.unverified_queue_size)),
 						paint(Green.bold(), format!("{:5}", queue_info.verified_queue_size))
 					),
-					true => format!("Syncing snapshot {}/{}", snapshot_current, snapshot_total),
+					true => {
+						self.snapshot.as_ref().map_or(String::new(), |s|
+							match s.status() {
+								RestorationStatus::Ongoing { state_chunks, block_chunks, state_chunks_done, block_chunks_done } => {
+									format!("Syncing snapshot {}/{}", state_chunks_done + block_chunks_done, state_chunks + block_chunks)
+								},
+								RestorationStatus::Initializing { chunks_done } => {
+									format!("Snapshot initializing ({} chunks restored)", chunks_done)
+								},
+								_ => String::new(),
+							}
+						)
+					},
 				},
 				false => String::new(),
 			},
@ -395,6 +404,33 @@ impl ChainNotify for Informant<FullNodeInformantData> {
 	}
 }

+impl LightChainNotify for Informant<LightNodeInformantData> {
+	fn new_headers(&self, good: &[H256]) {
+		let mut last_import = self.last_import.lock();
+		let client = &self.target.client;
+
+		let importing = self.target.is_major_importing();
+		let ripe = Instant::now() > *last_import + Duration::from_secs(1) && !importing;
+
+		if ripe {
+			if let Some(header) = good.last().and_then(|h| client.block_header(BlockId::Hash(*h))) {
+				info!(target: "import", "Imported {} {} ({} Mgas){}",
+					  Colour::White.bold().paint(format!("#{}", header.number())),
+					  Colour::White.bold().paint(format!("{}", header.hash())),
+					  Colour::Yellow.bold().paint(format!("{:.2}", header.gas_used().low_u64() as f32  / 1000000f32)),
+					  if good.len() > 1 {
+						  format!(" + another {} header(s)",
+								  Colour::Red.bold().paint(format!("{}", good.len() - 1)))
+					  } else {
+						  String::new()
+					  }
+				);
+				*last_import = Instant::now();
+			}
+		}
+	}
+}
+
 const INFO_TIMER: TimerToken = 0;

 impl<T: InformantData> IoHandler<ClientIoMessage> for Informant<T> {
--- a/parity/run.rs
+++ b/parity/run.rs
@ -412,7 +412,7 @@ fn execute_light_impl(cmd: RunCmd, logger: Arc<RotatingLogger>) -> Result<Runnin
 		Some(rpc_stats),
 		cmd.logger_config.color,
 	));
-
+	service.add_notify(informant.clone());
 	service.register_handler(informant.clone()).map_err(|_| "Unable to register informant handler".to_owned())?;

 	Ok(RunningClient::Light {
@ -913,7 +913,8 @@ fn execute_impl<Cr, Rr>(cmd: RunCmd, logger: Arc<RotatingLogger>, on_client_rq:
 	Ok(RunningClient::Full {
 		informant,
 		client,
-		keep_alive: Box::new((watcher, service, updater, ws_server, http_server, ipc_server, ui_server, secretstore_key_server, ipfs_server, event_loop)),
+		client_service: Arc::new(service),
+		keep_alive: Box::new((watcher, updater, ws_server, http_server, ipc_server, ui_server, secretstore_key_server, ipfs_server, event_loop)),
 	})
 }

@ -926,6 +927,7 @@ enum RunningClient {
 	Full {
 		informant: Arc<Informant<FullNodeInformantData>>,
 		client: Arc<Client>,
+		client_service: Arc<ClientService>,
 		keep_alive: Box<Any>,
 	},
 }
@ -943,11 +945,14 @@ impl RunningClient {
 				drop(client);
 				wait_for_drop(weak_client);
 			},
-			RunningClient::Full { informant, client, keep_alive } => {
+			RunningClient::Full { informant, client, client_service, keep_alive } => {
 				info!("Finishing work, please wait...");
 				// Create a weak reference to the client so that we can wait on shutdown
 				// until it is dropped
 				let weak_client = Arc::downgrade(&client);
+				// Shutdown and drop the ServiceClient
+				client_service.shutdown();
+				drop(client_service);
 				// drop this stuff as soon as exit detected.
 				drop(keep_alive);
 				// to make sure timer does not spawn requests while shutdown is in progress
--- a/parity/snapshot.rs
+++ b/parity/snapshot.rs
@ -123,6 +123,7 @@ fn restore_using<R: SnapshotReader>(snapshot: Arc<SnapshotService>, reader: &R,

 	match snapshot.status() {
 		RestorationStatus::Ongoing { .. } => Err("Snapshot file is incomplete and missing chunks.".into()),
+		RestorationStatus::Initializing { .. } => Err("Snapshot restoration is still initializing.".into()),
 		RestorationStatus::Failed => Err("Snapshot restoration failed.".into()),
 		RestorationStatus::Inactive => {
 			info!("Restoration complete.");
--- a/parity/whisper.rs
+++ b/parity/whisper.rs
@ -89,7 +89,6 @@ pub fn setup(target_pool_size: usize, protos: &mut Vec<AttachedProtocol>)

 	protos.push(AttachedProtocol {
 		handler: net.clone() as Arc<_>,
-		packet_count: whisper_net::PACKET_COUNT,
 		versions: whisper_net::SUPPORTED_VERSIONS,
 		protocol_id: whisper_net::PROTOCOL_ID,
 	});
@ -97,7 +96,6 @@ pub fn setup(target_pool_size: usize, protos: &mut Vec<AttachedProtocol>)
 	// parity-only extensions to whisper.
 	protos.push(AttachedProtocol {
 		handler: Arc::new(whisper_net::ParityExtensions),
-		packet_count: whisper_net::PACKET_COUNT,
 		versions: whisper_net::SUPPORTED_VERSIONS,
 		protocol_id: whisper_net::PARITY_PROTOCOL_ID,
 	});
--- a/rpc/Cargo.toml
+++ b/rpc/Cargo.toml
@ -48,7 +48,7 @@ ethcore-miner = { path = "../miner" }
 ethcore-private-tx = { path = "../ethcore/private-tx" }
 ethcore-sync = { path = "../ethcore/sync" }
 ethcore-transaction = { path = "../ethcore/transaction" }
-ethereum-types = "0.3"
+ethereum-types = "0.3.2"

 ethjson = { path = "../json" }
 ethkey = { path = "../ethkey" }
--- a/rpc/src/v1/helpers/errors.rs
+++ b/rpc/src/v1/helpers/errors.rs
@ -338,6 +338,8 @@ pub fn transaction_message(error: &TransactionError) -> String {
 		RecipientBanned => "Recipient is banned in local queue.".into(),
 		CodeBanned => "Code is banned in local queue.".into(),
 		NotAllowed => "Transaction is not permitted.".into(),
+		TooBig => "Transaction is too big, see chain specification for the limit.".into(),
+		InvalidRlp(ref descr) => format!("Invalid RLP data: {}", descr),
 	}
 }

@ -358,6 +360,19 @@ pub fn transaction<T: Into<EthcoreError>>(error: T) -> Error {
 	}
 }

+pub fn decode<T: Into<EthcoreError>>(error: T) -> Error {
+	let error = error.into();
+	match *error.kind() {
+		ErrorKind::Decoder(ref dec_err) => rlp(dec_err.clone()),
+		_ => Error {
+			code: ErrorCode::InternalError,
+			message: "decoding error".into(),
+			data: None,
+		}
+
+	}
+}
+
 pub fn rlp(error: DecoderError) -> Error {
 	Error {
 		code: ErrorCode::InvalidParams,
--- a/rpc/src/v1/helpers/light_fetch.rs
+++ b/rpc/src/v1/helpers/light_fetch.rs
@ -129,9 +129,8 @@ impl LightFetch {
 				}
 			}
 			BlockId::Hash(h) => {
-				reqs.push(request::HeaderByHash(h.into()).into());
-
 				let idx = reqs.len();
+				reqs.push(request::HeaderByHash(h.into()).into());
 				Ok(HeaderRef::Unresolved(idx, h.into()))
 			}
 			_ => Err(errors::unknown_block()) // latest, earliest, and pending will have all already returned.
--- a/rpc/src/v1/impls/eth.rs
+++ b/rpc/src/v1/impls/eth.rs
@ -343,7 +343,10 @@ impl<C, SN: ?Sized, S: ?Sized, M, EM, T: StateInfo + 'static> EthClient<C, SN, S
 				let uncle_id = UncleId { block: block_id, position };

 				let uncle = match client.uncle(uncle_id) {
-					Some(hdr) => hdr.decode(),
+					Some(hdr) => match hdr.decode() {
+						Ok(h) => h,
+						Err(e) => return Err(errors::decode(e))
+					},
 					None => { return Ok(None); }
 				};

@ -851,9 +854,9 @@ impl<C, SN: ?Sized, S: ?Sized, M, EM, T: StateInfo + 'static> Eth for EthClient<
 			};

 			let state = try_bf!(self.client.state_at(id).ok_or(errors::state_pruned()));
-			let header = try_bf!(self.client.block_header(id).ok_or(errors::state_pruned()));
+			let header = try_bf!(self.client.block_header(id).ok_or(errors::state_pruned()).and_then(|h| h.decode().map_err(errors::decode)));

-			(state, header.decode())
+			(state, header)
 		};

 		let result = self.client.call(&signed, Default::default(), &mut state, &header);
@ -890,9 +893,9 @@ impl<C, SN: ?Sized, S: ?Sized, M, EM, T: StateInfo + 'static> Eth for EthClient<
 			};

 			let state = try_bf!(self.client.state_at(id).ok_or(errors::state_pruned()));
-			let header = try_bf!(self.client.block_header(id).ok_or(errors::state_pruned()));
+			let header = try_bf!(self.client.block_header(id).ok_or(errors::state_pruned()).and_then(|h| h.decode().map_err(errors::decode)));

-			(state, header.decode())
+			(state, header)
 		};

 		Box::new(future::done(self.client.estimate_gas(&signed, &state, &header)
--- a/rpc/src/v1/impls/light/eth.rs
+++ b/rpc/src/v1/impls/light/eth.rs
@ -371,7 +371,7 @@ impl<T: LightChainClient + 'static> Eth for EthClient<T> {
 	}

 	fn send_raw_transaction(&self, raw: Bytes) -> Result<RpcH256> {
-		let best_header = self.client.best_block_header().decode();
+		let best_header = self.client.best_block_header().decode().map_err(errors::decode)?;

 		Rlp::new(&raw.into_vec()).as_val()
 			.map_err(errors::rlp)
--- a/rpc/src/v1/impls/light/parity.rs
+++ b/rpc/src/v1/impls/light/parity.rs
@ -395,9 +395,9 @@ impl Parity for ParityClient {

 		let engine = self.light_dispatch.client.engine().clone();
 		let from_encoded = move |encoded: encoded::Header| {
-			let header = encoded.decode();
+			let header = encoded.decode().map_err(errors::decode)?;
 			let extra_info = engine.extra_info(&header);
-			RichHeader {
+			Ok(RichHeader {
 				inner: Header {
 					hash: Some(header.hash().into()),
 					size: Some(encoded.rlp().as_raw().len().into()),
@ -418,9 +418,8 @@ impl Parity for ParityClient {
 					extra_data: Bytes::new(header.extra_data().clone()),
 				},
 				extra_info: extra_info,
-			}
+			})
 		};
-
 		// Note: Here we treat `Pending` as `Latest`.
 		//       Since light clients don't produce pending blocks
 		//       (they don't have state) we can safely fallback to `Latest`.
@ -430,7 +429,7 @@ impl Parity for ParityClient {
 			BlockNumber::Latest | BlockNumber::Pending => BlockId::Latest,
 		};

-		Box::new(self.fetcher().header(id).map(from_encoded))
+		Box::new(self.fetcher().header(id).and_then(from_encoded))
 	}

 	fn ipfs_cid(&self, content: Bytes) -> Result<String> {
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
André Silva	7bf16cce1b	[beta] Backports (#8785 ) * Fix light sync with initial validator-set contract (#8528) * Fix #8468 * Use U256::max_value() instead * Fix again * Also change initial transaction gas * Resumable warp-sync / Seed downloaded snapshots (#8544) * Start dividing sync chain : first supplier method * WIP - updated chain sync supplier * Finish refactoring the Chain Sync Supplier * Create Chain Sync Requester * Add Propagator for Chain Sync * Add the Chain Sync Handler * Move tests from mod -> handler * Move tests to propagator * Refactor SyncRequester arguments * Refactoring peer fork header handler * Fix wrong highest block number in snapshot sync * Small refactor... * Resume warp-sync downloaded chunks * Add comments * Refactoring the previous chunks import * Fix tests * Address PR grumbles * Fix not seeding current snapshot * Address PR Grumbles * Address PR grumble * Retry failed CI job * Update SnapshotService readiness check Fix restoration locking issue for previous chunks restoration * Fix tests * Fix tests * Fix test * Early abort importing previous chunks * PR Grumbles * Update Gitlab CI config * SyncState back to Waiting when Manifest peers disconnect * Move fix * Better fix * Revert GitLab CI changes * Fix Warning * Refactor resuming snapshots * Fix string construction * Revert "Refactor resuming snapshots" This reverts commit 75fd4b553a38e4a49dc5d6a878c70e830ff382eb. * Update informant log * Fix string construction * Refactor resuming snapshots * Fix informant * PR Grumbles * Update informant message : show chunks done * PR Grumbles * Fix * Fix Warning * PR Grumbles * Don't open Browser post-install on Mac (#8641) Since we start parity with the UI disabled per default now, opening the browser post installation will show an annoying error message, confusing the user. This patch removes opening the browser to prevent that annoyance. fixes #8194 * Fix not downloading old blocks (#8642) * Fix PoW blockchains sealing notifications in chain_new_blocks (#8656) * Shutdown the Snapshot Service early (#8658) * Shutdown the Snapshot Service when shutting down the runner * Rename `service` to `client_service` * Fix tests * Fix cli signer (#8682) * Update ethereum-types so `{:#x}` applies 0x prefix * Set the request index to that of the current request (#8683) * Set the request index to that of the current request When setting up the chain of (two) requests to look up a block by hash, the second need to refer to the first. This fixes an issue where the back ref was set to the subsequent request, not the current one. When the requests are executed we loop through them in order and ensure the requests that should produce headers all match up. We do this by index so they better be right. In other words: off by one. * network-devp2p: handle UselessPeer disconnect (#8686) * Fix local transactions policy. (#8691) * CI: Fixes for Android Pipeline (#8745) * ci: Remove check for shared libraries in gitlab script * ci: allow android arm build to fail * Custom Error Messages on ENFILE and EMFILE IO Errors (#8744) * Custom Error Messages on ENFILE and EMFILE IO Errors Add custom mapping of ENFILE and EMFILE IO Errors (Failure because of missing system resource) right when chaining ioError into ::util::Network::Error to improve Error Messages given to user Note: Adds libc as a dependency to util/network * Use assert-matches for more readable tests * Fix Wording and consistency * ethcore-sync: fix connection to peers behind chain fork block (#8710)	2018-06-04 22:29:20 +02:00
Afri Schoedon	69d6d8239f	parity-version: bump beta to 1.11.2 (#8750 ) * parity-version: bump beta to 1.11.2 * parity-version: unset critical flag	2018-06-01 14:28:01 +02:00
Andrew Jones	6654d02163	[beta] Backports (#8624 ) * Trace precompiled contracts when the transfer value is not zero (#8486) * Trace precompiled contracts when the transfer value is not zero * Add tests for precompiled CALL tracing * Use byzantium test machine for the new test * Add notes in comments on why we don't trace all precompileds * Use is_transferred instead of transferred * Return error if RLP size of transaction exceeds the limit (#8473) * Return error if RLP size of transaction exceeds the limit * Review comments fixed * RLP check moved to verifier, corresponding pool test added * Don't block sync when importing old blocks (#8530) * Alter IO queueing. * Don't require IoMessages to be Clone * Ancient blocks imported via IoChannel. * Get rid of private transactions io message. * Get rid of deadlock and fix disconnected handler. * Revert to old disconnect condition. * Fix tests. * Fix deadlock. * Refactoring `ethcore-sync` - Fixing warp-sync barrier (#8543) * Start dividing sync chain : first supplier method * WIP - updated chain sync supplier * Finish refactoring the Chain Sync Supplier * Create Chain Sync Requester * Add Propagator for Chain Sync * Add the Chain Sync Handler * Move tests from mod -> handler * Move tests to propagator * Refactor SyncRequester arguments * Refactoring peer fork header handler * Fix wrong highest block number in snapshot sync * Small refactor... * Address PR grumbles * Retry failed CI job * Fix tests * PR Grumbles * Handle socket address parsing errors (#8545) Unpack errors and check for io::ErrorKind::InvalidInput and return our own AddressParse error. Remove the foreign link to std::net::AddrParseError and add an `impl From` for that error. Test parsing properly. * Fix packet count when talking with PAR2 peers (#8555) * Support diferent packet counts in different protocol versions. * Fix light timeouts and eclipse protection. * Fix devp2p tests. * Fix whisper-cli compilation. * Fix compilation. * Fix ethcore-sync tests. * Revert "Fix light timeouts and eclipse protection." This reverts commit 06285ea8c1d9d184d809f64b5507aece633da6cc. * Increase timeouts. * Add whisper CLI to the pipelines (#8578) * Add whisper CLI to the pipelines * Address todo, ref #8579 * Rename `whisper-cli binary` to `whisper` (#8579) * rename whisper-cli binary to whisper * fix tests * Remove manually added text to the errors (#8595) These messages were confusing for the users especially the help message. * Fix account list double 0x display (#8596) * Remove unused self import * Fix account list double 0x display * Fix BlockReward contract "arithmetic operation overflow" (#8611) * Fix BlockReward contract "arithmetic operation overflow" * Add docs on how execute_as_system works * Fix typo * Rlp decode returns Result (#8527) rlp::decode returns Result Make a best effort to handle decoding errors gracefully throughout the code, using `expect` where the value is guaranteed to be valid (and in other places where it makes sense). * Remove expect (#8536) * Remove expect and propagate rlp::DecoderErrors as TrieErrors * Decoding headers can fail (#8570) * rlp::decode returns Result * Fix journaldb to handle rlp::decode Result * Fix ethcore to work with rlp::decode returning Result * Light client handles rlp::decode returning Result * Fix tests in rlp_derive * Fix tests * Cleanup * cleanup * Allow panic rather than breaking out of iterator * Let decoding failures when reading from disk blow up * syntax * Fix the trivial grumbles * Fix failing tests * Make Account::from_rlp return Result * Syntx, sigh * Temp-fix for decoding failures * Header::decode returns Result Handle new return type throughout the code base. * Do not continue reading from the DB when a value could not be read * Fix tests * Handle header decoding in light_sync * Handling header decoding errors * Let the DecodeError bubble up unchanged * Remove redundant error conversion * fix compiler warning (#8590) * Attempt to fix intermittent test failures (#8584) Occasionally should_return_correct_nonces_when_dropped_because_of_limit fails, possibly because of multiple threads competing to finish. See CI logs here for an example: https://gitlab.parity.io/parity/parity/-/jobs/86738 * block_header can fail so return Result (#8581) * block_header can fail so return Result * Restore previous return type based on feedback * Fix failing doc tests running on non-code * Block::decode() returns Result (#8586) * Gitlab test script fixes (#8573) * Exclude /docs from modified files. * Ensure all references in the working tree are available * Remove duplicated line from test script	2018-05-15 07:41:30 +02:00
Afri Schoedon	885f45c8c1	Bump beta to 1.11.1 (#8627 )	2018-05-14 15:53:12 +02:00
Wei Tang	62ccdd7ad4	[beta] Backports (#8558 ) * Fetching logs by hash in blockchain database (#8463) * Fetch logs by hash in blockchain database * Fix tests * Add unit test for branch block logs fetching * Add docs that blocks must already be sorted * Handle branch block cases properly * typo: empty -> is_empty * Remove return_empty_if_none by using a closure * Use BTreeSet to avoid sorting again * Move is_canon to BlockChain * typo: pass value by reference * Use loop and wrap inside blocks to simplify the code Borrowed from https://github.com/paritytech/parity/pull/8463#discussion_r183453326 * typo: missed a comment * Pass on storage keys tracing to handle the case when it is not modified (#8491) * Pass on storage keys even if it is not modified * typo: account and storage query `to_pod_diff` builds both `touched_addresses` merge and storage keys merge. * Fix tests * Use state query directly because of suicided accounts * Fix a RefCell borrow issue * Add tests for unmodified storage trace * Address grumbles * typo: remove unwanted empty line * ensure_cached compiles with the original signature * Update wasmi and pwasm-utils (#8493) * Update wasmi to 0.2 New wasmi supports 32bit platforms and no longer requires a special feature to build for such platforms. * Update pwasm-utils to 0.1.5 * Show imported messages for light client (#8517) * Enable WebAssembly and Byzantium for Ellaism (#8520) * Enable WebAssembly and Byzantium for Ellaism * Fix indentation * Remove empty lines * Don't panic in import_block if invalid rlp (#8522) * Don't panic in import_block if invalid rlp * Remove redundant type annotation * Replace RLP header view usage with safe decoding Using the view will panic with invalid RLP. Here we use Rlp decoding directly which will return a `Result<_, DecoderError>`. While this path currently should not have any invalid RLP - it makes it safer if ever called with invalid RLP from other code paths. * Node table sorting according to last contact data (#8541) * network-devp2p: sort nodes in node table using last contact data * network-devp2p: rename node contact types in node table json output * network-devp2p: fix node table tests * network-devp2p: note node failure when failed to establish connection * network-devp2p: handle UselessPeer error * network-devp2p: note failure when marking node as useless	2018-05-07 20:17:52 +02:00
Afri Schoedon	aae451de9e	Betalize 1.11 :) (#8475 ) * Betalize 1.11 :) * Update Gitlab scripts * Use master as gitlab latest * Fix snap builds (#8483) * Update hardcodedSync for Ethereum, Kovan, and Ropsten (#8489)	2018-04-26 09:46:06 +02:00