js-precompiled 20170608-105446

Backporting to beta (#5791 )
* v1.6.8 * Update expanse json with fork at block 600000 (#5351) * Update expanse json with fork at block 600000 * update exp chainID to 2 * Bumped mio * Fixed default UI port for mac installer (#5782) * Blacklist empty phrase account. * Update Cid/multihash/ring/tinykeccak (#5785) * Updating ring,multihash,tiny-keccak * Updating CID in ipfs. * Disable compression for RLP strings
2017-06-08 13:52:25 +02:00 · 2017-06-07 22:09:16 +02:00 · 2017-06-07 22:08:25 +02:00 · 2017-06-07 21:51:06 +03:00 · 2017-06-07 20:14:01 +03:00 · 2017-06-07 19:41:45 +03:00
182 changed files with 7145 additions and 1452 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -19,6 +19,9 @@
 # mac stuff
 .DS_Store

+# npm stuff
+npm-debug.log
+
 # gdb files
 .gdb_history

--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -14,7 +14,7 @@ cache:
  untracked: true
 linux-stable:
  stage: build
-  image: ethcore/rust:stable
+  image: parity/rust:gitlab-ci
  only:
    - beta
    - tags
@@ -26,14 +26,14 @@ linux-stable:
    - cargo build -j $(nproc) --release -p ethstore
    - cargo build -j $(nproc) --release -p ethkey
    - strip target/release/parity
-    - strip target/release/evm
+    - strip target/release/parity-evm
    - strip target/release/ethstore
    - strip target/release/ethkey
    - export SHA3=$(target/release/parity tools hash target/release/parity)
    - md5sum target/release/parity > parity.md5
    - sh scripts/deb-build.sh amd64
    - cp target/release/parity deb/usr/bin/parity
-    - cp target/release/evm deb/usr/bin/evm
+    - cp target/release/parity-evm deb/usr/bin/parity-evm
    - cp target/release/ethstore deb/usr/bin/ethstore
    - cp target/release/ethkey deb/usr/bin/ethkey
    - export VER=$(grep -m 1 version Cargo.toml | awk '{print $3}' | tr -d '"' | tr -d "\n")
@@ -41,7 +41,7 @@ linux-stable:
    - md5sum "parity_"$VER"_amd64.deb" > "parity_"$VER"_amd64.deb.md5"
    - aws configure set aws_access_key_id $s3_key
    - aws configure set aws_secret_access_key $s3_secret
-    - if [[ $CI_BUILD_REF_NAME =~ ^(master|beta|stable)$ ]]; then export S3_BUCKET=builds-parity-published; else export S3_BUCKET=builds-parity; fi
+    - if [[ $CI_BUILD_REF_NAME =~ ^(master|beta|stable|nightly)$ ]]; then export S3_BUCKET=builds-parity-published; else export S3_BUCKET=builds-parity; fi
    - aws s3 rm --recursive s3://$S3_BUCKET/$CI_BUILD_REF_NAME/x86_64-unknown-linux-gnu
    - aws s3api put-object --bucket $S3_BUCKET --key $CI_BUILD_REF_NAME/x86_64-unknown-linux-gnu/parity --body target/release/parity
    - aws s3api put-object --bucket $S3_BUCKET --key $CI_BUILD_REF_NAME/x86_64-unknown-linux-gnu/parity.md5 --body parity.md5
@@ -55,13 +55,45 @@ linux-stable:
  artifacts:
    paths:
    - target/release/parity
-    - target/release/parity/evmbin
-    - target/release/parity/ethstore
-    - target/release/parity/ethkey
+    - target/release/parity-evm
+    - target/release/ethstore
+    - target/release/ethkey
    name: "stable-x86_64-unknown-linux-gnu_parity"
+linux-snap:
+  stage: build
+  image: parity/snapcraft:gitlab-ci
+  only:
+    - snap
+    - beta
+    - tags
+    - triggers
+  script:
+    - export VER=$(grep -m 1 version Cargo.toml | awk '{print $3}' | tr -d '"' | tr -d "\n")
+    - cd scripts
+    - rm -rf *snap
+    - sed -i 's/master/'"$VER"'/g' snapcraft.yaml
+    - echo "Version:"$VER
+    - snapcraft
+    - ls
+    - cp parity_beta_amd64.snap parity_"$VER"_amd64.snap
+    - md5sum "parity_"$VER"_amd64.snap" > "parity_"$VER"_amd64.snap.md5"
+    - aws configure set aws_access_key_id $s3_key
+    - aws configure set aws_secret_access_key $s3_secret
+    - if [[ $CI_BUILD_REF_NAME =~ ^(master|beta|stable|nightly)$ ]]; then export S3_BUCKET=builds-parity-published; else export S3_BUCKET=builds-parity; fi
+    - aws s3api put-object --bucket $S3_BUCKET --key $CI_BUILD_REF_NAME/x86_64-unknown-linux-gnu/"parity_"$VER"_amd64.snap" --body "parity_"$VER"_amd64.snap"
+    - aws s3api put-object --bucket $S3_BUCKET --key $CI_BUILD_REF_NAME/x86_64-unknown-linux-gnu/"parity_"$VER"_amd64.snap.md5" --body "parity_"$VER"_amd64.snap.md5"
+    - curl --data "commit=$CI_BUILD_REF&sha3=$SHA3&filename=parity&secret=$RELEASES_SECRET" http://update.parity.io:1337/push-build/$CI_BUILD_REF_NAME/x86_64-unknown-linux-gnu
+    - curl --data "commit=$CI_BUILD_REF&sha3=$SHA3&filename=parity&secret=$RELEASES_SECRET" http://update.parity.io:1338/push-build/$CI_BUILD_REF_NAME/x86_64-unknown-linux-gnu
+  tags:
+    - rust
+    - rust-stable
+  artifacts:
+    paths:
+    - scripts/parity_*_amd64.snap
+    name: "stable-x86_64-unknown-snap-gnu_parity"
 linux-stable-debian:
  stage: build
-  image: ethcore/rust-debian:latest
+  image: parity/rust-debian:gitlab-ci
  only:
    - beta
    - tags
@@ -73,14 +105,14 @@ linux-stable-debian:
    - cargo build -j $(nproc) --release -p ethstore
    - cargo build -j $(nproc) --release -p ethkey
    - strip target/release/parity
-    - strip target/release/evm
+    - strip target/release/parity-evm
    - strip target/release/ethstore
    - strip target/release/ethkey
    - export SHA3=$(target/release/parity tools hash target/release/parity)
    - md5sum target/release/parity > parity.md5
    - sh scripts/deb-build.sh amd64
    - cp target/release/parity deb/usr/bin/parity
-    - cp target/release/evm deb/usr/bin/evm
+    - cp target/release/parity-evm deb/usr/bin/parity-evm
    - cp target/release/ethstore deb/usr/bin/ethstore
    - cp target/release/ethkey deb/usr/bin/ethkey
    - export VER=$(grep -m 1 version Cargo.toml | awk '{print $3}' | tr -d '"' | tr -d "\n")
@@ -88,7 +120,7 @@ linux-stable-debian:
    - md5sum "parity_"$VER"_amd64.deb" > "parity_"$VER"_amd64.deb.md5"
    - aws configure set aws_access_key_id $s3_key
    - aws configure set aws_secret_access_key $s3_secret
-    - if [[ $CI_BUILD_REF_NAME =~ ^(master|beta|stable)$ ]]; then export S3_BUCKET=builds-parity-published; else export S3_BUCKET=builds-parity; fi
+    - if [[ $CI_BUILD_REF_NAME =~ ^(master|beta|stable|nightly)$ ]]; then export S3_BUCKET=builds-parity-published; else export S3_BUCKET=builds-parity; fi
    - aws s3 rm --recursive s3://$S3_BUCKET/$CI_BUILD_REF_NAME/x86_64-unknown-debian-gnu
    - aws s3api put-object --bucket $S3_BUCKET --key $CI_BUILD_REF_NAME/x86_64-unknown-debian-gnu/parity --body target/release/parity
    - aws s3api put-object --bucket $S3_BUCKET --key $CI_BUILD_REF_NAME/x86_64-unknown-debian-gnu/parity.md5 --body parity.md5
@@ -105,7 +137,7 @@ linux-stable-debian:
    name: "stable-x86_64-unknown-debian-gnu_parity"
 linux-beta:
  stage: build
-  image: ethcore/rust:beta
+  image: parity/rust:gitlab-ci
  only:
    - beta
    - tags
@@ -124,7 +156,7 @@ linux-beta:
  allow_failure: true
 linux-nightly:
  stage: build
-  image: ethcore/rust:nightly
+  image: parity/rust:gitlab-ci
  only:
    - beta
    - tags
@@ -143,7 +175,7 @@ linux-nightly:
  allow_failure: true
 linux-centos:
  stage: build
-  image: ethcore/rust-centos:latest
+  image: parity/rust-centos:gitlab-ci
  only:
    - beta
    - tags
@@ -159,7 +191,7 @@ linux-centos:
    - export SHA3=$(target/release/parity tools hash target/release/parity)
    - aws configure set aws_access_key_id $s3_key
    - aws configure set aws_secret_access_key $s3_secret
-    - if [[ $CI_BUILD_REF_NAME =~ ^(master|beta|stable)$ ]]; then export S3_BUCKET=builds-parity-published; else export S3_BUCKET=builds-parity; fi
+    - if [[ $CI_BUILD_REF_NAME =~ ^(master|beta|stable|nightly)$ ]]; then export S3_BUCKET=builds-parity-published; else export S3_BUCKET=builds-parity; fi
    - aws s3 rm --recursive s3://$S3_BUCKET/$CI_BUILD_REF_NAME/x86_64-unknown-centos-gnu
    - aws s3api put-object --bucket builds-parity --key $CI_BUILD_REF_NAME/x86_64-unknown-centos-gnu/parity --body target/release/parity
    - aws s3api put-object --bucket builds-parity --key $CI_BUILD_REF_NAME/x86_64-unknown-centos-gnu/parity.md5 --body parity.md5
@@ -174,7 +206,7 @@ linux-centos:
    name: "x86_64-unknown-centos-gnu_parity"
 linux-i686:
  stage: build
-  image: ethcore/rust-i686:latest
+  image: parity/rust-i686:gitlab-ci
  only:
    - beta
    - tags
@@ -196,7 +228,7 @@ linux-i686:
    - md5sum "parity_"$VER"_i386.deb" > "parity_"$VER"_i386.deb.md5"
    - aws configure set aws_access_key_id $s3_key
    - aws configure set aws_secret_access_key $s3_secret
-    - if [[ $CI_BUILD_REF_NAME =~ ^(master|beta|stable)$ ]]; then export S3_BUCKET=builds-parity-published; else export S3_BUCKET=builds-parity; fi
+    - if [[ $CI_BUILD_REF_NAME =~ ^(master|beta|stable|nightly)$ ]]; then export S3_BUCKET=builds-parity-published; else export S3_BUCKET=builds-parity; fi
    - aws s3 rm --recursive s3://$S3_BUCKET/$CI_BUILD_REF_NAME/$PLATFORM
    - aws s3api put-object --bucket $S3_BUCKET --key $CI_BUILD_REF_NAME/$PLATFORM/parity --body target/$PLATFORM/release/parity
    - aws s3api put-object --bucket $S3_BUCKET --key $CI_BUILD_REF_NAME/$PLATFORM/parity.md5 --body parity.md5
@@ -214,7 +246,7 @@ linux-i686:
  allow_failure: true
 linux-armv7:
  stage: build
-  image: ethcore/rust-armv7:latest
+  image: parity/rust-armv7:gitlab-ci
  only:
    - beta
    - tags
@@ -242,7 +274,7 @@ linux-armv7:
    - md5sum "parity_"$VER"_armhf.deb" > "parity_"$VER"_armhf.deb.md5"
    - aws configure set aws_access_key_id $s3_key
    - aws configure set aws_secret_access_key $s3_secret
-    - if [[ $CI_BUILD_REF_NAME =~ ^(master|beta|stable)$ ]]; then export S3_BUCKET=builds-parity-published; else export S3_BUCKET=builds-parity; fi
+    - if [[ $CI_BUILD_REF_NAME =~ ^(master|beta|stable|nightly)$ ]]; then export S3_BUCKET=builds-parity-published; else export S3_BUCKET=builds-parity; fi
    - aws s3 rm --recursive s3://$S3_BUCKET/$CI_BUILD_REF_NAME/$PLATFORM
    - aws s3api put-object --bucket $S3_BUCKET --key $CI_BUILD_REF_NAME/$PLATFORM/parity --body target/$PLATFORM/release/parity
    - aws s3api put-object --bucket $S3_BUCKET --key $CI_BUILD_REF_NAME/$PLATFORM/parity.md5 --body parity.md5
@@ -260,7 +292,7 @@ linux-armv7:
  allow_failure: true
 linux-arm:
  stage: build
-  image: ethcore/rust-arm:latest
+  image: parity/rust-arm:gitlab-ci
  only:
    - beta
    - tags
@@ -288,7 +320,7 @@ linux-arm:
    - md5sum "parity_"$VER"_armhf.deb" > "parity_"$VER"_armhf.deb.md5"
    - aws configure set aws_access_key_id $s3_key
    - aws configure set aws_secret_access_key $s3_secret
-    - if [[ $CI_BUILD_REF_NAME =~ ^(master|beta|stable)$ ]]; then export S3_BUCKET=builds-parity-published; else export S3_BUCKET=builds-parity; fi
+    - if [[ $CI_BUILD_REF_NAME =~ ^(master|beta|stable|nightly)$ ]]; then export S3_BUCKET=builds-parity-published; else export S3_BUCKET=builds-parity; fi
    - aws s3 rm --recursive s3://$S3_BUCKET/$CI_BUILD_REF_NAME/$PLATFORM
    - aws s3api put-object --bucket $S3_BUCKET --key $CI_BUILD_REF_NAME/$PLATFORM/parity --body target/$PLATFORM/release/parity
    - aws s3api put-object --bucket $S3_BUCKET --key $CI_BUILD_REF_NAME/$PLATFORM/parity.md5 --body parity.md5
@@ -306,12 +338,12 @@ linux-arm:
  allow_failure: true
 linux-armv6:
  stage: build
-  image: ethcore/rust-armv6:latest
+  image: parity/rust-armv6:gitlab-ci
  only:
-    - beta
+#    - beta
 #    - tags
 #    - stable
-#    - triggers
+    - triggers
  script:
    - export CC=arm-linux-gnueabi-gcc
    - export CXX=arm-linux-gnueabi-g++
@@ -329,7 +361,7 @@ linux-armv6:
    - md5sum target/$PLATFORM/release/parity > parity.md5
    - aws configure set aws_access_key_id $s3_key
    - aws configure set aws_secret_access_key $s3_secret
-    - if [[ $CI_BUILD_REF_NAME =~ ^(master|beta|stable)$ ]]; then export S3_BUCKET=builds-parity-published; else export S3_BUCKET=builds-parity; fi
+    - if [[ $CI_BUILD_REF_NAME =~ ^(master|beta|stable|nightly)$ ]]; then export S3_BUCKET=builds-parity-published; else export S3_BUCKET=builds-parity; fi
    - aws s3 rm --recursive s3://$S3_BUCKET/$CI_BUILD_REF_NAME/$PLATFORM
    - aws s3api put-object --bucket $S3_BUCKET --key $CI_BUILD_REF_NAME/$PLATFORM/parity --body target/$PLATFORM/release/parity
    - aws s3api put-object --bucket $S3_BUCKET --key $CI_BUILD_REF_NAME/$PLATFORM/parity.md5 --body parity.md5
@@ -345,7 +377,7 @@ linux-armv6:
  allow_failure: true
 linux-aarch64:
  stage: build
-  image: ethcore/rust-aarch64:latest
+  image: parity/rust-arm64:gitlab-ci
  only:
    - beta
    - tags
@@ -373,7 +405,7 @@ linux-aarch64:
    - md5sum "parity_"$VER"_arm64.deb" > "parity_"$VER"_arm64.deb.md5"
    - aws configure set aws_access_key_id $s3_key
    - aws configure set aws_secret_access_key $s3_secret
-    - if [[ $CI_BUILD_REF_NAME =~ ^(master|beta|stable)$ ]]; then export S3_BUCKET=builds-parity-published; else export S3_BUCKET=builds-parity; fi
+    - if [[ $CI_BUILD_REF_NAME =~ ^(master|beta|stable|nightly)$ ]]; then export S3_BUCKET=builds-parity-published; else export S3_BUCKET=builds-parity; fi
    - aws s3 rm --recursive s3://$S3_BUCKET/$CI_BUILD_REF_NAME/$PLATFORM
    - aws s3api put-object --bucket $S3_BUCKET --key $CI_BUILD_REF_NAME/$PLATFORM/parity.md5 --body parity.md5
    - aws s3api put-object --bucket $S3_BUCKET --key $CI_BUILD_REF_NAME/$PLATFORM/"parity_"$VER"_arm64.deb" --body "parity_"$VER"_arm64.deb"
@@ -409,16 +441,16 @@ darwin:
      packagesbuild -v mac/Parity.pkgproj
      productsign --sign 'Developer ID Installer: PARITY TECHNOLOGIES LIMITED (P2PX3JU8FT)' target/release/Parity\ Ethereum.pkg target/release/Parity\ Ethereum-signed.pkg
      export VER=$(grep -m 1 version Cargo.toml | awk '{print $3}' | tr -d '"' | tr -d "\n")
-      mv target/release/Parity\ Ethereum-signed.pkg "parity-"$VER"-osx-installer-EXPERIMENTAL.pkg"
-      md5sum "parity-"$VER"-osx-installer-EXPERIMENTAL.pkg" >> "parity-"$VER"-osx-installer-EXPERIMENTAL.pkg.md5"
+      mv target/release/Parity\ Ethereum-signed.pkg "parity-"$VER"-osx-installer.pkg"
+      md5sum "parity-"$VER"-osx-installer.pkg" >> "parity-"$VER"-osx-installer.pkg.md5"
      aws configure set aws_access_key_id $s3_key
      aws configure set aws_secret_access_key $s3_secret
-      if [[ $CI_BUILD_REF_NAME =~ ^(master|beta|stable)$ ]]; then export S3_BUCKET=builds-parity-published; else export S3_BUCKET=builds-parity; fi
+      if [[ $CI_BUILD_REF_NAME =~ ^(master|beta|stable|nightly)$ ]]; then export S3_BUCKET=builds-parity-published; else export S3_BUCKET=builds-parity; fi
      aws s3 rm --recursive s3://$S3_BUCKET/$CI_BUILD_REF_NAME/$PLATFORM
      aws s3api put-object --bucket $S3_BUCKET --key $CI_BUILD_REF_NAME/$PLATFORM/parity --body target/release/parity
      aws s3api put-object --bucket $S3_BUCKET --key $CI_BUILD_REF_NAME/$PLATFORM/parity.md5 --body parity.md5
-      aws s3api put-object --bucket $S3_BUCKET --key $CI_BUILD_REF_NAME/$PLATFORM/"parity-"$VER"-osx-installer-EXPERIMENTAL.pkg" --body "parity-"$VER"-osx-installer-EXPERIMENTAL.pkg"
-      aws s3api put-object --bucket $S3_BUCKET --key $CI_BUILD_REF_NAME/$PLATFORM/"parity-"$VER"-osx-installer-EXPERIMENTAL.pkg.md5" --body "parity-"$VER"-osx-installer-EXPERIMENTAL.pkg.md5"
+      aws s3api put-object --bucket $S3_BUCKET --key $CI_BUILD_REF_NAME/$PLATFORM/"parity-"$VER"-osx-installer.pkg" --body "parity-"$VER"-osx-installer.pkg"
+      aws s3api put-object --bucket $S3_BUCKET --key $CI_BUILD_REF_NAME/$PLATFORM/"parity-"$VER"-osx-installer.pkg.md5" --body "parity-"$VER"-osx-installer.pkg.md5"
      curl --data "commit=$CI_BUILD_REF&sha3=$SHA3&filename=parity&secret=$RELEASES_SECRET" http://update.parity.io:1337/push-build/$CI_BUILD_REF_NAME/$PLATFORM
      curl --data "commit=$CI_BUILD_REF&sha3=$SHA3&filename=parity&secret=$RELEASES_SECRET" http://update.parity.io:1338/push-build/$CI_BUILD_REF_NAME/$PLATFORM
  tags:
@@ -467,9 +499,10 @@ windows:
    - aws configure set aws_access_key_id %s3_key%
    - aws configure set aws_secret_access_key %s3_secret%
    - echo %CI_BUILD_REF_NAME%
-    - echo %CI_BUILD_REF_NAME% | findstr /R "master" >nul 2>&1 && set S3_BUCKET=builds-parity-published || set S3_BUCKET=builds-parity
-    - echo %CI_BUILD_REF_NAME% | findstr /R "beta" >nul 2>&1 && set S3_BUCKET=builds-parity-published || set S3_BUCKET=builds-parity
-    - echo %CI_BUILD_REF_NAME% | findstr /R "stable" >nul 2>&1 && set S3_BUCKET=builds-parity-published || set S3_BUCKET=builds-parity
+    - echo %CI_BUILD_REF_NAME% | findstr /R "master" >nul 2>&1 && set S3_BUCKET=builds-parity-published|| set S3_BUCKET=builds-parity
+    - echo %CI_BUILD_REF_NAME% | findstr /R "beta" >nul 2>&1 && set S3_BUCKET=builds-parity-published|| set S3_BUCKET=builds-parity
+    - echo %CI_BUILD_REF_NAME% | findstr /R "stable" >nul 2>&1 && set S3_BUCKET=builds-parity-published|| set S3_BUCKET=builds-parity
+    - echo %CI_BUILD_REF_NAME% | findstr /R "nightly" >nul 2>&1 && set S3_BUCKET=builds-parity-published|| set S3_BUCKET=builds-parity
    - echo %S3_BUCKET%
    - aws s3 rm --recursive s3://%S3_BUCKET%/%CI_BUILD_REF_NAME%/x86_64-pc-windows-msvc
    - aws s3api put-object --bucket %S3_BUCKET% --key %CI_BUILD_REF_NAME%/x86_64-pc-windows-msvc/parity.exe --body target\release\parity.exe
@@ -500,6 +533,10 @@ docker-build:
    - if [ "$CI_BUILD_REF_NAME" == "beta-release" ]; then DOCKER_TAG="latest"; else DOCKER_TAG=$CI_BUILD_REF_NAME; fi
    - docker login -u $Docker_Hub_User -p $Docker_Hub_Pass
    - sh scripts/docker-build.sh $DOCKER_TAG
+    - docker logout
+    - docker login -u $Docker_Hub_User_Parity -p $Docker_Hub_Pass_Parity
+    - sh scripts/docker-build.sh $DOCKER_TAG
+    - docker logout
  tags:
    - docker
 test-darwin:
@@ -529,19 +566,19 @@ test-windows:
  allow_failure: true
 test-rust-stable:
  stage: test
-  image: ethcore/rust:stable
+  image: parity/rust:gitlab-ci
  before_script:
    - git submodule update --init --recursive
    - export RUST_FILES_MODIFIED=$(git --no-pager diff --name-only $CI_BUILD_REF^ $CI_BUILD_REF | grep -v -e ^js -e ^\\. -e ^LICENSE -e ^README.md -e ^appveyor.yml -e ^test.sh -e ^windows/ -e ^scripts/ -e^mac/ -e ^nsis/ | wc -l)
  script:
    - export RUST_BACKTRACE=1
-    - if [ $RUST_FILES_MODIFIED -eq 0 ]; then echo "Skipping Rust tests since no Rust files modified."; else ./test.sh $CARGOFLAGS&&./scripts/cov.sh "$KCOV_CMD"; fi
+    - if [ $RUST_FILES_MODIFIED -eq 0 ]; then echo "Skipping Rust tests since no Rust files modified."; else ./test.sh $CARGOFLAGS; fi
  tags:
    - rust
    - rust-stable
 js-test:
  stage: test
-  image: ethcore/rust:stable
+  image: parity/rust:gitlab-ci
  before_script:
    - git submodule update --init --recursive
    - export JS_FILES_MODIFIED=$(git --no-pager diff --name-only $CI_BUILD_REF^ $CI_BUILD_REF | grep ^js/ | wc -l)
@@ -555,11 +592,12 @@ test-rust-beta:
  stage: test
  only:
    - triggers
-  image: ethcore/rust:beta
+  image: parity/rust:gitlab-ci
  before_script:
    - git submodule update --init --recursive
    - export RUST_FILES_MODIFIED=$(git --no-pager diff --name-only $CI_BUILD_REF^ $CI_BUILD_REF | grep -v -e ^js -e ^\\. -e ^LICENSE -e ^README.md -e ^appveyor.yml -e ^test.sh -e ^windows/ -e ^scripts/ -e^mac/ -e ^nsis/ | wc -l)
  script:
+    - rustup default beta
    - export RUST_BACKTRACE=1
    - if [ $RUST_FILES_MODIFIED -eq 0 ]; then echo "Skipping Rust tests since no Rust files modified."; else ./test.sh $CARGOFLAGS; fi
  tags:
@@ -570,11 +608,12 @@ test-rust-nightly:
  stage: test
  only:
    - triggers
-  image: ethcore/rust:nightly
+  image: parity/rust:gitlab-ci
  before_script:
    - git submodule update --init --recursive
    - export RUST_FILES_MODIFIED=$(git --no-pager diff --name-only $CI_BUILD_REF^ $CI_BUILD_REF | grep -v -e ^js -e ^\\. -e ^LICENSE -e ^README.md -e ^appveyor.yml -e ^test.sh -e ^windows/ -e ^scripts/ -e^mac/ -e ^nsis/ | wc -l)
  script:
+    - rustup default nightly
    - export RUST_BACKTRACE=1
    - if [ $RUST_FILES_MODIFIED -eq 0 ]; then echo "Skipping Rust tests since no Rust files modified."; else ./test.sh $CARGOFLAGS; fi
  tags:
@@ -588,7 +627,7 @@ js-release:
    - beta
    - stable
    - tags
-  image: ethcore/rust:stable
+  image: parity/rust:gitlab-ci
  before_script:
    - export JS_FILES_MODIFIED=$(git --no-pager diff --name-only $CI_BUILD_REF^ $CI_BUILD_REF | grep ^js/ | wc -l)
    - echo $JS_FILES_MODIFIED
@@ -602,7 +641,7 @@ push-release:
  stage: push-release
  only:
    - tags
-  image: ethcore/rust:stable
+  image: parity/rust:gitlab-ci
  script:
    - curl --data "secret=$RELEASES_SECRET" http://update.parity.io:1337/push-release/$CI_BUILD_REF_NAME/$CI_BUILD_REF
    - curl --data "secret=$RELEASES_SECRET" http://update.parity.io:1338/push-release/$CI_BUILD_REF_NAME/$CI_BUILD_REF
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
--- a/Cargo.lock
+++ b/Cargo.lock
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 description = "Parity Ethereum client"
 name = "parity"
-version = "1.6.2"
+version = "1.6.8"
 license = "GPL-3.0"
 authors = ["Parity Technologies <admin@parity.io>"]

@@ -24,8 +24,8 @@ serde_json = "0.9"
 app_dirs = "1.1.1"
 fdlimit = "0.1"
 hyper = { default-features = false, git = "https://github.com/ethcore/hyper" }
-ctrlc = { git = "https://github.com/ethcore/rust-ctrlc.git" }
-jsonrpc-core = { git = "https://github.com/ethcore/jsonrpc.git" }
+ctrlc = { git = "https://github.com/paritytech/rust-ctrlc.git" }
+jsonrpc-core = { git = "https://github.com/paritytech/jsonrpc.git", branch = "parity-1.6" }
 ethsync = { path = "sync" }
 ethcore = { path = "ethcore" }
 ethcore-util = { path = "util" }
--- a/dapps/Cargo.toml
+++ b/dapps/Cargo.toml
@@ -12,8 +12,8 @@ rand = "0.3"
 log = "0.3"
 env_logger = "0.3"
 futures = "0.1"
-jsonrpc-core = { git = "https://github.com/ethcore/jsonrpc.git" }
-jsonrpc-http-server = { git = "https://github.com/ethcore/jsonrpc.git" }
+jsonrpc-core = { git = "https://github.com/paritytech/jsonrpc.git", branch = "parity-1.6" }
+jsonrpc-http-server = { git = "https://github.com/paritytech/jsonrpc.git", branch = "parity-1.6" }
 hyper = { default-features = false, git = "https://github.com/ethcore/hyper" }
 unicase = "1.3"
 url = "1.0"
@@ -22,7 +22,7 @@ serde = "0.9"
 serde_json = "0.9"
 serde_derive = "0.9"
 linked-hash-map = "0.3"
-parity-dapps-glue = "1.4"
+parity-dapps-glue = "1.7"
 base32 = "0.3"
 mime = "0.2"
 mime_guess = "1.6.1"
--- a/dapps/js-glue/Cargo.toml
+++ b/dapps/js-glue/Cargo.toml
@@ -7,17 +7,17 @@ authors = ["Parity Technologies <admin@parity.io>"]
 build = "build.rs"

 [build-dependencies]
-quasi_codegen = { version = "0.11", optional = true }
-syntex = { version = "0.33", optional = true }
+quasi_codegen = { version = "0.32", optional = true }
+syntex = { version = "0.58", optional = true }

 [dependencies]
 glob = { version = "0.2.11" }
 mime_guess = { version = "1.6.1" }
-aster = { version = "0.17", default-features = false }
-quasi = { version = "0.11", default-features = false }
-quasi_macros = { version = "0.11", optional = true }
-syntex = { version = "0.33", optional = true }
-syntex_syntax = { version = "0.33", optional = true }
+aster = { version = "0.41", default-features = false }
+quasi = { version = "0.32", default-features = false }
+quasi_macros = { version = "0.32", optional = true }
+syntex = { version = "0.58", optional = true }
+syntex_syntax = { version = "0.58", optional = true }
 clippy = { version = "0.0.90", optional = true }

 [features]
--- a/dapps/js-glue/build.rs
+++ b/dapps/js-glue/build.rs
@@ -25,13 +25,11 @@ mod inner {

 	pub fn main() {
 		let out_dir = env::var_os("OUT_DIR").unwrap();
-		let mut registry = syntex::Registry::new();
-		quasi_codegen::register(&mut registry);

 		let src = Path::new("src/lib.rs.in");
 		let dst = Path::new(&out_dir).join("lib.rs");

-		registry.expand("", &src, &dst).unwrap();
+		quasi_codegen::expand(&src, &dst).unwrap();
 	}
 }

--- a/dapps/js-glue/src/build.rs
+++ b/dapps/js-glue/src/build.rs
@@ -13,9 +13,8 @@ pub mod inner {

 		impl fold::Folder for StripAttributeFolder {
 			fn fold_attribute(&mut self, attr: ast::Attribute) -> Option<ast::Attribute> {
-				match attr.node.value.node {
-					ast::MetaItemKind::List(ref n, _) if n == &"webapp" => { return None; }
-					_ => {}
+				if &*attr.value.name.as_str() == "webapp" {
+					return None;
 				}

 				Some(attr)
--- a/dapps/js-glue/src/codegen.rs
+++ b/dapps/js-glue/src/codegen.rs
@@ -22,16 +22,12 @@ use self::mime_guess::guess_mime_type;
 use std::path::{self, Path, PathBuf};
 use std::ops::Deref;

-use syntax::ast::{MetaItem, Item};
-
-use syntax::ast;
 use syntax::attr;
+use syntax::ast::{self, MetaItem, Item};
 use syntax::codemap::Span;
 use syntax::ext::base::{Annotatable, ExtCtxt};
-use syntax::ptr::P;
-use syntax::print::pprust::{lit_to_string};
-use syntax::parse::token::{InternedString};
-
+use syntax::print::pprust::lit_to_string;
+use syntax::symbol::InternedString;

 pub fn expand_webapp_implementation(
 	cx: &mut ExtCtxt,
@@ -48,7 +44,7 @@ pub fn expand_webapp_implementation(
 		},
 	};
 	let builder = aster::AstBuilder::new().span(span);
-	implement_webapp(cx, &builder, &item, push);
+	implement_webapp(cx, &builder, item, push);
 }

 fn implement_webapp(cx: &ExtCtxt, builder: &aster::AstBuilder, item: &Item, push: &mut FnMut(Annotatable)) {
@@ -117,11 +113,12 @@ fn implement_webapp(cx: &ExtCtxt, builder: &aster::AstBuilder, item: &Item, push
 }

 fn extract_path(cx: &ExtCtxt, item: &Item) -> String {
-	for meta_items in item.attrs().iter().filter_map(webapp_meta_items) {
+	for meta_items in item.attrs.iter().filter_map(webapp_meta_items) {
 		for meta_item in meta_items {
+			let is_path = &*meta_item.name.as_str() == "path";
 			match meta_item.node {
-				ast::MetaItemKind::NameValue(ref name, ref lit) if name == &"path" => {
-					if let Some(s) = get_str_from_lit(cx, name, lit) {
+				ast::MetaItemKind::NameValue(ref lit) if is_path => {
+					if let Some(s) = get_str_from_lit(cx, lit) {
 						return s.deref().to_owned();
 					}
 				},
@@ -134,14 +131,32 @@ fn extract_path(cx: &ExtCtxt, item: &Item) -> String {
 	"web".to_owned()
 }

-fn get_str_from_lit(cx: &ExtCtxt, name: &str, lit: &ast::Lit) -> Option<InternedString> {
+fn webapp_meta_items(attr: &ast::Attribute) -> Option<Vec<ast::MetaItem>> {
+	let is_webapp = &*attr.value.name.as_str() == "webapp";
+	match attr.value.node {
+		ast::MetaItemKind::List(ref items) if is_webapp => {
+			attr::mark_used(&attr);
+			Some(
+				items.iter()
+				.map(|item| item.node.clone())
+				.filter_map(|item| match item {
+					ast::NestedMetaItemKind::MetaItem(item) => Some(item),
+					_ => None,
+				})
+				.collect()
+			)
+		}
+		_ => None
+	}
+}
+
+fn get_str_from_lit(cx: &ExtCtxt, lit: &ast::Lit) -> Option<InternedString> {
 	match lit.node {
-		ast::LitKind::Str(ref s, _) => Some(s.clone()),
+		ast::LitKind::Str(ref s, _) => Some(s.clone().as_str()),
 		_ => {
 			cx.span_err(
 				lit.span,
-				&format!("webapp annotation `{}` must be a string, not `{}`",
-					name,
+				&format!("webapp annotation path must be a string, not `{}`",
 					lit_to_string(lit)
 				)
 			);
@@ -150,16 +165,6 @@ fn get_str_from_lit(cx: &ExtCtxt, name: &str, lit: &ast::Lit) -> Option<Interned
 	}
 }

-fn webapp_meta_items(attr: &ast::Attribute) -> Option<&[P<ast::MetaItem>]> {
-	match attr.node.value.node {
-		ast::MetaItemKind::List(ref name, ref items) if name == &"webapp" => {
-			attr::mark_used(&attr);
-			Some(items)
-		}
-		_ => None
-	}
-}
-
 fn as_uri(path: &Path) -> String {
 	let mut s = String::new();
 	for component in path.iter() {
@@ -169,7 +174,6 @@ fn as_uri(path: &Path) -> String {
 	s[0..s.len()-1].into()
 }

-
 #[test]
 fn should_convert_path_separators_on_all_platforms() {
 	// given
--- a/dapps/js-glue/src/lib.rs
+++ b/dapps/js-glue/src/lib.rs
@@ -22,7 +22,6 @@
 extern crate syntex;

 #[cfg(feature = "with-syntex")]
-#[macro_use]
 extern crate syntex_syntax as syntax;

 #[cfg(feature = "with-syntex")]
--- a/dapps/ui/Cargo.toml
+++ b/dapps/ui/Cargo.toml
@@ -11,7 +11,7 @@ rustc_version = "0.1"

 [dependencies]
 parity-ui-dev = { path = "../../js", optional = true }
-parity-ui-precompiled = { git = "https://github.com/ethcore/js-precompiled.git", branch = "beta", optional = true }
+parity-ui-precompiled = { git = "https://github.com/paritytech/js-precompiled.git", branch = "beta", optional = true }

 [features]
 no-precompiled-js = ["parity-ui-dev"]
--- a/db/Cargo.toml
+++ b/db/Cargo.toml
@@ -14,10 +14,10 @@ ethcore-ipc-codegen = { path = "../ipc/codegen" }
 clippy = { version = "0.0.103", optional = true}
 ethcore-devtools = { path = "../devtools" }
 ethcore-ipc = { path = "../ipc/rpc" }
-rocksdb = { git = "https://github.com/ethcore/rust-rocksdb" }
+rocksdb = { git = "https://github.com/paritytech/rust-rocksdb" }
 semver = "0.5"
 ethcore-ipc-nano = { path = "../ipc/nano" }
-nanomsg = { git = "https://github.com/ethcore/nanomsg.rs.git" }
+nanomsg = { git = "https://github.com/paritytech/nanomsg.rs.git" }
 crossbeam = "0.2"
 ethcore-util = { path = "../util" }

--- a/docker/hub/Dockerfile
+++ b/docker/hub/Dockerfile
@@ -48,7 +48,7 @@ RUN apt-get update && \
 # show backtraces
 RUST_BACKTRACE=1 && \
 # build parity
- cd /build&&git clone https://github.com/ethcore/parity && \
+ cd /build&&git clone https://github.com/paritytech/parity && \
        cd parity && \
 	git pull&& \
 	git checkout $BUILD_TAG && \
--- a/ethcore/Cargo.toml
+++ b/ethcore/Cargo.toml
@@ -27,7 +27,8 @@ byteorder = "1.0"
 transient-hashmap = "0.1"
 linked-hash-map = "0.3.0"
 lru-cache = "0.1.0"
-ethabi = "1.0.0"
+itertools = "0.5"
+ethabi = "1.0"
 evmjit = { path = "../evmjit", optional = true }
 clippy = { version = "0.0.103", optional = true}
 ethash = { path = "../ethash" }
@@ -46,7 +47,7 @@ hardware-wallet = { path = "../hw" }
 stats = { path = "../util/stats" }

 [dependencies.hyper]
-git = "https://github.com/ethcore/hyper"
+git = "https://github.com/paritytech/hyper"
 default-features = false

 [features]
--- a/ethcore/res/authority_round.json
+++ b/ethcore/res/authority_round.json
@@ -33,7 +33,7 @@
 		"timestamp": "0x00",
 		"parentHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
 		"extraData": "0x",
-		"gasLimit": "0x2fefd8"
+		"gasLimit": "0x222222"
 	},
 	"accounts": {
 		"0000000000000000000000000000000000000001": { "balance": "1", "nonce": "1048576", "builtin": { "name": "ecrecover", "pricing": { "linear": { "base": 3000, "word": 0 } } } },
--- a/ethcore/res/ethereum/classic.json
+++ b/ethcore/res/ethereum/classic.json
@@ -53,7 +53,9 @@
 		"enode://5fbfb426fbb46f8b8c1bd3dd140f5b511da558cd37d60844b525909ab82e13a25ee722293c829e52cb65c2305b1637fa9a2ea4d6634a224d5f400bfe244ac0de@162.243.55.45:30303",
 		"enode://42d8f29d1db5f4b2947cd5c3d76c6d0d3697e6b9b3430c3d41e46b4bb77655433aeedc25d4b4ea9d8214b6a43008ba67199374a9b53633301bca0cd20c6928ab@104.155.176.151:30303",
 		"enode://814920f1ec9510aa9ea1c8f79d8b6e6a462045f09caa2ae4055b0f34f7416fca6facd3dd45f1cf1673c0209e0503f02776b8ff94020e98b6679a0dc561b4eba0@104.154.136.117:30303",
-		"enode://72e445f4e89c0f476d404bc40478b0df83a5b500d2d2e850e08eb1af0cd464ab86db6160d0fde64bd77d5f0d33507ae19035671b3c74fec126d6e28787669740@104.198.71.200:30303"
+		"enode://72e445f4e89c0f476d404bc40478b0df83a5b500d2d2e850e08eb1af0cd464ab86db6160d0fde64bd77d5f0d33507ae19035671b3c74fec126d6e28787669740@104.198.71.200:30303",
+		"enode://39abab9d2a41f53298c0c9dc6bbca57b0840c3ba9dccf42aa27316addc1b7e56ade32a0a9f7f52d6c5db4fe74d8824bcedfeaecf1a4e533cacb71cf8100a9442@144.76.238.49:30303",
+		"enode://f50e675a34f471af2438b921914b5f06499c7438f3146f6b8936f1faeb50b8a91d0d0c24fb05a66f05865cd58c24da3e664d0def806172ddd0d4c5bdbf37747e@144.76.238.49:30306"
 	],
 	"accounts": {
 		"0000000000000000000000000000000000000001": { "builtin": { "name": "ecrecover", "pricing": { "linear": { "base": 3000, "word": 0 } } } },
--- a/ethcore/res/ethereum/expanse.json
+++ b/ethcore/res/ethereum/expanse.json
@@ -15,11 +15,11 @@
 				"difficultyHardforkTransition": "0x59d9",
 				"difficultyHardforkBoundDivisor": "0x0200",
 				"bombDefuseTransition": "0x30d40",
-				"eip150Transition": "0x7fffffffffffffff",
-				"eip155Transition": "0x7fffffffffffffff",
-				"eip160Transition": "0x7fffffffffffffff",
-				"eip161abcTransition": "0x7fffffffffffffff",
-				"eip161dTransition": "0x7fffffffffffffff"
+				"eip150Transition": "0x927C0",
+				"eip155Transition": "0x927C0",
+				"eip160Transition": "0x927C0",
+				"eip161abcTransition": "0x927C0",
+				"eip161dTransition": "0x927C0"
 			}
 		}
 	},
@@ -28,6 +28,7 @@
 		"maximumExtraDataSize": "0x20",
 		"minGasLimit": "0x1388",
 		"networkID": "0x1",
+		"chainID": "0x2",
 		"subprotocolName": "exp",
 		"eip98Transition": "0x7fffffffffffff"
 	},
--- a/ethcore/res/ethereum/kovan.json
+++ b/ethcore/res/ethereum/kovan.json
@@ -23,14 +23,18 @@

            "0x00a0a24b9f0e5ec7aa4c7389b8302fd0123194de"
          ]
-        }
+        },
+        "validateScoreTransition": 1000000,
+        "eip155Transition": 1000000,
+        "validateStepTransition": 1500000
      }
    }
  },
  "params": {
    "maximumExtraDataSize": "0x20",
    "minGasLimit": "0x1388",
-    "networkID" : "0x2A"
+    "networkID" : "0x2A",
+    "validateReceiptsTransition" : 1000000
  },
  "genesis": {
    "seal": {
--- a/ethcore/res/ethereum/ropsten.json
+++ b/ethcore/res/ethereum/ropsten.json
@@ -25,8 +25,8 @@
 		"maximumExtraDataSize": "0x20",
 		"minGasLimit": "0x1388",
 		"networkID" : "0x3",
-		"forkBlock": 333922,
-		"forkCanonHash": "0x8737eb141d4f05db57af63fc8d3b4d4d8f9cddb0c4e1ab855de8c288fdc1924f",
+		"forkBlock": 641350,
+		"forkCanonHash": "0x8033403e9fe5811a7b6d6b469905915de1c59207ce2172cbcf5d6ff14fa6a2eb",
 		"eip98Transition": "0x7fffffffffffff"
 	},
 	"genesis": {
@@ -44,11 +44,8 @@
 		"gasLimit": "0x1000000"
 	},
 	"nodes": [
-		"enode://a22f0977ce02653bf95e38730106356342df48b5222e2c2a1a6f9ef34769bf593bae9ca0a888cf60839edd52efc1b6e393c63a57d76f4c4fe14e641f1f9e637e@128.199.55.137:30303",
-		"enode://012239fccf3ff1d92b036983a430cb6705c6528c96c0354413f8854802138e5135c084ab36e7c54efb621c46728df8c3a6f4c1db9bb48a1330efe3f82f2dd7a6@52.169.94.142:30303",
-		"enode://1462682e4b7ba2258346d55e25e5b9d264b0db40cee12bdfba4e72b1d7050350ea954c006e9106dd96a128e6e0bd6dffb17eed51f9f99bf7f9cdadfeaf8da4ff@51.15.61.253:30303",
-		"enode://98fbb020c799ae39a828bd75dc2bd5d4721539faf317076b275f91182a5c8900b592e8abfdddceae674a7c3bb40ea00a6ca9ccb7805ab58c4b7b29c61c8f7239@51.15.62.44:30303",
-		"enode://d801dd4e3d15a8bf785931add164bd9c313e3f6b5749d9302b311f2b48064cba5c86c32b1302c27cd983fc89ae07d4d306dd1197610835b8782e95dfb1b3f9ea@51.15.43.255:30303"
+		"enode://20c9ad97c081d63397d7b685a412227a40e23c8bdc6688c6f37e97cfbc22d2b4d1db1510d8f61e6a8866ad7f0e17c02b14182d37ea7c3c8b9c2683aeb6b733a1@52.169.14.227:30303",
+		"enode://6ce05930c72abc632c58e2e4324f7c7ea478cec0ed4fa2528982cf34483094e9cbc9216e7aa349691242576d552a2a56aaeae426c5303ded677ce455ba1acd9d@13.84.180.240:30303"
 	],
 	"accounts": {
 		"0000000000000000000000000000000000000001": { "balance": "1", "nonce": "0", "builtin": { "name": "ecrecover", "pricing": { "linear": { "base": 3000, "word": 0 } } } },
--- a/ethcore/res/ethereum/tests
+++ b/ethcore/res/ethereum/tests
--- a/ethcore/res/ethereum/transition_test.json
+++ b/ethcore/res/ethereum/transition_test.json
@@ -139,6 +139,7 @@
 		}
 	},
 	"params": {
+		"eip98Transition": "0x7fffffffffffffff",
 		"accountStartNonce": "0x00",
 		"maximumExtraDataSize": "0x20",
 		"minGasLimit": "0x1388",
--- a/ethcore/res/tendermint.json
+++ b/ethcore/res/tendermint.json
@@ -38,7 +38,7 @@
 		"timestamp": "0x00",
 		"parentHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
 		"extraData": "0x",
-		"gasLimit": "0x2fefd8"
+		"gasLimit": "0x222222"
 	},
 	"accounts": {
 		"0000000000000000000000000000000000000001": { "balance": "1", "builtin": { "name": "ecrecover", "pricing": { "linear": { "base": 3000, "word": 0 } } } },
--- a/ethcore/res/validator_contract.json
+++ b/ethcore/res/validator_contract.json
@@ -27,7 +27,7 @@
 		"timestamp": "0x00",
 		"parentHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
 		"extraData": "0x",
-		"gasLimit": "0x2fefd8"
+		"gasLimit": "0x222222"
 	},
 	"accounts": {
 		"0000000000000000000000000000000000000001": { "balance": "1", "builtin": { "name": "ecrecover", "pricing": { "linear": { "base": 3000, "word": 0 } } } },
--- a/ethcore/res/validator_multi.json
+++ b/ethcore/res/validator_multi.json
@@ -0,0 +1,42 @@
+{
+	"name": "TestMutiValidator",
+	"engine": {
+		"basicAuthority": {
+			"params": {
+				"gasLimitBoundDivisor": "0x0400",
+				"durationLimit": "0x0d",
+				"validators": {
+					"multi": {
+						"0": { "list": ["0x82a978b3f5962a5b0957d9ee9eef472ee55b42f1"] },
+						"2": { "list": ["0x7d577a597b2742b498cb5cf0c26cdcd726d39e6e"] }
+					}
+				}
+			}
+		}
+	},
+	"params": {
+		"accountStartNonce": "0x0",
+		"maximumExtraDataSize": "0x20",
+		"minGasLimit": "0x1388",
+		"networkID" : "0x69"
+	},
+	"genesis": {
+		"seal": {
+			"generic": "0xc180"
+		},
+		"difficulty": "0x20000",
+		"author": "0x0000000000000000000000000000000000000000",
+		"timestamp": "0x00",
+		"parentHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
+		"extraData": "0x",
+		"gasLimit": "0x2fefd8"
+	},
+	"accounts": {
+		"0000000000000000000000000000000000000001": { "balance": "1", "builtin": { "name": "ecrecover", "pricing": { "linear": { "base": 3000, "word": 0 } } } },
+		"0000000000000000000000000000000000000002": { "balance": "1", "builtin": { "name": "sha256", "pricing": { "linear": { "base": 60, "word": 12 } } } },
+		"0000000000000000000000000000000000000003": { "balance": "1", "builtin": { "name": "ripemd160", "pricing": { "linear": { "base": 600, "word": 120 } } } },
+		"0000000000000000000000000000000000000004": { "balance": "1", "builtin": { "name": "identity", "pricing": { "linear": { "base": 15, "word": 3 } } } },
+		"0x82a978b3f5962a5b0957d9ee9eef472ee55b42f1": { "balance": "99999999999999999999999" },
+		"0x7d577a597b2742b498cb5cf0c26cdcd726d39e6e": { "balance": "99999999999999999999999" }
+	}
+}
--- a/ethcore/src/account_provider/mod.rs
+++ b/ethcore/src/account_provider/mod.rs
@@ -123,6 +123,8 @@ pub struct AccountProvider {
 	transient_sstore: EthMultiStore,
 	/// Accounts in hardware wallets.
 	hardware_store: Option<HardwareWalletManager>,
+	/// Disallowed accounts.
+	blacklisted_accounts: Vec<Address>,
 }

 /// Account management settings.
@@ -131,6 +133,8 @@ pub struct AccountProviderSettings {
 	pub enable_hardware_wallets: bool,
 	/// Use the classic chain key on the hardware wallet.
 	pub hardware_wallet_classic_key: bool,
+	/// Disallowed accounts.
+	pub blacklisted_accounts: Vec<Address>,
 }

 impl Default for AccountProviderSettings {
@@ -138,6 +142,7 @@ impl Default for AccountProviderSettings {
 		AccountProviderSettings {
 			enable_hardware_wallets: false,
 			hardware_wallet_classic_key: false,
+			blacklisted_accounts: vec![],
 		}
 	}
 }
@@ -155,13 +160,21 @@ impl AccountProvider {
 				Err(e) => debug!("Error initializing hardware wallets: {}", e),
 			}
 		}
+
+		// Remove blacklisted accounts from address book.
+		let mut address_book = AddressBook::new(&sstore.local_path());
+		for addr in &settings.blacklisted_accounts {
+			address_book.remove(*addr);
+		}
+
 		AccountProvider {
 			unlocked: RwLock::new(HashMap::new()),
-			address_book: RwLock::new(AddressBook::new(&sstore.local_path())),
+			address_book: RwLock::new(address_book),
 			dapps_settings: RwLock::new(DappsSettingsStore::new(&sstore.local_path())),
 			sstore: sstore,
 			transient_sstore: transient_sstore(),
 			hardware_store: hardware_store,
+			blacklisted_accounts: settings.blacklisted_accounts,
 		}
 	}

@@ -174,6 +187,7 @@ impl AccountProvider {
 			sstore: Box::new(EthStore::open(Box::new(MemoryDirectory::default())).expect("MemoryDirectory load always succeeds; qed")),
 			transient_sstore: transient_sstore(),
 			hardware_store: None,
+			blacklisted_accounts: vec![],
 		}
 	}

@@ -195,6 +209,10 @@ impl AccountProvider {
 	/// Does not unlock account!
 	pub fn insert_account(&self, secret: Secret, password: &str) -> Result<Address, Error> {
 		let account = self.sstore.insert_account(SecretVaultRef::Root, secret, password)?;
+		if self.blacklisted_accounts.contains(&account.address) {
+			self.sstore.remove_account(&account, password)?;
+			return Err(SSError::InvalidAccount.into());
+		}
 		Ok(account.address)
 	}

@@ -221,6 +239,10 @@ impl AccountProvider {
 	/// Import a new presale wallet.
 	pub fn import_wallet(&self, json: &[u8], password: &str) -> Result<Address, Error> {
 		let account = self.sstore.import_wallet(SecretVaultRef::Root, json, password)?;
+		if self.blacklisted_accounts.contains(&account.address) {
+			self.sstore.remove_account(&account, password)?;
+			return Err(SSError::InvalidAccount.into());
+		}
 		Ok(Address::from(account.address).into())
 	}

@@ -232,7 +254,12 @@ impl AccountProvider {
 	/// Returns addresses of all accounts.
 	pub fn accounts(&self) -> Result<Vec<Address>, Error> {
 		let accounts = self.sstore.accounts()?;
-		Ok(accounts.into_iter().map(|a| a.address).collect())
+		Ok(accounts
+		   .into_iter()
+		   .map(|a| a.address)
+		   .filter(|address| !self.blacklisted_accounts.contains(address))
+		   .collect()
+		)
 	}

 	/// Returns addresses of hardware accounts.
@@ -434,6 +461,7 @@ impl AccountProvider {
 	pub fn accounts_info(&self) -> Result<HashMap<Address, AccountMeta>, Error> {
 		let r = self.sstore.accounts()?
 			.into_iter()
+			.filter(|a| !self.blacklisted_accounts.contains(&a.address))
 			.map(|a| (a.address.clone(), self.account_meta(a.address).ok().unwrap_or_default()))
 			.collect();
 		Ok(r)
@@ -712,7 +740,7 @@ impl AccountProvider {
 mod tests {
 	use super::{AccountProvider, Unlock, DappId};
 	use std::time::Instant;
-	use ethstore::ethkey::{Generator, Random};
+	use ethstore::ethkey::{Generator, Random, Address};
 	use ethstore::{StoreAccountRef, Derivation};
 	use util::H256;

@@ -927,4 +955,16 @@ mod tests {
 		assert_eq!(ap.new_dapps_default_address().unwrap(), address);
 		assert_eq!(ap.dapp_default_address("app1".into()).unwrap(), address);
 	}
+
+	#[test]
+	fn should_not_return_blacklisted_account() {
+		// given
+		let mut ap = AccountProvider::transient_provider();
+		let acc = ap.new_account("test").unwrap();
+		ap.blacklisted_accounts = vec![acc];
+
+		// then
+		assert_eq!(ap.accounts_info().unwrap().keys().cloned().collect::<Vec<Address>>(), vec![]);
+		assert_eq!(ap.accounts().unwrap(), vec![]);
+	}
 }
--- a/ethcore/src/block.rs
+++ b/ethcore/src/block.rs
@@ -493,6 +493,16 @@ impl LockedBlock {
 			_ => Ok(SealedBlock { block: s.block, uncle_bytes: s.uncle_bytes }),
 		}
 	}
+
+	/// Remove state root from transaction receipts to make them EIP-98 compatible.
+	pub fn strip_receipts(self) -> LockedBlock {
+		let mut block = self;
+		for receipt in &mut block.block.receipts {
+			receipt.state_root = None;
+		}
+		block.block.header.set_receipts_root(ordered_trie_root(block.block.receipts.iter().map(|r| r.rlp_bytes().to_vec())));
+		block
+	}
 }

 impl Drain for LockedBlock {
@@ -553,7 +563,6 @@ pub fn enact(
 	b.set_extra_data(header.extra_data().clone()).unwrap_or_else(|e| warn!("Couldn't set extradata: {}. Ignoring.", e));
 	b.set_uncles_hash(header.uncles_hash().clone());
 	b.set_transactions_root(header.transactions_root().clone());
-	b.set_receipts_root(header.receipts_root().clone());

 	push_transactions(&mut b, transactions)?;
 	for u in uncles {
--- a/ethcore/src/client/client.rs
+++ b/ethcore/src/client/client.rs
@@ -253,7 +253,7 @@ impl Client {
 		if let Some(reg_addr) = client.additional_params().get("registrar").and_then(|s| Address::from_str(s).ok()) {
 			trace!(target: "client", "Found registrar at {}", reg_addr);
 			let weak = Arc::downgrade(&client);
-			let registrar = Registry::new(reg_addr, move |a, d| weak.upgrade().ok_or("No client!".into()).and_then(|c| c.call_contract(a, d)));
+			let registrar = Registry::new(reg_addr, move |a, d| weak.upgrade().ok_or("No client!".into()).and_then(|c| c.call_contract(BlockId::Latest, a, d)));
 			*client.registrar.lock() = Some(registrar);
 		}
 		Ok(client)
@@ -355,7 +355,7 @@ impl Client {
 		let chain = self.chain.read();
 		// Check the block isn't so old we won't be able to enact it.
 		let best_block_number = chain.best_block_number();
-		if best_block_number >= self.history && header.number() <= best_block_number - self.history {
+		if self.pruning_info().earliest_state > header.number() {
 			warn!(target: "client", "Block import failed for #{} ({})\nBlock is ancient (current best block: #{}).", header.number(), header.hash(), best_block_number);
 			return Err(());
 		}
@@ -375,10 +375,14 @@ impl Client {
 			let db = self.state_db.lock().boxed_clone_canon(header.parent_hash());

 			let enact_result = enact_verified(block, engine, self.tracedb.read().tracing_enabled(), db, &parent, last_hashes, self.factories.clone());
-			let locked_block = enact_result.map_err(|e| {
+			let mut locked_block = enact_result.map_err(|e| {
 				warn!(target: "client", "Block import failed for #{} ({})\nError: {:?}", header.number(), header.hash(), e);
 			})?;

+			if header.number() < self.engine().params().validate_receipts_transition && header.receipts_root() != locked_block.block().header().receipts_root() {
+				locked_block = locked_block.strip_receipts();
+			}
+	
 			// Final Verification
 			if let Err(e) = self.verifier.verify_block_final(header, locked_block.block().header()) {
 				warn!(target: "client", "Stage 4 block verification failed for #{} ({})\nError: {:?}", header.number(), header.hash(), e);
@@ -673,7 +677,7 @@ impl Client {
 			let db = self.state_db.lock().boxed_clone();

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

@@ -774,7 +778,7 @@ impl Client {
 		let best_block_number = self.chain_info().best_block_number;
 		let block_number = self.block_number(at).ok_or(snapshot::Error::InvalidStartingBlock(at))?;

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

@@ -1445,7 +1449,7 @@ impl BlockChainClient for Client {
 		}
 	}

-	fn call_contract(&self, address: Address, data: Bytes) -> Result<Bytes, String> {
+	fn call_contract(&self, block_id: BlockId, address: Address, data: Bytes) -> Result<Bytes, String> {
 		let from = Address::default();
 		let transaction = Transaction {
 			nonce: self.latest_nonce(&from),
@@ -1456,7 +1460,7 @@ impl BlockChainClient for Client {
 			data: data,
 		}.fake_sign(from);

-		self.call(&transaction, BlockId::Latest, Default::default())
+		self.call(&transaction, block_id, Default::default())
 			.map_err(|e| format!("{:?}", e))
 			.map(|executed| {
 				executed.output
--- a/ethcore/src/client/test_client.rs
+++ b/ethcore/src/client/test_client.rs
@@ -731,7 +731,7 @@ impl BlockChainClient for TestBlockChainClient {
 		}
 	}

-	fn call_contract(&self, _address: Address, _data: Bytes) -> Result<Bytes, String> { Ok(vec![]) }
+	fn call_contract(&self, _id: BlockId, _address: Address, _data: Bytes) -> Result<Bytes, String> { Ok(vec![]) }

 	fn transact_contract(&self, address: Address, data: Bytes) -> Result<TransactionImportResult, EthcoreError> {
 		let transaction = Transaction {
--- a/ethcore/src/client/traits.rs
+++ b/ethcore/src/client/traits.rs
@@ -254,7 +254,7 @@ pub trait BlockChainClient : Sync + Send {
 	fn pruning_info(&self) -> PruningInfo;

 	/// Like `call`, but with various defaults. Designed to be used for calling contracts.
-	fn call_contract(&self, address: Address, data: Bytes) -> Result<Bytes, String>;
+	fn call_contract(&self, id: BlockId, address: Address, data: Bytes) -> Result<Bytes, String>;

 	/// Import a transaction: used for misbehaviour reporting.
 	fn transact_contract(&self, address: Address, data: Bytes) -> Result<TransactionImportResult, EthcoreError>;
--- a/ethcore/src/engines/authority_round.rs
+++ b/ethcore/src/engines/authority_round.rs
@@ -27,12 +27,13 @@ use block::*;
 use spec::CommonParams;
 use engines::{Engine, Seal, EngineError};
 use header::Header;
-use error::{Error, BlockError};
+use error::{Error, TransactionError, BlockError};
 use evm::Schedule;
 use ethjson;
 use io::{IoContext, IoHandler, TimerToken, IoService};
 use env_info::EnvInfo;
 use builtin::Builtin;
+use transaction::UnverifiedTransaction;
 use client::{Client, EngineClient};
 use state::CleanupMode;
 use super::signer::EngineSigner;
@@ -53,6 +54,12 @@ pub struct AuthorityRoundParams {
 	pub start_step: Option<u64>,
 	/// Valid validators.
 	pub validators: ethjson::spec::ValidatorSet,
+	/// Chain score validation transition block.
+	pub validate_score_transition: u64,
+	/// Number of first block where EIP-155 rules are validated.
+	pub eip155_transition: u64,
+	/// Monotonic step validation transition block.
+	pub validate_step_transition: u64,
 }

 impl From<ethjson::spec::AuthorityRoundParams> for AuthorityRoundParams {
@@ -64,6 +71,9 @@ impl From<ethjson::spec::AuthorityRoundParams> for AuthorityRoundParams {
 			block_reward: p.block_reward.map_or_else(U256::zero, Into::into),
 			registrar: p.registrar.map_or_else(Address::new, Into::into),
 			start_step: p.start_step.map(Into::into),
+			validate_score_transition: p.validate_score_transition.map_or(0, Into::into),
+			eip155_transition: p.eip155_transition.map_or(0, Into::into),
+			validate_step_transition: p.validate_step_transition.map_or(0, Into::into),
 		}
 	}
 }
@@ -82,9 +92,12 @@ pub struct AuthorityRound {
 	proposed: AtomicBool,
 	client: RwLock<Option<Weak<EngineClient>>>,
 	signer: EngineSigner,
-	validators: Box<ValidatorSet + Send + Sync>,
+	validators: Box<ValidatorSet>,
 	/// Is this Engine just for testing (prevents step calibration).
 	calibrate_step: bool,
+	validate_score_transition: u64,
+	eip155_transition: u64,
+	validate_step_transition: u64,
 }

 fn header_step(header: &Header) -> Result<usize, ::rlp::DecoderError> {
@@ -125,6 +138,9 @@ impl AuthorityRound {
 				signer: Default::default(),
 				validators: new_validator_set(our_params.validators),
 				calibrate_step: our_params.start_step.is_none(),
+				validate_score_transition: our_params.validate_score_transition,
+				eip155_transition: our_params.eip155_transition,
+				validate_step_transition: our_params.validate_step_transition,
 			});
 		// Do not initialize timeouts for tests.
 		if should_timeout {
@@ -150,12 +166,12 @@ impl AuthorityRound {
 		}
 	}

-	fn step_proposer(&self, step: usize) -> Address {
-		self.validators.get(step)
+	fn step_proposer(&self, bh: &H256, step: usize) -> Address {
+		self.validators.get(bh, step)
 	}

-	fn is_step_proposer(&self, step: usize, address: &Address) -> bool {
-		self.step_proposer(step) == *address
+	fn is_step_proposer(&self, bh: &H256, step: usize, address: &Address) -> bool {
+		self.step_proposer(bh, step) == *address
 	}

 	fn is_future_step(&self, step: usize) -> bool {
@@ -249,7 +265,7 @@ impl Engine for AuthorityRound {
 	}

 	fn seals_internally(&self) -> Option<bool> {
-		Some(self.validators.contains(&self.signer.address()))
+		Some(self.signer.address() != Address::default())
 	}

 	/// Attempt to seal the block internally.
@@ -260,7 +276,7 @@ impl Engine for AuthorityRound {
 		if self.proposed.load(AtomicOrdering::SeqCst) { return Seal::None; }
 		let header = block.header();
 		let step = self.step.load(AtomicOrdering::SeqCst);
-		if self.is_step_proposer(step, header.author()) {
+		if self.is_step_proposer(header.parent_hash(), step, header.author()) {
 			if let Ok(signature) = self.signer.sign(header.bare_hash()) {
 				trace!(target: "engine", "generate_seal: Issuing a block for step {}.", step);
 				self.proposed.store(true, AtomicOrdering::SeqCst);
@@ -294,40 +310,47 @@ impl Engine for AuthorityRound {
 			Err(From::from(BlockError::InvalidSealArity(
 				Mismatch { expected: self.seal_fields(), found: header.seal().len() }
 			)))
+		} else if header.number() >= self.validate_score_transition && *header.difficulty() >= U256::from(U128::max_value()) {
+			Err(From::from(BlockError::DifficultyOutOfBounds(
+				OutOfBounds { min: None, max: Some(U256::from(U128::max_value())), found: *header.difficulty() }
+			)))
 		} else {
 			Ok(())
 		}
 	}

-	/// Check if the signature belongs to the correct proposer.
-	fn verify_block_unordered(&self, header: &Header, _block: Option<&[u8]>) -> Result<(), Error> {
-		let header_step = header_step(header)?;
+	fn verify_block_unordered(&self, _header: &Header, _block: Option<&[u8]>) -> Result<(), Error> {
+		Ok(())
+	}
+
+	/// Do the validator and gas limit validation.
+	fn verify_block_family(&self, header: &Header, parent: &Header, _block: Option<&[u8]>) -> Result<(), Error> {
+		let step = header_step(header)?;
 		// Give one step slack if step is lagging, double vote is still not possible.
-		if self.is_future_step(header_step) {
+		if self.is_future_step(step) {
 			trace!(target: "engine", "verify_block_unordered: block from the future");
 			self.validators.report_benign(header.author());
 			Err(BlockError::InvalidSeal)?
 		} else {
+			// Check if the signature belongs to a validator, can depend on parent state.
 			let proposer_signature = header_signature(header)?;
-			let correct_proposer = self.step_proposer(header_step);
-			if verify_address(&correct_proposer, &proposer_signature, &header.bare_hash())? {
-				Ok(())
-			} else {
-				trace!(target: "engine", "verify_block_unordered: bad proposer for step: {}", header_step);
+			let correct_proposer = self.step_proposer(header.parent_hash(), step);
+			if !verify_address(&correct_proposer, &proposer_signature, &header.bare_hash())? {
+				trace!(target: "engine", "verify_block_unordered: bad proposer for step: {}", step);
 				Err(EngineError::NotProposer(Mismatch { expected: correct_proposer, found: header.author().clone() }))?
 			}
 		}
-	}

-	fn verify_block_family(&self, header: &Header, parent: &Header, _block: Option<&[u8]>) -> Result<(), Error> {
+		// Do not calculate difficulty for genesis blocks.
 		if header.number() == 0 {
 			return Err(From::from(BlockError::RidiculousNumber(OutOfBounds { min: Some(1), max: None, found: header.number() })));
 		}

-		let step = header_step(header)?;
 		// Check if parent is from a previous step.
-		if step == header_step(parent)? {
-			trace!(target: "engine", "Multiple blocks proposed for step {}.", step);
+		let parent_step = header_step(parent)?;
+		if step == parent_step
+			|| (header.number() >= self.validate_step_transition && step <= parent_step) {
+			trace!(target: "engine", "Multiple blocks proposed for step {}.", parent_step);
 			self.validators.report_malicious(header.author());
 			Err(EngineError::DoubleVote(header.author().clone()))?;
 		}
@@ -341,6 +364,18 @@ impl Engine for AuthorityRound {
 		Ok(())
 	}

+	fn verify_transaction_basic(&self, t: &UnverifiedTransaction, header: &Header) -> result::Result<(), Error> {
+		t.check_low_s()?;
+
+		if let Some(n) = t.network_id() {
+			if header.number() >= self.eip155_transition && n != self.params().chain_id {
+				return Err(TransactionError::InvalidNetworkId.into());
+			}
+		}
+
+		Ok(())
+	}
+
 	fn register_client(&self, client: Weak<Client>) {
 		*self.client.write() = Some(client.clone());
 		self.validators.register_contract(client);
@@ -412,7 +447,7 @@ mod tests {
 		let mut header: Header = Header::default();
 		header.set_seal(vec![encode(&H520::default()).to_vec()]);

-		let verify_result = engine.verify_block_unordered(&header, None);
+		let verify_result = engine.verify_block_family(&header, &Default::default(), None);
 		assert!(verify_result.is_err());
 	}

@@ -450,10 +485,14 @@ mod tests {

 	#[test]
 	fn proposer_switching() {
-		let mut header: Header = Header::default();
 		let tap = AccountProvider::transient_provider();
 		let addr = tap.insert_account(Secret::from_slice(&"0".sha3()).unwrap(), "0").unwrap();
-
+		let mut parent_header: Header = Header::default();
+		parent_header.set_seal(vec![encode(&0usize).to_vec()]);
+		parent_header.set_gas_limit(U256::from_str("222222").unwrap());
+		let mut header: Header = Header::default();
+		header.set_number(1);
+		header.set_gas_limit(U256::from_str("222222").unwrap());
 		header.set_author(addr);

 		let engine = Spec::new_test_round().engine;
@@ -462,17 +501,22 @@ mod tests {
 		// Two validators.
 		// Spec starts with step 2.
 		header.set_seal(vec![encode(&2usize).to_vec(), encode(&(&*signature as &[u8])).to_vec()]);
-		assert!(engine.verify_block_seal(&header).is_err());
+		assert!(engine.verify_block_family(&header, &parent_header, None).is_err());
 		header.set_seal(vec![encode(&1usize).to_vec(), encode(&(&*signature as &[u8])).to_vec()]);
-		assert!(engine.verify_block_seal(&header).is_ok());
+		assert!(engine.verify_block_family(&header, &parent_header, None).is_ok());
 	}

 	#[test]
 	fn rejects_future_block() {
-		let mut header: Header = Header::default();
 		let tap = AccountProvider::transient_provider();
 		let addr = tap.insert_account(Secret::from_slice(&"0".sha3()).unwrap(), "0").unwrap();

+		let mut parent_header: Header = Header::default();
+		parent_header.set_seal(vec![encode(&0usize).to_vec()]);
+		parent_header.set_gas_limit(U256::from_str("222222").unwrap());
+		let mut header: Header = Header::default();
+		header.set_number(1);
+		header.set_gas_limit(U256::from_str("222222").unwrap());
 		header.set_author(addr);

 		let engine = Spec::new_test_round().engine;
@@ -481,8 +525,8 @@ mod tests {
 		// Two validators.
 		// Spec starts with step 2.
 		header.set_seal(vec![encode(&1usize).to_vec(), encode(&(&*signature as &[u8])).to_vec()]);
-		assert!(engine.verify_block_seal(&header).is_ok());
+		assert!(engine.verify_block_family(&header, &parent_header, None).is_ok());
 		header.set_seal(vec![encode(&5usize).to_vec(), encode(&(&*signature as &[u8])).to_vec()]);
-		assert!(engine.verify_block_seal(&header).is_err());
+		assert!(engine.verify_block_family(&header, &parent_header, None).is_err());
 	}
 }
--- a/ethcore/src/engines/basic_authority.rs
+++ b/ethcore/src/engines/basic_authority.rs
@@ -58,7 +58,7 @@ pub struct BasicAuthority {
 	gas_limit_bound_divisor: U256,
 	builtins: BTreeMap<Address, Builtin>,
 	signer: EngineSigner,
-	validators: Box<ValidatorSet + Send + Sync>,
+	validators: Box<ValidatorSet>,
 }

 impl BasicAuthority {
@@ -104,14 +104,14 @@ impl Engine for BasicAuthority {
 	}

 	fn seals_internally(&self) -> Option<bool> {
-		Some(self.validators.contains(&self.signer.address()))
+		Some(self.signer.address() != Address::default())
 	}

 	/// Attempt to seal the block internally.
 	fn generate_seal(&self, block: &ExecutedBlock) -> Seal {
 		let header = block.header();
 		let author = header.author();
-		if self.validators.contains(author) {
+		if self.validators.contains(header.parent_hash(), author) {
 			// account should be pernamently unlocked, otherwise sealing will fail
 			if let Ok(signature) = self.signer.sign(header.bare_hash()) {
 				return Seal::Regular(vec![::rlp::encode(&(&H520::from(signature) as &[u8])).to_vec()]);
@@ -133,20 +133,20 @@ impl Engine for BasicAuthority {
 		Ok(())
 	}

-	fn verify_block_unordered(&self, header: &Header, _block: Option<&[u8]>) -> result::Result<(), Error> {
-		use rlp::{UntrustedRlp, View};
-
-		// check the signature is legit.
-		let sig = UntrustedRlp::new(&header.seal()[0]).as_val::<H520>()?;
-		let signer = public_to_address(&recover(&sig.into(), &header.bare_hash())?);
-		if !self.validators.contains(&signer) {
-			return Err(BlockError::InvalidSeal)?;
-		}
+	fn verify_block_unordered(&self, _header: &Header, _block: Option<&[u8]>) -> result::Result<(), Error> {
 		Ok(())
 	}

 	fn verify_block_family(&self, header: &Header, parent: &Header, _block: Option<&[u8]>) -> result::Result<(), Error> {
-		// we should not calculate difficulty for genesis blocks
+		use rlp::{UntrustedRlp, View};
+		// Check if the signature belongs to a validator, can depend on parent state.
+		let sig = UntrustedRlp::new(&header.seal()[0]).as_val::<H520>()?;
+		let signer = public_to_address(&recover(&sig.into(), &header.bare_hash())?);
+		if !self.validators.contains(header.parent_hash(), &signer) {
+			return Err(BlockError::InvalidSeal)?;
+		}
+
+		// Do not calculate difficulty for genesis blocks.
 		if header.number() == 0 {
 			return Err(From::from(BlockError::RidiculousNumber(OutOfBounds { min: Some(1), max: None, found: header.number() })));
 		}
@@ -239,7 +239,7 @@ mod tests {
 		let mut header: Header = Header::default();
 		header.set_seal(vec![::rlp::encode(&H520::default()).to_vec()]);

-		let verify_result = engine.verify_block_unordered(&header, None);
+		let verify_result = engine.verify_block_family(&header, &Default::default(), None);
 		assert!(verify_result.is_err());
 	}

--- a/ethcore/src/engines/mod.rs
+++ b/ethcore/src/engines/mod.rs
@@ -39,7 +39,7 @@ use account_provider::AccountProvider;
 use block::ExecutedBlock;
 use builtin::Builtin;
 use env_info::EnvInfo;
-use error::Error;
+use error::{Error, TransactionError};
 use spec::CommonParams;
 use evm::Schedule;
 use header::Header;
@@ -157,6 +157,13 @@ pub trait Engine : Sync + Send {
 	// TODO: consider including State in the params.
 	fn verify_transaction_basic(&self, t: &UnverifiedTransaction, _header: &Header) -> Result<(), Error> {
 		t.check_low_s()?;
+
+		if let Some(n) = t.network_id() {
+			if n != self.params().chain_id {
+				return Err(TransactionError::InvalidNetworkId.into());
+			}
+		}
+
 		Ok(())
 	}

--- a/ethcore/src/engines/tendermint/mod.rs
+++ b/ethcore/src/engines/tendermint/mod.rs
@@ -95,8 +95,10 @@ pub struct Tendermint {
 	last_lock: AtomicUsize,
 	/// Bare hash of the proposed block, used for seal submission.
 	proposal: RwLock<Option<H256>>,
+	/// Hash of the proposal parent block.
+	proposal_parent: RwLock<H256>,
 	/// Set used to determine the current validators.
-	validators: Box<ValidatorSet + Send + Sync>,
+	validators: Box<ValidatorSet>,
 }

 impl Tendermint {
@@ -114,11 +116,12 @@ impl Tendermint {
 				height: AtomicUsize::new(1),
 				view: AtomicUsize::new(0),
 				step: RwLock::new(Step::Propose),
-				votes: VoteCollector::default(),
+				votes: Default::default(),
 				signer: Default::default(),
 				lock_change: RwLock::new(None),
 				last_lock: AtomicUsize::new(0),
 				proposal: RwLock::new(None),
+				proposal_parent: Default::default(),
 				validators: new_validator_set(our_params.validators),
 			});
 		let handler = TransitionHandler::new(Arc::downgrade(&engine) as Weak<Engine>, Box::new(our_params.timeouts));
@@ -232,7 +235,7 @@ impl Tendermint {
 				let height = self.height.load(AtomicOrdering::SeqCst);
 				if let Some(block_hash) = *self.proposal.read() {
 					// Generate seal and remove old votes.
-					if self.is_signer_proposer() {
+					if self.is_signer_proposer(&*self.proposal_parent.read()) {
 						let proposal_step = VoteStep::new(height, view, Step::Propose);
 						let precommit_step = VoteStep::new(proposal_step.height, proposal_step.view, Step::Precommit);
 						if let Some(seal) = self.votes.seal_signatures(proposal_step, precommit_step, &block_hash) {
@@ -254,23 +257,23 @@ impl Tendermint {
 	}

 	fn is_authority(&self, address: &Address) -> bool {
-		self.validators.contains(address)
+		self.validators.contains(&*self.proposal_parent.read(), address)
 	}

 	fn is_above_threshold(&self, n: usize) -> bool {
-		n > self.validators.count() * 2/3
+		n > self.validators.count(&*self.proposal_parent.read()) * 2/3
 	}

 	/// Find the designated for the given view.
-	fn view_proposer(&self, height: Height, view: View) -> Address {
+	fn view_proposer(&self, bh: &H256, height: Height, view: View) -> Address {
 		let proposer_nonce = height + view;
 		trace!(target: "engine", "Proposer nonce: {}", proposer_nonce);
-		self.validators.get(proposer_nonce)
+		self.validators.get(bh, proposer_nonce)
 	}

 	/// Check if address is a proposer for given view.
-	fn is_view_proposer(&self, height: Height, view: View, address: &Address) -> Result<(), EngineError> {
-		let proposer = self.view_proposer(height, view);
+	fn is_view_proposer(&self, bh: &H256, height: Height, view: View, address: &Address) -> Result<(), EngineError> {
+		let proposer = self.view_proposer(bh, height, view);
 		if proposer == *address {
 			Ok(())
 		} else {
@@ -279,8 +282,8 @@ impl Tendermint {
 	}

 	/// Check if current signer is the current proposer.
-	fn is_signer_proposer(&self) -> bool {
-		let proposer = self.view_proposer(self.height.load(AtomicOrdering::SeqCst), self.view.load(AtomicOrdering::SeqCst));
+	fn is_signer_proposer(&self, bh: &H256) -> bool {
+		let proposer = self.view_proposer(bh, self.height.load(AtomicOrdering::SeqCst), self.view.load(AtomicOrdering::SeqCst));
 		self.signer.is_address(&proposer)
 	}

@@ -419,7 +422,7 @@ impl Engine for Tendermint {

 	/// Should this node participate.
 	fn seals_internally(&self) -> Option<bool> {
-		Some(self.is_authority(&self.signer.address()))
+		Some(self.signer.address() != Address::default())
 	}

 	/// Attempt to seal generate a proposal seal.
@@ -427,7 +430,7 @@ impl Engine for Tendermint {
 		let header = block.header();
 		let author = header.author();
 		// Only proposer can generate seal if None was generated.
-		if !self.is_signer_proposer() || self.proposal.read().is_some() {
+		if !self.is_signer_proposer(header.parent_hash()) || self.proposal.read().is_some() {
 			return Seal::None;
 		}

@@ -441,6 +444,7 @@ impl Engine for Tendermint {
 			self.votes.vote(ConsensusMessage::new(signature, height, view, Step::Propose, bh), author);
 			// Remember proposal for later seal submission.
 			*self.proposal.write() = bh;
+			*self.proposal_parent.write() = header.parent_hash().clone();
 			Seal::Proposal(vec![
 				::rlp::encode(&view).to_vec(),
 				::rlp::encode(&signature).to_vec(),
@@ -505,7 +509,12 @@ impl Engine for Tendermint {

 	}

-	fn verify_block_unordered(&self, header: &Header, _block: Option<&[u8]>) -> Result<(), Error> {
+	fn verify_block_unordered(&self, _header: &Header, _block: Option<&[u8]>) -> Result<(), Error> {
+		Ok(())
+	}
+
+	/// Verify validators and gas limit.
+	fn verify_block_family(&self, header: &Header, parent: &Header, _block: Option<&[u8]>) -> Result<(), Error> {
 		let proposal = ConsensusMessage::new_proposal(header)?;
 		let proposer = proposal.verify()?;
 		if !self.is_authority(&proposer) {
@@ -522,7 +531,7 @@ impl Engine for Tendermint {
 				Some(a) => a,
 				None => public_to_address(&recover(&precommit.signature.into(), &precommit_hash)?),
 			};
-			if !self.validators.contains(&address) {
+			if !self.validators.contains(header.parent_hash(), &address) {
 				Err(EngineError::NotAuthorized(address.to_owned()))?
 			}

@@ -545,12 +554,9 @@ impl Engine for Tendermint {
 					found: signatures_len
 				}))?;
 			}
-			self.is_view_proposer(proposal.vote_step.height, proposal.vote_step.view, &proposer)?;
+			self.is_view_proposer(header.parent_hash(), proposal.vote_step.height, proposal.vote_step.view, &proposer)?;
 		}
-		Ok(())
-	}

-	fn verify_block_family(&self, header: &Header, parent: &Header, _block: Option<&[u8]>) -> Result<(), Error> {
 		if header.number() == 0 {
 			Err(BlockError::RidiculousNumber(OutOfBounds { min: Some(1), max: None, found: header.number() }))?;
 		}
@@ -595,6 +601,7 @@ impl Engine for Tendermint {
 		debug!(target: "engine", "Received a new proposal {:?} from {}.", proposal.vote_step, proposer);
 		if self.is_view(&proposal) {
 			*self.proposal.write() = proposal.block_hash.clone();
+			*self.proposal_parent.write() = header.parent_hash().clone();
 		}
 		self.votes.vote(proposal, &proposer);
 		true
@@ -607,7 +614,7 @@ impl Engine for Tendermint {
 				trace!(target: "engine", "Propose timeout.");
 				if self.proposal.read().is_none() {
 					// Report the proposer if no proposal was received.
-					let current_proposer = self.view_proposer(self.height.load(AtomicOrdering::SeqCst), self.view.load(AtomicOrdering::SeqCst));
+					let current_proposer = self.view_proposer(&*self.proposal_parent.read(), self.height.load(AtomicOrdering::SeqCst), self.view.load(AtomicOrdering::SeqCst));
 					self.validators.report_benign(&current_proposer);
 				}
 				Step::Prevote
@@ -765,20 +772,25 @@ mod tests {
 		let (spec, tap) = setup();
 		let engine = spec.engine;

-		let mut header = Header::default();
-		let validator = insert_and_unlock(&tap, "0");
-		header.set_author(validator);
-		let seal = proposal_seal(&tap, &header, 0);
-		header.set_seal(seal);
-		// Good proposer.
-		assert!(engine.verify_block_unordered(&header.clone(), None).is_ok());
+		let mut parent_header: Header = Header::default();
+		parent_header.set_gas_limit(U256::from_str("222222").unwrap());

+		let mut header = Header::default();
+		header.set_number(1);
+		header.set_gas_limit(U256::from_str("222222").unwrap());
 		let validator = insert_and_unlock(&tap, "1");
 		header.set_author(validator);
 		let seal = proposal_seal(&tap, &header, 0);
 		header.set_seal(seal);
+		// Good proposer.
+		assert!(engine.verify_block_family(&header, &parent_header, None).is_ok());
+
+		let validator = insert_and_unlock(&tap, "0");
+		header.set_author(validator);
+		let seal = proposal_seal(&tap, &header, 0);
+		header.set_seal(seal);
 		// Bad proposer.
-		match engine.verify_block_unordered(&header, None) {
+		match engine.verify_block_family(&header, &parent_header, None) {
 			Err(Error::Engine(EngineError::NotProposer(_))) => {},
 			_ => panic!(),
 		}
@@ -788,7 +800,7 @@ mod tests {
 		let seal = proposal_seal(&tap, &header, 0);
 		header.set_seal(seal);
 		// Not authority.
-		match engine.verify_block_unordered(&header, None) {
+		match engine.verify_block_family(&header, &parent_header, None) {
 			Err(Error::Engine(EngineError::NotAuthorized(_))) => {},
 			_ => panic!(),
 		};
@@ -800,19 +812,24 @@ mod tests {
 		let (spec, tap) = setup();
 		let engine = spec.engine;

+		let mut parent_header: Header = Header::default();
+		parent_header.set_gas_limit(U256::from_str("222222").unwrap());
+
 		let mut header = Header::default();
+		header.set_number(2);
+		header.set_gas_limit(U256::from_str("222222").unwrap());
 		let proposer = insert_and_unlock(&tap, "1");
 		header.set_author(proposer);
 		let mut seal = proposal_seal(&tap, &header, 0);

-		let vote_info = message_info_rlp(&VoteStep::new(0, 0, Step::Precommit), Some(header.bare_hash()));
+		let vote_info = message_info_rlp(&VoteStep::new(2, 0, Step::Precommit), Some(header.bare_hash()));
 		let signature1 = tap.sign(proposer, None, vote_info.sha3()).unwrap();

 		seal[2] = ::rlp::encode(&vec![H520::from(signature1.clone())]).to_vec();
 		header.set_seal(seal.clone());

 		// One good signature is not enough.
-		match engine.verify_block_unordered(&header, None) {
+		match engine.verify_block_family(&header, &parent_header, None) {
 			Err(Error::Engine(EngineError::BadSealFieldSize(_))) => {},
 			_ => panic!(),
 		}
@@ -823,7 +840,7 @@ mod tests {
 		seal[2] = ::rlp::encode(&vec![H520::from(signature1.clone()), H520::from(signature0.clone())]).to_vec();
 		header.set_seal(seal.clone());

-		assert!(engine.verify_block_unordered(&header, None).is_ok());
+		assert!(engine.verify_block_family(&header, &parent_header, None).is_ok());

 		let bad_voter = insert_and_unlock(&tap, "101");
 		let bad_signature = tap.sign(bad_voter, None, vote_info.sha3()).unwrap();
@@ -832,7 +849,7 @@ mod tests {
 		header.set_seal(seal);

 		// One good and one bad signature.
-		match engine.verify_block_unordered(&header, None) {
+		match engine.verify_block_family(&header, &parent_header, None) {
 			Err(Error::Engine(EngineError::NotAuthorized(_))) => {},
 			_ => panic!(),
 		};
--- a/ethcore/src/engines/validator_set/contract.rs
+++ b/ethcore/src/engines/validator_set/contract.rs
@@ -26,30 +26,30 @@ use super::safe_contract::ValidatorSafeContract;
 /// The validator contract should have the following interface:
 /// [{"constant":true,"inputs":[],"name":"getValidators","outputs":[{"name":"","type":"address[]"}],"payable":false,"type":"function"}]
 pub struct ValidatorContract {
-	validators: Arc<ValidatorSafeContract>,
+	validators: ValidatorSafeContract,
 	provider: RwLock<Option<provider::Contract>>,
 }

 impl ValidatorContract {
 	pub fn new(contract_address: Address) -> Self {
 		ValidatorContract {
-			validators: Arc::new(ValidatorSafeContract::new(contract_address)),
+			validators: ValidatorSafeContract::new(contract_address),
 			provider: RwLock::new(None),
 		}
 	}
 }

-impl ValidatorSet for Arc<ValidatorContract> {
-	fn contains(&self, address: &Address) -> bool {
-		self.validators.contains(address)
+impl ValidatorSet for ValidatorContract {
+	fn contains(&self, bh: &H256, address: &Address) -> bool {
+		self.validators.contains(bh, address)
 	}

-	fn get(&self, nonce: usize) -> Address {
-		self.validators.get(nonce)
+	fn get(&self, bh: &H256, nonce: usize) -> Address {
+		self.validators.get(bh, nonce)
 	}

-	fn count(&self) -> usize {
-		self.validators.count()
+	fn count(&self, bh: &H256) -> usize {
+		self.validators.count(bh)
 	}

 	fn report_malicious(&self, address: &Address) {
@@ -144,6 +144,7 @@ mod tests {
 	use header::Header;
 	use account_provider::AccountProvider;
 	use miner::MinerService;
+	use types::ids::BlockId;
 	use client::BlockChainClient;
 	use tests::helpers::generate_dummy_client_with_spec_and_accounts;
 	use super::super::ValidatorSet;
@@ -154,8 +155,9 @@ mod tests {
 		let client = generate_dummy_client_with_spec_and_accounts(Spec::new_validator_contract, None);
 		let vc = Arc::new(ValidatorContract::new(Address::from_str("0000000000000000000000000000000000000005").unwrap()));
 		vc.register_contract(Arc::downgrade(&client));
-		assert!(vc.contains(&Address::from_str("7d577a597b2742b498cb5cf0c26cdcd726d39e6e").unwrap()));
-		assert!(vc.contains(&Address::from_str("82a978b3f5962a5b0957d9ee9eef472ee55b42f1").unwrap()));
+		let last_hash = client.best_block_header().hash();
+		assert!(vc.contains(&last_hash, &Address::from_str("7d577a597b2742b498cb5cf0c26cdcd726d39e6e").unwrap()));
+		assert!(vc.contains(&last_hash, &Address::from_str("82a978b3f5962a5b0957d9ee9eef472ee55b42f1").unwrap()));
 	}
 	
 	#[test]
@@ -171,18 +173,21 @@ mod tests {

 		client.miner().set_engine_signer(v1, "".into()).unwrap();
 		let mut header = Header::default();
-		let seal = encode(&vec!(5u8)).to_vec();	
-		header.set_seal(vec!(seal));
+		let seal = vec![encode(&5u8).to_vec(), encode(&(&H520::default() as &[u8])).to_vec()];	
+		header.set_seal(seal);
 		header.set_author(v1);
-		header.set_number(1);
+		header.set_number(2);
+		header.set_parent_hash(client.chain_info().best_block_hash);
+		
 		// `reportBenign` when the designated proposer releases block from the future (bad clock).
-		assert!(client.engine().verify_block_unordered(&header, None).is_err());
+		assert!(client.engine().verify_block_family(&header, &header, None).is_err());
 		// Seal a block.
 		client.engine().step();
 		assert_eq!(client.chain_info().best_block_number, 1);
 		// Check if the unresponsive validator is `disliked`.
-		assert_eq!(client.call_contract(validator_contract, "d8f2e0bf".from_hex().unwrap()).unwrap().to_hex(), "0000000000000000000000007d577a597b2742b498cb5cf0c26cdcd726d39e6e");
+		assert_eq!(client.call_contract(BlockId::Latest, validator_contract, "d8f2e0bf".from_hex().unwrap()).unwrap().to_hex(), "0000000000000000000000007d577a597b2742b498cb5cf0c26cdcd726d39e6e");
 		// Simulate a misbehaving validator by handling a double proposal.
+		let header = client.best_block_header().decode();
 		assert!(client.engine().verify_block_family(&header, &header, None).is_err());
 		// Seal a block.
 		client.engine().step();
--- a/ethcore/src/engines/validator_set/mod.rs
+++ b/ethcore/src/engines/validator_set/mod.rs
@@ -19,31 +19,36 @@
 mod simple_list;
 mod safe_contract;
 mod contract;
+mod multi;

 use std::sync::Weak;
-use util::{Address, Arc};
+use util::{Address, H256};
 use ethjson::spec::ValidatorSet as ValidatorSpec;
 use client::Client;
 use self::simple_list::SimpleList;
 use self::contract::ValidatorContract;
 use self::safe_contract::ValidatorSafeContract;
+use self::multi::Multi;

 /// Creates a validator set from spec.
-pub fn new_validator_set(spec: ValidatorSpec) -> Box<ValidatorSet + Send + Sync> {
+pub fn new_validator_set(spec: ValidatorSpec) -> Box<ValidatorSet> {
 	match spec {
 		ValidatorSpec::List(list) => Box::new(SimpleList::new(list.into_iter().map(Into::into).collect())),
-		ValidatorSpec::SafeContract(address) => Box::new(Arc::new(ValidatorSafeContract::new(address.into()))),
-		ValidatorSpec::Contract(address) => Box::new(Arc::new(ValidatorContract::new(address.into()))),
+		ValidatorSpec::SafeContract(address) => Box::new(ValidatorSafeContract::new(address.into())),
+		ValidatorSpec::Contract(address) => Box::new(ValidatorContract::new(address.into())),
+		ValidatorSpec::Multi(sequence) => Box::new(
+			Multi::new(sequence.into_iter().map(|(block, set)| (block.into(), new_validator_set(set))).collect())
+		),
 	}
 }

-pub trait ValidatorSet {
+pub trait ValidatorSet: Send + Sync {
 	/// Checks if a given address is a validator.
-	fn contains(&self, address: &Address) -> bool;
+	fn contains(&self, parent_block_hash: &H256, address: &Address) -> bool;
 	/// Draws an validator nonce modulo number of validators.
-	fn get(&self, nonce: usize) -> Address;
+	fn get(&self, parent_block_hash: &H256, nonce: usize) -> Address;
 	/// Returns the current number of validators.
-	fn count(&self) -> usize;
+	fn count(&self, parent_block_hash: &H256) -> usize;
 	/// Notifies about malicious behaviour.
 	fn report_malicious(&self, _validator: &Address) {}
 	/// Notifies about benign misbehaviour.
--- a/ethcore/src/engines/validator_set/multi.rs
+++ b/ethcore/src/engines/validator_set/multi.rs
@@ -0,0 +1,158 @@
+// Copyright 2015-2017 Parity Technologies (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+/// Validator set changing at fork blocks.
+
+use std::collections::BTreeMap;
+use std::sync::Weak;
+use util::{H256, Address, RwLock};
+use ids::BlockId;
+use header::BlockNumber;
+use client::{Client, BlockChainClient};
+use super::ValidatorSet;
+
+type BlockNumberLookup = Box<Fn(&H256) -> Result<BlockNumber, String> + Send + Sync + 'static>;
+
+pub struct Multi {
+	sets: BTreeMap<BlockNumber, Box<ValidatorSet>>,
+	block_number: RwLock<BlockNumberLookup>,
+}
+
+impl Multi {
+	pub fn new(set_map: BTreeMap<BlockNumber, Box<ValidatorSet>>) -> Self {
+		assert!(set_map.get(&0u64).is_some(), "ValidatorSet has to be specified from block 0.");
+		Multi {
+			sets: set_map,
+			block_number: RwLock::new(Box::new(move |_| Err("No client!".into()))),
+		}
+	}
+
+	fn correct_set(&self, bh: &H256) -> Option<&Box<ValidatorSet>> {
+		match self
+			.block_number
+			.read()(bh)
+			.map(|parent_block| self
+					 .sets
+					 .iter()
+					 .rev()
+					 .find(|&(block, _)| *block <= parent_block + 1)
+					 .expect("constructor validation ensures that there is at least one validator set for block 0;
+									 block 0 is less than any uint;
+									 qed")
+				) {
+			Ok((block, set)) => {
+				trace!(target: "engine", "Multi ValidatorSet retrieved for block {}.", block);
+				Some(set)
+			},
+			Err(e) => {
+				debug!(target: "engine", "ValidatorSet could not be recovered: {}", e);
+				None
+			},
+		}
+	}
+}
+
+impl ValidatorSet for Multi {
+	fn contains(&self, bh: &H256, address: &Address) -> bool {
+		self.correct_set(bh).map_or(false, |set| set.contains(bh, address))
+	}
+
+	fn get(&self, bh: &H256, nonce: usize) -> Address {
+		self.correct_set(bh).map_or_else(Default::default, |set| set.get(bh, nonce))
+	}
+
+	fn count(&self, bh: &H256) -> usize {
+		self.correct_set(bh).map_or_else(usize::max_value, |set| set.count(bh))
+	}
+
+	fn report_malicious(&self, validator: &Address) {
+		for set in self.sets.values() {
+			set.report_malicious(validator);
+		}
+	}
+
+	fn report_benign(&self, validator: &Address) {
+		for set in self.sets.values() {
+			set.report_benign(validator);
+		}
+	}
+
+	fn register_contract(&self, client: Weak<Client>) {
+		for set in self.sets.values() {
+			set.register_contract(client.clone());
+		}
+		*self.block_number.write() = Box::new(move |hash| client
+			.upgrade()
+			.ok_or("No client!".into())
+			.and_then(|c| c.block_number(BlockId::Hash(*hash)).ok_or("Unknown block".into())));
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use util::*;
+	use types::ids::BlockId;
+	use spec::Spec;
+	use account_provider::AccountProvider;
+	use client::{BlockChainClient, EngineClient};
+	use ethkey::Secret;
+	use miner::MinerService;
+	use tests::helpers::{generate_dummy_client_with_spec_and_accounts, generate_dummy_client_with_spec_and_data};
+
+	#[test]
+	fn uses_current_set() {
+		::env_logger::init().unwrap();
+		let tap = Arc::new(AccountProvider::transient_provider());
+		let s0 = Secret::from_slice(&"0".sha3()).unwrap();
+		let v0 = tap.insert_account(s0.clone(), "").unwrap();
+		let v1 = tap.insert_account(Secret::from_slice(&"1".sha3()).unwrap(), "").unwrap();
+		let client = generate_dummy_client_with_spec_and_accounts(Spec::new_validator_multi, Some(tap));
+		client.engine().register_client(Arc::downgrade(&client));
+
+		// Make sure txs go through.
+		client.miner().set_gas_floor_target(1_000_000.into());
+
+		// Wrong signer for the first block.
+		client.miner().set_engine_signer(v1, "".into()).unwrap();
+		client.transact_contract(Default::default(), Default::default()).unwrap();
+		client.update_sealing();
+		assert_eq!(client.chain_info().best_block_number, 0);
+		// Right signer for the first block.
+		client.miner().set_engine_signer(v0, "".into()).unwrap();
+		client.update_sealing();
+		assert_eq!(client.chain_info().best_block_number, 1);
+		// This time v0 is wrong.
+		client.transact_contract(Default::default(), Default::default()).unwrap();
+		client.update_sealing();
+		assert_eq!(client.chain_info().best_block_number, 1);
+		client.miner().set_engine_signer(v1, "".into()).unwrap();
+		client.update_sealing();
+		assert_eq!(client.chain_info().best_block_number, 2);
+		// v1 is still good.
+		client.transact_contract(Default::default(), Default::default()).unwrap();
+		client.update_sealing();
+		assert_eq!(client.chain_info().best_block_number, 3);
+
+		// Check syncing.
+		let sync_client = generate_dummy_client_with_spec_and_data(Spec::new_validator_multi, 0, 0, &[]);
+		sync_client.engine().register_client(Arc::downgrade(&sync_client));
+		for i in 1..4 {
+			sync_client.import_block(client.block(BlockId::Number(i)).unwrap().into_inner()).unwrap();
+		}
+		sync_client.flush_queue();
+		assert_eq!(sync_client.chain_info().best_block_number, 3);
+	}
+}
--- a/ethcore/src/engines/validator_set/safe_contract.rs
+++ b/ethcore/src/engines/validator_set/safe_contract.rs
@@ -17,17 +17,23 @@
 /// Validator set maintained in a contract, updated using `getValidators` method.

 use std::sync::Weak;
+use ethabi;
 use util::*;
+use util::cache::MemoryLruCache;
+use types::ids::BlockId;
 use client::{Client, BlockChainClient};
-use client::chain_notify::ChainNotify;
 use super::ValidatorSet;
 use super::simple_list::SimpleList;

+const MEMOIZE_CAPACITY: usize = 500;
+const CONTRACT_INTERFACE: &'static [u8] = b"[{\"constant\":true,\"inputs\":[],\"name\":\"getValidators\",\"outputs\":[{\"name\":\"\",\"type\":\"address[]\"}],\"payable\":false,\"type\":\"function\"}]";
+const GET_VALIDATORS: &'static str = "getValidators";
+
 /// The validator contract should have the following interface:
 /// [{"constant":true,"inputs":[],"name":"getValidators","outputs":[{"name":"","type":"address[]"}],"payable":false,"type":"function"}]
 pub struct ValidatorSafeContract {
 	pub address: Address,
-	validators: RwLock<SimpleList>,
+	validators: RwLock<MemoryLruCache<H256, SimpleList>>,
 	provider: RwLock<Option<provider::Contract>>,
 }

@@ -35,102 +41,127 @@ impl ValidatorSafeContract {
 	pub fn new(contract_address: Address) -> Self {
 		ValidatorSafeContract {
 			address: contract_address,
-			validators: Default::default(),
+			validators: RwLock::new(MemoryLruCache::new(MEMOIZE_CAPACITY)),
 			provider: RwLock::new(None),
 		}
 	}

-	/// Queries the state and updates the set of validators.
-	pub fn update(&self) {
+	/// Queries the state and gets the set of validators.
+	fn get_list(&self, block_hash: H256) -> Option<SimpleList> {
 		if let Some(ref provider) = *self.provider.read() {
-			match provider.get_validators() {
+			match provider.get_validators(BlockId::Hash(block_hash)) {
 				Ok(new) => {
 					debug!(target: "engine", "Set of validators obtained: {:?}", new);
-					*self.validators.write() = SimpleList::new(new);
+					Some(SimpleList::new(new))
+				},
+				Err(s) => {
+					debug!(target: "engine", "Set of validators could not be updated: {}", s);
+					None
 				},
-				Err(s) => warn!(target: "engine", "Set of validators could not be updated: {}", s),
 			}
 		} else {
-			warn!(target: "engine", "Set of validators could not be updated: no provider contract.")
+			warn!(target: "engine", "Set of validators could not be updated: no provider contract.");
+			None
 		}
 	}
 }

-/// Checks validators on every block.
-impl ChainNotify for ValidatorSafeContract {
-	fn new_blocks(
-		&self,
-		_: Vec<H256>,
-		_: Vec<H256>,
-		enacted: Vec<H256>,
-		_: Vec<H256>,
-		_: Vec<H256>,
-		_: Vec<Bytes>,
-		_duration: u64) {
-		if !enacted.is_empty() {
-			self.update();
-		}
-	}
-}
-
-impl ValidatorSet for Arc<ValidatorSafeContract> {
-	fn contains(&self, address: &Address) -> bool {
-		self.validators.read().contains(address)
+impl ValidatorSet for ValidatorSafeContract {
+	fn contains(&self, block_hash: &H256, address: &Address) -> bool {
+		let mut guard = self.validators.write();
+		let maybe_existing = guard
+			.get_mut(block_hash)
+			.map(|list| list.contains(block_hash, address));
+		maybe_existing
+			.unwrap_or_else(|| self
+				.get_list(block_hash.clone())
+				.map_or(false, |list| {
+					let contains = list.contains(block_hash, address);
+					guard.insert(block_hash.clone(), list);
+					contains
+				 }))
 	}

-	fn get(&self, nonce: usize) -> Address {
-		self.validators.read().get(nonce)
+	fn get(&self, block_hash: &H256, nonce: usize) -> Address {
+		let mut guard = self.validators.write();
+		let maybe_existing = guard
+			.get_mut(block_hash)
+			.map(|list| list.get(block_hash, nonce));
+		maybe_existing
+			.unwrap_or_else(|| self
+				.get_list(block_hash.clone())
+				.map_or_else(Default::default, |list| {
+					let address = list.get(block_hash, nonce);
+					guard.insert(block_hash.clone(), list);
+					address
+				 }))
 	}

-	fn count(&self) -> usize {
-		self.validators.read().count()
+	fn count(&self, block_hash: &H256) -> usize {
+		let mut guard = self.validators.write();
+		let maybe_existing = guard
+			.get_mut(block_hash)
+			.map(|list| list.count(block_hash));
+		maybe_existing
+			.unwrap_or_else(|| self
+				.get_list(block_hash.clone())
+				.map_or_else(usize::max_value, |list| {
+					let address = list.count(block_hash);
+					guard.insert(block_hash.clone(), list);
+					address
+				 }))
 	}

 	fn register_contract(&self, client: Weak<Client>) {
-		if let Some(c) = client.upgrade() {
-			c.add_notify(self.clone());
-		}
-		{
-			*self.provider.write() = Some(provider::Contract::new(self.address, move |a, d| client.upgrade().ok_or("No client!".into()).and_then(|c| c.call_contract(a, d))));
-		}
-		self.update();
+		trace!(target: "engine", "Setting up contract caller.");
+		let contract = ethabi::Contract::new(ethabi::Interface::load(CONTRACT_INTERFACE).expect("JSON interface is valid; qed"));
+		let call = contract.function(GET_VALIDATORS.into()).expect("Method name is valid; qed");
+		let data = call.encode_call(vec![]).expect("get_validators does not take any arguments; qed");
+		let contract_address = self.address.clone();
+		let do_call = move |id| client
+			.upgrade()
+			.ok_or("No client!".into())
+			.and_then(|c| c.call_contract(id, contract_address.clone(), data.clone()))
+			.map(|raw_output| call.decode_output(raw_output).expect("ethabi is correct; qed"));
+		*self.provider.write() = Some(provider::Contract::new(do_call));
 	}
 }

 mod provider {
-	// Autogenerated from JSON contract definition using Rust contract convertor.
-	#![allow(unused_imports)]
 	use std::string::String;
 	use std::result::Result;
-	use std::fmt;
 	use {util, ethabi};
-	use util::{FixedHash, Uint};
+	use types::ids::BlockId;

 	pub struct Contract {
-		contract: ethabi::Contract,
-		address: util::Address,
-		do_call: Box<Fn(util::Address, Vec<u8>) -> Result<Vec<u8>, String> + Send + Sync + 'static>,
+		do_call: Box<Fn(BlockId) -> Result<Vec<ethabi::Token>, String> + Send + Sync + 'static>,
 	}
+
 	impl Contract {
-		pub fn new<F>(address: util::Address, do_call: F) -> Self where F: Fn(util::Address, Vec<u8>) -> Result<Vec<u8>, String> + Send + Sync + 'static {
+		pub fn new<F>(do_call: F) -> Self where F: Fn(BlockId) -> Result<Vec<ethabi::Token>, String> + Send + Sync + 'static {
 			Contract {
-				contract: ethabi::Contract::new(ethabi::Interface::load(b"[{\"constant\":true,\"inputs\":[],\"name\":\"getValidators\",\"outputs\":[{\"name\":\"\",\"type\":\"address[]\"}],\"payable\":false,\"type\":\"function\"}]").expect("JSON is autogenerated; qed")),
-				address: address,
 				do_call: Box::new(do_call),
 			}
 		}
-		fn as_string<T: fmt::Debug>(e: T) -> String { format!("{:?}", e) }
-		
-		/// Auto-generated from: `{"constant":true,"inputs":[],"name":"getValidators","outputs":[{"name":"","type":"address[]"}],"payable":false,"type":"function"}`
-		#[allow(dead_code)]
-		pub fn get_validators(&self) -> Result<Vec<util::Address>, String> {
-			let call = self.contract.function("getValidators".into()).map_err(Self::as_string)?;
-			let data = call.encode_call(
-				vec![]
-			).map_err(Self::as_string)?;
-			let output = call.decode_output((self.do_call)(self.address.clone(), data)?).map_err(Self::as_string)?;
-			let mut result = output.into_iter().rev().collect::<Vec<_>>();
-			Ok(({ let r = result.pop().ok_or("Invalid return arity")?; let r = r.to_array().and_then(|v| v.into_iter().map(|a| a.to_address()).collect::<Option<Vec<[u8; 20]>>>()).ok_or("Invalid type returned")?; r.into_iter().map(|a| util::Address::from(a)).collect::<Vec<_>>() }))
+
+		/// Gets validators from contract with interface: `{"constant":true,"inputs":[],"name":"getValidators","outputs":[{"name":"","type":"address[]"}],"payable":false,"type":"function"}`
+		pub fn get_validators(&self, id: BlockId) -> Result<Vec<util::Address>, String> {
+			Ok((self.do_call)(id)?
+				 .into_iter()
+				 .rev()
+				 .collect::<Vec<_>>()
+				 .pop()
+				 .expect("get_validators returns one argument; qed")
+				 .to_array()
+				 .and_then(|v| v
+					 .into_iter()
+					 .map(|a| a.to_address())
+					 .collect::<Option<Vec<[u8; 20]>>>())
+				 .expect("get_validators returns a list of addresses; qed")
+				 .into_iter()
+				 .map(util::Address::from)
+				 .collect::<Vec<_>>()
+			)
 		}
 	}
 }
@@ -138,13 +169,14 @@ mod provider {
 #[cfg(test)]
 mod tests {
 	use util::*;
+	use types::ids::BlockId;
 	use spec::Spec;
 	use account_provider::AccountProvider;
 	use transaction::{Transaction, Action};
 	use client::{BlockChainClient, EngineClient};
 	use ethkey::Secret;
 	use miner::MinerService;
-	use tests::helpers::generate_dummy_client_with_spec_and_accounts;
+	use tests::helpers::{generate_dummy_client_with_spec_and_accounts, generate_dummy_client_with_spec_and_data};
 	use super::super::ValidatorSet;
 	use super::ValidatorSafeContract;

@@ -153,12 +185,13 @@ mod tests {
 		let client = generate_dummy_client_with_spec_and_accounts(Spec::new_validator_safe_contract, None);
 		let vc = Arc::new(ValidatorSafeContract::new(Address::from_str("0000000000000000000000000000000000000005").unwrap()));
 		vc.register_contract(Arc::downgrade(&client));
-		assert!(vc.contains(&Address::from_str("7d577a597b2742b498cb5cf0c26cdcd726d39e6e").unwrap()));
-		assert!(vc.contains(&Address::from_str("82a978b3f5962a5b0957d9ee9eef472ee55b42f1").unwrap()));
+		let last_hash = client.best_block_header().hash();
+		assert!(vc.contains(&last_hash, &Address::from_str("7d577a597b2742b498cb5cf0c26cdcd726d39e6e").unwrap()));
+		assert!(vc.contains(&last_hash, &Address::from_str("82a978b3f5962a5b0957d9ee9eef472ee55b42f1").unwrap()));
 	}

 	#[test]
-	fn updates_validators() {
+	fn knows_validators() {
 		let tap = Arc::new(AccountProvider::transient_provider());
 		let s0 = Secret::from_slice(&"1".sha3()).unwrap();
 		let v0 = tap.insert_account(s0.clone(), "").unwrap();
@@ -212,5 +245,14 @@ mod tests {
 		client.update_sealing();
 		// Able to seal again.
 		assert_eq!(client.chain_info().best_block_number, 3);
+
+		// Check syncing.
+		let sync_client = generate_dummy_client_with_spec_and_data(Spec::new_validator_safe_contract, 0, 0, &[]);
+		sync_client.engine().register_client(Arc::downgrade(&sync_client));
+		for i in 1..4 {
+			sync_client.import_block(client.block(BlockId::Number(i)).unwrap().into_inner()).unwrap();
+		}
+		sync_client.flush_queue();
+		assert_eq!(sync_client.chain_info().best_block_number, 3);
 	}
 }
--- a/ethcore/src/engines/validator_set/simple_list.rs
+++ b/ethcore/src/engines/validator_set/simple_list.rs
@@ -16,7 +16,7 @@

 /// Preconfigured validator list.

-use util::Address;
+use util::{H256, Address, HeapSizeOf};
 use super::ValidatorSet;

 #[derive(Debug, PartialEq, Eq, Default)]
@@ -34,16 +34,22 @@ impl SimpleList {
 	}
 }

+impl HeapSizeOf for SimpleList {
+	fn heap_size_of_children(&self) -> usize {
+		self.validators.heap_size_of_children() + self.validator_n.heap_size_of_children()
+	}
+}
+
 impl ValidatorSet for SimpleList {
-	fn contains(&self, address: &Address) -> bool {
+	fn contains(&self, _bh: &H256, address: &Address) -> bool {
 		self.validators.contains(address)
 	}

-	fn get(&self, nonce: usize) -> Address {
+	fn get(&self, _bh: &H256, nonce: usize) -> Address {
 		self.validators.get(nonce % self.validator_n).expect("There are validator_n authorities; taking number modulo validator_n gives number in validator_n range; qed").clone()
 	}

-	fn count(&self) -> usize {
+	fn count(&self, _bh: &H256) -> usize {
 		self.validator_n
 	}
 }
@@ -60,9 +66,9 @@ mod tests {
 		let a1 = Address::from_str("cd1722f3947def4cf144679da39c4c32bdc35681").unwrap();
 		let a2 = Address::from_str("0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6").unwrap();
 		let list = SimpleList::new(vec![a1.clone(), a2.clone()]);
-		assert!(list.contains(&a1));
-		assert_eq!(list.get(0), a1);
-		assert_eq!(list.get(1), a2);
-		assert_eq!(list.get(2), a1);
+		assert!(list.contains(&Default::default(), &a1));
+		assert_eq!(list.get(&Default::default(), 0), a1);
+		assert_eq!(list.get(&Default::default(), 1), a2);
+		assert_eq!(list.get(&Default::default(), 2), a1);
 	}
 }
--- a/ethcore/src/lib.rs
+++ b/ethcore/src/lib.rs
@@ -107,6 +107,7 @@ extern crate ethcore_stratum;
 extern crate ethabi;
 extern crate hardware_wallet;
 extern crate stats;
+extern crate itertools;

 #[macro_use]
 extern crate log;
--- a/ethcore/src/miner/miner.rs
+++ b/ethcore/src/miner/miner.rs
@@ -230,7 +230,8 @@ pub struct Miner {
 impl Miner {
 	/// Push notifier that will handle new jobs
 	pub fn push_notifier(&self, notifier: Box<NotifyWork>) {
-		self.notifiers.write().push(notifier)
+		self.notifiers.write().push(notifier);
+		self.sealing_work.lock().enabled = true;
 	}

 	/// Creates new instance of miner Arc.
@@ -298,7 +299,7 @@ impl Miner {
 	}

 	fn forced_sealing(&self) -> bool {
-		self.options.force_sealing || !self.options.new_work_notify.is_empty()
+		self.options.force_sealing || !self.notifiers.read().is_empty()
 	}

 	/// Clear all pending block states
@@ -1007,6 +1008,16 @@ impl MinerService for Miner {
 		}
 	}

+	fn remove_pending_transaction(&self, chain: &MiningBlockChainClient, hash: &H256) -> Option<PendingTransaction> {
+		let mut queue = self.transaction_queue.lock();
+		let tx = queue.find(hash);
+		if tx.is_some() {
+			let fetch_nonce = |a: &Address| chain.latest_nonce(a);
+			queue.remove_invalid(hash, &fetch_nonce);
+		}
+		tx
+	}
+
 	fn pending_receipt(&self, best_block: BlockNumber, hash: &H256) -> Option<RichReceipt> {
 		self.from_pending_block(
 			best_block,
--- a/ethcore/src/miner/mod.rs
+++ b/ethcore/src/miner/mod.rs
@@ -150,6 +150,10 @@ pub trait MinerService : Send + Sync {
 	/// Query pending transactions for hash.
 	fn transaction(&self, best_block: BlockNumber, hash: &H256) -> Option<PendingTransaction>;

+	/// Removes transaction from the queue.
+	/// NOTE: The transaction is not removed from pending block if mining.
+	fn remove_pending_transaction(&self, chain: &MiningBlockChainClient, hash: &H256) -> Option<PendingTransaction>;
+
 	/// Get a list of all pending transactions in the queue.
 	fn pending_transactions(&self) -> Vec<PendingTransaction>;

--- a/ethcore/src/miner/service_transaction_checker.rs
+++ b/ethcore/src/miner/service_transaction_checker.rs
@@ -14,6 +14,7 @@
 // You should have received a copy of the GNU General Public License
 // along with Parity. If not, see <http://www.gnu.org/licenses/>.

+use types::ids::BlockId;
 use client::MiningBlockChainClient;
 use transaction::SignedTransaction;
 use util::{U256, Uint, Mutex};
@@ -45,7 +46,7 @@ impl ServiceTransactionChecker {
 		debug_assert_eq!(tx.gas_price, U256::zero());

 		if let Some(ref contract) = *self.contract.lock() {
-			let do_call = |a, d| client.call_contract(a, d);
+			let do_call = |a, d| client.call_contract(BlockId::Latest, a, d);
 			contract.certified(&do_call, &tx.sender())
 		} else {
 			Err("contract is not configured".to_owned())
--- a/ethcore/src/miner/stratum.rs
+++ b/ethcore/src/miner/stratum.rs
@@ -211,6 +211,8 @@ impl From<AddrParseError> for Error {

 impl super::work_notify::NotifyWork for Stratum {
 	fn notify(&self, pow_hash: H256, difficulty: U256, number: u64) {
+		trace!(target: "stratum", "Notify work");
+
 		self.service.push_work_all(
 			self.dispatcher.payload(pow_hash, difficulty, number)
 		).unwrap_or_else(
--- a/ethcore/src/snapshot/account.rs
+++ b/ethcore/src/snapshot/account.rs
@@ -23,6 +23,7 @@ use snapshot::Error;
 use util::{U256, FixedHash, H256, Bytes, HashDB, SHA3_EMPTY, SHA3_NULL_RLP};
 use util::trie::{TrieDB, Trie};
 use rlp::{RlpStream, Stream, UntrustedRlp, View};
+use itertools::Itertools;

 use std::collections::HashSet;

@@ -60,55 +61,53 @@ impl CodeState {
 	}
 }

-// walk the account's storage trie, returning an RLP item containing the
-// account properties and the storage.
-pub fn to_fat_rlp(acc: &BasicAccount, acct_db: &AccountDB, used_code: &mut HashSet<H256>) -> Result<Bytes, Error> {
+// walk the account's storage trie, returning a vector of RLP items containing the
+// account properties and the storage. Each item contains at most `max_storage_items`
+// storage records split according to snapshot format definition.
+pub fn to_fat_rlps(acc: &BasicAccount, acct_db: &AccountDB, used_code: &mut HashSet<H256>, max_storage_items: usize) -> Result<Vec<Bytes>, Error> {
 	if acc == &ACC_EMPTY {
-		return Ok(::rlp::NULL_RLP.to_vec());
+		return Ok(vec![::rlp::NULL_RLP.to_vec()]);
 	}

 	let db = TrieDB::new(acct_db, &acc.storage_root)?;

-	let mut pairs = Vec::new();
+	let chunks = db.iter()?.chunks(max_storage_items);
+	let pair_chunks = chunks.into_iter().map(|chunk| chunk.collect());
+	pair_chunks.pad_using(1, |_| Vec::new(), ).map(|pairs| {
+		let mut stream = RlpStream::new_list(pairs.len());

-	for item in db.iter()? {
-		let (k, v) = item?;
-		pairs.push((k, v));
-	}
+		for r in pairs {
+			let (k, v) = r?;
+			stream.begin_list(2).append(&k).append(&&*v);
+		}

-	let mut stream = RlpStream::new_list(pairs.len());
+		let pairs_rlp = stream.out();

-	for (k, v) in pairs {
-		stream.begin_list(2).append(&k).append(&&*v);
-	}
+		let mut account_stream = RlpStream::new_list(5);
+		account_stream.append(&acc.nonce)
+					  .append(&acc.balance);

-	let pairs_rlp = stream.out();
-
-	let mut account_stream = RlpStream::new_list(5);
-	account_stream.append(&acc.nonce)
-				  .append(&acc.balance);
-
-	// [has_code, code_hash].
-	if acc.code_hash == SHA3_EMPTY {
-		account_stream.append(&CodeState::Empty.raw()).append_empty_data();
-	} else if used_code.contains(&acc.code_hash) {
-		account_stream.append(&CodeState::Hash.raw()).append(&acc.code_hash);
-	} else {
-		match acct_db.get(&acc.code_hash) {
-			Some(c) => {
-				used_code.insert(acc.code_hash.clone());
-				account_stream.append(&CodeState::Inline.raw()).append(&&*c);
-			}
-			None => {
-				warn!("code lookup failed during snapshot");
-				account_stream.append(&false).append_empty_data();
+		// [has_code, code_hash].
+		if acc.code_hash == SHA3_EMPTY {
+			account_stream.append(&CodeState::Empty.raw()).append_empty_data();
+		} else if used_code.contains(&acc.code_hash) {
+			account_stream.append(&CodeState::Hash.raw()).append(&acc.code_hash);
+		} else {
+			match acct_db.get(&acc.code_hash) {
+				Some(c) => {
+					used_code.insert(acc.code_hash.clone());
+					account_stream.append(&CodeState::Inline.raw()).append(&&*c);
+				}
+				None => {
+					warn!("code lookup failed during snapshot");
+					account_stream.append(&false).append_empty_data();
+				}
 			}
 		}
-	}

-	account_stream.append_raw(&pairs_rlp, 1);
-
-	Ok(account_stream.out())
+		account_stream.append_raw(&pairs_rlp, 1);
+		Ok(account_stream.out())
+	}).collect()
 }

 // decode a fat rlp, and rebuild the storage trie as we go.
@@ -117,6 +116,7 @@ pub fn to_fat_rlp(acc: &BasicAccount, acct_db: &AccountDB, used_code: &mut HashS
 pub fn from_fat_rlp(
 	acct_db: &mut AccountDBMut,
 	rlp: UntrustedRlp,
+	mut storage_root: H256,
 ) -> Result<(BasicAccount, Option<Bytes>), Error> {
 	use util::{TrieDBMut, TrieMut};

@@ -148,10 +148,12 @@ pub fn from_fat_rlp(
 		}
 	};

-	let mut storage_root = H256::zero();
-
 	{
-		let mut storage_trie = TrieDBMut::new(acct_db, &mut storage_root);
+		let mut storage_trie = if storage_root.is_zero() {
+			TrieDBMut::new(acct_db, &mut storage_root)
+		} else {
+			TrieDBMut::from_existing(acct_db, &mut storage_root)?
+		};
 		let pairs = rlp.at(4)?;
 		for pair_rlp in pairs.iter() {
 			let k: Bytes  = pair_rlp.val_at(0)?;
@@ -184,7 +186,7 @@ mod tests {

 	use std::collections::HashSet;

-	use super::{ACC_EMPTY, to_fat_rlp, from_fat_rlp};
+	use super::{ACC_EMPTY, to_fat_rlps, from_fat_rlp};

 	#[test]
 	fn encoding_basic() {
@@ -201,9 +203,9 @@ mod tests {
 		let thin_rlp = ::rlp::encode(&account);
 		assert_eq!(::rlp::decode::<BasicAccount>(&thin_rlp), account);

-		let fat_rlp = to_fat_rlp(&account, &AccountDB::new(db.as_hashdb(), &addr), &mut Default::default()).unwrap();
-		let fat_rlp = UntrustedRlp::new(&fat_rlp);
-		assert_eq!(from_fat_rlp(&mut AccountDBMut::new(db.as_hashdb_mut(), &addr), fat_rlp).unwrap().0, account);
+		let fat_rlps = to_fat_rlps(&account, &AccountDB::new(db.as_hashdb(), &addr), &mut Default::default(), usize::max_value()).unwrap();
+		let fat_rlp = UntrustedRlp::new(&fat_rlps[0]);
+		assert_eq!(from_fat_rlp(&mut AccountDBMut::new(db.as_hashdb_mut(), &addr), fat_rlp, H256::zero()).unwrap().0, account);
 	}

 	#[test]
@@ -226,9 +228,40 @@ mod tests {
 		let thin_rlp = ::rlp::encode(&account);
 		assert_eq!(::rlp::decode::<BasicAccount>(&thin_rlp), account);

-		let fat_rlp = to_fat_rlp(&account, &AccountDB::new(db.as_hashdb(), &addr), &mut Default::default()).unwrap();
-		let fat_rlp = UntrustedRlp::new(&fat_rlp);
-		assert_eq!(from_fat_rlp(&mut AccountDBMut::new(db.as_hashdb_mut(), &addr), fat_rlp).unwrap().0, account);
+		let fat_rlp = to_fat_rlps(&account, &AccountDB::new(db.as_hashdb(), &addr), &mut Default::default(), usize::max_value()).unwrap();
+		let fat_rlp = UntrustedRlp::new(&fat_rlp[0]);
+		assert_eq!(from_fat_rlp(&mut AccountDBMut::new(db.as_hashdb_mut(), &addr), fat_rlp, H256::zero()).unwrap().0, account);
+	}
+
+	#[test]
+	fn encoding_storage_split() {
+		let mut db = get_temp_state_db();
+		let addr = Address::random();
+
+		let account = {
+			let acct_db = AccountDBMut::new(db.as_hashdb_mut(), &addr);
+			let mut root = SHA3_NULL_RLP;
+			fill_storage(acct_db, &mut root, &mut H256::zero());
+			BasicAccount {
+				nonce: 25.into(),
+				balance: 987654321.into(),
+				storage_root: root,
+				code_hash: SHA3_EMPTY,
+			}
+		};
+
+		let thin_rlp = ::rlp::encode(&account);
+		assert_eq!(::rlp::decode::<BasicAccount>(&thin_rlp), account);
+
+		let fat_rlps = to_fat_rlps(&account, &AccountDB::new(db.as_hashdb(), &addr), &mut Default::default(), 100).unwrap();
+		let mut root = SHA3_NULL_RLP;
+		let mut restored_account = None;
+		for rlp in fat_rlps {
+			let fat_rlp = UntrustedRlp::new(&rlp);
+			restored_account = Some(from_fat_rlp(&mut AccountDBMut::new(db.as_hashdb_mut(), &addr), fat_rlp, root).unwrap().0);
+			root = restored_account.as_ref().unwrap().storage_root.clone();
+		}
+		assert_eq!(restored_account, Some(account));
 	}

 	#[test]
@@ -264,18 +297,18 @@ mod tests {

 		let mut used_code = HashSet::new();

-		let fat_rlp1 = to_fat_rlp(&account1, &AccountDB::new(db.as_hashdb(), &addr1), &mut used_code).unwrap();
-		let fat_rlp2 = to_fat_rlp(&account2, &AccountDB::new(db.as_hashdb(), &addr2), &mut used_code).unwrap();
+		let fat_rlp1 = to_fat_rlps(&account1, &AccountDB::new(db.as_hashdb(), &addr1), &mut used_code, usize::max_value()).unwrap();
+		let fat_rlp2 = to_fat_rlps(&account2, &AccountDB::new(db.as_hashdb(), &addr2), &mut used_code, usize::max_value()).unwrap();
 		assert_eq!(used_code.len(), 1);

-		let fat_rlp1 = UntrustedRlp::new(&fat_rlp1);
-		let fat_rlp2 = UntrustedRlp::new(&fat_rlp2);
+		let fat_rlp1 = UntrustedRlp::new(&fat_rlp1[0]);
+		let fat_rlp2 = UntrustedRlp::new(&fat_rlp2[0]);

-		let (acc, maybe_code) = from_fat_rlp(&mut AccountDBMut::new(db.as_hashdb_mut(), &addr2), fat_rlp2).unwrap();
+		let (acc, maybe_code) = from_fat_rlp(&mut AccountDBMut::new(db.as_hashdb_mut(), &addr2), fat_rlp2, H256::zero()).unwrap();
 		assert!(maybe_code.is_none());
 		assert_eq!(acc, account2);

-		let (acc, maybe_code) = from_fat_rlp(&mut AccountDBMut::new(db.as_hashdb_mut(), &addr1), fat_rlp1).unwrap();
+		let (acc, maybe_code) = from_fat_rlp(&mut AccountDBMut::new(db.as_hashdb_mut(), &addr1), fat_rlp1, H256::zero()).unwrap();
 		assert_eq!(maybe_code, Some(b"this is definitely code".to_vec()));
 		assert_eq!(acc, account1);
 	}
@@ -285,7 +318,7 @@ mod tests {
 		let mut db = get_temp_state_db();
 		let mut used_code = HashSet::new();

-		assert_eq!(to_fat_rlp(&ACC_EMPTY, &AccountDB::new(db.as_hashdb(), &Address::default()), &mut used_code).unwrap(), ::rlp::NULL_RLP.to_vec());
-		assert_eq!(from_fat_rlp(&mut AccountDBMut::new(db.as_hashdb_mut(), &Address::default()), UntrustedRlp::new(&::rlp::NULL_RLP)).unwrap(), (ACC_EMPTY, None));
+		assert_eq!(to_fat_rlps(&ACC_EMPTY, &AccountDB::new(db.as_hashdb(), &Address::default()), &mut used_code, usize::max_value()).unwrap(), vec![::rlp::NULL_RLP.to_vec()]);
+		assert_eq!(from_fat_rlp(&mut AccountDBMut::new(db.as_hashdb_mut(), &Address::default()), UntrustedRlp::new(&::rlp::NULL_RLP), H256::zero()).unwrap(), (ACC_EMPTY, None));
 	}
 }
--- a/ethcore/src/snapshot/error.rs
+++ b/ethcore/src/snapshot/error.rs
@@ -53,6 +53,8 @@ pub enum Error {
 	Decoder(DecoderError),
 	/// Io error.
 	Io(::std::io::Error),
+	/// Snapshot version is not supported.
+	VersionNotSupported(u64),
 }

 impl fmt::Display for Error {
@@ -73,6 +75,7 @@ impl fmt::Display for Error {
 			Error::Io(ref err) => err.fmt(f),
 			Error::Decoder(ref err) => err.fmt(f),
 			Error::Trie(ref err) => err.fmt(f),
+			Error::VersionNotSupported(ref ver) => write!(f, "Snapshot version {} is not supprted.", ver),
 		}
 	}
 }
--- a/ethcore/src/snapshot/io.rs
+++ b/ethcore/src/snapshot/io.rs
@@ -31,6 +31,8 @@ use rlp::{self, Encodable, RlpStream, UntrustedRlp, Stream, View};

 use super::ManifestData;

+const SNAPSHOT_VERSION: u64 = 2;
+
 /// Something which can write snapshots.
 /// Writing the same chunk multiple times will lead to implementation-defined
 /// behavior, and is not advised.
@@ -120,8 +122,9 @@ impl SnapshotWriter for PackedWriter {
 	fn finish(mut self, manifest: ManifestData) -> io::Result<()> {
 		// we ignore the hashes fields of the manifest under the assumption that
 		// they are consistent with ours.
-		let mut stream = RlpStream::new_list(5);
+		let mut stream = RlpStream::new_list(6);
 		stream
+			.append(&SNAPSHOT_VERSION)
 			.append(&self.state_hashes)
 			.append(&self.block_hashes)
 			.append(&manifest.state_root)
@@ -223,7 +226,7 @@ impl PackedReader {
 	/// Create a new `PackedReader` for the file at the given path.
 	/// This will fail if any io errors are encountered or the file
 	/// is not a valid packed snapshot.
-	pub fn new(path: &Path) -> Result<Option<Self>, ::error::Error> {
+	pub fn new(path: &Path) -> Result<Option<Self>, ::snapshot::error::Error> {
 		let mut file = File::open(path)?;
 		let file_len = file.metadata()?.len();
 		if file_len < 8 {
@@ -257,15 +260,26 @@ impl PackedReader {

 		let rlp = UntrustedRlp::new(&manifest_buf);

-		let state: Vec<ChunkInfo> = rlp.val_at(0)?;
-		let blocks: Vec<ChunkInfo> = rlp.val_at(1)?;
+		let (start, version) = if rlp.item_count() == 5 {
+			(0, 1)
+		} else {
+			(1, rlp.val_at(0)?)
+		};
+
+		if version > SNAPSHOT_VERSION {
+			return Err(::snapshot::error::Error::VersionNotSupported(version));
+		}
+
+		let state: Vec<ChunkInfo> = rlp.val_at(0 + start)?;
+		let blocks: Vec<ChunkInfo> = rlp.val_at(1 + start)?;

 		let manifest = ManifestData {
+			version: version,
 			state_hashes: state.iter().map(|c| c.0).collect(),
 			block_hashes: blocks.iter().map(|c| c.0).collect(),
-			state_root: rlp.val_at(2)?,
-			block_number: rlp.val_at(3)?,
-			block_hash: rlp.val_at(4)?,
+			state_root: rlp.val_at(2 + start)?,
+			block_number: rlp.val_at(3 + start)?,
+			block_hash: rlp.val_at(4 + start)?,
 		};

 		Ok(Some(PackedReader {
@@ -348,7 +362,7 @@ mod tests {
 	use util::sha3::Hashable;

 	use snapshot::ManifestData;
-	use super::{SnapshotWriter, SnapshotReader, PackedWriter, PackedReader, LooseWriter, LooseReader};
+	use super::{SnapshotWriter, SnapshotReader, PackedWriter, PackedReader, LooseWriter, LooseReader, SNAPSHOT_VERSION};

 	const STATE_CHUNKS: &'static [&'static [u8]] = &[b"dog", b"cat", b"hello world", b"hi", b"notarealchunk"];
 	const BLOCK_CHUNKS: &'static [&'static [u8]] = &[b"hello!", b"goodbye!", b"abcdefg", b"hijklmnop", b"qrstuvwxy", b"and", b"z"];
@@ -374,6 +388,7 @@ mod tests {
 		}

 		let manifest = ManifestData {
+			version: SNAPSHOT_VERSION,
 			state_hashes: state_hashes,
 			block_hashes: block_hashes,
 			state_root: b"notarealroot".sha3(),
@@ -412,6 +427,7 @@ mod tests {
 		}

 		let manifest = ManifestData {
+			version: SNAPSHOT_VERSION,
 			state_hashes: state_hashes,
 			block_hashes: block_hashes,
 			state_root: b"notarealroot".sha3(),
@@ -428,4 +444,4 @@ mod tests {
 			reader.chunk(hash.clone()).unwrap();
 		}
 	}
-}
+}
--- a/ethcore/src/snapshot/mod.rs
+++ b/ethcore/src/snapshot/mod.rs
@@ -56,6 +56,7 @@ pub use self::traits::SnapshotService;
 pub use self::watcher::Watcher;
 pub use types::snapshot_manifest::ManifestData;
 pub use types::restoration_status::RestorationStatus;
+pub use types::basic_account::BasicAccount;

 pub mod io;
 pub mod service;
@@ -82,6 +83,9 @@ mod traits {
 // Try to have chunks be around 4MB (before compression)
 const PREFERRED_CHUNK_SIZE: usize = 4 * 1024 * 1024;

+// Try to have chunks be around 4MB (before compression)
+const MAX_STORAGE_ENTRIES_PER_ACCOUNT_RECORD: usize = 80_000;
+
 // How many blocks to include in a snapshot, starting from the head of the chain.
 const SNAPSHOT_BLOCKS: u64 = 30000;

@@ -147,6 +151,7 @@ pub fn take_snapshot<W: SnapshotWriter + Send>(
 	info!("produced {} state chunks and {} block chunks.", state_hashes.len(), block_hashes.len());

 	let manifest_data = ManifestData {
+		version: 2,
 		state_hashes: state_hashes,
 		block_hashes: block_hashes,
 		state_root: *state_root,
@@ -300,14 +305,14 @@ impl<'a> StateChunker<'a> {
 	//
 	// If the buffer is greater than the desired chunk size,
 	// this will write out the data to disk.
-	fn push(&mut self, account_hash: Bytes, data: Bytes) -> Result<(), Error> {
+	fn push(&mut self, account_hash: Bytes, data: Bytes, force_chunk: bool) -> Result<(), Error> {
 		let pair = {
 			let mut stream = RlpStream::new_list(2);
 			stream.append(&account_hash).append_raw(&data, 1);
 			stream.out()
 		};

-		if self.cur_size + pair.len() >= PREFERRED_CHUNK_SIZE {
+		if force_chunk || self.cur_size + pair.len() >= PREFERRED_CHUNK_SIZE {
 			self.write_chunk()?;
 		}

@@ -372,8 +377,10 @@ pub fn chunk_state<'a>(db: &HashDB, root: &H256, writer: &Mutex<SnapshotWriter +

 		let account_db = AccountDB::from_hash(db, account_key_hash);

-		let fat_rlp = account::to_fat_rlp(&account, &account_db, &mut used_code)?;
-		chunker.push(account_key, fat_rlp)?;
+		let fat_rlps = account::to_fat_rlps(&account, &account_db, &mut used_code, MAX_STORAGE_ENTRIES_PER_ACCOUNT_RECORD)?;
+		for (i, fat_rlp) in fat_rlps.into_iter().enumerate() {
+			chunker.push(account_key.clone(), fat_rlp, i > 0)?;
+		}
 	}

 	if chunker.cur_size != 0 {
@@ -390,6 +397,7 @@ pub struct StateRebuilder {
 	known_code: HashMap<H256, H256>, // code hashes mapped to first account with this code.
 	missing_code: HashMap<H256, Vec<H256>>, // maps code hashes to lists of accounts missing that code.
 	bloom: Bloom,
+	known_storage_roots: HashMap<H256, H256>, // maps account hashes to last known storage root. Only filled for last account per chunk.
 }

 impl StateRebuilder {
@@ -401,6 +409,7 @@ impl StateRebuilder {
 			known_code: HashMap::new(),
 			missing_code: HashMap::new(),
 			bloom: StateDB::load_bloom(&*db),
+			known_storage_roots: HashMap::new(),
 		}
 	}

@@ -418,6 +427,7 @@ impl StateRebuilder {
 			rlp,
 			&mut pairs,
 			&self.known_code,
+			&mut self.known_storage_roots,
 			flag
 		)?;

@@ -464,14 +474,18 @@ impl StateRebuilder {
 		Ok(())
 	}

-	/// Check for accounts missing code. Once all chunks have been fed, there should
-	/// be none.
-	pub fn check_missing(self) -> Result<(), Error> {
+	/// Finalize the restoration. Check for accounts missing code and make a dummy
+	/// journal entry.
+	/// Once all chunks have been fed, there should be nothing missing.
+	pub fn finalize(mut self, era: u64, id: H256) -> Result<(), ::error::Error> {
 		let missing = self.missing_code.keys().cloned().collect::<Vec<_>>();
-		match missing.is_empty() {
-			true => Ok(()),
-			false => Err(Error::MissingCode(missing)),
-		}
+		if !missing.is_empty() { return Err(Error::MissingCode(missing).into()) }
+
+		let mut batch = self.db.backing().transaction();
+		self.db.journal_under(&mut batch, era, &id)?;
+		self.db.backing().write_buffered(batch);
+
+		Ok(())
 	}

 	/// Get the state root of the rebuilder.
@@ -492,10 +506,11 @@ fn rebuild_accounts(
 	account_fat_rlps: UntrustedRlp,
 	out_chunk: &mut [(H256, Bytes)],
 	known_code: &HashMap<H256, H256>,
+	known_storage_roots: &mut HashMap<H256, H256>,
 	abort_flag: &AtomicBool,
 ) -> Result<RebuiltStatus, ::error::Error> {
 	let mut status = RebuiltStatus::default();
-	for (account_rlp, out) in account_fat_rlps.into_iter().zip(out_chunk) {
+	for (account_rlp, out) in account_fat_rlps.into_iter().zip(out_chunk.iter_mut()) {
 		if !abort_flag.load(Ordering::SeqCst) { return Err(Error::RestorationAborted.into()) }

 		let hash: H256 = account_rlp.val_at(0)?;
@@ -506,7 +521,8 @@ fn rebuild_accounts(
 			// fill out the storage trie and code while decoding.
 			let (acc, maybe_code) = {
 				let mut acct_db = AccountDBMut::from_hash(db, hash);
-				account::from_fat_rlp(&mut acct_db, fat_rlp)?
+				let storage_root = known_storage_roots.get(&hash).cloned().unwrap_or(H256::zero());
+				account::from_fat_rlp(&mut acct_db, fat_rlp, storage_root)?
 			};

 			let code_hash = acc.code_hash.clone();
@@ -538,6 +554,12 @@ 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);
+	}
+	if let Some(&(ref hash, ref rlp)) = out_chunk.iter().next() {
+		known_storage_roots.insert(*hash, ::rlp::decode::<BasicAccount>(rlp).storage_root);
+	}
 	Ok(status)
 }

--- a/ethcore/src/snapshot/service.rs
+++ b/ethcore/src/snapshot/service.rs
@@ -166,7 +166,7 @@ impl Restoration {
 		}

 		// check for missing code.
-		self.state.check_missing()?;
+		self.state.finalize(self.manifest.block_number, self.manifest.block_hash)?;

 		// connect out-of-order chunks and verify chain integrity.
 		self.blocks.finalize(self.canonical_hashes)?;
@@ -656,6 +656,7 @@ mod tests {
 		assert_eq!(service.status(), RestorationStatus::Inactive);

 		let manifest = ManifestData {
+			version: 2,
 			state_hashes: vec![],
 			block_hashes: vec![],
 			state_root: Default::default(),
--- a/ethcore/src/snapshot/tests/blocks.rs
+++ b/ethcore/src/snapshot/tests/blocks.rs
@@ -63,6 +63,7 @@ fn chunk_and_restore(amount: u64) {
 	let writer = Mutex::new(PackedWriter::new(&snapshot_path).unwrap());
 	let block_hashes = chunk_blocks(&bc, best_hash, &writer, &Progress::default()).unwrap();
 	let manifest = ::snapshot::ManifestData {
+		version: 2,
 		state_hashes: Vec::new(),
 		block_hashes: block_hashes,
 		state_root: ::util::sha3::SHA3_NULL_RLP,
@@ -125,6 +126,7 @@ fn checks_flag() {
 	let chain = BlockChain::new(Default::default(), &genesis, db.clone());

 	let manifest = ::snapshot::ManifestData {
+		version: 2,
 		state_hashes: Vec::new(),
 		block_hashes: Vec::new(),
 		state_root: ::util::sha3::SHA3_NULL_RLP,
--- a/ethcore/src/snapshot/tests/mod.rs
+++ b/ethcore/src/snapshot/tests/mod.rs
@@ -27,6 +27,7 @@ use super::ManifestData;
 #[test]
 fn manifest_rlp() {
 	let manifest = ManifestData {
+		version: 2,
 		block_hashes: Vec::new(),
 		state_hashes: Vec::new(),
 		block_number: 1234567,
@@ -35,4 +36,4 @@ fn manifest_rlp() {
 	};
 	let raw = manifest.clone().into_rlp();
 	assert_eq!(ManifestData::from_rlp(&raw).unwrap(), manifest);
-}
+}
--- a/ethcore/src/snapshot/tests/service.rs
+++ b/ethcore/src/snapshot/tests/service.rs
@@ -122,6 +122,7 @@ fn guards_delete_folders() {
 	path.push("restoration");

 	let manifest = ManifestData {
+		version: 2,
 		state_hashes: vec![],
 		block_hashes: vec![],
 		block_number: 0,
--- a/ethcore/src/snapshot/tests/state.rs
+++ b/ethcore/src/snapshot/tests/state.rs
@@ -58,10 +58,11 @@ fn snap_and_restore() {
 	let state_hashes = chunk_state(&old_db, &state_root, &writer, &Progress::default()).unwrap();

 	writer.into_inner().finish(::snapshot::ManifestData {
+		version: 2,
 		state_hashes: state_hashes,
 		block_hashes: Vec::new(),
 		state_root: state_root,
-		block_number: 0,
+		block_number: 1000,
 		block_hash: H256::default(),
 	}).unwrap();

@@ -69,7 +70,7 @@ fn snap_and_restore() {
 	db_path.push("db");
 	let db = {
 		let new_db = Arc::new(Database::open(&db_cfg, &db_path.to_string_lossy()).unwrap());
-		let mut rebuilder = StateRebuilder::new(new_db.clone(), Algorithm::Archive);
+		let mut rebuilder = StateRebuilder::new(new_db.clone(), Algorithm::OverlayRecent);
 		let reader = PackedReader::new(&snap_file).unwrap().unwrap();

 		let flag = AtomicBool::new(true);
@@ -82,12 +83,13 @@ fn snap_and_restore() {
 		}

 		assert_eq!(rebuilder.state_root(), state_root);
-		rebuilder.check_missing().unwrap();
+		rebuilder.finalize(1000, H256::default()).unwrap();

 		new_db
 	};

-	let new_db = journaldb::new(db, Algorithm::Archive, ::db::COL_STATE);
+	let new_db = journaldb::new(db, Algorithm::OverlayRecent, ::db::COL_STATE);
+	assert_eq!(new_db.earliest_era(), Some(1000));

 	compare_dbs(&old_db, new_db.as_hashdb());
 }
@@ -120,10 +122,10 @@ fn get_code_from_prev_chunk() {
 		let mut db = MemoryDB::new();
 		AccountDBMut::from_hash(&mut db, hash).insert(&code[..]);

-		let fat_rlp = account::to_fat_rlp(&acc, &AccountDB::from_hash(&db, hash), &mut used_code).unwrap();
+		let fat_rlp = account::to_fat_rlps(&acc, &AccountDB::from_hash(&db, hash), &mut used_code, usize::max_value()).unwrap();

 		let mut stream = RlpStream::new_list(1);
-		stream.begin_list(2).append(&hash).append_raw(&fat_rlp, 1);
+		stream.begin_list(2).append(&hash).append_raw(&fat_rlp[0], 1);
 		stream.out()
 	};

@@ -134,13 +136,18 @@ fn get_code_from_prev_chunk() {
 	let db_cfg = DatabaseConfig::with_columns(::db::NUM_COLUMNS);
 	let new_db = Arc::new(Database::open(&db_cfg, &db_path.to_string_lossy()).unwrap());

-	let mut rebuilder = StateRebuilder::new(new_db, Algorithm::Archive);
-	let flag = AtomicBool::new(true);
+	{
+		let mut rebuilder = StateRebuilder::new(new_db.clone(), Algorithm::OverlayRecent);
+		let flag = AtomicBool::new(true);

-	rebuilder.feed(&chunk1, &flag).unwrap();
-	rebuilder.feed(&chunk2, &flag).unwrap();
+		rebuilder.feed(&chunk1, &flag).unwrap();
+		rebuilder.feed(&chunk2, &flag).unwrap();

-	rebuilder.check_missing().unwrap();
+		rebuilder.finalize(1000, H256::random()).unwrap();
+	}
+
+	let state_db = journaldb::new(new_db, Algorithm::OverlayRecent, ::db::COL_STATE);
+	assert_eq!(state_db.earliest_era(), Some(1000));
 }

 #[test]
@@ -164,6 +171,7 @@ fn checks_flag() {
 	let state_hashes = chunk_state(&old_db, &state_root, &writer, &Progress::default()).unwrap();

 	writer.into_inner().finish(::snapshot::ManifestData {
+		version: 2,
 		state_hashes: state_hashes,
 		block_hashes: Vec::new(),
 		state_root: state_root,
@@ -175,7 +183,7 @@ fn checks_flag() {
 	db_path.push("db");
 	{
 		let new_db = Arc::new(Database::open(&db_cfg, &db_path.to_string_lossy()).unwrap());
-		let mut rebuilder = StateRebuilder::new(new_db.clone(), Algorithm::Archive);
+		let mut rebuilder = StateRebuilder::new(new_db.clone(), Algorithm::OverlayRecent);
 		let reader = PackedReader::new(&snap_file).unwrap().unwrap();

 		let flag = AtomicBool::new(false);
--- a/ethcore/src/spec/spec.rs
+++ b/ethcore/src/spec/spec.rs
@@ -55,6 +55,8 @@ pub struct CommonParams {
 	pub fork_block: Option<(BlockNumber, H256)>,
 	/// Number of first block where EIP-98 rules begin.
 	pub eip98_transition: BlockNumber,
+	/// Validate block receipts root.
+	pub validate_receipts_transition: u64,
 }

 impl From<ethjson::spec::Params> for CommonParams {
@@ -68,6 +70,7 @@ impl From<ethjson::spec::Params> for CommonParams {
 			min_gas_limit: p.min_gas_limit.into(),
 			fork_block: if let (Some(n), Some(h)) = (p.fork_block, p.fork_hash) { Some((n.into(), h.into())) } else { None },
 			eip98_transition: p.eip98_transition.map_or(0, Into::into),
+			validate_receipts_transition: p.validate_receipts_transition.map_or(0, Into::into),
 		}
 	}
 }
@@ -357,6 +360,10 @@ impl Spec {
 	/// Account is marked with `reportBenign` it can be checked as disliked with "0xd8f2e0bf".
 	/// Validator can be removed with `reportMalicious`.
 	pub fn new_validator_contract() -> Self { load_bundled!("validator_contract") }
+
+	/// Create a new Spec with BasicAuthority which uses multiple validator sets changing with height.
+	/// Account with secrets "0".sha3() is the validator for block 1 and with "1".sha3() onwards.
+	pub fn new_validator_multi() -> Self { load_bundled!("validator_multi") }
 }

 #[cfg(test)]
--- a/ethcore/src/state/mod.rs
+++ b/ethcore/src/state/mod.rs
@@ -546,7 +546,7 @@ impl<B: Backend> State<B> {

 		// TODO uncomment once to_pod() works correctly.
 //		trace!("Applied transaction. Diff:\n{}\n", state_diff::diff_pod(&old, &self.to_pod()));
-		let state_root = if env_info.number < engine.params().eip98_transition {
+		let state_root = if env_info.number < engine.params().eip98_transition || env_info.number < engine.params().validate_receipts_transition {
 			self.commit()?;
 			Some(self.root().clone())
 		} else {
--- a/ethcore/src/types/snapshot_manifest.rs
+++ b/ethcore/src/types/snapshot_manifest.rs
@@ -24,6 +24,8 @@ use util::Bytes;
 #[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "ipc", binary)]
 pub struct ManifestData {
+	/// Snapshot format version.
+	pub version: u64,
 	/// List of state chunk hashes.
 	pub state_hashes: Vec<H256>,
 	/// List of block chunk hashes.
@@ -39,7 +41,8 @@ pub struct ManifestData {
 impl ManifestData {
 	/// Encode the manifest data to rlp.
 	pub fn into_rlp(self) -> Bytes {
-		let mut stream = RlpStream::new_list(5);
+		let mut stream = RlpStream::new_list(6);
+		stream.append(&self.version);
 		stream.append(&self.state_hashes);
 		stream.append(&self.block_hashes);
 		stream.append(&self.state_root);
@@ -52,14 +55,20 @@ impl ManifestData {
 	/// Try to restore manifest data from raw bytes, interpreted as RLP.
 	pub fn from_rlp(raw: &[u8]) -> Result<Self, DecoderError> {
 		let decoder = UntrustedRlp::new(raw);
+		let (start, version) = if decoder.item_count() == 5 {
+			(0, 1)
+		} else {
+			(1, decoder.val_at(0)?)
+		};

-		let state_hashes: Vec<H256> = decoder.val_at(0)?;
-		let block_hashes: Vec<H256> = decoder.val_at(1)?;
-		let state_root: H256 = decoder.val_at(2)?;
-		let block_number: u64 = decoder.val_at(3)?;
-		let block_hash: H256 = decoder.val_at(4)?;
+		let state_hashes: Vec<H256> = decoder.val_at(start + 0)?;
+		let block_hashes: Vec<H256> = decoder.val_at(start + 1)?;
+		let state_root: H256 = decoder.val_at(start + 2)?;
+		let block_number: u64 = decoder.val_at(start + 3)?;
+		let block_hash: H256 = decoder.val_at(start + 4)?;

 		Ok(ManifestData {
+			version: version,
 			state_hashes: state_hashes,
 			block_hashes: block_hashes,
 			state_root: state_root,
--- a/ethcrypto/Cargo.toml
+++ b/ethcrypto/Cargo.toml
@@ -5,8 +5,8 @@ authors = ["Parity Technologies <admin@parity.io>"]

 [dependencies]
 rust-crypto = "0.2.36"
-tiny-keccak = "1.0"
-eth-secp256k1 = { git = "https://github.com/ethcore/rust-secp256k1" }
+tiny-keccak = "1.2"
+eth-secp256k1 = { git = "https://github.com/paritytech/rust-secp256k1" }
 ethkey = { path = "../ethkey" }
 ethcore-bigint = { path = "../util/bigint" }

--- a/ethkey/Cargo.toml
+++ b/ethkey/Cargo.toml
@@ -6,8 +6,8 @@ authors = ["Parity Technologies <admin@parity.io>"]
 [dependencies]
 rand = "0.3.14"
 lazy_static = "0.2"
-tiny-keccak = "1.0"
-eth-secp256k1 = { git = "https://github.com/ethcore/rust-secp256k1" }
+tiny-keccak = "1.2"
+eth-secp256k1 = { git = "https://github.com/paritytech/rust-secp256k1" }
 rustc-serialize = "0.3"
 docopt = { version = "0.6", optional = true }
 ethcore-bigint = { path = "../util/bigint" }
--- a/ethkey/src/brain.rs
+++ b/ethkey/src/brain.rs
@@ -57,8 +57,8 @@ mod tests {
 	#[test]
 	fn test_brain() {
 		let words = "this is sparta!".to_owned();
-		let first_keypair = Brain(words.clone()).generate().unwrap();
-		let second_keypair = Brain(words.clone()).generate().unwrap();
+		let first_keypair = Brain::new(words.clone()).generate().unwrap();
+		let second_keypair = Brain::new(words.clone()).generate().unwrap();
 		assert_eq!(first_keypair.secret(), second_keypair.secret());
 	}
 }
--- a/ethstore/Cargo.toml
+++ b/ethstore/Cargo.toml
@@ -13,7 +13,7 @@ serde_json = "0.9"
 serde_derive = "0.9"
 rustc-serialize = "0.3"
 rust-crypto = "0.2.36"
-tiny-keccak = "1.0"
+tiny-keccak = "1.2"
 docopt = { version = "0.6", optional = true }
 time = "0.1.34"
 lazy_static = "0.2"
--- a/evmbin/Cargo.toml
+++ b/evmbin/Cargo.toml
@@ -5,11 +5,11 @@ version = "0.1.0"
 authors = ["Parity Technologies <admin@parity.io>"]

 [lib]
-name = "evm"
+name = "evmbin"
 path = "./src/main.rs"

 [[bin]]
-name = "evm"
+name = "parity-evm"
 path = "./src/main.rs"

 [dependencies]
--- a/evmjit/Cargo.toml
+++ b/evmjit/Cargo.toml
@@ -7,4 +7,4 @@ authors = ["Parity Technologies <admin@parity.io>"]
 crate-type = ["dylib"]

 [dependencies]
-tiny-keccak = "1.0"
+tiny-keccak = "1.2"
--- a/hash-fetch/Cargo.toml
+++ b/hash-fetch/Cargo.toml
@@ -7,7 +7,7 @@ version = "1.6.0"
 authors = ["Parity Technologies <admin@parity.io>"]

 [dependencies]
-ethabi = "1.0.0"
+ethabi = "1.0"
 futures = "0.1"
 log = "0.3"
 mime = "0.2"
--- a/hw/Cargo.toml
+++ b/hw/Cargo.toml
@@ -9,8 +9,8 @@ authors = ["Parity Technologies <admin@parity.io>"]
 [dependencies]
 log = "0.3"
 parking_lot = "0.3"
-hidapi = { git = "https://github.com/ethcore/hidapi-rs" }
-libusb = { git = "https://github.com/ethcore/libusb-rs" }
+hidapi = { git = "https://github.com/paritytech/hidapi-rs" }
+libusb = { git = "https://github.com/paritytech/libusb-rs" }
 ethkey = { path = "../ethkey" }
 ethcore-bigint = { path = "../util/bigint" }

--- a/hw/src/ledger.rs
+++ b/hw/src/ledger.rs
@@ -271,7 +271,7 @@ impl Manager {
 					chunk_size += size;
 				}
 				trace!("writing {:?}", &hid_chunk[..]);
-				let n = handle.write(&hid_chunk[0..chunk_size])?;
+				let n = handle.write(&hid_chunk[..])?;
 				if n < chunk_size {
 					return Err(Error::Protocol("Write data size mismatch"));
 				}
--- a/ipc/codegen/Cargo.toml
+++ b/ipc/codegen/Cargo.toml
@@ -14,13 +14,13 @@ nightly-testing = ["clippy"]
 with-syntex = ["quasi/with-syntex", "quasi_codegen", "quasi_codegen/with-syntex", "syntex", "syntex_syntax"]

 [build-dependencies]
-quasi_codegen = { version = "0.11", optional = true }
-syntex = { version = "0.33", optional = true }
+quasi_codegen = { version = "0.32", optional = true }
+syntex = { version = "0.58", optional = true }

 [dependencies]
-aster = { version = "0.17", default-features = false }
+aster = { version = "0.41", default-features = false }
 clippy = { version = "^0.*", optional = true }
-quasi = { version = "0.11", default-features = false }
-quasi_macros = { version = "0.11", optional = true }
-syntex = { version = "0.33", optional = true }
-syntex_syntax = { version = "0.33", optional = true }
+quasi = { version = "0.32", default-features = false }
+quasi_macros = { version = "0.32", optional = true }
+syntex = { version = "0.58", optional = true }
+syntex_syntax = { version = "0.58", optional = true }
--- a/ipc/codegen/build.rs
+++ b/ipc/codegen/build.rs
@@ -25,13 +25,11 @@ mod inner {

 	pub fn main() {
 		let out_dir = env::var_os("OUT_DIR").unwrap();
-		let mut registry = syntex::Registry::new();
-		quasi_codegen::register(&mut registry);

 		let src = Path::new("src/lib.rs.in");
 		let dst = Path::new(&out_dir).join("lib.rs");

-		registry.expand("", &src, &dst).unwrap();
+		quasi_codegen::expand(&src, &dst).unwrap();
 	}
 }

--- a/ipc/codegen/src/codegen.rs
+++ b/ipc/codegen/src/codegen.rs
@@ -56,7 +56,7 @@ pub fn expand_ipc_implementation(

 	let builder = aster::AstBuilder::new().span(span);

-	let interface_map = match implement_interface(cx, &builder, &item, push) {
+	let interface_map = match implement_interface(cx, &builder, &item, push, meta_item) {
 		Ok(interface_map) => interface_map,
 		Err(Error) => { return; },
 	};
@@ -99,9 +99,9 @@ fn push_invoke_signature_aster(
 	let inputs = &named_signature.sig.decl.inputs;
 	let (input_type_name, input_arg_names, input_arg_tys) = if inputs.len() > 0 {
 		let first_field_name = field_name(builder, &inputs[0]).name.as_str();
-		if first_field_name == "self" && inputs.len() == 1 { (None, vec![], vec![]) }
+		if &*first_field_name == "self" && inputs.len() == 1 { (None, vec![], vec![]) }
 		else {
-			let skip = if first_field_name == "self" { 2 } else { 1 };
+			let skip = if &*first_field_name == "self" { 2 } else { 1 };
 			let name_str = format!("{}_input", named_signature.ident.name.as_str());

 			let mut arg_names = Vec::new();
@@ -181,6 +181,7 @@ fn implement_dispatch_arm_invoke_stmt(
 	dispatch: &Dispatch,
 ) -> ast::Stmt
 {
+	use ::syntax::tokenstream::TokenTree::Token;
 	let function_name = builder.id(dispatch.function_name.as_str());

 	let input_args_exprs = dispatch.input_arg_names.iter().enumerate().map(|(arg_index, arg_name)| {
@@ -193,56 +194,56 @@ fn implement_dispatch_arm_invoke_stmt(
 	let ext_cx = &*cx;
 	::quasi::parse_stmt_panic(&mut ::syntax::parse::new_parser_from_tts(
 		ext_cx.parse_sess(),
-		ext_cx.cfg(),
 		{
 			let _sp = ext_cx.call_site();
 			let mut tt = ::std::vec::Vec::new();

-			tt.push(::syntax::ast::TokenTree::Token(_sp, ::syntax::parse::token::OpenDelim(::syntax::parse::token::Brace)));
+			tt.push(Token(_sp, ::syntax::parse::token::OpenDelim(::syntax::parse::token::Brace)));

 			if dispatch.return_type_ty.is_some() {
-				tt.push(::syntax::ast::TokenTree::Token(_sp, ::syntax::parse::token::ModSep));
-				tt.push(::syntax::ast::TokenTree::Token(_sp, ::syntax::parse::token::Ident(ext_cx.ident_of("ipc"))));
-				tt.push(::syntax::ast::TokenTree::Token(_sp, ::syntax::parse::token::ModSep));
-				tt.push(::syntax::ast::TokenTree::Token(_sp, ::syntax::parse::token::Ident(ext_cx.ident_of("binary"))));
-				tt.push(::syntax::ast::TokenTree::Token(_sp, ::syntax::parse::token::ModSep));
-				tt.push(::syntax::ast::TokenTree::Token(_sp, ::syntax::parse::token::Ident(ext_cx.ident_of("serialize"))));
-				tt.push(::syntax::ast::TokenTree::Token(_sp, ::syntax::parse::token::OpenDelim(::syntax::parse::token::Paren)));
-				tt.push(::syntax::ast::TokenTree::Token(_sp, ::syntax::parse::token::BinOp(::syntax::parse::token::And)));
+				tt.push(Token(_sp, ::syntax::parse::token::ModSep));
+				tt.push(Token(_sp, ::syntax::parse::token::Ident(ext_cx.ident_of("ipc"))));
+				tt.push(Token(_sp, ::syntax::parse::token::ModSep));
+				tt.push(Token(_sp, ::syntax::parse::token::Ident(ext_cx.ident_of("binary"))));
+				tt.push(Token(_sp, ::syntax::parse::token::ModSep));
+				tt.push(Token(_sp, ::syntax::parse::token::Ident(ext_cx.ident_of("serialize"))));
+				tt.push(Token(_sp, ::syntax::parse::token::OpenDelim(::syntax::parse::token::Paren)));
+				tt.push(Token(_sp, ::syntax::parse::token::BinOp(::syntax::parse::token::And)));
 			}

-			tt.push(::syntax::ast::TokenTree::Token(_sp, ::syntax::parse::token::Ident(ext_cx.ident_of("self"))));
-			tt.push(::syntax::ast::TokenTree::Token(_sp, ::syntax::parse::token::Dot));
+			tt.push(Token(_sp, ::syntax::parse::token::Ident(ext_cx.ident_of("self"))));
+			tt.push(Token(_sp, ::syntax::parse::token::Dot));
 			tt.extend(::quasi::ToTokens::to_tokens(&function_name, ext_cx).into_iter());
-			tt.push(::syntax::ast::TokenTree::Token(_sp, ::syntax::parse::token::OpenDelim(::syntax::parse::token::Paren)));
+			tt.push(Token(_sp, ::syntax::parse::token::OpenDelim(::syntax::parse::token::Paren)));

 			for arg_expr in input_args_exprs {
 				tt.extend(::quasi::ToTokens::to_tokens(&arg_expr, ext_cx).into_iter());
-				tt.push(::syntax::ast::TokenTree::Token(_sp, ::syntax::parse::token::Comma));
+				tt.push(Token(_sp, ::syntax::parse::token::Comma));
 			}

-			tt.push(::syntax::ast::TokenTree::Token(_sp, ::syntax::parse::token::CloseDelim(::syntax::parse::token::Paren)));
+			tt.push(Token(_sp, ::syntax::parse::token::CloseDelim(::syntax::parse::token::Paren)));

 			if dispatch.return_type_ty.is_some() {
-				tt.push(::syntax::ast::TokenTree::Token(_sp, ::syntax::parse::token::CloseDelim(::syntax::parse::token::Paren)));
-				tt.push(::syntax::ast::TokenTree::Token(_sp, ::syntax::parse::token::Dot));
-				tt.push(::syntax::ast::TokenTree::Token(_sp, ::syntax::parse::token::Ident(ext_cx.ident_of("unwrap"))));
-				tt.push(::syntax::ast::TokenTree::Token(_sp, ::syntax::parse::token::OpenDelim(::syntax::parse::token::Paren)));
-				tt.push(::syntax::ast::TokenTree::Token(_sp, ::syntax::parse::token::CloseDelim(::syntax::parse::token::Paren)));
+				tt.push(Token(_sp, ::syntax::parse::token::CloseDelim(::syntax::parse::token::Paren)));
+				tt.push(Token(_sp, ::syntax::parse::token::Dot));
+				tt.push(Token(_sp, ::syntax::parse::token::Ident(ext_cx.ident_of("unwrap"))));
+				tt.push(Token(_sp, ::syntax::parse::token::OpenDelim(::syntax::parse::token::Paren)));
+				tt.push(Token(_sp, ::syntax::parse::token::CloseDelim(::syntax::parse::token::Paren)));
 			}
 			else {
-				tt.push(::syntax::ast::TokenTree::Token(_sp, ::syntax::parse::token::Semi));
-				tt.push(::syntax::ast::TokenTree::Token(_sp, ::syntax::parse::token::Ident(ext_cx.ident_of("Vec"))));
-				tt.push(::syntax::ast::TokenTree::Token(_sp, ::syntax::parse::token::ModSep));
-				tt.push(::syntax::ast::TokenTree::Token(_sp, ::syntax::parse::token::Ident(ext_cx.ident_of("new"))));
-				tt.push(::syntax::ast::TokenTree::Token(_sp, ::syntax::parse::token::OpenDelim(::syntax::parse::token::Paren)));
-				tt.push(::syntax::ast::TokenTree::Token(_sp, ::syntax::parse::token::CloseDelim(::syntax::parse::token::Paren)));
+				tt.push(Token(_sp, ::syntax::parse::token::Semi));
+				tt.push(Token(_sp, ::syntax::parse::token::Ident(ext_cx.ident_of("Vec"))));
+				tt.push(Token(_sp, ::syntax::parse::token::ModSep));
+				tt.push(Token(_sp, ::syntax::parse::token::Ident(ext_cx.ident_of("new"))));
+				tt.push(Token(_sp, ::syntax::parse::token::OpenDelim(::syntax::parse::token::Paren)));
+				tt.push(Token(_sp, ::syntax::parse::token::CloseDelim(::syntax::parse::token::Paren)));

 			}
-			tt.push(::syntax::ast::TokenTree::Token(_sp, ::syntax::parse::token::CloseDelim(::syntax::parse::token::Brace)));
+			tt.push(Token(_sp, ::syntax::parse::token::CloseDelim(::syntax::parse::token::Brace)));

 			tt
-		})).unwrap()
+		}
+	)).unwrap()
 }

 fn implement_dispatch_arm_invoke(
@@ -344,6 +345,8 @@ fn implement_client_method_body(
 	interface_map: &InterfaceMap,
 ) -> P<ast::Expr>
 {
+	use ::syntax::tokenstream::TokenTree::Token;
+
 	let dispatch = &interface_map.dispatches[index as usize];
 	let index_ident = builder.id(format!("{}", index + RESERVED_MESSAGE_IDS).as_str());

@@ -391,26 +394,25 @@ fn implement_client_method_body(
 			let ext_cx = &*cx;
 			::quasi::parse_stmt_panic(&mut ::syntax::parse::new_parser_from_tts(
 				ext_cx.parse_sess(),
-				ext_cx.cfg(),
 				{
 					let _sp = ext_cx.call_site();
 					let mut tt = ::std::vec::Vec::new();
-					tt.push(::syntax::ast::TokenTree::Token(_sp, ::syntax::parse::token::Ident(ext_cx.ident_of("let"))));
-					tt.push(::syntax::ast::TokenTree::Token(_sp, ::syntax::parse::token::Ident(ext_cx.ident_of("payload"))));
-					tt.push(::syntax::ast::TokenTree::Token(_sp, ::syntax::parse::token::Eq));
-					tt.push(::syntax::ast::TokenTree::Token(_sp, ::syntax::parse::token::Ident(ext_cx.ident_of("Request"))));
-					tt.push(::syntax::ast::TokenTree::Token(_sp, ::syntax::parse::token::OpenDelim(::syntax::parse::token::Brace)));
+					tt.push(Token(_sp, ::syntax::parse::token::Ident(ext_cx.ident_of("let"))));
+					tt.push(Token(_sp, ::syntax::parse::token::Ident(ext_cx.ident_of("payload"))));
+					tt.push(Token(_sp, ::syntax::parse::token::Eq));
+					tt.push(Token(_sp, ::syntax::parse::token::Ident(ext_cx.ident_of("Request"))));
+					tt.push(Token(_sp, ::syntax::parse::token::OpenDelim(::syntax::parse::token::Brace)));

 					for arg in dispatch.input_arg_names.iter() {
-						tt.push(::syntax::ast::TokenTree::Token(_sp, ::syntax::parse::token::Ident(ext_cx.ident_of(arg.as_str()))));
-						tt.push(::syntax::ast::TokenTree::Token(_sp, ::syntax::parse::token::Colon));
-						tt.push(::syntax::ast::TokenTree::Token(_sp, ::syntax::parse::token::BinOp(::syntax::parse::token::And)));
+						tt.push(Token(_sp, ::syntax::parse::token::Ident(ext_cx.ident_of(arg.as_str()))));
+						tt.push(Token(_sp, ::syntax::parse::token::Colon));
+						tt.push(Token(_sp, ::syntax::parse::token::BinOp(::syntax::parse::token::And)));

-						tt.push(::syntax::ast::TokenTree::Token(_sp, ::syntax::parse::token::Ident(ext_cx.ident_of(arg.as_str()))));
-						tt.push(::syntax::ast::TokenTree::Token(_sp, ::syntax::parse::token::Comma));
+						tt.push(Token(_sp, ::syntax::parse::token::Ident(ext_cx.ident_of(arg.as_str()))));
+						tt.push(Token(_sp, ::syntax::parse::token::Comma));
 					}

-					tt.push(::syntax::ast::TokenTree::Token(_sp, ::syntax::parse::token::CloseDelim(::syntax::parse::token::Brace)));
+					tt.push(Token(_sp, ::syntax::parse::token::CloseDelim(::syntax::parse::token::Brace)));
 					tt
 				}))
 			});
@@ -465,6 +467,8 @@ fn implement_client_method(
 )
 	-> ast::ImplItem
 {
+	use ::syntax::tokenstream::TokenTree::Token;
+
 	let dispatch = &interface_map.dispatches[index as usize];
 	let method_name = builder.id(dispatch.function_name.as_str());
 	let body = implement_client_method_body(cx, builder, index, interface_map);
@@ -476,36 +480,35 @@ fn implement_client_method(
 	let signature = ::syntax::parse::parser::Parser::parse_impl_item(
 		&mut ::syntax::parse::new_parser_from_tts(
 			ext_cx.parse_sess(),
-			ext_cx.cfg(),
 			{
 				let _sp = ext_cx.call_site();
 				let mut tt = ::std::vec::Vec::new();
-				tt.push(::syntax::ast::TokenTree::Token(_sp, ::syntax::parse::token::Ident(ext_cx.ident_of("fn"))));
+				tt.push(Token(_sp, ::syntax::parse::token::Ident(ext_cx.ident_of("fn"))));
 				tt.extend(::quasi::ToTokens::to_tokens(&method_name, ext_cx).into_iter());
-				tt.push(::syntax::ast::TokenTree::Token(_sp, ::syntax::parse::token::OpenDelim(::syntax::parse::token::Paren)));
-				tt.push(::syntax::ast::TokenTree::Token(_sp, ::syntax::parse::token::BinOp(::syntax::parse::token::And)));
-				tt.push(::syntax::ast::TokenTree::Token(_sp, ::syntax::parse::token::Ident(ext_cx.ident_of("self"))));
-				tt.push(::syntax::ast::TokenTree::Token(_sp, ::syntax::parse::token::Comma));
+				tt.push(Token(_sp, ::syntax::parse::token::OpenDelim(::syntax::parse::token::Paren)));
+				tt.push(Token(_sp, ::syntax::parse::token::BinOp(::syntax::parse::token::And)));
+				tt.push(Token(_sp, ::syntax::parse::token::Ident(ext_cx.ident_of("self"))));
+				tt.push(Token(_sp, ::syntax::parse::token::Comma));

 				for arg_idx in 0..dispatch.input_arg_names.len() {
 					let arg_name = dispatch.input_arg_names[arg_idx].as_str();
 					let arg_ty = dispatch.input_arg_tys[arg_idx].clone();

-					tt.push(::syntax::ast::TokenTree::Token(_sp, ::syntax::parse::token::Ident(ext_cx.ident_of(arg_name))));
-					tt.push(::syntax::ast::TokenTree::Token(_sp, ::syntax::parse::token::Colon));
+					tt.push(Token(_sp, ::syntax::parse::token::Ident(ext_cx.ident_of(arg_name))));
+					tt.push(Token(_sp, ::syntax::parse::token::Colon));
 					tt.extend(::quasi::ToTokens::to_tokens(&arg_ty, ext_cx).into_iter());
-					tt.push(::syntax::ast::TokenTree::Token(_sp, ::syntax::parse::token::Comma));
+					tt.push(Token(_sp, ::syntax::parse::token::Comma));
 				}
-				tt.push(::syntax::ast::TokenTree::Token(_sp, ::syntax::parse::token::CloseDelim(::syntax::parse::token::Paren)));
+				tt.push(Token(_sp, ::syntax::parse::token::CloseDelim(::syntax::parse::token::Paren)));

 				if let Some(ref return_ty) = dispatch.return_type_ty {
-					tt.push(::syntax::ast::TokenTree::Token(_sp, ::syntax::parse::token::RArrow));
+					tt.push(Token(_sp, ::syntax::parse::token::RArrow));
 					tt.extend(::quasi::ToTokens::to_tokens(return_ty, ext_cx).into_iter());
 				}

-				tt.push(::syntax::ast::TokenTree::Token(_sp, ::syntax::parse::token::OpenDelim(::syntax::parse::token::Brace)));
+				tt.push(Token(_sp, ::syntax::parse::token::OpenDelim(::syntax::parse::token::Brace)));
 				tt.extend(::quasi::ToTokens::to_tokens(&body, ext_cx).into_iter());
-				tt.push(::syntax::ast::TokenTree::Token(_sp, ::syntax::parse::token::CloseDelim(::syntax::parse::token::Brace)));
+				tt.push(Token(_sp, ::syntax::parse::token::CloseDelim(::syntax::parse::token::Brace)));

 				tt
 			}));
@@ -526,7 +529,7 @@ fn client_generics(builder: &aster::AstBuilder, interface_map: &InterfaceMap) ->

 fn client_qualified_ident(cx: &ExtCtxt, builder: &aster::AstBuilder, interface_map: &InterfaceMap) -> P<Ty> {
 	let generics = client_generics(builder, interface_map);
-	aster::ty::TyBuilder::new().path().segment(interface_map.ident_map.client_ident(cx, builder, &interface_map.original_item))
+	aster::ty::TyBuilder::new().path().segment(interface_map.ident_map.client_ident(cx, builder))
 		.with_generics(generics).build()
 		.build()
 }
@@ -542,7 +545,7 @@ fn client_phantom_ident(builder: &aster::AstBuilder, interface_map: &InterfaceMa
 /// for say `Service` it generates `ServiceClient`
 fn push_client_struct(cx: &ExtCtxt, builder: &aster::AstBuilder, interface_map: &InterfaceMap, push: &mut FnMut(Annotatable)) {
 	let generics = client_generics(builder, interface_map);
-	let client_short_ident = interface_map.ident_map.client_ident(cx, builder, &interface_map.original_item);
+	let client_short_ident = interface_map.ident_map.client_ident(cx, builder);
 	let phantom = client_phantom_ident(builder, interface_map);

 	let client_struct_item = quote_item!(cx,
@@ -575,7 +578,7 @@ fn push_with_socket_client_implementation(
 	let generics = client_generics(builder, interface_map);
 	let client_ident = client_qualified_ident(cx, builder, interface_map);
 	let where_clause = &generics.where_clause;
-	let client_short_ident = interface_map.ident_map.client_ident(cx, builder, &interface_map.original_item);
+	let client_short_ident = interface_map.ident_map.client_ident(cx, builder);

 	let implement = quote_item!(cx,
 		impl $generics ::ipc::WithSocket<S> for $client_ident $where_clause {
@@ -717,33 +720,31 @@ fn get_str_from_lit(cx: &ExtCtxt, name: &str, lit: &ast::Lit) -> Result<String,
 	}
 }

-pub fn get_ipc_meta_items(attr: &ast::Attribute) -> Option<&[P<ast::MetaItem>]> {
-    match attr.node.value.node {
-        ast::MetaItemKind::List(ref name, ref items) if name == &"ipc" => {
-            Some(items)
-        }
-        _ => None
-    }
-}
-
-fn client_ident_renamed(cx: &ExtCtxt, item: &ast::Item) -> Option<String> {
-	for meta_items in item.attrs().iter().filter_map(get_ipc_meta_items) {
-		for meta_item in meta_items {
-			match meta_item.node {
-				ast::MetaItemKind::NameValue(ref name, ref lit) if name == &"client_ident" => {
-					if let Ok(s) = get_str_from_lit(cx, name, lit) {
-						return Some(s);
+fn client_ident_renamed(cx: &ExtCtxt, meta_item: &MetaItem) -> Option<String> {
+	if let ast::MetaItemKind::List(ref list) = meta_item.node {
+		for nested in list {
+			match nested.node {
+				ast::NestedMetaItemKind::MetaItem(ref meta_item) => {
+					let is_client_ident = &*meta_item.name.as_str() == "client_ident";
+					match meta_item.node {
+						ast::MetaItemKind::NameValue(ref lit) if is_client_ident => {
+							if let Ok(s) = get_str_from_lit(cx, "client_ident", lit) {
+								return Some(s);
+							}
+						}
+						_ => {
+							cx.span_err(
+								meta_item.span,
+								&format!("unknown client_ident container attribute `{}`",
+										 ::syntax::print::pprust::meta_item_to_string(&meta_item)));
+						}
 					}
-				}
-				_ => {
-					cx.span_err(
-						meta_item.span,
-						&format!("unknown client_ident container attribute `{}`",
-								 ::syntax::print::pprust::meta_item_to_string(meta_item)));
-				}
+				},
+				_ => {},
 			}
 		}
 	}
+
 	None
 }

@@ -759,6 +760,7 @@ struct InterfaceMap {

 struct IdentMap {
 	original_path: ast::Path,
+	meta_item: MetaItem,
 }

 impl IdentMap {
@@ -766,8 +768,8 @@ impl IdentMap {
 		builder.id(format!("{}", ::syntax::print::pprust::path_to_string(&self.original_path)))
 	}

-	fn client_ident(&self, cx: &ExtCtxt, builder: &aster::AstBuilder, item: &ast::Item) -> Ident {
-		if let Some(new_name) = client_ident_renamed(cx, item) {
+	fn client_ident(&self, cx: &ExtCtxt, builder: &aster::AstBuilder) -> Ident {
+		if let Some(new_name) = client_ident_renamed(cx, &self.meta_item) {
 			builder.id(new_name)
 		}
 		else {
@@ -776,12 +778,12 @@ impl IdentMap {
 	}
 }

-fn ty_ident_map(original_ty: &P<Ty>) -> IdentMap {
+fn ty_ident_map(original_ty: &P<Ty>, meta_item: &MetaItem) -> IdentMap {
 	let original_path = match original_ty.node {
 		::syntax::ast::TyKind::Path(_, ref path) => path.clone(),
 		_ => { panic!("incompatible implementation"); }
 	};
-	let ident_map = IdentMap { original_path: original_path };
+	let ident_map = IdentMap { original_path: original_path, meta_item: meta_item.clone() };
 	ident_map
 }

@@ -791,6 +793,7 @@ fn implement_interface(
 	builder: &aster::AstBuilder,
 	item: &Item,
 	push: &mut FnMut(Annotatable),
+	meta_item: &MetaItem,
 ) -> Result<InterfaceMap, Error> {
 	let (generics, impl_trait, original_ty, dispatch_table) = match item.node {
 		ast::ItemKind::Impl(_, _, ref generics, ref impl_trait, ref ty, ref impl_items) => {
@@ -844,7 +847,7 @@ fn implement_interface(

 	let (handshake_arm, handshake_arm_buf) = implement_handshake_arm(cx);

-	let ty = ty_ident_map(&original_ty).ident(builder);
+	let ty = ty_ident_map(&original_ty, meta_item).ident(builder);
 	let (interface_endpoint, host_generics) = match impl_trait {
 		Some(ref trait_) => (builder.id(::syntax::print::pprust::path_to_string(&trait_.path)), None),
 		None => (ty, Some(&impl_generics)),
@@ -884,7 +887,7 @@ fn implement_interface(
 	).unwrap();

 	Ok(InterfaceMap {
-		ident_map: ty_ident_map(&original_ty),
+		ident_map: ty_ident_map(&original_ty, meta_item),
 		original_item: item.clone(),
 		item: ipc_item,
 		dispatches: dispatch_table,
--- a/ipc/codegen/src/lib.rs
+++ b/ipc/codegen/src/lib.rs
@@ -66,9 +66,11 @@ struct StripAttributeFolder<'a> {
 #[cfg(feature = "with-syntex")]
 impl<'a> fold::Folder for StripAttributeFolder<'a> {
 	fn fold_attribute(&mut self, attr: ast::Attribute) -> Option<ast::Attribute> {
-		match attr.node.value.node {
-			ast::MetaItemKind::List(ref n, _) if n == self.attr_title => { return None; }
-			ast::MetaItemKind::Word(ref n) if n == self.attr_title => { return None; }
+		let is_self = &*attr.value.name.as_str() == self.attr_title;
+
+		match attr.value.node {
+			ast::MetaItemKind::List(_) if is_self => { return None; }
+			ast::MetaItemKind::Word if is_self => { return None; }
 			_ => {}
 		}

--- a/ipc/codegen/src/serialization.rs
+++ b/ipc/codegen/src/serialization.rs
@@ -151,7 +151,7 @@ fn binary_expr(
 		_ => {
 			cx.span_bug(item.span,
 						"expected ItemStruct or ItemEnum in #[derive(Binary)]");
-			Err(Error)
+			Err(Error) as Result<BinaryExpressions, Error>
 		},
 	}
 }
@@ -184,13 +184,17 @@ fn binary_expr_struct(
 	let size_exprs: Vec<P<ast::Expr>> = fields.iter().enumerate().map(|(index, field)| {
 		let raw_ident = ::syntax::print::pprust::ty_to_string(&codegen::strip_ptr(&field.ty));
 		let index_ident = builder.id(format!("__field{}", index));
+		let field_id = match field.ident {
+			Some(ident) => builder.id(ident),
+			None => builder.id(format!("{}", index)),
+		};
+
 		match raw_ident.as_ref() {
 			"u8" => {
 				quote_expr!(cx, 1)
 			},
 			"[u8]" => {
 				value_ident.and_then(|x| {
-						let field_id = builder.id(field.ident.unwrap());
 						Some(quote_expr!(cx, $x. $field_id .len()))
 					})
 					.unwrap_or_else(|| {
@@ -207,7 +211,6 @@ fn binary_expr_struct(

 				value_ident.and_then(|x|
 					{
-						let field_id = builder.id(field.ident.unwrap());
 						Some(quote_expr!(cx,
 							match $field_type_ident_qualified::len_params() {
 								0 => ::std::mem::size_of::<$field_type_ident>(),
@@ -232,12 +235,12 @@ fn binary_expr_struct(
 	}

 	let mut write_stmts = Vec::<ast::Stmt>::new();
-	write_stmts.push(quote_stmt!(cx, let mut offset = 0usize;).unwrap());
+	write_stmts.push(quote_stmt!(cx, let mut offset = 0usize;).expect("stmt1"));

 	let mut map_stmts = Vec::<ast::Stmt>::new();
 	let field_amount = builder.id(&format!("{}",fields.len()));
-	map_stmts.push(quote_stmt!(cx, let mut map = vec![0usize; $field_amount];).unwrap());
-	map_stmts.push(quote_stmt!(cx, let mut total = 0usize;).unwrap());
+	map_stmts.push(quote_stmt!(cx, let mut map = vec![0usize; $field_amount];).expect("stmt2"));
+	map_stmts.push(quote_stmt!(cx, let mut total = 0usize;).expect("stmt3"));

 	let mut post_write_stmts = Vec::<ast::Stmt>::new();

@@ -248,9 +251,12 @@ fn binary_expr_struct(
 		let field_type_ident_qualified = builder.id(
 			replace_qualified(&::syntax::print::pprust::ty_to_string(&codegen::strip_ptr(&field.ty))));

+		let field_id = match field.ident {
+			Some(ident) => builder.id(ident),
+			None => builder.id(format!("{}", index)),
+		};
 		let member_expr = match value_ident {
 			Some(x) => {
-				let field_id = builder.id(field.ident.unwrap());
 				quote_expr!(cx, $x . $field_id)
 			},
 			None => {
@@ -267,8 +273,8 @@ fn binary_expr_struct(

 		match raw_ident.as_ref() {
 			"u8" => {
-				write_stmts.push(quote_stmt!(cx, let next_line = offset + 1;).unwrap());
-				write_stmts.push(quote_stmt!(cx, buffer[offset] = $member_expr; ).unwrap());
+				write_stmts.push(quote_stmt!(cx, let next_line = offset + 1;).expect("stmt4"));
+				write_stmts.push(quote_stmt!(cx, buffer[offset] = $member_expr; ).expect("stm5"));
 			},
 			"[u8]" => {
 				write_stmts.push(quote_stmt!(cx, let size = $member_expr .len();).unwrap());
@@ -374,7 +380,7 @@ fn binary_expr_item_struct(
 			cx.span_bug(span,
 				&format!("#[derive(Binary)] Unsupported struct content, expected tuple/struct, found: {:?}",
 					variant_data));
-			Err(Error)
+			Err(Error) as Result<BinaryExpressions, Error>
 		},
 	}
 }
@@ -431,13 +437,12 @@ fn fields_sequence(
 	variant_ident: &ast::Ident,
 ) -> ast::Expr {
 	use syntax::parse::token;
-	use syntax::ast::TokenTree::Token;
+	use syntax::tokenstream::TokenTree::Token;

 	let named_members = fields.iter().any(|f| f.ident.is_some());

 	::quasi::parse_expr_panic(&mut ::syntax::parse::new_parser_from_tts(
 		ext_cx.parse_sess(),
-		ext_cx.cfg(),
 		{
 			let _sp = ext_cx.call_site();
 			let mut tt = ::std::vec::Vec::new();
@@ -569,11 +574,10 @@ fn named_fields_sequence(
 	fields: &[ast::StructField],
 ) -> ast::Stmt {
 	use syntax::parse::token;
-	use syntax::ast::TokenTree::Token;
+	use syntax::tokenstream::TokenTree::Token;

 	::quasi::parse_stmt_panic(&mut ::syntax::parse::new_parser_from_tts(
 		ext_cx.parse_sess(),
-		ext_cx.cfg(),
 		{
 			let _sp = ext_cx.call_site();
 			let mut tt = ::std::vec::Vec::new();
@@ -590,7 +594,10 @@ fn named_fields_sequence(
 			tt.push(Token(_sp, token::OpenDelim(token::Brace)));

 			for (idx, field) in fields.iter().enumerate() {
-				tt.push(Token(_sp, token::Ident(field.ident.clone().expect("function is called for named fields"))));
+				tt.push(Token(_sp, match field.ident {
+					Some(ident) => token::Ident(ident),
+					None => token::Ident(ext_cx.ident_of(&format!("{}", idx))),
+				}));
 				tt.push(Token(_sp, token::Colon));

 				// special case for u8, it just takes byte form sequence
--- a/ipc/hypervisor/Cargo.toml
+++ b/ipc/hypervisor/Cargo.toml
@@ -9,7 +9,7 @@ build = "build.rs"

 [dependencies]
 ethcore-ipc = { path = "../rpc" }
-nanomsg = { git = "https://github.com/ethcore/nanomsg.rs.git" }
+nanomsg = { git = "https://github.com/paritytech/nanomsg.rs.git", branch = "parity-1.7" }
 ethcore-ipc-nano = { path = "../nano" }
 semver = "0.5"
 log = "0.3"
--- a/ipc/nano/Cargo.toml
+++ b/ipc/nano/Cargo.toml
@@ -8,6 +8,6 @@ license = "GPL-3.0"

 [dependencies]
 ethcore-ipc = { path = "../rpc" }
-nanomsg = { git = "https://github.com/ethcore/nanomsg.rs.git" }
+nanomsg = { git = "https://github.com/paritytech/nanomsg.rs.git", branch = "parity-1.7" }
 log = "0.3"
 lazy_static = "0.2"
--- a/ipc/rpc/Cargo.toml
+++ b/ipc/rpc/Cargo.toml
@@ -8,6 +8,6 @@ license = "GPL-3.0"

 [dependencies]
 ethcore-devtools = { path = "../../devtools" }
-nanomsg = { git = "https://github.com/ethcore/nanomsg.rs.git" }
+nanomsg = { git = "https://github.com/paritytech/nanomsg.rs.git", branch = "parity-1.7" }
 ethcore-util = { path = "../../util" }
 semver = "0.5"
--- a/ipc/tests/Cargo.toml
+++ b/ipc/tests/Cargo.toml
@@ -11,7 +11,7 @@ path = "run.rs"
 ethcore-ipc = { path = "../rpc" }
 ethcore-devtools = { path = "../../devtools" }
 semver = "0.5"
-nanomsg = { git = "https://github.com/ethcore/nanomsg.rs.git" }
+nanomsg = { git = "https://github.com/paritytech/nanomsg.rs.git", branch = "parity-1.7" }
 ethcore-ipc-nano = { path = "../nano" }
 ethcore-util = { path = "../../util" }
 log = "0.3"
--- a/ipfs/Cargo.toml
+++ b/ipfs/Cargo.toml
@@ -8,9 +8,9 @@ authors = ["Parity Technologies <admin@parity.io>"]
 [dependencies]
 ethcore = { path = "../ethcore" }
 ethcore-util = { path = "../util" }
-jsonrpc-http-server = { git = "https://github.com/ethcore/jsonrpc.git" }
+jsonrpc-http-server = { git = "https://github.com/ethcore/jsonrpc.git", branch = "parity-1.6" }
 rlp = { path = "../util/rlp" }
 mime = "0.2"
 hyper = { default-features = false, git = "https://github.com/ethcore/hyper" }
-cid = "0.2.1"
-multihash = "0.5"
+cid = "0.2.2"
+multihash = "0.6"
--- a/js/Cargo.precompiled.toml
+++ b/js/Cargo.precompiled.toml
@@ -12,8 +12,8 @@ use-precompiled-js = ["parity-dapps-glue/use-precompiled-js"]
 with-syntex = ["parity-dapps-glue/with-syntex"]

 [build-dependencies]
-parity-dapps-glue = "1.4"
+parity-dapps-glue = "1.7"

 [dependencies]
-parity-dapps-glue = "1.4"
+parity-dapps-glue = "1.7"

--- a/js/Cargo.toml
+++ b/js/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 description = "Parity built-in dapps."
 name = "parity-ui-dev"
-version = "1.4.0"
+version = "1.7.0"
 license = "GPL-3.0"
 authors = ["Parity Technologies <admin@parity.io>"]
 build = "build.rs"
@@ -11,8 +11,8 @@ default = ["with-syntex"]
 with-syntex = ["parity-dapps-glue/with-syntex"]

 [build-dependencies]
-parity-dapps-glue = "1.4"
+parity-dapps-glue = "1.7"

 [dependencies]
-parity-dapps-glue = "1.4"
+parity-dapps-glue = "1.7"

--- a/js/package.json
+++ b/js/package.json
@@ -150,6 +150,7 @@
    "blockies": "0.0.2",
    "brace": "0.9.0",
    "bytes": "2.4.0",
+    "date-difference": "1.0.0",
    "debounce": "1.0.0",
    "es6-error": "4.0.0",
    "es6-promise": "4.0.5",
--- a/js/scripts/build-rpc-markdown.js
+++ b/js/scripts/build-rpc-markdown.js
@@ -37,7 +37,11 @@ Object.keys(rustMethods).forEach((group) => {
  });
 });

-function printType (type) {
+function printType (type, obj) {
+  if (!type) {
+    throw new Error(`Invalid type in ${JSON.stringify(obj)}`);
+  }
+
  return type.print || `\`${type.name}\``;
 }

@@ -45,7 +49,7 @@ function formatDescription (obj, prefix = '', indent = '') {
  const optional = obj.optional ? '(optional) ' : '';
  const defaults = obj.default ? `(default: \`${obj.default}\`) ` : '';

-  return `${indent}${prefix}${printType(obj.type)} - ${optional}${defaults}${obj.desc}`;
+  return `${indent}${prefix}${printType(obj.type, obj)} - ${optional}${defaults}${obj.desc}`;
 }

 function formatType (obj) {
--- a/js/scripts/release.sh
+++ b/js/scripts/release.sh
@@ -5,8 +5,8 @@ set -e
 UTCDATE=`date -u "+%Y%m%d-%H%M%S"`
 PACKAGES=( "parity" "etherscan" "shapeshift" "jsonrpc" )
 BRANCH=$CI_BUILD_REF_NAME
-GIT_JS_PRECOMPILED="https://${GITHUB_JS_PRECOMPILED}:@github.com/ethcore/js-precompiled.git"
-GIT_PARITY="https://${GITHUB_JS_PRECOMPILED}:@github.com/ethcore/parity.git"
+GIT_JS_PRECOMPILED="https://${GITHUB_JS_PRECOMPILED}:@github.com/paritytech/js-precompiled.git"
+GIT_PARITY="https://${GITHUB_JS_PRECOMPILED}:@github.com/paritytech/parity.git"

 # setup the git user defaults for the current repo
 function setup_git_user {
--- a/js/src/api/format/input.js
+++ b/js/src/api/format/input.js
@@ -211,3 +211,36 @@ export function inTraceType (whatTrace) {

  return whatTrace;
 }
+
+function inDeriveType (derive) {
+  return derive && derive.type === 'hard' ? 'hard' : 'soft';
+}
+
+export function inDeriveHash (derive) {
+  const hash = derive && derive.hash ? derive.hash : derive;
+  const type = inDeriveType(derive);
+
+  return {
+    hash: inHex(hash),
+    type
+  };
+}
+
+export function inDeriveIndex (derive) {
+  if (!derive) {
+    return [];
+  }
+
+  if (!isArray(derive)) {
+    derive = [derive];
+  }
+
+  return derive.map(item => {
+    const index = inNumber10(item && item.index ? item.index : item);
+
+    return {
+      index,
+      type: inDeriveType(item)
+    };
+  });
+}
--- a/js/src/api/format/input.spec.js
+++ b/js/src/api/format/input.spec.js
@@ -16,7 +16,11 @@

 import BigNumber from 'bignumber.js';

-import { inAddress, inBlockNumber, inData, inFilter, inHex, inNumber10, inNumber16, inOptions, inTraceType } from './input';
+import {
+  inAddress, inBlockNumber, inData, inFilter, inHex,
+  inNumber10, inNumber16, inOptions, inTraceType,
+  inDeriveHash, inDeriveIndex
+} from './input';
 import { isAddress } from '../../../test/types';

 describe('api/format/input', () => {
@@ -215,7 +219,7 @@ describe('api/format/input', () => {
      expect(formatted.to).to.equal('');
    });

-    ['gas', 'gasPrice', 'value', 'minBlock', 'nonce'].forEach((input) => {
+    ['gas', 'gasPrice', 'value', 'nonce'].forEach((input) => {
      it(`formats ${input} number as hexnumber`, () => {
        const block = {};

@@ -226,8 +230,8 @@ describe('api/format/input', () => {
      });
    });

-    it('passes minBlock as null when specified as such', () => {
-      expect(inOptions({ minBlock: null })).to.deep.equal({ minBlock: null });
+    it('passes condition as null when specified as such', () => {
+      expect(inOptions({ condition: null })).to.deep.equal({ condition: null });
    });

    it('ignores and passes through unknown keys', () => {
@@ -272,4 +276,66 @@ describe('api/format/input', () => {
      expect(inTraceType(type)).to.deep.equal([type]);
    });
  });
+
+  describe('inDeriveHash', () => {
+    it('returns derive hash', () => {
+      expect(inDeriveHash(1)).to.deep.equal({
+        hash: '0x1',
+        type: 'soft'
+      });
+
+      expect(inDeriveHash(null)).to.deep.equal({
+        hash: '0x',
+        type: 'soft'
+      });
+
+      expect(inDeriveHash({
+        hash: 5
+      })).to.deep.equal({
+        hash: '0x5',
+        type: 'soft'
+      });
+
+      expect(inDeriveHash({
+        hash: 5,
+        type: 'hard'
+      })).to.deep.equal({
+        hash: '0x5',
+        type: 'hard'
+      });
+    });
+  });
+
+  describe('inDeriveIndex', () => {
+    it('returns derive hash', () => {
+      expect(inDeriveIndex(null)).to.deep.equal([]);
+      expect(inDeriveIndex([])).to.deep.equal([]);
+
+      expect(inDeriveIndex([1])).to.deep.equal([{
+        index: 1,
+        type: 'soft'
+      }]);
+
+      expect(inDeriveIndex({
+        index: 1
+      })).to.deep.equal([{
+        index: 1,
+        type: 'soft'
+      }]);
+
+      expect(inDeriveIndex([{
+        index: 1,
+        type: 'hard'
+      }, 5])).to.deep.equal([
+        {
+          index: 1,
+          type: 'hard'
+        },
+        {
+          index: 5,
+          type: 'soft'
+        }
+      ]);
+    });
+  });
 });
--- a/js/src/api/format/output.js
+++ b/js/src/api/format/output.js
@@ -280,12 +280,6 @@ export function outTransaction (tx) {
          tx[key] = outTransactionCondition(tx[key]);
          break;

-        case 'minBlock':
-          tx[key] = tx[key]
-            ? outNumber(tx[key])
-            : null;
-          break;
-
        case 'creates':
        case 'from':
        case 'to':
--- a/js/src/api/format/output.spec.js
+++ b/js/src/api/format/output.spec.js
@@ -384,7 +384,7 @@ describe('api/format/output', () => {
      });
    });

-    ['blockNumber', 'gasPrice', 'gas', 'minBlock', 'nonce', 'transactionIndex', 'value'].forEach((input) => {
+    ['blockNumber', 'gasPrice', 'gas', 'nonce', 'transactionIndex', 'value'].forEach((input) => {
      it(`formats ${input} number as hexnumber`, () => {
        const block = {};

@@ -396,8 +396,8 @@ describe('api/format/output', () => {
      });
    });

-    it('passes minBlock as null when null', () => {
-      expect(outTransaction({ minBlock: null })).to.deep.equal({ minBlock: null });
+    it('passes condition as null when null', () => {
+      expect(outTransaction({ condition: null })).to.deep.equal({ condition: null });
    });

    it('ignores and passes through unknown keys', () => {
--- a/js/src/api/rpc/parity/parity.js
+++ b/js/src/api/rpc/parity/parity.js
@@ -14,7 +14,9 @@
 // You should have received a copy of the GNU General Public License
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.

-import { inAddress, inAddresses, inData, inHex, inNumber16, inOptions, inBlockNumber } from '../../format/input';
+import {
+  inAddress, inAddresses, inData, inHex, inNumber16, inOptions, inBlockNumber, inDeriveHash, inDeriveIndex
+} from '../../format/input';
 import { outAccountInfo, outAddress, outAddresses, outChainStatus, outHistogram, outHwAccountInfo, outNumber, outPeers, outRecentDapps, outTransaction, outVaultMeta } from '../../format/output';

 export default class Parity {
@@ -117,6 +119,18 @@ export default class Parity {
      .execute('parity_devLogsLevels');
  }

+  deriveAddressHash (address, password, hash, shouldSave) {
+    return this._transport
+      .execute('parity_deriveAddressHash', inAddress(address), password, inDeriveHash(hash), !!shouldSave)
+      .then(outAddress);
+  }
+
+  deriveAddressIndex (address, password, index, shouldSave) {
+    return this._transport
+      .execute('parity_deriveAddressIndex', inAddress(address), password, inDeriveIndex(index), !!shouldSave)
+      .then(outAddress);
+  }
+
  dropNonReservedPeers () {
    return this._transport
      .execute('parity_dropNonReservedPeers');
@@ -137,6 +151,11 @@ export default class Parity {
      .execute('parity_executeUpgrade');
  }

+  exportAccount (address, password) {
+    return this._transport
+      .execute('parity_exportAccount', inAddress(address), password);
+  }
+
  extraData () {
    return this._transport
      .execute('parity_extraData');
@@ -389,6 +408,12 @@ export default class Parity {
      .execute('parity_removeReservedPeer', encode);
  }

+  removeTransaction (hash) {
+    return this._transport
+      .execute('parity_removeTransaction', inHex(hash))
+      .then(outTransaction);
+  }
+
  rpcSettings () {
    return this._transport
      .execute('parity_rpcSettings');
--- a/js/src/api/subscriptions/personal.js
+++ b/js/src/api/subscriptions/personal.js
@@ -42,7 +42,7 @@ export default class Personal {

  // FIXME: Because of the different API instances, the "wait for valid changes" approach
  // doesn't work. Since the defaultAccount is critical to operation, we poll in exactly
-  // same way we do in ../eth (ala same as eth_blockNumber) and update. This should be moved
+  // same way we do in ../eth (ala eth_blockNumber) and update. This should be moved
  // to pub-sub as it becomes available
  _defaultAccount = (timerDisabled = false) => {
    const nextTimeout = (timeout = 1000) => {
--- a/js/src/dapps/registry/Accounts/accounts.css
+++ b/js/src/dapps/registry/Accounts/accounts.css
@@ -15,24 +15,10 @@
 /* along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 */

-.button {
-  /* TODO remove !important once material design lite is used */
-  padding: 0 !important;
-}
-
 .icon {
  /* TODO remove !important once material design lite is used */
-  margin: 0 !important;
-  width: 30px !important;
  height: 30px !important;
-}
-
-.menuIcon {
-  display: inline-block;
-  vertical-align: middle;
-}
-.menuText {
-  display: inline-block;
-  line-height: 24px;
-  vertical-align: top;
+  margin: 0 !important;
+  padding: 0 !important;
+  width: 30px !important;
 }
--- a/js/src/dapps/registry/Accounts/accounts.js
+++ b/js/src/dapps/registry/Accounts/accounts.js
@@ -17,83 +17,50 @@
 import React, { Component, PropTypes } from 'react';
 import { connect } from 'react-redux';
 import { bindActionCreators } from 'redux';
-import IconMenu from 'material-ui/IconMenu';
-import IconButton from 'material-ui/IconButton/IconButton';
 import AccountIcon from 'material-ui/svg-icons/action/account-circle';
-import MenuItem from 'material-ui/MenuItem';

+import { init } from './actions';
 import IdentityIcon from '../IdentityIcon';
-import Address from '../ui/address';

-import { select } from './actions';
 import styles from './accounts.css';

 class Accounts extends Component {
  static propTypes = {
-    all: PropTypes.object.isRequired,
-    selected: PropTypes.object,
+    selected: PropTypes.oneOfType([
+      PropTypes.oneOf([ null ]),
+      PropTypes.string
+    ]),
+    onInit: PropTypes.func.isRequired
+  };

-    select: PropTypes.func.isRequired
+  componentWillMount () {
+    this.props.onInit();
  }

  render () {
-    const { all, selected } = this.props;
+    const { selected } = this.props;

-    const origin = { horizontal: 'right', vertical: 'top' };
-
-    const accountsButton = (
-      <IconButton className={ styles.button }>
-        { selected
-          ? (
-            <IdentityIcon
-              className={ styles.icon }
-              address={ selected.address }
-            />
-          ) : (
-            <AccountIcon
-              className={ styles.icon }
-              color='white'
-            />
-          )
-        }
-      </IconButton>);
+    if (!selected) {
+      return (
+        <AccountIcon
+          className={ styles.icon }
+          color='white'
+        />
+      );
+    }

    return (
-      <IconMenu
-        value={ selected ? this.renderAccount(selected) : null }
-        onChange={ this.onAccountSelect }
-        iconButtonElement={ accountsButton }
-
-        anchorOrigin={ origin }
-        targetOrigin={ origin }
-      >
-        { Object.values(all).map(this.renderAccount) }
-      </IconMenu>
+      <IdentityIcon
+        className={ styles.icon }
+        address={ selected }
+      />
    );
  }
-
-  renderAccount = (account) => {
-    const { selected } = this.props;
-    const isSelected = selected && selected.address === account.address;
-
-    return (
-      <MenuItem
-        key={ account.address }
-        value={ account.address }
-        checked={ isSelected }
-        insetChildren={ !isSelected }
-      >
-        <Address address={ account.address } />
-      </MenuItem>
-    );
-  };
-
-  onAccountSelect = (e, address) => {
-    this.props.select(address);
-  };
 }

 const mapStateToProps = (state) => state.accounts;
-const mapDispatchToProps = (dispatch) => bindActionCreators({ select }, dispatch);
+const mapDispatchToProps = (dispatch) => bindActionCreators({
+  onInit: init
+}, dispatch);

 export default connect(mapStateToProps, mapDispatchToProps)(Accounts);
--- a/js/src/dapps/registry/Accounts/actions.js
+++ b/js/src/dapps/registry/Accounts/actions.js
@@ -14,4 +14,27 @@
 // You should have received a copy of the GNU General Public License
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.

+import { api } from '../parity';
+
 export const select = (address) => ({ type: 'accounts select', address });
+
+export const init = () => (dispatch) => {
+  api.subscribe('parity_defaultAccount', (error, accountAddress) => {
+    if (error) {
+      return console.error(error);
+    }
+
+    if (accountAddress) {
+      dispatch(select(accountAddress));
+    }
+  });
+
+  return api.parity
+    .defaultAccount()
+    .then((accountAddress) => {
+      dispatch(select(accountAddress));
+    })
+    .catch((error) => {
+      console.error(error);
+    });
+};
--- a/js/src/dapps/registry/Application/application.css
+++ b/js/src/dapps/registry/Application/application.css
@@ -16,9 +16,11 @@
 */

 .header {
+  align-items: center;
  display: flex;
  justify-content: space-between;
-  margin: 0; padding: .3em 1em;
+  margin: 0;
+  padding: 0.3em 1em;
  color: #fff;
  background-color: #333;
 }
@@ -54,6 +56,7 @@
  background: #f80;
  bottom: 0;
  color: #fff;
+  cursor: pointer;
  left: 0;
  opacity: 1;
  padding: 1.5em;
--- a/js/src/dapps/registry/Application/application.js
+++ b/js/src/dapps/registry/Application/application.js
@@ -23,6 +23,7 @@ import CircularProgress from 'material-ui/CircularProgress';
 import { Card, CardText } from 'material-ui/Card';

 import { nullableProptype } from '~/util/proptypes';
+import { api } from '../parity';

 import styles from './application.css';
 import Accounts from '../Accounts';
@@ -39,7 +40,7 @@ export default class Application extends Component {
  };

  getChildContext () {
-    return { muiTheme, api: window.parity.api };
+    return { muiTheme, api };
  }

  static propTypes = {
@@ -48,8 +49,11 @@ export default class Application extends Component {
    fee: nullableProptype(PropTypes.object.isRequired)
  };

+  state = {
+    showWarning: true
+  };
+
  render () {
-    const { api } = window.parity;
    const { contract, fee } = this.props;
    let warning = null;

@@ -65,9 +69,7 @@ export default class Application extends Component {
            <Lookup />
            { this.renderActions() }
            <Events />
-            <div className={ styles.warning }>
-              WARNING: The name registry is experimental. Please ensure that you understand the risks, benefits & consequences of registering a name before doing so. A non-refundable fee of { api.util.fromWei(fee).toFormat(3) }<small>ETH</small> is required for all registrations.
-            </div>
+            { this.renderWarning() }
          </div>
        ) : (
          <CircularProgress size={ 60 } />
@@ -98,4 +100,39 @@ export default class Application extends Component {
      </div>
    );
  }
+
+  renderWarning () {
+    const { showWarning } = this.state;
+    const { fee } = this.props;
+
+    if (!showWarning) {
+      return null;
+    }
+
+    return (
+      <div
+        className={ styles.warning }
+        onClick={ this.handleHideWarning }
+      >
+        <span>
+          WARNING: The name registry is experimental. Please ensure that you understand the risks,
+          benefits & consequences of registering a name before doing so.
+        </span>
+        {
+          fee && api.util.fromWei(fee).gt(0)
+          ? (
+            <span>
+                &nbsp;A non-refundable fee of { api.util.fromWei(fee).toFormat(3) } <small>ETH</small>
+              &nbsp;is required for all registrations.
+            </span>
+          )
+          : null
+        }
+      </div>
+    );
+  }
+
+  handleHideWarning = () => {
+    this.setState({ showWarning: false });
+  }
 }
--- a/js/src/dapps/registry/Names/actions.js
+++ b/js/src/dapps/registry/Names/actions.js
@@ -33,11 +33,11 @@ export const reserveFail = (name, error) => ({ type: 'names reserve fail', name,

 export const reserve = (name) => (dispatch, getState) => {
  const state = getState();
-  const account = state.accounts.selected;
+  const accountAddress = state.accounts.selected;
  const contract = state.contract;
  const fee = state.fee;

-  if (!contract || !account) {
+  if (!contract || !accountAddress) {
    return;
  }

@@ -58,7 +58,7 @@ export const reserve = (name) => (dispatch, getState) => {
      const { reserve } = contract.instance;

      const options = {
-        from: account.address,
+        from: accountAddress,
        value: fee
      };
      const values = [
@@ -88,10 +88,10 @@ export const dropFail = (name, error) => ({ type: 'names drop fail', name, error

 export const drop = (name) => (dispatch, getState) => {
  const state = getState();
-  const account = state.accounts.selected;
+  const accountAddress = state.accounts.selected;
  const contract = state.contract;

-  if (!contract || !account) {
+  if (!contract || !accountAddress) {
    return;
  }

@@ -105,14 +105,14 @@ export const drop = (name) => (dispatch, getState) => {

  return getOwner(contract, name)
    .then((owner) => {
-      if (owner.toLowerCase() !== account.address.toLowerCase()) {
+      if (owner.toLowerCase() !== accountAddress.toLowerCase()) {
        throw new Error(`you are not the owner of "${name}"`);
      }

      const { drop } = contract.instance;

      const options = {
-        from: account.address
+        from: accountAddress
      };

      const values = [
--- a/js/src/dapps/registry/Records/actions.js
+++ b/js/src/dapps/registry/Records/actions.js
@@ -30,10 +30,10 @@ export const fail = (error) => ({ type: 'records update fail', error });

 export const update = (name, key, value) => (dispatch, getState) => {
  const state = getState();
-  const account = state.accounts.selected;
+  const accountAddress = state.accounts.selected;
  const contract = state.contract;

-  if (!contract || !account) {
+  if (!contract || !accountAddress) {
    return;
  }

@@ -42,7 +42,7 @@ export const update = (name, key, value) => (dispatch, getState) => {

  return getOwner(contract, name)
    .then((owner) => {
-      if (owner.toLowerCase() !== account.address.toLowerCase()) {
+      if (owner.toLowerCase() !== accountAddress.toLowerCase()) {
        throw new Error(`you are not the owner of "${name}"`);
      }

@@ -51,7 +51,7 @@ export const update = (name, key, value) => (dispatch, getState) => {
        : contract.instance.setData || contract.instance.set;

      const options = {
-        from: account.address
+        from: accountAddress
      };

      const values = [
--- a/js/src/dapps/registry/Reverse/actions.js
+++ b/js/src/dapps/registry/Reverse/actions.js
@@ -30,10 +30,10 @@ export const fail = (action, error) => ({ type: `reverse ${action} fail`, error

 export const propose = (name, address) => (dispatch, getState) => {
  const state = getState();
-  const account = state.accounts.selected;
+  const accountAddress = state.accounts.selected;
  const contract = state.contract;

-  if (!contract || !account) {
+  if (!contract || !accountAddress) {
    return;
  }

@@ -42,14 +42,14 @@ export const propose = (name, address) => (dispatch, getState) => {

  return getOwner(contract, name)
    .then((owner) => {
-      if (owner.toLowerCase() !== account.address.toLowerCase()) {
+      if (owner.toLowerCase() !== accountAddress.toLowerCase()) {
        throw new Error(`you are not the owner of "${name}"`);
      }

      const { proposeReverse } = contract.instance;

      const options = {
-        from: account.address
+        from: accountAddress
      };

      const values = [
@@ -74,10 +74,10 @@ export const propose = (name, address) => (dispatch, getState) => {

 export const confirm = (name) => (dispatch, getState) => {
  const state = getState();
-  const account = state.accounts.selected;
+  const accountAddress = state.accounts.selected;
  const contract = state.contract;

-  if (!contract || !account) {
+  if (!contract || !accountAddress) {
    return;
  }

@@ -86,14 +86,14 @@ export const confirm = (name) => (dispatch, getState) => {

  return getOwner(contract, name)
    .then((owner) => {
-      if (owner.toLowerCase() !== account.address.toLowerCase()) {
+      if (owner.toLowerCase() !== accountAddress.toLowerCase()) {
        throw new Error(`you are not the owner of "${name}"`);
      }

      const { confirmReverse } = contract.instance;

      const options = {
-        from: account.address
+        from: accountAddress
      };

      const values = [
--- a/js/src/dapps/registry/addresses/accounts-reducer.js
+++ b/js/src/dapps/registry/addresses/accounts-reducer.js
@@ -31,8 +31,8 @@ export default (state = initialState, action) => {
    return { ...state, all: accounts };
  }

-  if (action.type === 'accounts select' && state.all[action.address]) {
-    return { ...state, selected: state.all[action.address] };
+  if (action.type === 'accounts select') {
+    return { ...state, selected: action.address };
  }

  return state;
--- a/js/src/dapps/registry/util/etherscan-url.js
+++ b/js/src/dapps/registry/util/etherscan-url.js
@@ -22,7 +22,7 @@ const etherscanUrl = (hash, isTestnet, netVersion) => {
  hash = hash.toLowerCase().replace(leading0x, '');
  const type = hash.length === 40 ? 'address' : 'tx';

-  return `https://${externalUrl(isTestnet, netVersion)}/${type}/0x${hash}`;
+  return `${externalUrl(isTestnet, netVersion)}/${type}/0x${hash}`;
 };

 export default etherscanUrl;
--- a/js/src/dapps/tokenreg/Accounts/actions.js
+++ b/js/src/dapps/tokenreg/Accounts/actions.js
@@ -14,7 +14,7 @@
 // You should have received a copy of the GNU General Public License
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.

-const { api } = window.parity;
+import { api } from '../parity';

 export const SET_ACCOUNTS = 'SET_ACCOUNTS';
 export const setAccounts = (accounts) => ({
--- a/js/src/dapps/tokenreg/Status/actions.js
+++ b/js/src/dapps/tokenreg/Status/actions.js
@@ -17,8 +17,7 @@
 import Contracts from '~/contracts';

 import { loadToken, setTokenPending, deleteToken, setTokenData } from '../Tokens/actions';
-
-const { api } = window.parity;
+import { api } from '../parity';

 export const SET_LOADING = 'SET_LOADING';
 export const setLoading = (isLoading) => ({
--- a/js/src/dapps/tokenreg/Status/status.js
+++ b/js/src/dapps/tokenreg/Status/status.js
@@ -16,12 +16,11 @@

 import React, { Component, PropTypes } from 'react';

+import { api } from '../parity';
 import Chip from '../Chip';

 import styles from './status.css';

-const { api } = window.parity;
-
 export default class Status extends Component {
  static propTypes = {
    address: PropTypes.string.isRequired,
--- a/js/src/dapps/tokenreg/Tokens/actions.js
+++ b/js/src/dapps/tokenreg/Tokens/actions.js
@@ -15,8 +15,9 @@
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.

 import { getTokenTotalSupply } from '../utils';
+import { api } from '../parity';

-const { bytesToHex } = window.parity.api.util;
+const { bytesToHex } = api.util;

 export const SET_TOKENS_LOADING = 'SET_TOKENS_LOADING';
 export const setTokensLoading = (isLoading) => ({
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
arkpar	c39622952d	js-precompiled 20170608-105446	2017-06-08 13:52:25 +02:00
Arkadiy Paronyan	b8b5a23b12	Backporting to beta (#5791 ) * v1.6.8 * Update expanse json with fork at block 600000 (#5351) * Update expanse json with fork at block 600000 * update exp chainID to 2 * Bumped mio * Fixed default UI port for mac installer (#5782) * Blacklist empty phrase account. * Update Cid/multihash/ring/tinykeccak (#5785) * Updating ring,multihash,tiny-keccak * Updating CID in ipfs. * Disable compression for RLP strings	2017-06-07 22:09:16 +02:00
Jaco Greeff	fb82c6c415	[beta] Backports (#5789 ) * Merge #5716 * Merge #5784 * Merge #5698	2017-06-07 22:08:25 +02:00
Denis S. Soldatov aka General-Beck	4a9bd0af64	fix snap build paths [ci skip]	2017-06-07 21:51:06 +03:00
Denis S. Soldatov aka General-Beck	d20475d9ad	small fix snap build [ci skip]	2017-06-07 20:14:01 +03:00
Denis S. Soldatov aka General-Beck	f1cd03bf1f	add snap package	2017-06-07 19:41:45 +03:00
Arkadiy Paronyan	e128418147	Backporting to beta (#5657 ) * Add CHANGELOG.md (#5513) * Add CHANGELOG.md * Add some more verbose CHANGELOG information for beta and stable releases * Add dates to releases * reorg into blocks before minimum history (#5558) * v1.6.7	2017-05-18 16:10:34 +02:00
GitLab Build Bot	314e2764ae	[ci skip] js-precompiled 20170518-135504	2017-05-18 13:58:06 +00:00
Tomasz Drwięga	1aea9caf6d	[beta] Cancel Transaction (#5656 ) * option to disable persistent txqueue (#5544) * option to disable persistent txqueue * New option goes with kin * Remove transaction RPC (#4949) * Cancel tx JS (#4958) * Remove transaction RPC * Bumping multihash and libc * Updating nanomsg * bump nanomsg * cancel tx * cancel-tx-js * cancel-tx-js * cancel-tx-js * cancel-tx-hs * cancel-tx-js * cancel-tx-js * cancel-tx-js * small fixes * edit & time till submit * edit & time till submit * updates * updates * udpates * udpates * grumbles * step 1 * Wonderful updates * ready * small refact * small refact * grumbles 1 * ffx2 * good ol' fashioned updates * latest and greatest * removeHash * removeHash * spec * fix 1 * fix 1 * fix 2 * fix 2 * ff * ff * ff * updates * Updating documentation for RPCs (#5392) * Removing minBlocks occurrencies * Docs for new RPCs. * Fixing linting issues, updating withToken documentatiojn. Adding missing RPCs. Fixing tests. * Fixing lint issues.	2017-05-18 15:19:29 +02:00
Tomasz Drwięga	8dfc10ede9	[beta] Fix ethsign (#5600 ) * Fix ethsign in beta. * Fix tests. * Fix compilation. * CI fix remove kcov	2017-05-18 13:50:17 +01:00
GitLab Build Bot	4d9f13196f	[ci skip] js-precompiled 20170518-105555	2017-05-18 10:59:00 +00:00
Jaco Greeff	4b857bf4b0	[beta] Backport #5645 (Recover button) (#5654 ) * Backport #5645 * Update property	2017-05-18 12:44:40 +02:00
keorn	0a5c6a9ac7	add monotonic transition to kovan (#5587 ) (#5630 )	2017-05-16 12:06:12 +02:00
Denis S. Soldatov aka General-Beck	6cce5c8c9e	fix snap build	2017-05-03 18:13:15 +03:00
Denis S. Soldatov aka General-Beck	ab065ecbd0	backports from master add docker build for hub.docker.com/r/parity add snap build	2017-05-03 18:04:35 +03:00
GitLab Build Bot	36015c960a	[ci skip] js-precompiled 20170418-102604	2017-04-18 10:28:44 +00:00
Afri	8c4938d9c6	[beta] registry backports (#5445 ) * Fixes to the Registry dapp (#4984) * Don't show fee warning when there is none * Hide Warning in Registry onclick * Use the default account in the Registry * Fix Etherscan links in Regsitry * Fix references to api outside of `parity.js` (#4981)	2017-04-18 12:18:30 +02:00
Denis S. Soldatov aka General-Beck	2f3cddeea8	update URLs for docker	2017-04-11 18:15:29 +03:00
GitLab Build Bot	8c6e3f314a	js-precompiled 20170411-114812	2017-04-11 14:28:38 +02:00
Arkadiy Paronyan	96cbfba916	Fixed repo URLs	2017-04-11 13:37:33 +02:00
Tomasz Drwięga	18b8d6aca6	Fix signerstore	2017-04-11 10:29:19 +02:00
Arkadiy Paronyan	6a44a0cf95	[beta] Backports (#5434 ) * v1.6.6 * Strict validation transitions (#4988) * ability to make validation stricter * fix consensus * remove logger * Fix eth_sign showing as wallet account (#5309) * defaultProps for account * Pass signing account * Update tests for Connect(...) * Add new seed nodes (#5345) * Kovan warp sync fixed	2017-04-10 13:35:57 +02:00
Denis S. Soldatov aka General-Beck	b7860e4a3f	Update .gitlab-ci.yml remove EXPERIMENTAL from darwin installer	2017-04-04 21:45:11 +03:00
keorn	4a910a762d	[Beta] Aura eip155 validation transition (#5363 ) * add eip155 validation * add transition block	2017-04-01 13:21:29 +02:00
keorn	1626c78ae2	add eip155 validation (#5350 )	2017-03-30 20:45:22 +02:00
Nikolay Volf	7f4e700013	Backport syntex update (#5316 )	2017-03-29 10:43:13 +02:00
GitLab Build Bot	987390fb7d	js-precompiled 20170328-003032	2017-03-28 09:30:58 +02:00
Arkadiy Paronyan	797f23f30b	[beta] Backports (#5299 ) * Fix FireFox overflows (#5000) * Max width for container * Set min-width * Switching ValidatorSet (#4961) * add multi validator set * nicer comment * validate in constructor * reporting * Avoid clogging up tmp when updater dir has bad permissions. (#5024) * force earliest era set in snapshot restore (#5021) * v1.6.5 * Fine grained snapshot chunking * Ropsten revival	2017-03-28 01:45:56 +02:00
keorn	c1da49bbc4	Fix validator contract syncing (#4789 ) (#5011 ) * make validator set aware of various states * fix updater build * clean up contract call * failing sync test * adjust tests * nicer indent [ci skip] * revert bound divisor	2017-03-23 20:39:51 +01:00
Arkadiy Paronyan	1164193019	Backporting to beta (#4995 ) * v1.6.4 * ensure sealing work enabled if notifier registed * fix condition check * Always send full chunks (#4960) * Bump nanomsg (#4965) * Renaming evm binary to avoid conflicts. (#4899)	2017-03-22 13:46:32 +01:00
Jaco Greeff	1c217cbf2b	[beta] UI backports (#4993 ) * [ci skip] js-precompiled 20170314-121823 * Attach hardware wallets already in addressbook (#4912) * Attach hardware wallets already in addressbook * Only set values changed * Add Vaults logic to First Run (#4894) (#4914) * Add ability to configure Secure API (for #4885) (#4922) * Add z-index to small modals as well (#4923) * eth_sign where account === undefined (#4964) * Update for case where account === undefined * Update tests to not mask account === undefined * default account = {} where undefined (thanks @tomusdrw) * Fix Password Dialog forms style issue (#4968)	2017-03-22 12:45:55 +01:00
Tomasz Drwięga	d24f71f150	Bump multihash, libc and nanomsg (#4957 )	2017-03-18 22:36:03 +01:00
Denis S. Soldatov aka General-Beck	4c66a021ec	fix docker-build [ci skip]	2017-03-14 20:22:36 +03:00
GitLab Build Bot	ccc57328e2	js-precompiled 20170314-121823	2017-03-14 13:32:08 +01:00
arkpar	77240b6e5a	Merge branch 'beta' of github.com:ethcore/parity into beta	2017-03-14 13:06:37 +01:00
Jaco Greeff	2e428ddd58	[beta] Safari fixes (#4902 ) * Add intitial max-width to sections * Move background z-index to -1	2017-03-14 13:04:08 +01:00
arkpar	cd4081c149	Additional kovan params	2017-03-14 12:04:18 +01:00
arkpar	428342d69d	v1.6.3	2017-03-13 17:54:27 +01:00
arkpar	8ee9b262f9	Recalculate receipt roots in close_and_lock	2017-03-13 17:51:34 +01:00