Remove make_exe (installer) target

.gitignore

@@ -38,7 +38,6 @@ node_modules
 
 # Build artifacts
 out/
-parity-clib-examples/cpp/build/
 
 .vscode
 rls/

.gitlab-ci.yml

@@ -2,18 +2,18 @@ stages:
   - test
   - push-release
   - build
-  - docs
 variables:
   RUST_BACKTRACE: "1"
   RUSTFLAGS: ""
   CARGOFLAGS: ""
   CI_SERVER_NAME: "GitLab CI"
+  LIBSSL: "libssl1.0.0 (>=1.0.0)"
 cache:
   key: "$CI_BUILD_STAGE-$CI_BUILD_REF_NAME"
   paths:
     - target/
   untracked: true
-linux-amd64:
+linux-ubuntu:
   stage: build
   image: parity/rust:gitlab-ci
   only:
@@ -24,13 +24,46 @@ linux-amd64:
   script:
     - rustup default stable
     # ARGUMENTS: 1. BUILD_PLATFORM (target for binaries) 2. PLATFORM (target for cargo) 3. ARC (architecture) 4. & 5. CC & CXX flags 6. binary identifier
-    - scripts/gitlab-build.sh x86_64-unknown-linux-gnu x86_64-unknown-linux-gnu amd64 gcc g++ linux
+    - scripts/gitlab-build.sh x86_64-unknown-linux-gnu x86_64-unknown-linux-gnu amd64 gcc g++ ubuntu
   tags:
     - rust-stable
   artifacts:
     paths:
     - parity.zip
     name: "stable-x86_64-unknown-linux-gnu_parity"
+linux-debian:
+  stage: build
+  image: parity/rust-debian:gitlab-ci
+  only:
+    - beta
+    - tags
+    - stable
+    - triggers
+  script:
+    - export LIBSSL="libssl1.1 (>=1.1.0)"
+    - scripts/gitlab-build.sh x86_64-unknown-debian-gnu x86_64-unknown-linux-gnu amd64 gcc g++ debian
+  tags:
+    - rust-debian
+  artifacts:
+    paths:
+    - parity.zip
+    name: "stable-x86_64-unknown-debian-gnu_parity"
+linux-centos:
+  stage: build
+  image: parity/rust-centos:gitlab-ci
+  only:
+    - beta
+    - tags
+    - stable
+    - triggers
+  script:
+    - scripts/gitlab-build.sh x86_64-unknown-centos-gnu x86_64-unknown-linux-gnu x86_64 gcc g++ centos
+  tags:
+    - rust-centos
+  artifacts:
+    paths:
+    - parity.zip
+    name: "x86_64-unknown-centos-gnu_parity"
 linux-i686:
   stage: build
   image: parity/rust-i686:gitlab-ci
@@ -40,7 +73,7 @@ linux-i686:
     - stable
     - triggers
   script:
-    - scripts/gitlab-build.sh i686-unknown-linux-gnu i686-unknown-linux-gnu i386 gcc g++ linux
+    - scripts/gitlab-build.sh i686-unknown-linux-gnu i686-unknown-linux-gnu i386 gcc g++ ubuntu
   tags:
     - rust-i686
   artifacts:
@@ -57,7 +90,7 @@ linux-armv7:
     - stable
     - triggers
   script:
-    - scripts/gitlab-build.sh armv7-unknown-linux-gnueabihf armv7-unknown-linux-gnueabihf armhf arm-linux-gnueabihf-gcc arm-linux-gnueabihf-g++ linux
+    - scripts/gitlab-build.sh armv7-unknown-linux-gnueabihf armv7-unknown-linux-gnueabihf armhf arm-linux-gnueabihf-gcc arm-linux-gnueabihf-g++ ubuntu
   tags:
     - rust-arm
   artifacts:
@@ -65,7 +98,7 @@ linux-armv7:
     - parity.zip
     name: "armv7_unknown_linux_gnueabihf_parity"
   allow_failure: true
-linux-armhf:
+linux-arm:
   stage: build
   image: parity/rust-arm:gitlab-ci
   only:
@@ -74,7 +107,7 @@ linux-armhf:
     - stable
     - triggers
   script:
-    - scripts/gitlab-build.sh arm-unknown-linux-gnueabihf arm-unknown-linux-gnueabihf armhf arm-linux-gnueabihf-gcc arm-linux-gnueabihf-g++ linux
+    - scripts/gitlab-build.sh arm-unknown-linux-gnueabihf arm-unknown-linux-gnueabihf armhf arm-linux-gnueabihf-gcc arm-linux-gnueabihf-g++ ubuntu
   tags:
     - rust-arm
   artifacts:
@@ -91,7 +124,7 @@ linux-aarch64:
     - stable
     - triggers
   script:
-    - scripts/gitlab-build.sh aarch64-unknown-linux-gnu aarch64-unknown-linux-gnu arm64 aarch64-linux-gnu-gcc aarch64-linux-gnu-g++ linux
+    - scripts/gitlab-build.sh aarch64-unknown-linux-gnu aarch64-unknown-linux-gnu arm64 aarch64-linux-gnu-gcc aarch64-linux-gnu-g++ ubuntu
   tags:
     - rust-arm
   artifacts:
@@ -140,7 +173,7 @@ windows:
     - stable
     - triggers
   script:
-    - sh scripts/gitlab-build.sh x86_64-pc-windows-msvc x86_64-pc-windows-msvc amd64 "" "" windows
+    - sh scripts/gitlab-build.sh x86_64-pc-windows-msvc x86_64-pc-windows-msvc "" "" "" windows
   tags:
    - rust-windows
   artifacts:
@@ -168,9 +201,6 @@ docker-build:
   stage: build
   only:
     - tags
-    - master
-    - beta
-    - stable
     - triggers
   before_script:
     - docker info
@@ -221,15 +251,6 @@ test-rust-nightly:
     - rust
     - rust-nightly
   allow_failure: true
-json-rpc-docs:
-  stage: docs
-  only:
-    - tags
-  image: parity/rust:gitlab-ci
-  script:
-    - scripts/gitlab-rpc-docs.sh
-  tags:
-    - docs
 push-release:
   stage: push-release
   only:

CHANGELOG.md

@@ -1,261 +1,3 @@
-## Parity [v1.11.6](https://github.com/paritytech/parity/releases/tag/v1.11.6) (2018-07-09)
-
-Parity 1.11.6 is a bug-fix release to improve performance and stability.
-
-The full list of included changes:
-
-- Beta: 1.11.6 backports ([#9015](https://github.com/paritytech/parity/pull/9015))
-  - Parity-version: bump beta to 1.11.6
-  - Scripts: remove md5 checksums ([#8884](https://github.com/paritytech/parity/pull/8884))
-  - Add support for --chain tobalaba
-    - Convert indents to tabs :)
-  - Fixes for misbehavior reporting in AuthorityRound ([#8998](https://github.com/paritytech/parity/pull/8998))
-    - Aura: only report after checking for repeated skipped primaries
-    - Aura: refactor duplicate code for getting epoch validator set
-    - Aura: verify_external: report on validator set contract instance
-    - Aura: use correct validator set epoch number when reporting
-    - Aura: use epoch set when verifying blocks
-    - Aura: report skipped primaries when generating seal
-    - Aura: handle immediate transitions
-    - Aura: don't report skipped steps from genesis to first block
-    - Aura: fix reporting test
-    - Aura: refactor duplicate code to handle immediate_transitions
-    - Aura: let reporting fail on verify_block_basic
-    - Aura: add comment about possible failure of reporting
-  - Only return error log for rustls ([#9025](https://github.com/paritytech/parity/pull/9025))
-  - Transaction Pool improvements ([#8470](https://github.com/paritytech/parity/pull/8470))
-    - Don't use ethereum_types in transaction pool.
-    - Hide internal insertion_id.
-    - Fix tests.
-    - Review grumbles.
-  - Improve should_replace on NonceAndGasPrice ([#8980](https://github.com/paritytech/parity/pull/8980))
-    - Additional tests for NonceAndGasPrice::should_replace.
-    - Fix should_replace in the distinct sender case.
-    - Use natural priority ordering to simplify should_replace.
-  - Minimal effective gas price in the queue ([#8934](https://github.com/paritytech/parity/pull/8934))
-    - Minimal effective gas price.
-    - Fix naming, add test
-    - Fix minimal entry score and add test.
-    - Fix worst_transaction.
-    - Remove effective gas price threshold.
-    - Don't leak gas_price decisions out of Scoring.
-  - Never drop local transactions from different senders. ([#9002](https://github.com/paritytech/parity/pull/9002))
-  - Recently rejected cache for transaction queue ([#9005](https://github.com/paritytech/parity/pull/9005))
-    - Store recently rejected transactions.
-    - Don't cache AlreadyImported rejections.
-    - Make the size of transaction verification queue dependent on pool size.
-    - Add a test for recently rejected.
-    - Fix logging for recently rejected.
-    - Make rejection cache smaller.
-    - Obsolete test removed
-    - Obsolete test removed
-    - Construct cache with_capacity.
-  - Optimize pending transactions filter ([#9026](https://github.com/paritytech/parity/pull/9026))
-    - Rpc: return unordered transactions in pending transactions filter
-    - Ethcore: use LruCache for nonce cache
-      - Only clear the nonce cache when a block is retracted
-    - Revert "ethcore: use LruCache for nonce cache"
-      - This reverts commit b382c19.
-    - Use only cached nonces when computing pending hashes.
-    - Give filters their own locks, so that they don't block one another.
-    - Fix pending transaction count if not sealing.
-    - Clear cache only when block is enacted.
-    - Fix RPC tests.
-    - Address review comments.
-  - A last bunch of txqueue performance optimizations ([#9024](https://github.com/paritytech/parity/pull/9024))
-    - Clear cache only when block is enacted.
-    - Add tracing for cull.
-    - Cull split.
-    - Cull after creating pending block.
-    - Add constant, remove sync::read tracing.
-    - Reset debug.
-    - Remove excessive tracing.
-    - Use struct for NonceCache.
-    - Fix build
-    - Remove warnings.
-    - Fix build again.
-  - Miner: add missing macro use for trace_time
-  - Ci: remove md5 merge leftovers
-
-## Parity [v1.11.5](https://github.com/paritytech/parity/releases/tag/v1.11.5) (2018-06-29)
-
-Parity 1.11.5 is a bug-fix release to improve performance and stability.
-
-The full list of included changes:
-
-- Bump beta to 1.11.5 / Backports ([#8955](https://github.com/paritytech/parity/pull/8955))
-  - Parity-version: bump beta to 1.11.5
-  - Update ropsten.json ([#8926](https://github.com/paritytech/parity/pull/8926))
-  - Update hardcoded headers ([#8925](https://github.com/paritytech/parity/pull/8925))
-    - Update kovan.json
-      - Update Kovan to block 7693549
-    - Update foundation.json
-      - Updated to block 5812225
-    - Update ropsten.json
-      - Update to 3465217
-  - Scripts: minor improvements ([#8930](https://github.com/paritytech/parity/pull/8930))
-    - CI: enable 'latest' docker tag on master pipeline
-    - CI: mark both beta and stable as stable snap.
-    - CI: sign all windows binaries
-  - Scripts: fix docker build tag on latest using master ([#8952](https://github.com/paritytech/parity/pull/8952))
-  - Rpc: cap gas limit of local calls ([#8943](https://github.com/paritytech/parity/pull/8943))
-  - Snap: downgrade rust to revision 1.26.2, ref snapcraft/+bug/1778530 ([#8984](https://github.com/paritytech/parity/pull/8984))
-    - Snap: downgrade rust to revision 1.26.2, ref snapcraft/+bug/1778530
-    - Snap: use plugin rust
-  - Fix deadlock in blockchain. ([#8977](https://github.com/paritytech/parity/pull/8977))
-  - Remove js-glue from workspace
-    - This fixes test error on Rust 1.27 but also prevents js-glue from building itself.
-    - Builtin dapp users can still use js-glue from crates.io.
-  - Fix Android build on beta ([#9003](https://github.com/paritytech/parity/pull/9003))
-
-## Parity [v1.11.4](https://github.com/paritytech/parity/releases/tag/v1.11.4) (2018-06-20)
-
-Parity 1.11.4 is a bug-fix release to improve performance and stability.
-
-The full list of included changes:
-
-- Backports ([#8916](https://github.com/paritytech/parity/pull/8916))
-  - `Duration_ns: u64 -> duration: Duration` ([#8457](https://github.com/paritytech/parity/pull/8457))
-    - Duration_ns: u64 -> duration: Duration
-    - Format on millis {:.2} -> {}
-  - Keep all enacted blocks notify in order ([#8524](https://github.com/paritytech/parity/pull/8524))
-    - Keep all enacted blocks notify in order
-    - Collect is unnecessary
-    - Update ChainNotify to use ChainRouteType
-    - Fix all ethcore fn defs
-    - Wrap the type within ChainRoute
-    - Fix private-tx and sync api
-    - Fix secret_store API
-    - Fix updater API
-    - Fix rpc api
-    - Fix informant api
-    - Eagerly cache enacted/retracted and remove contain_enacted/retracted
-    - Fix indent
-    - Tests: should use full expr form for struct constructor
-    - Use into_enacted_retracted to further avoid copy
-    - Typo: not a function
-    - Rpc/tests: ChainRoute -> ChainRoute::new
-  - Handle removed logs in filter changes and add geth compatibility field ([#8796](https://github.com/paritytech/parity/pull/8796))
-    - Add removed geth compatibility field in log
-    - Fix mocked tests
-    - Add field block hash in PollFilter
-    - Store last block hash info for log filters
-    - Implement canon route
-    - Use canon logs for fetching reorg logs
-    - Make sure removed flag is set
-    - Address grumbles
-  - Fixed AuthorityRound deadlock on shutdown, closes [#8088](https://github.com/paritytech/parity/issues/8088) ([#8803](https://github.com/paritytech/parity/pull/8803))
-  - Ci: Fix docker tags ([#8822](https://github.com/paritytech/parity/pull/8822))
-    - Scripts: enable docker builds for beta and stable
-    - Scripts: docker latest should be beta not master
-    - Scripts: docker latest is master
-  - Ethcore: fix ancient block error msg handling ([#8832](https://github.com/paritytech/parity/pull/8832))
-  - Disable parallel verification and skip verifiying already imported txs. ([#8834](https://github.com/paritytech/parity/pull/8834))
-    - Reject transactions that are already in pool without verifying them.
-    - Avoid verifying already imported transactions.
-  - Fix concurrent access to signer queue ([#8854](https://github.com/paritytech/parity/pull/8854))
-    - Fix concurrent access to signer queue
-    - Put request back to the queue if confirmation failed
-    - Typo: fix docs and rename functions to be more specific
-    - Change trace info "Transaction" -> "Request"
-  - Don't allocate in expect_valid_rlp unless necessary ([#8867](https://github.com/paritytech/parity/pull/8867))
-    - Don't allocate via format! in case there's no error
-    - Fix test?
-  - Fixed ipc leak, closes [#8774](https://github.com/paritytech/parity/issues/8774) ([#8876](https://github.com/paritytech/parity/pull/8876))
-  - Add new ovh bootnodes and fix port for foundation bootnode 3.2 ([#8886](https://github.com/paritytech/parity/pull/8886))
-    - Add new ovh bootnodes and fix port for foundation bootnode 3.2
-    - Remove old bootnodes.
-    - Remove duplicate 1118980bf48b0a3640bdba04e0fe78b1add18e1cd99bf22d53daac1fd9972ad650df52176e7c7d89d1114cfef2bc23a2959aa54998a46afcf7d91809f0855082
-  - Block 0 is valid in queries ([#8891](https://github.com/paritytech/parity/pull/8891))
-  - Add ETC Cooperative-run load balanced parity node ([#8892](https://github.com/paritytech/parity/pull/8892))
-  - Minor fix in chain supplier and light provider ([#8906](https://github.com/paritytech/parity/pull/8906))
-    - Fix chain supplier increment
-    - Fix light provider block_headers
-  - Check whether we need resealing in miner and unwrap has_account in account_provider ([#8853](https://github.com/paritytech/parity/pull/8853))
-    - Remove unused Result wrap in has_account
-    - Check whether we need to reseal for external transactions
-    - Fix reference to has_account interface
-    - Typo: missing )
-    - Refactor duplicates to prepare_and_update_sealing
-    - Fix build
-  - Allow disabling local-by-default for transactions with new config entry ([#8882](https://github.com/paritytech/parity/pull/8882))
-    - Add tx_queue_allow_unknown_local config option
-    - Refactor flag name + don't change import_own_tx behaviour
-    - Add fn to TestMinerService
-    - Avoid race condition from trusted sources
-- Parity-version: beta release 1.11.4 ([#8856](https://github.com/paritytech/parity/pull/8856))
-  - Cherry-pick network-specific release flag ([#8821](https://github.com/paritytech/parity/pull/8821))
-  - Parity-version: bump beta to 1.11.4
-  - Parity-version: remove merge leftovers
-
-## Parity [v1.11.3](https://github.com/paritytech/parity/releases/tag/v1.11.3) (2018-06-06)
-
-Parity 1.11.3 is a security-relevant release. Please upgrade your nodes as soon as possible to [v1.10.6](https://github.com/paritytech/parity/releases/tag/v1.10.6) or [v1.11.3](https://github.com/paritytech/parity/releases/tag/v1.11.3).
-
-The full list of included changes:
-
-- Parity-version: bump beta to 1.11.3 ([#8806](https://github.com/paritytech/parity/pull/8806))
-  - Parity-version: bump beta to 1.11.3
-  - Disallow unsigned transactions in case EIP-86 is disabled ([#8802](https://github.com/paritytech/parity/pull/8802))
-  - Fix ancient blocks queue deadlock ([#8751](https://github.com/paritytech/parity/pull/8751))
-- Update shell32-sys to fix windows build ([#8792](https://github.com/paritytech/parity/pull/8792))
-- Backports ([#8785](https://github.com/paritytech/parity/pull/8785))
-  - Fix light sync with initial validator-set contract ([#8528](https://github.com/paritytech/parity/pull/8528))
-    - Fix #8468
-    - Use U256::max_value() instead
-    - Also change initial transaction gas
-  - Resumable warp-sync / Seed downloaded snapshots ([#8544](https://github.com/paritytech/parity/pull/8544))
-    - Start dividing sync chain : first supplier method
-    - WIP - updated chain sync supplier
-    - Finish refactoring the Chain Sync Supplier
-    - Create Chain Sync Requester
-    - Add Propagator for Chain Sync
-    - Add the Chain Sync Handler
-    - Move tests from mod -> handler
-    - Move tests to propagator
-    - Refactor SyncRequester arguments
-    - Refactoring peer fork header handler
-    - Fix wrong highest block number in snapshot sync
-    - Small refactor...
-    - Resume warp-sync downloaded chunks
-    - Refactoring the previous chunks import
-    - Address PR grumbles
-    - Fix not seeding current snapshot
-    - Update SnapshotService readiness check
-    - Early abort importing previous chunks
-    - Update Gitlab CI config
-    - SyncState back to Waiting when Manifest peers disconnect
-    - Revert GitLab CI changes
-    - Refactor resuming snapshots
-    - Revert "Refactor resuming snapshots"
-    - Update informant log
-    - Refactor resuming snapshots
-    - Update informant message : show chunks done
-  - Don't open Browser post-install on Mac ([#8641](https://github.com/paritytech/parity/pull/8641))
-  - Fix not downloading old blocks ([#8642](https://github.com/paritytech/parity/pull/8642))
-  - Fix PoW blockchains sealing notifications in chain_new_blocks ([#8656](https://github.com/paritytech/parity/pull/8656))
-  - Shutdown the Snapshot Service early ([#8658](https://github.com/paritytech/parity/pull/8658))
-    - Shutdown the Snapshot Service when shutting down the runner
-    - Rename `service` to `client_service`
-    - Fix tests
-  - Fix cli signer ([#8682](https://github.com/paritytech/parity/pull/8682))
-    - Update ethereum-types so `{:#x}` applies 0x prefix
-  - Set the request index to that of the current request ([#8683](https://github.com/paritytech/parity/pull/8683))
-    - Set the request index to that of the current request
-  - Network-devp2p: handle UselessPeer disconnect ([#8686](https://github.com/paritytech/parity/pull/8686))
-  - Fix local transactions policy. ([#8691](https://github.com/paritytech/parity/pull/8691))
-  - CI: Fixes for Android Pipeline ([#8745](https://github.com/paritytech/parity/pull/8745))
-    - Ci: Remove check for shared libraries in gitlab script
-    - Ci: allow android arm build to fail
-  - Custom Error Messages on ENFILE and EMFILE IO Errors ([#8744](https://github.com/paritytech/parity/pull/8744))
-    - Custom Error Messages on ENFILE and EMFILE IO Errors
-    - Use assert-matches for more readable tests
-    - Fix Wording and consistency
-  - Ethcore-sync: fix connection to peers behind chain fork block ([#8710](https://github.com/paritytech/parity/pull/8710))
-- Parity-version: bump beta to 1.11.2 ([#8750](https://github.com/paritytech/parity/pull/8750))
-  - Parity-version: bump beta to 1.11.2
-  - Parity-version: unset critical flag
-
 ## Parity [v1.11.1](https://github.com/paritytech/parity/releases/tag/v1.11.1) (2018-05-15)
 
 This is the Parity 1.11.1-beta release! Hurray!
@@ -414,47 +156,47 @@ The full list of included changes:
 
 - Backports ([#8558](https://github.com/paritytech/parity/pull/8558))
   - Fetching logs by hash in blockchain database ([#8463](https://github.com/paritytech/parity/pull/8463))
-    - Fetch logs by hash in blockchain database
-    - Fix tests
-    - Add unit test for branch block logs fetching
-    - Add docs that blocks must already be sorted
-    - Handle branch block cases properly
-    - typo: empty -> is_empty
-    - Remove return_empty_if_none by using a closure
-    - Use BTreeSet to avoid sorting again
-    - Move is_canon to BlockChain
-    - typo: pass value by reference
-    - Use loop and wrap inside blocks to simplify the code
-    - typo: missed a comment
+	  - Fetch logs by hash in blockchain database
+	  - Fix tests
+	  - Add unit test for branch block logs fetching
+	  - Add docs that blocks must already be sorted
+	  - Handle branch block cases properly
+	  - typo: empty -> is_empty
+	  - Remove return_empty_if_none by using a closure
+	  - Use BTreeSet to avoid sorting again
+	  - Move is_canon to BlockChain
+	  - typo: pass value by reference
+	  - Use loop and wrap inside blocks to simplify the code
+	  - typo: missed a comment
   - Pass on storage keys tracing to handle the case when it is not modified ([#8491](https://github.com/paritytech/parity/pull/8491))
-    - Pass on storage keys even if it is not modified
-    - typo: account and storage query
-    - Fix tests
-    - Use state query directly because of suicided accounts
-    - Fix a RefCell borrow issue
-    - Add tests for unmodified storage trace
-    - Address grumbles
-    - typo: remove unwanted empty line
-    - ensure_cached compiles with the original signature
+	  - Pass on storage keys even if it is not modified
+	  - typo: account and storage query
+	  - Fix tests
+	  - Use state query directly because of suicided accounts
+	  - Fix a RefCell borrow issue
+	  - Add tests for unmodified storage trace
+	  - Address grumbles
+	  - typo: remove unwanted empty line
+	  - ensure_cached compiles with the original signature
   - Update wasmi and pwasm-utils ([#8493](https://github.com/paritytech/parity/pull/8493))
-    - Update wasmi to 0.2
-    - Update pwasm-utils to 0.1.5
+	  - Update wasmi to 0.2
+	  - Update pwasm-utils to 0.1.5
   - Show imported messages for light client ([#8517](https://github.com/paritytech/parity/pull/8517))
   - Enable WebAssembly and Byzantium for Ellaism ([#8520](https://github.com/paritytech/parity/pull/8520))
-    - Enable WebAssembly and Byzantium for Ellaism
-    - Fix indentation
-    - Remove empty lines
+	  - Enable WebAssembly and Byzantium for Ellaism
+	  - Fix indentation
+	  - Remove empty lines
   - Don't panic in import_block if invalid rlp ([#8522](https://github.com/paritytech/parity/pull/8522))
-    - Don't panic in import_block if invalid rlp
-    - Remove redundant type annotation
-    - Replace RLP header view usage with safe decoding
+	  - Don't panic in import_block if invalid rlp
+	  - Remove redundant type annotation
+	  - Replace RLP header view usage with safe decoding
   - Node table sorting according to last contact data ([#8541](https://github.com/paritytech/parity/pull/8541))
-    - network-devp2p: sort nodes in node table using last contact data
-    - network-devp2p: rename node contact types in node table json output
-    - network-devp2p: fix node table tests
-    - network-devp2p: note node failure when failed to establish connection
-    - network-devp2p: handle UselessPeer error
-    - network-devp2p: note failure when marking node as useless
+	  - network-devp2p: sort nodes in node table using last contact data
+	  - network-devp2p: rename node contact types in node table json output
+	  - network-devp2p: fix node table tests
+	  - network-devp2p: note node failure when failed to establish connection
+	  - network-devp2p: handle UselessPeer error
+	  - network-devp2p: note failure when marking node as useless
 - Betalize 1.11 :) ([#8475](https://github.com/paritytech/parity/pull/8475))
   - Betalize 1.11 :)
   - Update Gitlab scripts

Cargo.toml

@@ -1,13 +1,12 @@
 [package]
 description = "Parity Ethereum client"
-name = "parity-ethereum"
+name = "parity"
 # NOTE Make sure to update util/version/Cargo.toml as well
-version = "2.0.5"
+version = "1.12.0"
 license = "GPL-3.0"
 authors = ["Parity Technologies <admin@parity.io>"]
 
 [dependencies]
-blooms-db = { path = "util/blooms-db" }
 log = "0.3"
 env_logger = "0.4"
 rustc-hex = "1.0"
@@ -20,7 +19,7 @@ number_prefix = "0.2"
 rpassword = "1.0"
 semver = "0.9"
 ansi_term = "0.10"
-parking_lot = "0.6"
+parking_lot = "0.5"
 regex = "0.2"
 atty = "0.2.8"
 toml = "0.4"
@@ -32,8 +31,8 @@ futures-cpupool = "0.1"
 fdlimit = "0.1"
 ctrlc = { git = "https://github.com/paritytech/rust-ctrlc.git" }
 jsonrpc-core = { git = "https://github.com/paritytech/jsonrpc.git", branch = "parity-1.11" }
-ethcore = { path = "ethcore", features = ["parity"] }
-parity-bytes = { git = "https://github.com/paritytech/parity-common" }
+ethcore = { path = "ethcore" }
+ethcore-bytes = { path = "util/bytes" }
 ethcore-io = { path = "util/io" }
 ethcore-light = { path = "ethcore/light" }
 ethcore-logger = { path = "logger" }
@@ -46,7 +45,8 @@ ethcore-transaction = { path = "ethcore/transaction" }
 ethereum-types = "0.3"
 node-filter = { path = "ethcore/node_filter" }
 ethkey = { path = "ethkey" }
-rlp = { git = "https://github.com/paritytech/parity-common" }
+node-health = { path = "dapps/node-health" }
+rlp = { path = "util/rlp" }
 rpc-cli = { path = "rpc_cli" }
 parity-hash-fetch = { path = "hash-fetch" }
 parity-ipfs-api = { path = "ipfs" }
@@ -57,16 +57,17 @@ parity-rpc-client = { path = "rpc_client" }
 parity-updater = { path = "updater" }
 parity-version = { path = "util/version" }
 parity-whisper = { path = "whisper" }
-path = { git = "https://github.com/paritytech/parity-common" }
+path = { path = "util/path" }
 dir = { path = "util/dir" }
 panic_hook = { path = "util/panic_hook" }
-keccak-hash = { git = "https://github.com/paritytech/parity-common" }
+keccak-hash = { path = "util/hash" }
 migration-rocksdb = { path = "util/migration-rocksdb" }
-kvdb = { git = "https://github.com/paritytech/parity-common" }
-kvdb-rocksdb = { git = "https://github.com/paritytech/parity-common" }
+kvdb = { path = "util/kvdb" }
+kvdb-rocksdb = { path = "util/kvdb-rocksdb" }
 journaldb = { path = "util/journaldb" }
 mem = { path = "util/mem" }
 
+parity-dapps = { path = "dapps", optional = true }
 ethcore-secretstore = { path = "secret_store", optional = true }
 
 registrar = { path = "registrar" }
@@ -87,7 +88,17 @@ winapi = { version = "0.3.4", features = ["winsock2", "winuser", "shellapi"] }
 daemonize = { git = "https://github.com/paritytech/daemonize" }
 
 [features]
-miner-debug = ["ethcore/miner-debug"]
+default = ["ui-precompiled"]
+ui = [
+	"ui-enabled",
+	"parity-dapps/ui",
+]
+ui-precompiled = [
+	"ui-enabled",
+	"parity-dapps/ui-precompiled",
+]
+ui-enabled = ["dapps"]
+dapps = ["parity-dapps"]
 json-tests = ["ethcore/json-tests"]
 test-heavy = ["ethcore/test-heavy"]
 evm-debug = ["ethcore/evm-debug"]
@@ -96,17 +107,6 @@ slow-blocks = ["ethcore/slow-blocks"]
 secretstore = ["ethcore-secretstore"]
 final = ["parity-version/final"]
 deadlock_detection = ["parking_lot/deadlock_detection"]
-# to create a memory profile (requires nightly rust), use e.g.
-# `heaptrack /path/to/parity <parity params>`,
-# to visualize a memory profile, use `heaptrack_gui`
-# or
-# `valgrind --tool=massif /path/to/parity <parity params>`
-# and `massif-visualizer` for visualization
-memory_profiling = []
-# hardcode version number 1.3.7 of parity to force an update
-# in order to manually test that parity fall-over to the local version
-# in case of invalid or deprecated command line arguments are entered
-test-updater = ["parity-updater/test-updater"]
 
 [lib]
 path = "parity/lib.rs"
@@ -116,13 +116,17 @@ path = "parity/main.rs"
 name = "parity"
 
 [profile.dev]
+panic = "abort"
 
 [profile.release]
 debug = false
+lto = false
+panic = "abort"
 
 [workspace]
 members = [
 	"chainspec",
+	"dapps/js-glue",
 	"ethcore/wasm/run",
 	"ethcore/types",
 	"ethkey/cli",
@@ -133,9 +137,6 @@ members = [
 	"transaction-pool",
 	"whisper",
 	"whisper/cli",
-	"util/triehash-ethereum",
-	"util/keccak-hasher",
-	"util/patricia-trie-ethereum",
 ]
 
 [patch.crates-io]

README.md

@@ -48,7 +48,7 @@ We recommend installing Rust through [rustup](https://www.rustup.rs/). If you do
 	$ curl https://sh.rustup.rs -sSf | sh
 	```
 
-	Parity also requires `gcc`, `g++`, `libssl-dev`/`openssl`, `libudev-dev`, `pkg-config`, `file` and `make` packages to be installed.
+	Parity also requires `gcc`, `g++`, `libssl-dev`/`openssl`, `libudev-dev` and `pkg-config` packages to be installed.
 
 - OSX:
 	```bash

dapps/Cargo.toml

@@ -0,0 +1,49 @@
+[package]
+description = "Parity Dapps crate"
+name = "parity-dapps"
+version = "1.12.0"
+license = "GPL-3.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+
+[lib]
+
+[dependencies]
+base32 = "0.3"
+futures = "0.1"
+futures-cpupool = "0.1"
+linked-hash-map = "0.5"
+log = "0.3"
+parity-dapps-glue = "1.9"
+parking_lot = "0.5"
+mime_guess = "2.0.0-alpha.2"
+rand = "0.4"
+rustc-hex = "1.0"
+serde = "1.0"
+serde_derive = "1.0"
+serde_json = "1.0"
+unicase = "1.4"
+zip = { version = "0.3", default-features = false, features = ["deflate"] }
+itertools = "0.5"
+
+jsonrpc-core = { git = "https://github.com/paritytech/jsonrpc.git", branch = "parity-1.11" }
+jsonrpc-http-server = { git = "https://github.com/paritytech/jsonrpc.git", branch = "parity-1.11" }
+
+ethcore-bytes = { path = "../util/bytes" }
+ethereum-types = "0.3"
+fetch = { path = "../util/fetch" }
+node-health = { path = "./node-health" }
+parity-hash-fetch = { path = "../hash-fetch" }
+parity-reactor = { path = "../util/reactor" }
+parity-ui = { path = "./ui" }
+parity-ui-deprecation = { path = "./ui-deprecation" }
+keccak-hash = { path = "../util/hash" }
+parity-version = { path = "../util/version" }
+registrar = { path = "../registrar" }
+
+[dev-dependencies]
+env_logger = "0.4"
+ethcore-devtools = { path = "../devtools" }
+
+[features]
+ui = ["parity-ui/no-precompiled-js"]
+ui-precompiled = ["parity-ui/use-precompiled-js"]

dapps/js-glue/Cargo.toml

@@ -0,0 +1,28 @@
+[package]
+description = "Base Package for all Parity built-in dapps"
+name = "parity-dapps-glue"
+version = "1.9.1"
+license = "GPL-3.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+build = "build.rs"
+
+[build-dependencies]
+quasi_codegen = { version = "0.32", optional = true }
+syntex = { version = "0.58", optional = true }
+
+[dependencies]
+glob = { version = "0.2.11" }
+mime_guess = { version = "2.0.0-alpha.2" }
+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 }
+
+[features]
+default = ["with-syntex"]
+nightly = ["quasi_macros"]
+with-syntex = ["quasi/with-syntex", "quasi_codegen", "quasi_codegen/with-syntex", "syntex", "syntex_syntax"]
+use-precompiled-js = []
+
+

dapps/js-glue/README.md

@@ -0,0 +1,65 @@
+# Parity Dapps (JS-glue)
+
+Code generator to simplify creating a built-in Parity Dapp
+
+# How to create new builtin Dapp.
+1. Clone this repository.
+
+   ```bash
+   $ git clone https://github.com/paritytech/parity.git
+   ```
+
+1. Create a new directory for your Dapp. (`./myapp`)
+
+   ```bash
+   $ mkdir -p ./parity/dapps/myapp/src/web
+   ```
+
+1. Copy your frontend files to `./dapps/myapp/src/web` (bundled ones)
+
+   ```bash
+   $ cp -r ./myapp-src/* ./parity/dapps/myapp/src/web
+   ```
+
+1. Instead of creating `web3` in your app. Load (as the first script tag in `head`):
+
+   ```html
+   <script src="/parity-utils/inject.js"></script>
+   ```
+
+   The `inject.js` script will create global `web3` instance with proper provider that should be used by your dapp.
+
+1. Create `./parity/dapps/myapp/Cargo.toml` with you apps details. See example here: [parity-status Cargo.toml](https://github.com/paritytech/parity-ui/blob/master/status/Cargo.toml).
+
+   ```bash
+   $ git clone https://github.com/paritytech/parity-ui.git
+   $ cd ./parity-ui/
+   $ cp ./home/Cargo.toml ../parity/dapps/myapp/Cargo.toml
+   $ cp ./home/build.rs ../parity/dapps/myapp/build.rs
+   $ cp ./home/src/lib.rs ../parity/dapps/myapp/src/lib.rs
+   $ cp ./home/src/lib.rs.in ../parity/dapps/myapp/src/lib.rs.in
+   # And edit the details of your app
+   $ vim ../parity/dapps/myapp/Cargo.toml # Edit the details
+   $ vim ./parity/dapps/myapp/src/lib.rs.in # Edit the details
+   ```
+# How to include your Dapp into `Parity`?
+1. Edit `dapps/Cargo.toml` and add dependency to your application (it can be optional)
+
+   ```toml
+   # Use git repo and version
+   parity-dapps-myapp = { path="./myapp" }
+   ```
+
+1. Edit `dapps/src/apps.rs` and add your application to `all_pages` (if it's optional you need to specify two functions - see `parity-dapps-wallet` example)
+
+1. Compile parity.
+
+   ```bash
+   $ cargo build --release # While inside `parity`
+   ```
+
+1. Commit the results.
+
+   ```bash
+   $ git add myapp && git commit -am "My first Parity Dapp".
+   ```

dapps/js-glue/build.rs

@@ -0,0 +1,42 @@
+// Copyright 2015-2018 Parity Technologies (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+#[cfg(feature = "with-syntex")]
+mod inner {
+	extern crate syntex;
+	extern crate quasi_codegen;
+
+	use std::env;
+	use std::path::Path;
+
+	pub fn main() {
+		let out_dir = env::var_os("OUT_DIR").unwrap();
+
+		let src = Path::new("src/lib.rs.in");
+		let dst = Path::new(&out_dir).join("lib.rs");
+
+		quasi_codegen::expand(&src, &dst).unwrap();
+	}
+}
+
+#[cfg(not(feature = "with-syntex"))]
+mod inner {
+	pub fn main() {}
+}
+
+fn main() {
+	inner::main();
+}

dapps/js-glue/src/build.rs

@@ -0,0 +1,80 @@
+// Copyright 2015-2018 Parity Technologies (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+#[cfg(feature = "with-syntex")]
+pub mod inner {
+	use syntex;
+	use codegen;
+	use syntax::{ast, fold};
+	use std::env;
+	use std::path::Path;
+
+	fn strip_attributes(krate: ast::Crate) -> ast::Crate {
+		/// Helper folder that strips the serde attributes after the extensions have been expanded.
+		struct StripAttributeFolder;
+
+		impl fold::Folder for StripAttributeFolder {
+			fn fold_attribute(&mut self, attr: ast::Attribute) -> Option<ast::Attribute> {
+				if &*attr.value.name.as_str() == "webapp" {
+					return None;
+				}
+
+				Some(attr)
+			}
+
+			fn fold_mac(&mut self, mac: ast::Mac) -> ast::Mac {
+				fold::noop_fold_mac(mac, self)
+			}
+		}
+
+		fold::Folder::fold_crate(&mut StripAttributeFolder, krate)
+	}
+
+	pub fn register(reg: &mut syntex::Registry) {
+		reg.add_attr("feature(custom_derive)");
+		reg.add_attr("feature(custom_attribute)");
+
+		reg.add_decorator("derive_WebAppFiles", codegen::expand_webapp_implementation);
+		reg.add_post_expansion_pass(strip_attributes);
+	}
+
+	pub fn generate() {
+		let out_dir = env::var_os("OUT_DIR").unwrap();
+		let mut registry = syntex::Registry::new();
+		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();
+	}
+}
+
+#[cfg(not(feature = "with-syntex"))]
+pub mod inner {
+	use codegen;
+
+	pub fn register(reg: &mut rustc_plugin::Registry) {
+		reg.register_syntax_extension(
+			syntax::parse::token::intern("derive_WebAppFiles"),
+			syntax::ext::base::MultiDecorator(
+				Box::new(codegen::expand_webapp_implementation)));
+
+		reg.register_attribute("webapp".to_owned(), AttributeType::Normal);
+	}
+
+	pub fn generate() {}
+}

dapps/js-glue/src/codegen.rs

@@ -0,0 +1,194 @@
+// Copyright 2015-2018 Parity Technologies (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+extern crate aster;
+extern crate glob;
+extern crate mime_guess;
+
+use self::mime_guess::guess_mime_type;
+use std::path::{self, Path, PathBuf};
+use std::ops::Deref;
+
+use syntax::attr;
+use syntax::ast::{self, MetaItem, Item};
+use syntax::codemap::Span;
+use syntax::ext::base::{Annotatable, ExtCtxt};
+use syntax::print::pprust::lit_to_string;
+use syntax::symbol::InternedString;
+
+pub fn expand_webapp_implementation(
+	cx: &mut ExtCtxt,
+	span: Span,
+	meta_item: &MetaItem,
+	annotatable: &Annotatable,
+	push: &mut FnMut(Annotatable)
+) {
+	let item = match *annotatable {
+		Annotatable::Item(ref item) => item,
+		_ => {
+			cx.span_err(meta_item.span, "`#[derive(WebAppFiles)]` may only be applied to struct implementations");
+			return;
+		},
+	};
+	let builder = aster::AstBuilder::new().span(span);
+	implement_webapp(cx, &builder, item, push);
+}
+
+fn implement_webapp(cx: &ExtCtxt, builder: &aster::AstBuilder, item: &Item, push: &mut FnMut(Annotatable)) {
+	let static_files_dir = extract_path(cx, item);
+
+	let src = Path::new("src");
+	let static_files = {
+		let mut buf = src.to_path_buf();
+		buf.push(static_files_dir.deref());
+		buf
+	};
+
+	let search_location = {
+		let mut buf = static_files.to_path_buf();
+		buf.push("**");
+		buf.push("*");
+		buf
+	};
+
+	let files = glob::glob(search_location.to_str().expect("Valid UTF8 path"))
+		.expect("The sources directory is missing.")
+		.collect::<Result<Vec<PathBuf>, glob::GlobError>>()
+		.expect("There should be no error when reading a list of files.");
+
+	let statements = files
+		.iter()
+		.filter(|path_buf| path_buf.is_file())
+		.map(|path_buf| {
+			let path = path_buf.as_path();
+			let filename = path.file_name().and_then(|s| s.to_str()).expect("Only UTF8 paths.");
+			let mime_type = guess_mime_type(filename).to_string();
+			let file_path = as_uri(path.strip_prefix(&static_files).ok().expect("Prefix is always there, cause it's absolute path;qed"));
+			let file_path_in_source = path.to_str().expect("Only UTF8 paths.");
+
+			let path_lit = builder.expr().str(file_path.as_str());
+			let mime_lit = builder.expr().str(mime_type.as_str());
+			let web_path_lit = builder.expr().str(file_path_in_source);
+			let separator_lit = builder.expr().str(path::MAIN_SEPARATOR.to_string().as_str());
+			let concat_id = builder.id("concat!");
+			let env_id = builder.id("env!");
+			let macro_id = builder.id("include_bytes!");
+
+			let content = quote_expr!(
+				cx,
+				$macro_id($concat_id($env_id("CARGO_MANIFEST_DIR"), $separator_lit, $web_path_lit))
+			);
+			quote_stmt!(
+				cx,
+				files.insert($path_lit, File { path: $path_lit, content_type: $mime_lit, content: $content });
+			).expect("The statement is always ok, because it just uses literals.")
+		}).collect::<Vec<ast::Stmt>>();
+
+	let type_name = item.ident;
+
+	let files_impl = quote_item!(cx,
+		impl $type_name {
+			#[allow(unused_mut)]
+			fn files() -> ::std::collections::HashMap<&'static str, File> {
+				let mut files = ::std::collections::HashMap::new();
+				$statements
+				files
+			}
+		}
+	).unwrap();
+
+	push(Annotatable::Item(files_impl));
+}
+
+fn extract_path(cx: &ExtCtxt, item: &Item) -> String {
+	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 lit) if is_path => {
+					if let Some(s) = get_str_from_lit(cx, lit) {
+						return s.deref().to_owned();
+					}
+				},
+				_ => {},
+			}
+		}
+	}
+
+	// default
+	"web".to_owned()
+}
+
+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().as_str()),
+		_ => {
+			cx.span_err(
+				lit.span,
+				&format!("webapp annotation path must be a string, not `{}`",
+					lit_to_string(lit)
+				)
+			);
+			return None;
+		}
+	}
+}
+
+fn as_uri(path: &Path) -> String {
+	let mut s = String::new();
+	for component in path.iter() {
+		s.push_str(component.to_str().expect("Only UTF-8 filenames are supported."));
+		s.push('/');
+	}
+	s[0..s.len()-1].into()
+}
+
+#[test]
+fn should_convert_path_separators_on_all_platforms() {
+	// given
+	let p = {
+		let mut p = PathBuf::new();
+		p.push("web");
+		p.push("src");
+		p.push("index.html");
+		p
+	};
+
+	// when
+	let path = as_uri(&p);
+
+	// then
+	assert_eq!(path, "web/src/index.html".to_owned());
+}

dapps/js-glue/src/js.rs

@@ -0,0 +1,89 @@
+// Copyright 2015-2018 Parity Technologies (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+#![cfg_attr(feature="use-precompiled-js", allow(dead_code))]
+#![cfg_attr(feature="use-precompiled-js", allow(unused_imports))]
+
+use std::fmt;
+use std::process::Command;
+
+#[cfg(not(windows))]
+mod platform {
+	use std::process::Command;
+
+	pub static NPM_CMD: &'static str = "npm";
+	pub fn handle_cmd(cmd: &mut Command) -> &mut Command {
+		cmd
+	}
+}
+
+#[cfg(windows)]
+mod platform {
+	use std::process::{Command, Stdio};
+
+	pub static NPM_CMD: &'static str = "cmd.exe";
+	// NOTE [ToDr] For some reason on windows
+	// The command doesn't have %~dp0 set properly
+	// and it cannot load globally installed node.exe
+	pub fn handle_cmd(cmd: &mut Command) -> &mut Command {
+		cmd.stdin(Stdio::null())
+			.arg("/c")
+			.arg("npm.cmd")
+	}
+}
+
+fn die<T : fmt::Debug>(s: &'static str, e: T) -> ! {
+	panic!("Error: {}: {:?}", s, e);
+}
+
+#[cfg(feature = "use-precompiled-js")]
+pub fn test(_path: &str) {
+}
+#[cfg(feature = "use-precompiled-js")]
+pub fn build(_path: &str, _dest: &str) {
+}
+
+#[cfg(not(feature = "use-precompiled-js"))]
+pub fn build(path: &str, dest: &str) {
+	let child = platform::handle_cmd(&mut Command::new(platform::NPM_CMD))
+		.arg("install")
+		.arg("--no-progress")
+		.current_dir(path)
+		.status()
+		.unwrap_or_else(|e| die("Installing node.js dependencies with npm", e));
+	assert!(child.success(), "There was an error installing dependencies.");
+
+	let child = platform::handle_cmd(&mut Command::new(platform::NPM_CMD))
+		.arg("run")
+		.arg("build")
+		.env("NODE_ENV", "production")
+		.env("BUILD_DEST", dest)
+		.current_dir(path)
+		.status()
+		.unwrap_or_else(|e| die("Building JS code", e));
+	assert!(child.success(), "There was an error build JS code.");
+}
+
+#[cfg(not(feature = "use-precompiled-js"))]
+pub fn test(path: &str) {
+	let child = Command::new(platform::NPM_CMD)
+		.arg("run")
+		.arg("test")
+		.current_dir(path)
+		.status()
+		.unwrap_or_else(|e| die("Running test command", e));
+	assert!(child.success(), "There was an error while running JS tests.");
+}

dapps/js-glue/src/lib.rs

@@ -0,0 +1,37 @@
+// Copyright 2015-2018 Parity Technologies (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+#![cfg_attr(not(feature = "with-syntex"), feature(rustc_private, plugin))]
+#![cfg_attr(not(feature = "with-syntex"), plugin(quasi_macros))]
+
+#[cfg(feature = "with-syntex")]
+extern crate syntex;
+
+#[cfg(feature = "with-syntex")]
+extern crate syntex_syntax as syntax;
+
+#[cfg(feature = "with-syntex")]
+include!(concat!(env!("OUT_DIR"), "/lib.rs"));
+
+#[cfg(not(feature = "with-syntex"))]
+#[macro_use]
+extern crate syntax;
+
+#[cfg(not(feature = "with-syntex"))]
+extern crate rustc_plugin;
+
+#[cfg(not(feature = "with-syntex"))]
+include!("lib.rs.in");

dapps/js-glue/src/lib.rs.in

@@ -0,0 +1,47 @@
+// Copyright 2015-2018 Parity Technologies (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity. If not, see <http://www.gnu.org/licenses/>.
+
+
+extern crate quasi;
+
+mod codegen;
+mod build;
+pub mod js;
+pub use build::inner::generate;
+
+use std::default::Default;
+
+#[derive(Clone)]
+pub struct File {
+	pub path: &'static str,
+	pub content: &'static [u8],
+	// TODO: use strongly-typed MIME.
+	pub content_type: &'static str,
+}
+
+#[derive(Clone, Debug)]
+pub struct Info {
+	pub name: &'static str,
+	pub version: &'static str,
+	pub author: &'static str,
+	pub description: &'static str,
+	pub icon_url: &'static str,
+}
+
+pub trait WebApp : Default + Send + Sync {
+	fn file(&self, path: &str) -> Option<&File>;
+	fn info(&self) -> Info;
+}

dapps/node-health/Cargo.toml

@@ -0,0 +1,18 @@
+[package]
+name = "node-health"
+description = "Node's health status"
+version = "0.1.0"
+license = "GPL-3.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+
+[dependencies]
+futures = "0.1"
+futures-cpupool = "0.1"
+log = "0.3"
+ntp = "0.3.0"
+parking_lot = "0.5"
+serde = "1.0"
+serde_derive = "1.0"
+time = "0.1.35"
+
+parity-reactor = { path = "../../util/reactor" }

dapps/node-health/src/health.rs

@@ -0,0 +1,122 @@
+// Copyright 2015-2018 Parity Technologies (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Reporting node's health.
+
+use std::sync::Arc;
+use std::time::Duration;
+use futures::Future;
+use futures::sync::oneshot;
+use types::{HealthInfo, HealthStatus, Health};
+use time::{TimeChecker, MAX_DRIFT};
+use parity_reactor::Remote;
+use parking_lot::Mutex;
+use {SyncStatus};
+
+const TIMEOUT: Duration = Duration::from_secs(5);
+const PROOF: &str = "Only one closure is invoked.";
+
+/// A struct enabling you to query for node's health.
+#[derive(Debug, Clone)]
+pub struct NodeHealth {
+	sync_status: Arc<SyncStatus>,
+	time: TimeChecker,
+	remote: Remote,
+}
+
+impl NodeHealth {
+	/// Creates new `NodeHealth`.
+	pub fn new(sync_status: Arc<SyncStatus>, time: TimeChecker, remote: Remote) -> Self {
+		NodeHealth { sync_status, time, remote, }
+	}
+
+	/// Query latest health report.
+	pub fn health(&self) -> Box<Future<Item = Health, Error = ()> + Send> {
+		trace!(target: "dapps", "Checking node health.");
+		// Check timediff
+		let sync_status = self.sync_status.clone();
+		let time = self.time.time_drift();
+		let (tx, rx) = oneshot::channel();
+		let tx = Arc::new(Mutex::new(Some(tx)));
+		let tx2 = tx.clone();
+		self.remote.spawn_with_timeout(
+			move |_| time.then(move |result| {
+				let _ = tx.lock().take().expect(PROOF).send(Ok(result));
+				Ok(())
+			}),
+			TIMEOUT,
+			move || {
+				let _ = tx2.lock().take().expect(PROOF).send(Err(()));
+			},
+		);
+
+		Box::new(rx.map_err(|err| {
+			warn!(target: "dapps", "Health request cancelled: {:?}", err);
+		}).and_then(move |time| {
+			// Check peers
+			let peers = {
+				let (connected, max) = sync_status.peers();
+				let (status, message) = match connected {
+					0 => {
+						(HealthStatus::Bad, "You are not connected to any peers. There is most likely some network issue. Fix connectivity.".into())
+					},
+					1 => (HealthStatus::NeedsAttention, "You are connected to only one peer. Your node might not be reliable. Check your network connection.".into()),
+					_ => (HealthStatus::Ok, "".into()),
+				};
+				HealthInfo { status, message, details: (connected, max) }
+			};
+
+			// Check sync
+			let sync = {
+				let is_syncing = sync_status.is_major_importing();
+				let (status, message) = if is_syncing {
+					(HealthStatus::NeedsAttention, "Your node is still syncing, the values you see might be outdated. Wait until it's fully synced.".into())
+				} else {
+					(HealthStatus::Ok, "".into())
+				};
+				HealthInfo { status, message, details: is_syncing }
+			};
+
+			// Check time
+			let time = {
+				let (status, message, details) = match time {
+					Ok(Ok(diff)) if diff < MAX_DRIFT && diff > -MAX_DRIFT => {
+						(HealthStatus::Ok, "".into(), diff)
+					},
+					Ok(Ok(diff)) => {
+						(HealthStatus::Bad, format!(
+							"Your clock is not in sync. Detected difference is too big for the protocol to work: {}ms. Synchronize your clock.",
+							diff,
+						), diff)
+					},
+					Ok(Err(err)) => {
+						(HealthStatus::NeedsAttention, format!(
+							"Unable to reach time API: {}. Make sure that your clock is synchronized.",
+							err,
+						), 0)
+					},
+					Err(_) => {
+						(HealthStatus::NeedsAttention, "Time API request timed out. Make sure that the clock is synchronized.".into(), 0)
+					},
+				};
+
+				HealthInfo { status, message, details, }
+			};
+
+			Ok(Health { peers, sync, time})
+		}))
+	}
+}

dapps/node-health/src/lib.rs

@@ -0,0 +1,49 @@
+// Copyright 2015-2018 Parity Technologies (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Node Health status reporting.
+
+#![warn(missing_docs)]
+
+extern crate futures;
+extern crate futures_cpupool;
+extern crate ntp;
+extern crate time as time_crate;
+extern crate parity_reactor;
+extern crate parking_lot;
+
+#[macro_use]
+extern crate log;
+#[macro_use]
+extern crate serde_derive;
+
+mod health;
+mod time;
+mod types;
+
+pub use futures_cpupool::CpuPool;
+pub use health::NodeHealth;
+pub use types::{Health, HealthInfo, HealthStatus};
+pub use time::{TimeChecker, Error};
+
+/// Indicates sync status
+pub trait SyncStatus: ::std::fmt::Debug + Send + Sync {
+	/// Returns true if there is a major sync happening.
+	fn is_major_importing(&self) -> bool;
+
+	/// Returns number of connected and ideal peers.
+	fn peers(&self) -> (usize, usize);
+}

dapps/node-health/src/time.rs

@@ -0,0 +1,357 @@
+// Copyright 2015-2018 Parity Technologies (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Periodically checks node's time drift using [SNTP](https://tools.ietf.org/html/rfc1769).
+//!
+//! An NTP packet is sent to the server with a local timestamp, the server then completes the packet, yielding the
+//! following timestamps:
+//!
+//!    Timestamp Name          ID   When Generated
+//!   ------------------------------------------------------------
+//!    Originate Timestamp     T1   time request sent by client
+//!    Receive Timestamp       T2   time request received at server
+//!    Transmit Timestamp      T3   time reply sent by server
+//!    Destination Timestamp   T4   time reply received at client
+//!
+//! The drift is defined as:
+//!
+//! drift = ((T2 - T1) + (T3 - T4)) / 2.
+//!
+
+use std::io;
+use std::{fmt, mem, time};
+use std::collections::VecDeque;
+use std::sync::atomic::{self, AtomicUsize};
+use std::sync::Arc;
+
+use futures::{self, Future};
+use futures::future::{self, IntoFuture};
+use futures_cpupool::{CpuPool, CpuFuture};
+use ntp;
+use parking_lot::RwLock;
+use time_crate::{Duration, Timespec};
+
+/// Time checker error.
+#[derive(Debug, Clone, PartialEq)]
+pub enum Error {
+	/// No servers are currently available for a query.
+	NoServersAvailable,
+	/// There was an error when trying to reach the NTP server.
+	Ntp(String),
+	/// IO error when reading NTP response.
+	Io(String),
+}
+
+impl fmt::Display for Error {
+	fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+		use self::Error::*;
+
+		match *self {
+			NoServersAvailable => write!(fmt, "No NTP servers available"),
+			Ntp(ref err) => write!(fmt, "NTP error: {}", err),
+			Io(ref err) => write!(fmt, "Connection Error: {}", err),
+		}
+	}
+}
+
+impl From<io::Error> for Error {
+	fn from(err: io::Error) -> Self { Error::Io(format!("{}", err)) }
+}
+
+impl From<ntp::errors::Error> for Error {
+	fn from(err: ntp::errors::Error) -> Self { Error::Ntp(format!("{}", err)) }
+}
+
+/// NTP time drift checker.
+pub trait Ntp {
+	/// Returned Future.
+	type Future: IntoFuture<Item=Duration, Error=Error>;
+
+	/// Returns the current time drift.
+	fn drift(&self) -> Self::Future;
+}
+
+const SERVER_MAX_POLL_INTERVAL_SECS: u64 = 60;
+#[derive(Debug)]
+struct Server {
+	pub address: String,
+	next_call: RwLock<time::Instant>,
+	failures: AtomicUsize,
+}
+
+impl Server {
+	pub fn is_available(&self) -> bool {
+		*self.next_call.read() < time::Instant::now()
+	}
+
+	pub fn report_success(&self) {
+		self.failures.store(0, atomic::Ordering::SeqCst);
+		self.update_next_call(1)
+	}
+
+	pub fn report_failure(&self) {
+		let errors = self.failures.fetch_add(1, atomic::Ordering::SeqCst);
+		self.update_next_call(1 << errors)
+	}
+
+	fn update_next_call(&self, delay: usize) {
+		*self.next_call.write() = time::Instant::now() + time::Duration::from_secs(delay as u64 * SERVER_MAX_POLL_INTERVAL_SECS);
+	}
+}
+
+impl<T: AsRef<str>> From<T> for Server {
+	fn from(t: T) -> Self {
+		Server {
+			address: t.as_ref().to_owned(),
+			next_call: RwLock::new(time::Instant::now()),
+			failures: Default::default(),
+		}
+	}
+}
+
+/// NTP client using the SNTP algorithm for calculating drift.
+#[derive(Clone)]
+pub struct SimpleNtp {
+	addresses: Vec<Arc<Server>>,
+	pool: CpuPool,
+}
+
+impl fmt::Debug for SimpleNtp {
+	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+		f
+			.debug_struct("SimpleNtp")
+			.field("addresses", &self.addresses)
+			.finish()
+	}
+}
+
+impl SimpleNtp {
+	fn new<T: AsRef<str>>(addresses: &[T], pool: CpuPool) -> SimpleNtp {
+		SimpleNtp {
+			addresses: addresses.iter().map(Server::from).map(Arc::new).collect(),
+			pool: pool,
+		}
+	}
+}
+
+impl Ntp for SimpleNtp {
+	type Future = future::Either<
+		CpuFuture<Duration, Error>,
+		future::FutureResult<Duration, Error>,
+	>;
+
+	fn drift(&self) -> Self::Future {
+		use self::future::Either::{A, B};
+
+		let server = self.addresses.iter().find(|server| server.is_available());
+		server.map(|server| {
+			let server = server.clone();
+			A(self.pool.spawn_fn(move || {
+				debug!(target: "dapps", "Fetching time from {}.", server.address);
+
+				match ntp::request(&server.address) {
+					Ok(packet) => {
+						let dest_time = ::time_crate::now_utc().to_timespec();
+						let orig_time = Timespec::from(packet.orig_time);
+						let recv_time = Timespec::from(packet.recv_time);
+						let transmit_time = Timespec::from(packet.transmit_time);
+
+						let drift = ((recv_time - orig_time) + (transmit_time - dest_time)) / 2;
+
+						server.report_success();
+						Ok(drift)
+					},
+					Err(err) => {
+						server.report_failure();
+						Err(err.into())
+					},
+				}
+			}))
+		}).unwrap_or_else(|| B(future::err(Error::NoServersAvailable)))
+	}
+}
+
+// NOTE In a positive scenario first results will be seen after:
+// MAX_RESULTS * UPDATE_TIMEOUT_INCOMPLETE_SECS seconds.
+const MAX_RESULTS: usize = 4;
+const UPDATE_TIMEOUT_OK_SECS: u64 = 6 * 60 * 60;
+const UPDATE_TIMEOUT_WARN_SECS: u64 = 15 * 60;
+const UPDATE_TIMEOUT_ERR_SECS: u64 = 60;
+const UPDATE_TIMEOUT_INCOMPLETE_SECS: u64 = 10;
+
+/// Maximal valid time drift.
+pub const MAX_DRIFT: i64 = 10_000;
+
+type BoxFuture<A, B> = Box<Future<Item = A, Error = B> + Send>;
+
+#[derive(Debug, Clone)]
+/// A time checker.
+pub struct TimeChecker<N: Ntp = SimpleNtp> {
+	ntp: N,
+	last_result: Arc<RwLock<(time::Instant, VecDeque<Result<i64, Error>>)>>,
+}
+
+impl TimeChecker<SimpleNtp> {
+	/// Creates new time checker given the NTP server address.
+	pub fn new<T: AsRef<str>>(ntp_addresses: &[T], pool: CpuPool) -> Self {
+		let last_result = Arc::new(RwLock::new(
+			// Assume everything is ok at the very beginning.
+			(time::Instant::now(), vec![Ok(0)].into())
+		));
+
+		let ntp = SimpleNtp::new(ntp_addresses, pool);
+
+		TimeChecker {
+			ntp,
+			last_result,
+		}
+	}
+}
+
+impl<N: Ntp> TimeChecker<N> where <N::Future as IntoFuture>::Future: Send + 'static {
+	/// Updates the time
+	pub fn update(&self) -> BoxFuture<i64, Error> {
+		trace!(target: "dapps", "Updating time from NTP.");
+		let last_result = self.last_result.clone();
+		Box::new(self.ntp.drift().into_future().then(move |res| {
+			let res = res.map(|d| d.num_milliseconds());
+
+			if let Err(Error::NoServersAvailable) = res {
+				debug!(target: "dapps", "No NTP servers available. Selecting an older result.");
+				return select_result(last_result.read().1.iter());
+			}
+
+			// Update the results.
+			let mut results = mem::replace(&mut last_result.write().1, VecDeque::new());
+			let has_all_results = results.len() >= MAX_RESULTS;
+			let valid_till = time::Instant::now() + time::Duration::from_secs(
+				match res {
+					Ok(time) if has_all_results && time < MAX_DRIFT => UPDATE_TIMEOUT_OK_SECS,
+					Ok(_) if has_all_results => UPDATE_TIMEOUT_WARN_SECS,
+					Err(_) if has_all_results => UPDATE_TIMEOUT_ERR_SECS,
+					_ => UPDATE_TIMEOUT_INCOMPLETE_SECS,
+				}
+			);
+
+			trace!(target: "dapps", "New time drift received: {:?}", res);
+			// Push the result.
+			results.push_back(res);
+			while results.len() > MAX_RESULTS {
+				results.pop_front();
+			}
+
+			// Select a response and update last result.
+			let res = select_result(results.iter());
+			*last_result.write() = (valid_till, results);
+			res
+		}))
+	}
+
+	/// Returns a current time drift or error if last request to NTP server failed.
+	pub fn time_drift(&self) -> BoxFuture<i64, Error> {
+		// return cached result
+		{
+			let res = self.last_result.read();
+			if res.0 > time::Instant::now() {
+				return Box::new(futures::done(select_result(res.1.iter())));
+			}
+		}
+		// or update and return result
+		self.update()
+	}
+}
+
+fn select_result<'a, T: Iterator<Item=&'a Result<i64, Error>>>(results: T) -> Result<i64, Error> {
+	let mut min = None;
+	for res in results {
+		min = Some(match (min.take(), res) {
+			(Some(Ok(min)), &Ok(ref new)) => Ok(::std::cmp::min(min, *new)),
+			(Some(Ok(old)), &Err(_)) => Ok(old),
+			(_, ref new) => (*new).clone(),
+		})
+	}
+
+	min.unwrap_or_else(|| Err(Error::Ntp("NTP server unavailable.".into())))
+}
+
+#[cfg(test)]
+mod tests {
+	use std::sync::Arc;
+	use std::cell::{Cell, RefCell};
+	use std::time::Instant;
+	use time::Duration;
+	use futures::{future, Future};
+	use super::{Ntp, TimeChecker, Error};
+	use parking_lot::RwLock;
+
+	#[derive(Clone)]
+	struct FakeNtp(RefCell<Vec<Duration>>, Cell<u64>);
+	impl FakeNtp {
+		fn new() -> FakeNtp {
+			FakeNtp(
+				RefCell::new(vec![Duration::milliseconds(150)]),
+				Cell::new(0))
+		}
+	}
+
+	impl Ntp for FakeNtp {
+		type Future = future::FutureResult<Duration, Error>;
+
+		fn drift(&self) -> Self::Future {
+			self.1.set(self.1.get() + 1);
+			future::ok(self.0.borrow_mut().pop().expect("Unexpected call to drift()."))
+		}
+	}
+
+	fn time_checker() -> TimeChecker<FakeNtp> {
+		let last_result = Arc::new(RwLock::new(
+			(Instant::now(), vec![Err(Error::Ntp("NTP server unavailable".into()))].into())
+		));
+
+		TimeChecker {
+			ntp: FakeNtp::new(),
+			last_result: last_result,
+		}
+	}
+
+	#[test]
+	fn should_fetch_time_on_start() {
+		// given
+		let time = time_checker();
+
+		// when
+		let diff = time.time_drift().wait().unwrap();
+
+		// then
+		assert_eq!(diff, 150);
+		assert_eq!(time.ntp.1.get(), 1);
+	}
+
+	#[test]
+	fn should_not_fetch_twice_if_timeout_has_not_passed() {
+		// given
+		let time = time_checker();
+
+		// when
+		let diff1 = time.time_drift().wait().unwrap();
+		let diff2 = time.time_drift().wait().unwrap();
+
+		// then
+		assert_eq!(diff1, 150);
+		assert_eq!(diff2, 150);
+		assert_eq!(time.ntp.1.get(), 1);
+	}
+}

dapps/node-health/src/types.rs

@@ -0,0 +1,57 @@
+// Copyright 2015-2018 Parity Technologies (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Base health types.
+
+/// Health API endpoint status.
+#[derive(Debug, PartialEq, Serialize)]
+pub enum HealthStatus {
+	/// Everything's OK.
+	#[serde(rename = "ok")]
+	Ok,
+	/// Node health need attention
+	/// (the issue is not critical, but may need investigation)
+	#[serde(rename = "needsAttention")]
+	NeedsAttention,
+	/// There is something bad detected with the node.
+	#[serde(rename = "bad")]
+	Bad,
+}
+
+/// Represents a single check in node health.
+/// Cointains the status of that check and apropriate message and details.
+#[derive(Debug, PartialEq, Serialize)]
+#[serde(deny_unknown_fields)]
+pub struct HealthInfo<T> {
+	/// Check status.
+	pub status: HealthStatus,
+	/// Human-readable message.
+	pub message: String,
+	/// Technical details of the check.
+	pub details: T,
+}
+
+/// Node Health status.
+#[derive(Debug, PartialEq, Serialize)]
+#[serde(deny_unknown_fields)]
+pub struct Health {
+	/// Status of peers.
+	pub peers: HealthInfo<(usize, usize)>,
+	/// Sync status.
+	pub sync: HealthInfo<bool>,
+	/// Time diff info.
+	pub time: HealthInfo<i64>,
+}

dapps/src/api/api.rs

@@ -0,0 +1,97 @@
+// Copyright 2015-2018 Parity Technologies (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+use std::sync::Arc;
+
+use hyper::{Method, StatusCode};
+
+use api::response;
+use apps::fetcher::Fetcher;
+use endpoint::{Endpoint, Request, Response, EndpointPath};
+use futures::{future, Future};
+use node_health::{NodeHealth, HealthStatus};
+
+#[derive(Clone)]
+pub struct RestApi {
+	fetcher: Arc<Fetcher>,
+	health: NodeHealth,
+}
+
+impl Endpoint for RestApi {
+	fn respond(&self, mut path: EndpointPath, req: Request) -> Response {
+		if let Method::Options = *req.method() {
+			return Box::new(future::ok(response::empty()));
+		}
+
+		let endpoint = path.app_params.get(0).map(String::to_owned);
+		let hash = path.app_params.get(1).map(String::to_owned);
+
+		// at this point path.app_id contains 'api', adjust it to the hash properly, otherwise
+		// we will try and retrieve 'api' as the hash when doing the /api/content route
+		if let Some(ref hash) = hash {
+			path.app_id = hash.to_owned();
+		}
+
+		trace!(target: "dapps", "Handling /api request: {:?}/{:?}", endpoint, hash);
+		match endpoint.as_ref().map(String::as_str) {
+			Some("ping") => Box::new(future::ok(response::ping(req))),
+			Some("health") => self.health(),
+			Some("content") => self.resolve_content(hash.as_ref().map(String::as_str), path, req),
+			_ => Box::new(future::ok(response::not_found())),
+		}
+	}
+}
+
+impl RestApi {
+	pub fn new(
+		fetcher: Arc<Fetcher>,
+		health: NodeHealth,
+	) -> Box<Endpoint> {
+		Box::new(RestApi {
+			fetcher,
+			health,
+		})
+	}
+
+	fn resolve_content(&self, hash: Option<&str>, path: EndpointPath, req: Request) -> Response {
+		trace!(target: "dapps", "Resolving content: {:?} from path: {:?}", hash, path);
+		match hash {
+			Some(hash) if self.fetcher.contains(hash) => {
+				self.fetcher.respond(path, req)
+			},
+			_ => Box::new(future::ok(response::not_found())),
+		}
+	}
+
+	fn health(&self) -> Response {
+		Box::new(self.health.health()
+			.then(|health| {
+				let status = match health {
+					Ok(ref health) => {
+						if [&health.peers.status, &health.sync.status].iter().any(|x| *x != &HealthStatus::Ok) {
+							StatusCode::PreconditionFailed // HTTP 412
+						} else {
+							StatusCode::Ok // HTTP 200
+						}
+					},
+					_ => StatusCode::ServiceUnavailable, // HTTP 503
+				};
+
+				Ok(response::as_json(status, &health).into())
+			})
+		)
+	}
+}

dapps/src/api/mod.rs

@@ -0,0 +1,23 @@
+// Copyright 2015-2018 Parity Technologies (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+//! REST API
+
+mod api;
+mod response;
+mod types;
+
+pub use self::api::RestApi;

dapps/src/api/response.rs

@@ -0,0 +1,43 @@
+// Copyright 2015-2018 Parity Technologies (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+use serde::Serialize;
+use serde_json;
+use hyper::{self, mime, StatusCode};
+
+use handlers::{ContentHandler, EchoHandler};
+
+pub fn empty() -> hyper::Response {
+	ContentHandler::ok("".into(), mime::TEXT_PLAIN).into()
+}
+
+pub fn as_json<T: Serialize>(status: StatusCode, val: &T) -> hyper::Response {
+	let json = serde_json::to_string(val)
+		.expect("serialization to string is infallible; qed");
+	ContentHandler::new(status, json, mime::APPLICATION_JSON).into()
+}
+
+pub fn ping(req: hyper::Request) -> hyper::Response {
+	EchoHandler::new(req).into()
+}
+
+pub fn not_found() -> hyper::Response {
+	as_json(StatusCode::NotFound, &::api::types::ApiError {
+		code: "404".into(),
+		title: "Not Found".into(),
+		detail: "Resource you requested has not been found.".into(),
+	})
+}

dapps/src/api/types.rs

@@ -0,0 +1,27 @@
+// Copyright 2015-2018 Parity Technologies (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+/// A structure representing any error in REST API.
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub struct ApiError {
+	/// Error code.
+	pub code: String,
+	/// Human-readable error summary.
+	pub title: String,
+	/// More technical error details.
+	pub detail: String,
+}

dapps/src/apps/app.rs

@@ -0,0 +1,39 @@
+// Copyright 2015-2018 Parity Technologies (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+#[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub struct App {
+	pub id: Option<String>,
+	pub name: String,
+	pub description: String,
+	pub version: String,
+	pub author: String,
+	#[serde(rename="iconUrl")]
+	pub icon_url: String,
+	#[serde(rename="localUrl")]
+	pub local_url: Option<String>,
+	#[serde(rename="allowJsEval")]
+	pub allow_js_eval: Option<bool>,
+}
+
+impl App {
+	pub fn with_id(&self, id: &str) -> Self {
+		let mut app = self.clone();
+		app.id = Some(id.into());
+		app
+	}
+}

dapps/src/apps/cache.rs

@@ -0,0 +1,128 @@
+// Copyright 2015-2018 Parity Technologies (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Fetchable Dapps support.
+
+use std::fs;
+
+use linked_hash_map::LinkedHashMap;
+use page::local;
+use handlers::FetchControl;
+
+pub enum ContentStatus {
+	Fetching(FetchControl),
+	Ready(local::Dapp),
+}
+
+#[derive(Default)]
+pub struct ContentCache {
+	cache: LinkedHashMap<String, ContentStatus>,
+}
+
+impl ContentCache {
+	pub fn insert(&mut self, content_id: String, status: ContentStatus) -> Option<ContentStatus> {
+		self.cache.insert(content_id, status)
+	}
+
+	pub fn remove(&mut self, content_id: &str) -> Option<ContentStatus> {
+		self.cache.remove(content_id)
+	}
+
+	pub fn get(&mut self, content_id: &str) -> Option<&mut ContentStatus> {
+		self.cache.get_refresh(content_id)
+	}
+
+	pub fn clear_garbage(&mut self, expected_size: usize) -> Vec<(String, ContentStatus)> {
+		let len = self.cache.len();
+
+		if len <= expected_size {
+			return Vec::new();
+		}
+
+		let mut removed = Vec::with_capacity(len - expected_size);
+
+		while self.cache.len() > expected_size {
+			let entry = self.cache.pop_front().expect("expected_size bounded at 0, len is greater; qed");
+
+			match entry.1 {
+				ContentStatus::Fetching(ref fetch) => {
+					trace!(target: "dapps", "Aborting {} because of limit.", entry.0);
+					// Mark as aborted
+					fetch.abort()
+				},
+				ContentStatus::Ready(ref endpoint) => {
+					trace!(target: "dapps", "Removing {} because of limit.", entry.0);
+					// Remove path (dir or file)
+					let res = fs::remove_dir_all(&endpoint.path()).or_else(|_| fs::remove_file(&endpoint.path()));
+					if let Err(e) = res {
+						warn!(target: "dapps", "Unable to remove dapp/content from cache: {:?}", e);
+					}
+				}
+			}
+
+			removed.push(entry);
+		}
+		removed
+	}
+
+	#[cfg(test)]
+	pub fn len(&self) -> usize {
+		self.cache.len()
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+
+	fn only_keys(data: Vec<(String, ContentStatus)>) -> Vec<String> {
+		data.into_iter().map(|x| x.0).collect()
+	}
+
+	#[test]
+	fn should_remove_least_recently_used() {
+		// given
+		let mut cache = ContentCache::default();
+		cache.insert("a".into(), ContentStatus::Fetching(Default::default()));
+		cache.insert("b".into(), ContentStatus::Fetching(Default::default()));
+		cache.insert("c".into(), ContentStatus::Fetching(Default::default()));
+
+		// when
+		let res = cache.clear_garbage(2);
+
+		// then
+		assert_eq!(cache.len(), 2);
+		assert_eq!(only_keys(res), vec!["a"]);
+	}
+
+	#[test]
+	fn should_update_lru_if_accessed() {
+		// given
+		let mut cache = ContentCache::default();
+		cache.insert("a".into(), ContentStatus::Fetching(Default::default()));
+		cache.insert("b".into(), ContentStatus::Fetching(Default::default()));
+		cache.insert("c".into(), ContentStatus::Fetching(Default::default()));
+
+		// when
+		cache.get("a");
+		let res = cache.clear_garbage(2);
+
+		// then
+		assert_eq!(cache.len(), 2);
+		assert_eq!(only_keys(res), vec!["b"]);
+	}
+
+}

dapps/src/apps/fetcher/installers.rs

@@ -0,0 +1,274 @@
+// Copyright 2015-2018 Parity Technologies (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+use zip;
+use std::{fs, fmt};
+use std::io::{self, Read, Write};
+use std::path::PathBuf;
+use ethereum_types::H256;
+use fetch;
+use futures_cpupool::CpuPool;
+use hash::keccak_pipe;
+use mime_guess::Mime;
+
+use apps::manifest::{MANIFEST_FILENAME, deserialize_manifest, serialize_manifest, Manifest};
+use handlers::{ContentValidator, ValidatorResponse};
+use page::{local, PageCache};
+use Embeddable;
+
+type OnDone = Box<Fn(Option<local::Dapp>) + Send>;
+
+fn write_response_and_check_hash(
+	id: &str,
+	mut content_path: PathBuf,
+	filename: &str,
+	response: fetch::Response
+) -> Result<(fs::File, PathBuf), ValidationError> {
+	// try to parse id
+	let id = id.parse().map_err(|_| ValidationError::InvalidContentId)?;
+
+	// check if content exists
+	if content_path.exists() {
+		warn!(target: "dapps", "Overwriting existing content at 0x{:?}", id);
+		fs::remove_dir_all(&content_path)?
+	}
+
+	// create directory
+	fs::create_dir_all(&content_path)?;
+
+	// append filename
+	content_path.push(filename);
+
+	// Now write the response
+	let mut file = io::BufWriter::new(fs::File::create(&content_path)?);
+	let mut reader = io::BufReader::new(fetch::BodyReader::new(response));
+	let hash = keccak_pipe(&mut reader, &mut file)?;
+	let mut file = file.into_inner()?;
+	file.flush()?;
+
+	// Validate hash
+	if id == hash {
+		// The writing above changed the file Read position, which we need later. So we just create a new file handle
+		// here.
+		Ok((fs::File::open(&content_path)?, content_path))
+	} else {
+		Err(ValidationError::HashMismatch {
+			expected: id,
+			got: hash,
+		})
+	}
+}
+
+pub struct Content {
+	id: String,
+	mime: Mime,
+	content_path: PathBuf,
+	on_done: OnDone,
+	pool: CpuPool,
+}
+
+impl Content {
+	pub fn new(id: String, mime: Mime, content_path: PathBuf, on_done: OnDone, pool: CpuPool) -> Self {
+		Content {
+			id,
+			mime,
+			content_path,
+			on_done,
+			pool,
+		}
+	}
+}
+
+impl ContentValidator for Content {
+	type Error = ValidationError;
+
+	fn validate_and_install(self, response: fetch::Response) -> Result<ValidatorResponse, ValidationError> {
+		let pool = self.pool;
+		let id = self.id.clone();
+		let mime = self.mime;
+		let validate = move |content_path: PathBuf| {
+			// Create dir
+			let (_, content_path) = write_response_and_check_hash(&id, content_path, &id, response)?;
+
+			Ok(local::Dapp::single_file(pool, content_path, mime, PageCache::Enabled))
+		};
+
+		// Prepare path for a file
+		let content_path = self.content_path.join(&self.id);
+		// Make sure to always call on_done (even in case of errors)!
+		let result = validate(content_path.clone());
+		// remove the file if there was an error
+		if result.is_err() {
+			// Ignore errors since the file might not exist
+			let _ = fs::remove_dir_all(&content_path);
+		}
+		(self.on_done)(result.as_ref().ok().cloned());
+		result.map(ValidatorResponse::Local)
+	}
+}
+
+pub struct Dapp {
+	id: String,
+	dapps_path: PathBuf,
+	on_done: OnDone,
+	embeddable_on: Embeddable,
+	pool: CpuPool,
+}
+
+impl Dapp {
+	pub fn new(id: String, dapps_path: PathBuf, on_done: OnDone, embeddable_on: Embeddable, pool: CpuPool) -> Self {
+		Dapp {
+			id,
+			dapps_path,
+			on_done,
+			embeddable_on,
+			pool,
+		}
+	}
+
+	fn find_manifest(zip: &mut zip::ZipArchive<fs::File>) -> Result<(Manifest, PathBuf), ValidationError> {
+		for i in 0..zip.len() {
+			let mut file = zip.by_index(i)?;
+
+			if !file.name().ends_with(MANIFEST_FILENAME) {
+				continue;
+			}
+
+			// try to read manifest
+			let mut manifest = String::new();
+			let manifest = file
+				.read_to_string(&mut manifest).ok()
+				.and_then(|_| deserialize_manifest(manifest).ok());
+
+			if let Some(manifest) = manifest {
+				let mut manifest_location = PathBuf::from(file.name());
+				manifest_location.pop(); // get rid of filename
+				return Ok((manifest, manifest_location));
+			}
+		}
+
+		Err(ValidationError::ManifestNotFound)
+	}
+}
+
+impl ContentValidator for Dapp {
+	type Error = ValidationError;
+
+	fn validate_and_install(self, response: fetch::Response) -> Result<ValidatorResponse, ValidationError> {
+		let id = self.id.clone();
+		let pool = self.pool;
+		let embeddable_on = self.embeddable_on;
+		let validate = move |dapp_path: PathBuf| {
+			let (file, zip_path) = write_response_and_check_hash(&id, dapp_path.clone(), &format!("{}.zip", id), response)?;
+			trace!(target: "dapps", "Opening dapp bundle at {:?}", zip_path);
+			// Unpack archive
+			let mut zip = zip::ZipArchive::new(file)?;
+			// First find manifest file
+			let (mut manifest, manifest_dir) = Self::find_manifest(&mut zip)?;
+			// Overwrite id to match hash
+			manifest.id = Some(id);
+
+			// Unpack zip
+			for i in 0..zip.len() {
+				let mut file = zip.by_index(i)?;
+				let is_dir = file.name().chars().rev().next() == Some('/');
+
+				let file_path = PathBuf::from(file.name());
+				let location_in_manifest_base = file_path.strip_prefix(&manifest_dir);
+				// Create files that are inside manifest directory
+				if let Ok(location_in_manifest_base) = location_in_manifest_base {
+					let p = dapp_path.join(location_in_manifest_base);
+					// Check if it's a directory
+					if is_dir {
+						fs::create_dir_all(p)?;
+					} else {
+						let mut target = fs::File::create(p)?;
+						io::copy(&mut file, &mut target)?;
+					}
+				}
+			}
+
+			// Remove zip
+			fs::remove_file(&zip_path)?;
+
+			// Write manifest
+			let manifest_str = serialize_manifest(&manifest).map_err(ValidationError::ManifestSerialization)?;
+			let manifest_path = dapp_path.join(MANIFEST_FILENAME);
+			let mut manifest_file = fs::File::create(manifest_path)?;
+			manifest_file.write_all(manifest_str.as_bytes())?;
+			// Create endpoint
+			let endpoint = local::Dapp::new(pool, dapp_path, manifest.into(), PageCache::Enabled, embeddable_on);
+			Ok(endpoint)
+		};
+
+		// Prepare directory for dapp
+		let target = self.dapps_path.join(&self.id);
+		// Validate the dapp
+		let result = validate(target.clone());
+		// remove the file if there was an error
+		if result.is_err() {
+			// Ignore errors since the file might not exist
+			let _ = fs::remove_dir_all(&target);
+		}
+		(self.on_done)(result.as_ref().ok().cloned());
+		result.map(ValidatorResponse::Local)
+	}
+}
+
+#[derive(Debug)]
+pub enum ValidationError {
+	Io(io::Error),
+	Zip(zip::result::ZipError),
+	InvalidContentId,
+	ManifestNotFound,
+	ManifestSerialization(String),
+	HashMismatch { expected: H256, got: H256, },
+}
+
+impl fmt::Display for ValidationError {
+	fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+		match *self {
+			ValidationError::Io(ref io) => write!(f, "Unexpected IO error occured: {:?}", io),
+			ValidationError::Zip(ref zip) => write!(f, "Unable to read ZIP archive: {:?}", zip),
+			ValidationError::InvalidContentId => write!(f, "ID is invalid. It should be 256 bits keccak hash of content."),
+			ValidationError::ManifestNotFound => write!(f, "Downloaded Dapp bundle did not contain valid manifest.json file."),
+			ValidationError::ManifestSerialization(ref err) => {
+				write!(f, "There was an error during Dapp Manifest serialization: {:?}", err)
+			},
+			ValidationError::HashMismatch { ref expected, ref got } => {
+				write!(f, "Hash of downloaded content did not match. Expected:{:?}, Got:{:?}.", expected, got)
+			},
+		}
+	}
+}
+
+impl From<io::Error> for ValidationError {
+	fn from(err: io::Error) -> Self {
+		ValidationError::Io(err)
+	}
+}
+
+impl From<zip::result::ZipError> for ValidationError {
+	fn from(err: zip::result::ZipError) -> Self {
+		ValidationError::Zip(err)
+	}
+}
+
+impl From<io::IntoInnerError<io::BufWriter<fs::File>>> for ValidationError {
+	fn from(err: io::IntoInnerError<io::BufWriter<fs::File>>) -> Self {
+		ValidationError::Io(err.into())
+	}
+}

dapps/src/apps/fetcher/mod.rs

@@ -0,0 +1,344 @@
+// Copyright 2015-2018 Parity Technologies (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Fetchable Dapps support.
+//! Manages downloaded (cached) Dapps and downloads them when necessary.
+//! Uses `URLHint` to resolve addresses into Dapps bundle file location.
+
+mod installers;
+
+use std::{fs, env};
+use std::path::PathBuf;
+use std::sync::Arc;
+use futures::{future, Future};
+use futures_cpupool::CpuPool;
+use fetch::{Client as FetchClient, Fetch};
+use hash_fetch::urlhint::{URLHintContract, URLHint, URLHintResult};
+
+use hyper::StatusCode;
+
+use ethereum_types::H256;
+use {Embeddable, SyncStatus, random_filename};
+use parking_lot::Mutex;
+use page::local;
+use handlers::{ContentHandler, ContentFetcherHandler};
+use endpoint::{self, Endpoint, EndpointPath};
+use apps::cache::{ContentCache, ContentStatus};
+
+/// Limit of cached dapps/content
+const MAX_CACHED_DAPPS: usize = 20;
+
+pub trait Fetcher: Endpoint + 'static {
+	fn contains(&self, content_id: &str) -> bool;
+}
+
+pub struct ContentFetcher<F: Fetch = FetchClient, R: URLHint + 'static = URLHintContract> {
+	cache_path: PathBuf,
+	resolver: R,
+	cache: Arc<Mutex<ContentCache>>,
+	sync: Arc<SyncStatus>,
+	embeddable_on: Embeddable,
+	fetch: F,
+	pool: CpuPool,
+	only_content: bool,
+}
+
+impl<R: URLHint + 'static, F: Fetch> Drop for ContentFetcher<F, R> {
+	fn drop(&mut self) {
+		// Clear cache path
+		let _ = fs::remove_dir_all(&self.cache_path);
+	}
+}
+
+impl<R: URLHint + 'static, F: Fetch> ContentFetcher<F, R> {
+	pub fn new(
+		resolver: R,
+		sync: Arc<SyncStatus>,
+		fetch: F,
+		pool: CpuPool,
+	) -> Self {
+		let mut cache_path = env::temp_dir();
+		cache_path.push(random_filename());
+
+		ContentFetcher {
+			cache_path,
+			resolver,
+			sync,
+			cache: Arc::new(Mutex::new(ContentCache::default())),
+			embeddable_on: None,
+			fetch,
+			pool,
+			only_content: true,
+		}
+	}
+
+	pub fn allow_dapps(mut self, dapps: bool) -> Self {
+		self.only_content = !dapps;
+		self
+	}
+
+	pub fn embeddable_on(mut self, embeddable_on: Embeddable) -> Self {
+		self.embeddable_on = embeddable_on;
+		self
+	}
+
+	fn not_found(embeddable: Embeddable) -> endpoint::Response {
+		Box::new(future::ok(ContentHandler::error(
+			StatusCode::NotFound,
+			"Resource Not Found",
+			"Requested resource was not found.",
+			None,
+			embeddable,
+		).into()))
+	}
+
+	fn still_syncing(embeddable: Embeddable) -> endpoint::Response {
+		Box::new(future::ok(ContentHandler::error(
+			StatusCode::ServiceUnavailable,
+			"Sync In Progress",
+			"Your node is still syncing. We cannot resolve any content before it's fully synced.",
+			Some("<a href=\"javascript:window.location.reload()\">Refresh</a>"),
+			embeddable,
+		).into()))
+	}
+
+	fn dapps_disabled(address: Embeddable) -> endpoint::Response {
+		Box::new(future::ok(ContentHandler::error(
+			StatusCode::ServiceUnavailable,
+			"Network Dapps Not Available",
+			"This interface doesn't support network dapps for security reasons.",
+			None,
+			address,
+		).into()))
+	}
+
+	#[cfg(test)]
+	fn set_status(&self, content_id: &str, status: ContentStatus) {
+		self.cache.lock().insert(content_id.to_owned(), status);
+	}
+
+	// resolve contract call synchronously.
+	// TODO: port to futures-based hyper and make it all async.
+	fn resolve(&self, content_id: H256) -> Option<URLHintResult> {
+		self.resolver.resolve(content_id)
+			.wait()
+			.unwrap_or_else(|e| { warn!("Error resolving content-id: {}", e); None })
+	}
+}
+
+impl<R: URLHint + 'static, F: Fetch> Fetcher for ContentFetcher<F, R> {
+	fn contains(&self, content_id: &str) -> bool {
+		{
+			let mut cache = self.cache.lock();
+			// Check if we already have the app
+			if cache.get(content_id).is_some() {
+				return true;
+			}
+		}
+		// fallback to resolver
+		if let Ok(content_id) = content_id.parse() {
+			// if there is content or we are syncing return true
+			self.sync.is_major_importing() || self.resolve(content_id).is_some()
+		} else {
+			false
+		}
+	}
+}
+
+impl<R: URLHint + 'static, F: Fetch> Endpoint for ContentFetcher<F, R> {
+	fn respond(&self, path: EndpointPath, req: endpoint::Request) -> endpoint::Response {
+		let mut cache = self.cache.lock();
+		let content_id = path.app_id.clone();
+
+		let (new_status, handler) = {
+			let status = cache.get(&content_id);
+			match status {
+				// Just serve the content
+				Some(&mut ContentStatus::Ready(ref endpoint)) => {
+					(None, endpoint.to_response(&path))
+				},
+				// Content is already being fetched
+				Some(&mut ContentStatus::Fetching(ref fetch_control)) if !fetch_control.is_deadline_reached() => {
+					trace!(target: "dapps", "Content fetching in progress. Waiting...");
+					(None, fetch_control.to_response(path))
+				},
+				// We need to start fetching the content
+				_ => {
+					trace!(target: "dapps", "Content unavailable. Fetching... {:?}", content_id);
+					let content_hex = content_id.parse().expect("to_handler is called only when `contains` returns true.");
+					let content = self.resolve(content_hex);
+
+					let cache = self.cache.clone();
+					let id = content_id.clone();
+					let on_done = move |result: Option<local::Dapp>| {
+						let mut cache = cache.lock();
+						match result {
+							Some(endpoint) => cache.insert(id.clone(), ContentStatus::Ready(endpoint)),
+							// In case of error
+							None => cache.remove(&id),
+						};
+					};
+
+					match content {
+						// Don't serve dapps if we are still syncing (but serve content)
+						Some(URLHintResult::Dapp(_)) if self.sync.is_major_importing() => {
+							(None, Self::still_syncing(self.embeddable_on.clone()))
+						},
+						Some(URLHintResult::Dapp(_)) if self.only_content => {
+							(None, Self::dapps_disabled(self.embeddable_on.clone()))
+						},
+						Some(content) => {
+							let handler = match content {
+								URLHintResult::Dapp(dapp) => {
+									ContentFetcherHandler::new(
+										req.method(),
+										&dapp.url(),
+										path,
+										installers::Dapp::new(
+											content_id.clone(),
+											self.cache_path.clone(),
+											Box::new(on_done),
+											self.embeddable_on.clone(),
+											self.pool.clone(),
+										),
+										self.embeddable_on.clone(),
+										self.fetch.clone(),
+										self.pool.clone(),
+									)
+								},
+							    URLHintResult::GithubDapp(content) => {
+									ContentFetcherHandler::new(
+										req.method(),
+										&content.url,
+										path,
+										installers::Dapp::new(
+											content_id.clone(),
+											self.cache_path.clone(),
+											Box::new(on_done),
+											self.embeddable_on.clone(),
+											self.pool.clone(),
+										),
+										self.embeddable_on.clone(),
+										self.fetch.clone(),
+										self.pool.clone(),
+									)
+							    },
+								URLHintResult::Content(content) => {
+									ContentFetcherHandler::new(
+										req.method(),
+										&content.url,
+										path,
+										installers::Content::new(
+											content_id.clone(),
+											content.mime,
+											self.cache_path.clone(),
+											Box::new(on_done),
+											self.pool.clone(),
+										),
+										self.embeddable_on.clone(),
+										self.fetch.clone(),
+										self.pool.clone(),
+									)
+								},
+							};
+
+							(Some(ContentStatus::Fetching(handler.fetch_control())), Box::new(handler) as endpoint::Response)
+						},
+						None if self.sync.is_major_importing() => {
+							(None, Self::still_syncing(self.embeddable_on.clone()))
+						},
+						None => {
+							// This may happen when sync status changes in between
+							// `contains` and `to_handler`
+							(None, Self::not_found(self.embeddable_on.clone()))
+						},
+					}
+				},
+			}
+		};
+
+		if let Some(status) = new_status {
+			cache.clear_garbage(MAX_CACHED_DAPPS);
+			cache.insert(content_id, status);
+		}
+
+		handler
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use std::env;
+	use std::sync::Arc;
+	use fetch::Client;
+	use futures::{future, Future};
+	use hash_fetch::urlhint::{URLHint, URLHintResult};
+	use ethereum_types::H256;
+
+	use apps::cache::ContentStatus;
+	use endpoint::EndpointInfo;
+	use page::local;
+	use super::{ContentFetcher, Fetcher};
+	use {SyncStatus};
+
+	#[derive(Clone)]
+	struct FakeResolver;
+	impl URLHint for FakeResolver {
+		fn resolve(&self, _id: H256) -> Box<Future<Item = Option<URLHintResult>, Error = String> + Send> {
+			Box::new(future::ok(None))
+		}
+	}
+
+	#[derive(Debug)]
+	struct FakeSync(bool);
+	impl SyncStatus for FakeSync {
+		fn is_major_importing(&self) -> bool { self.0 }
+		fn peers(&self) -> (usize, usize) { (0, 5) }
+	}
+
+	#[test]
+	fn should_true_if_contains_the_app() {
+		// given
+		let pool = ::futures_cpupool::CpuPool::new(1);
+		let path = env::temp_dir();
+		let fetcher = ContentFetcher::new(
+			FakeResolver,
+			Arc::new(FakeSync(false)),
+			Client::new().unwrap(),
+			pool.clone(),
+		).allow_dapps(true);
+
+		let handler = local::Dapp::new(pool, path, EndpointInfo {
+			id: None,
+			name: "fake".into(),
+			description: "".into(),
+			version: "".into(),
+			author: "".into(),
+			icon_url: "".into(),
+			local_url: Some("".into()),
+			allow_js_eval: None,
+		}, Default::default(), None);
+
+		// when
+		fetcher.set_status("test", ContentStatus::Ready(handler));
+		fetcher.set_status("test2", ContentStatus::Fetching(Default::default()));
+
+		// then
+		assert_eq!(fetcher.contains("test"), true);
+		assert_eq!(fetcher.contains("test2"), true);
+		assert_eq!(fetcher.contains("test3"), false);
+	}
+}

dapps/src/apps/fs.rs

@@ -0,0 +1,137 @@
+// Copyright 2015-2018 Parity Technologies (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+use std::collections::BTreeMap;
+use std::io;
+use std::io::Read;
+use std::fs;
+use std::path::{Path, PathBuf};
+use futures_cpupool::CpuPool;
+
+use apps::manifest::{MANIFEST_FILENAME, deserialize_manifest};
+use endpoint::{Endpoint, EndpointInfo};
+use page::{local, PageCache};
+use Embeddable;
+
+struct LocalDapp {
+	id: String,
+	path: PathBuf,
+	info: EndpointInfo,
+}
+
+/// Tries to find and read manifest file in given `path` to extract `EndpointInfo`
+/// If manifest is not found sensible default `EndpointInfo` is returned based on given `name`.
+fn read_manifest(name: &str, mut path: PathBuf) -> EndpointInfo {
+	path.push(MANIFEST_FILENAME);
+
+	fs::File::open(path.clone())
+		.map_err(|e| format!("{:?}", e))
+		.and_then(|mut f| {
+			// Reat file
+			let mut s = String::new();
+			f.read_to_string(&mut s).map_err(|e| format!("{:?}", e))?;
+			// Try to deserialize manifest
+			deserialize_manifest(s)
+		})
+		.unwrap_or_else(|e| {
+			warn!(target: "dapps", "Cannot read manifest file at: {:?}. Error: {:?}", path, e);
+
+			EndpointInfo {
+				id: None,
+				name: name.into(),
+				description: name.into(),
+				version: "0.0.0".into(),
+				author: "?".into(),
+				icon_url: "icon.png".into(),
+				local_url: None,
+				allow_js_eval: Some(false),
+			}
+		})
+}
+
+/// Returns Dapp Id and Local Dapp Endpoint for given filesystem path.
+/// Parses the path to extract last component (for name).
+/// `None` is returned when path is invalid or non-existent.
+pub fn local_endpoint<P: AsRef<Path>>(path: P, embeddable: Embeddable, pool: CpuPool) -> Option<(String, Box<local::Dapp>)> {
+	let path = path.as_ref().to_owned();
+	path.canonicalize().ok().and_then(|path| {
+		let name = path.file_name().and_then(|name| name.to_str());
+		name.map(|name| {
+			let dapp = local_dapp(name.into(), path.clone());
+			(dapp.id, Box::new(local::Dapp::new(
+				pool.clone(), dapp.path, dapp.info, PageCache::Disabled, embeddable.clone())
+			))
+		})
+	})
+}
+
+fn local_dapp(name: String, path: PathBuf) -> LocalDapp {
+	// try to get manifest file
+	let info = read_manifest(&name, path.clone());
+	LocalDapp {
+		id: name,
+		path: path,
+		info: info,
+	}
+}
+
+/// Returns endpoints for Local Dapps found for given filesystem path.
+/// Scans the directory and collects `local::Dapp`.
+pub fn local_endpoints<P: AsRef<Path>>(dapps_path: P, embeddable: Embeddable, pool: CpuPool) -> BTreeMap<String, Box<Endpoint>> {
+	let mut pages = BTreeMap::<String, Box<Endpoint>>::new();
+	for dapp in local_dapps(dapps_path.as_ref()) {
+		pages.insert(
+			dapp.id,
+			Box::new(local::Dapp::new(pool.clone(), dapp.path, dapp.info, PageCache::Disabled, embeddable.clone()))
+		);
+	}
+	pages
+}
+
+fn local_dapps(dapps_path: &Path) -> Vec<LocalDapp> {
+	let files = fs::read_dir(dapps_path);
+	if let Err(e) = files {
+		warn!(target: "dapps", "Unable to load local dapps from: {}. Reason: {:?}", dapps_path.display(), e);
+		return vec![];
+	}
+
+	let files = files.expect("Check is done earlier");
+	files.map(|dir| {
+			let entry = dir?;
+			let file_type = entry.file_type()?;
+
+			// skip files
+			if file_type.is_file() {
+				return Err(io::Error::new(io::ErrorKind::NotFound, "Not a file"));
+			}
+
+			// take directory name and path
+			entry.file_name().into_string()
+				.map(|name| (name, entry.path()))
+				.map_err(|e| {
+					info!(target: "dapps", "Unable to load dapp: {:?}. Reason: {:?}", entry.path(), e);
+					io::Error::new(io::ErrorKind::NotFound, "Invalid name")
+				})
+		})
+		.filter_map(|m| {
+			if let Err(ref e) = m {
+				debug!(target: "dapps", "Ignoring local dapp: {:?}", e);
+			}
+			m.ok()
+		})
+		.map(|(name, path)| local_dapp(name, path))
+		.collect()
+}

dapps/src/apps/manifest.rs

@@ -0,0 +1,34 @@
+// Copyright 2015-2018 Parity Technologies (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+use serde_json;
+pub use apps::App as Manifest;
+
+pub const MANIFEST_FILENAME: &'static str = "manifest.json";
+
+pub fn deserialize_manifest(manifest: String) -> Result<Manifest, String> {
+	let mut manifest = serde_json::from_str::<Manifest>(&manifest).map_err(|e| format!("{:?}", e))?;
+	if manifest.id.is_none() {
+		return Err("App 'id' is missing.".into());
+	}
+	manifest.allow_js_eval = Some(manifest.allow_js_eval.unwrap_or(false));
+
+	Ok(manifest)
+}
+
+pub fn serialize_manifest(manifest: &Manifest) -> Result<String, String> {
+	serde_json::to_string_pretty(manifest).map_err(|e| format!("{:?}", e))
+}

dapps/src/apps/mod.rs

@@ -0,0 +1,105 @@
+// Copyright 2015-2018 Parity Technologies (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+use std::path::PathBuf;
+use std::sync::Arc;
+
+use endpoint::{Endpoints, Endpoint};
+use futures_cpupool::CpuPool;
+use page;
+use proxypac::ProxyPac;
+use web::Web;
+use fetch::Fetch;
+use {WebProxyTokens, ParentFrameSettings};
+
+mod app;
+mod cache;
+mod ui;
+pub mod fs;
+pub mod fetcher;
+pub mod manifest;
+
+pub use self::app::App;
+
+pub const HOME_PAGE: &'static str = "home";
+pub const RPC_PATH: &'static str =  "rpc";
+pub const API_PATH: &'static str =  "api";
+pub const UTILS_PATH: &'static str =  "parity-utils";
+pub const WEB_PATH: &'static str = "web";
+pub const URL_REFERER: &'static str = "__referer=";
+
+pub fn utils(pool: CpuPool) -> Box<Endpoint> {
+	Box::new(page::builtin::Dapp::new(pool, ::parity_ui::App::default()))
+}
+
+pub fn ui(pool: CpuPool) -> Box<Endpoint> {
+	Box::new(page::builtin::Dapp::with_fallback_to_index(pool, ::parity_ui::App::default()))
+}
+
+pub fn ui_deprecation(pool: CpuPool) -> Box<Endpoint> {
+	Box::new(page::builtin::Dapp::with_fallback_to_index(pool, ::parity_ui_deprecation::App::default()))
+}
+
+pub fn ui_redirection(embeddable: Option<ParentFrameSettings>) -> Box<Endpoint> {
+	Box::new(ui::Redirection::new(embeddable))
+}
+
+pub fn all_endpoints<F: Fetch>(
+	dapps_path: PathBuf,
+	extra_dapps: Vec<PathBuf>,
+	dapps_domain: &str,
+	embeddable: Option<ParentFrameSettings>,
+	web_proxy_tokens: Arc<WebProxyTokens>,
+	fetch: F,
+	pool: CpuPool,
+) -> (Vec<String>, Endpoints) {
+	// fetch fs dapps at first to avoid overwriting builtins
+	let mut pages = fs::local_endpoints(dapps_path.clone(), embeddable.clone(), pool.clone());
+	let local_endpoints: Vec<String> = pages.keys().cloned().collect();
+	for path in extra_dapps {
+		if let Some((id, endpoint)) = fs::local_endpoint(path.clone(), embeddable.clone(), pool.clone()) {
+			pages.insert(id, endpoint);
+		} else {
+			warn!(target: "dapps", "Ignoring invalid dapp at {}", path.display());
+		}
+	}
+
+	// NOTE [ToDr] Dapps will be currently embeded on 8180
+	pages.insert(
+		"ui".into(),
+		Box::new(page::builtin::Dapp::new_safe_to_embed(pool.clone(), ::parity_ui::App::default(), embeddable.clone()))
+	);
+	// old version
+	pages.insert(
+		"v1".into(),
+		Box::new({
+			let mut page = page::builtin::Dapp::new_safe_to_embed(pool.clone(), ::parity_ui::old::App::default(), embeddable.clone());
+			// allow JS eval on old Wallet
+			page.allow_js_eval();
+			page
+		})
+	);
+	pages.insert(
+		"proxy".into(),
+		ProxyPac::boxed(embeddable.clone(), dapps_domain.to_owned())
+	);
+	pages.insert(
+		WEB_PATH.into(),
+		Web::boxed(embeddable.clone(), web_proxy_tokens.clone(), fetch.clone(), pool.clone())
+	);
+
+	(local_endpoints, pages)
+}

dapps/src/apps/ui.rs

@@ -0,0 +1,57 @@
+// Copyright 2015-2018 Parity Technologies (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+//! UI redirections
+
+use hyper::StatusCode;
+use futures::future;
+
+use endpoint::{Endpoint, Request, Response, EndpointPath};
+use {handlers, Embeddable};
+
+/// Redirection to UI server.
+pub struct Redirection {
+	embeddable_on: Embeddable,
+}
+
+impl Redirection {
+	pub fn new(
+		embeddable_on: Embeddable,
+	) -> Self {
+		Redirection {
+			embeddable_on,
+		}
+	}
+}
+
+impl Endpoint for Redirection {
+	fn respond(&self, _path: EndpointPath, req: Request) -> Response {
+		Box::new(future::ok(if let Some(ref frame) = self.embeddable_on {
+			trace!(target: "dapps", "Redirecting to signer interface.");
+			let protocol = req.uri().scheme().unwrap_or("http");
+			handlers::Redirection::new(format!("{}://{}:{}", protocol, &frame.host, frame.port)).into()
+		} else {
+			trace!(target: "dapps", "Signer disabled, returning 404.");
+			handlers::ContentHandler::error(
+				StatusCode::NotFound,
+				"404 Not Found",
+				"Your homepage is not available when Trusted Signer is disabled.",
+				Some("You can still access dapps by writing a correct address, though. Re-enable Signer to get your homepage back."),
+				None,
+			).into()
+		}))
+	}
+}

dapps/src/endpoint.rs

@@ -0,0 +1,49 @@
+// Copyright 2015-2018 Parity Technologies (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+//! URL Endpoint traits
+
+use std::collections::BTreeMap;
+
+use futures::Future;
+use hyper;
+
+#[derive(Debug, PartialEq, Default, Clone)]
+pub struct EndpointPath {
+	pub app_id: String,
+	pub app_params: Vec<String>,
+	pub query: Option<String>,
+	pub host: String,
+	pub port: u16,
+	pub using_dapps_domains: bool,
+}
+
+impl EndpointPath {
+	pub fn has_no_params(&self) -> bool {
+		self.app_params.is_empty() || self.app_params.iter().all(|x| x.is_empty())
+	}
+}
+
+pub type EndpointInfo = ::apps::App;
+pub type Endpoints = BTreeMap<String, Box<Endpoint>>;
+pub type Response = Box<Future<Item=hyper::Response, Error=hyper::Error> + Send>;
+pub type Request = hyper::Request;
+
+pub trait Endpoint : Send + Sync {
+	fn info(&self) -> Option<&EndpointInfo> { None }
+
+	fn respond(&self, path: EndpointPath, req: Request) -> Response;
+}

dapps/src/error_tpl.html

@@ -0,0 +1,21 @@
+<!DOCTYPE html>
+<html>
+	<head>
+		<meta charset="utf-8">
+		<meta name="viewport" content="width=device-width">
+		<title>{title}</title>
+		<link rel="stylesheet" href="/parity-utils/styles.css">
+	</head>
+	<body>
+		<div class="parity-navbar">
+		</div>
+		<div class="parity-box">
+			<h1>{title}</h1>
+			<h3>{message}</h3>
+			<p><code>{details}</code></p>
+		</div>
+		<div class="parity-status">
+			<small>{version}</small>
+		</div>
+	</body>
+</html>

dapps/src/handlers/content.rs

@@ -0,0 +1,88 @@
+// Copyright 2015-2018 Parity Technologies (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Simple Content Handler
+
+use hyper::{self, mime, header};
+use hyper::StatusCode;
+
+use parity_version::version;
+
+use handlers::add_security_headers;
+use Embeddable;
+
+#[derive(Debug, Clone)]
+pub struct ContentHandler {
+	code: StatusCode,
+	content: String,
+	mimetype: mime::Mime,
+	safe_to_embed_on: Embeddable,
+}
+
+impl ContentHandler {
+	pub fn ok(content: String, mimetype: mime::Mime) -> Self {
+		Self::new(StatusCode::Ok, content, mimetype)
+	}
+
+	pub fn html(code: StatusCode, content: String, embeddable_on: Embeddable) -> Self {
+		Self::new_embeddable(code, content, mime::TEXT_HTML, embeddable_on)
+	}
+
+	pub fn error(
+		code: StatusCode,
+		title: &str,
+		message: &str,
+		details: Option<&str>,
+		embeddable_on: Embeddable,
+	) -> Self {
+		Self::html(code, format!(
+			include_str!("../error_tpl.html"),
+			title=title,
+			message=message,
+			details=details.unwrap_or_else(|| ""),
+			version=version(),
+		), embeddable_on)
+	}
+
+	pub fn new(code: StatusCode, content: String, mimetype: mime::Mime) -> Self {
+		Self::new_embeddable(code, content, mimetype, None)
+	}
+
+	pub fn new_embeddable(
+		code: StatusCode,
+		content: String,
+		mimetype: mime::Mime,
+		safe_to_embed_on: Embeddable,
+	) -> Self {
+		ContentHandler {
+			code,
+			content,
+			mimetype,
+			safe_to_embed_on,
+		}
+	}
+}
+
+impl Into<hyper::Response> for ContentHandler {
+	fn into(self) -> hyper::Response {
+		let mut res = hyper::Response::new()
+			.with_status(self.code)
+			.with_header(header::ContentType(self.mimetype))
+			.with_body(self.content);
+		add_security_headers(&mut res.headers_mut(), self.safe_to_embed_on, false);
+		res
+	}
+}

dapps/src/handlers/echo.rs

@@ -0,0 +1,46 @@
+// Copyright 2015-2018 Parity Technologies (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Echo Handler
+
+use hyper::{self, header};
+
+use handlers::add_security_headers;
+
+#[derive(Debug)]
+pub struct EchoHandler {
+	request: hyper::Request,
+}
+
+impl EchoHandler {
+	pub fn new(request: hyper::Request) -> Self {
+		EchoHandler {
+			request,
+		}
+	}
+}
+
+impl Into<hyper::Response> for EchoHandler {
+	fn into(self) -> hyper::Response {
+		let content_type = self.request.headers().get().cloned();
+		let mut res = hyper::Response::new()
+			.with_header(content_type.unwrap_or(header::ContentType::json()))
+			.with_body(self.request.body());
+
+		add_security_headers(res.headers_mut(), None, false);
+		res
+	}
+}

dapps/src/handlers/fetch.rs

@@ -0,0 +1,372 @@
+// Copyright 2015-2018 Parity Technologies (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Hyper Server Handler that fetches a file during a request (proxy).
+
+use std::{fmt, mem};
+use std::sync::Arc;
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::time::{Instant, Duration};
+use fetch::{self, Fetch};
+use futures::sync::oneshot;
+use futures::{self, Future};
+use futures_cpupool::CpuPool;
+use hyper::{self, StatusCode};
+use parking_lot::Mutex;
+
+use endpoint::{self, EndpointPath};
+use handlers::{ContentHandler, StreamingHandler};
+use page::local;
+use {Embeddable};
+
+const FETCH_TIMEOUT: Duration = Duration::from_secs(300);
+
+pub enum ValidatorResponse {
+	Local(local::Dapp),
+	Streaming(StreamingHandler<fetch::BodyReader>),
+}
+
+pub trait ContentValidator: Sized + Send + 'static {
+	type Error: fmt::Debug + fmt::Display;
+
+	fn validate_and_install(self, fetch::Response) -> Result<ValidatorResponse, Self::Error>;
+}
+
+#[derive(Debug, Clone)]
+pub struct FetchControl {
+	abort: Arc<AtomicBool>,
+	listeners: Arc<Mutex<Vec<oneshot::Sender<WaitResult>>>>,
+	deadline: Instant,
+}
+
+impl Default for FetchControl {
+	fn default() -> Self {
+		FetchControl {
+			abort: Arc::new(AtomicBool::new(false)),
+			listeners: Arc::new(Mutex::new(Vec::new())),
+			deadline: Instant::now() + FETCH_TIMEOUT,
+		}
+	}
+}
+
+impl FetchControl {
+	pub fn is_deadline_reached(&self) -> bool {
+		self.deadline < Instant::now()
+	}
+
+	pub fn abort(&self) {
+		self.abort.store(true, Ordering::SeqCst);
+	}
+
+	pub fn to_response(&self, path: EndpointPath) -> endpoint::Response {
+		let (tx, receiver) = oneshot::channel();
+		self.listeners.lock().push(tx);
+
+		Box::new(WaitingHandler {
+			path,
+			state: WaitState::Waiting(receiver),
+		})
+	}
+
+	fn notify<F: Fn() -> WaitResult>(&self, status: F) {
+		let mut listeners = self.listeners.lock();
+		for sender in listeners.drain(..) {
+			trace!(target: "dapps", "Resuming request waiting for content...");
+			if let Err(_) = sender.send(status()) {
+				trace!(target: "dapps", "Waiting listener notification failed.");
+			}
+		}
+	}
+
+	fn set_status(&self, status: &FetchState) {
+		match *status {
+			FetchState::Error(ref handler) => self.notify(|| WaitResult::Error(handler.clone())),
+			FetchState::Done(ref endpoint, _) => self.notify(|| WaitResult::Done(endpoint.clone())),
+			FetchState::Streaming(_) => self.notify(|| WaitResult::NonAwaitable),
+			FetchState::InProgress(_) => {},
+			FetchState::Empty => {},
+		}
+	}
+}
+
+enum WaitState {
+	Waiting(oneshot::Receiver<WaitResult>),
+	Done(endpoint::Response),
+}
+
+#[derive(Debug)]
+enum WaitResult {
+	Error(ContentHandler),
+	Done(local::Dapp),
+	NonAwaitable,
+}
+
+pub struct WaitingHandler {
+	path: EndpointPath,
+	state: WaitState,
+}
+
+impl Future for WaitingHandler {
+	type Item = hyper::Response;
+	type Error = hyper::Error;
+
+	fn poll(&mut self) -> futures::Poll<Self::Item, Self::Error> {
+		loop {
+			let new_state = match self.state {
+				WaitState::Waiting(ref mut receiver) => {
+					let result = try_ready!(receiver.poll().map_err(|_| hyper::Error::Timeout));
+
+					match result {
+						WaitResult::Error(handler) => {
+							return Ok(futures::Async::Ready(handler.into()));
+						},
+						WaitResult::NonAwaitable => {
+							let errors = Errors { embeddable_on: None };
+							return Ok(futures::Async::Ready(errors.streaming().into()));
+						},
+						WaitResult::Done(endpoint) => {
+							WaitState::Done(endpoint.to_response(&self.path).into())
+						},
+					}
+				},
+				WaitState::Done(ref mut response) => {
+					return response.poll()
+				},
+			};
+
+			self.state = new_state;
+		}
+	}
+}
+
+#[derive(Debug, Clone)]
+struct Errors {
+	embeddable_on: Embeddable,
+}
+
+impl Errors {
+	fn streaming(&self) -> ContentHandler {
+		ContentHandler::error(
+			StatusCode::BadGateway,
+			"Streaming Error",
+			"This content is being streamed in other place.",
+			None,
+			self.embeddable_on.clone(),
+		)
+	}
+
+	fn download_error<E: fmt::Debug>(&self, e: E) -> ContentHandler {
+		ContentHandler::error(
+			StatusCode::BadGateway,
+			"Download Error",
+			"There was an error when fetching the content.",
+			Some(&format!("{:?}", e)),
+			self.embeddable_on.clone(),
+		)
+	}
+
+	fn invalid_content<E: fmt::Debug>(&self, e: E) -> ContentHandler {
+		ContentHandler::error(
+			StatusCode::BadGateway,
+			"Invalid Dapp",
+			"Downloaded bundle does not contain a valid content.",
+			Some(&format!("{:?}", e)),
+			self.embeddable_on.clone(),
+		)
+	}
+
+	fn timeout_error(&self) -> ContentHandler {
+		ContentHandler::error(
+			StatusCode::GatewayTimeout,
+			"Download Timeout",
+			&format!("Could not fetch content within {} seconds.", FETCH_TIMEOUT.as_secs()),
+			None,
+			self.embeddable_on.clone(),
+		)
+	}
+
+	fn method_not_allowed(&self) -> ContentHandler {
+		ContentHandler::error(
+			StatusCode::MethodNotAllowed,
+			"Method Not Allowed",
+			"Only <code>GET</code> requests are allowed.",
+			None,
+			self.embeddable_on.clone(),
+		)
+	}
+}
+
+enum FetchState {
+	Error(ContentHandler),
+	InProgress(Box<Future<Item=FetchState, Error=()> + Send>),
+	Streaming(hyper::Response),
+	Done(local::Dapp, endpoint::Response),
+	Empty,
+}
+
+impl fmt::Debug for FetchState {
+	fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+		use self::FetchState::*;
+
+		write!(fmt, "FetchState(")?;
+		match *self {
+			Error(ref error) => write!(fmt, "error: {:?}", error),
+			InProgress(_) => write!(fmt, "in progress"),
+			Streaming(ref res) => write!(fmt, "streaming: {:?}", res),
+			Done(ref endpoint, _) => write!(fmt, "done: {:?}", endpoint),
+			Empty => write!(fmt, "?"),
+		}?;
+		write!(fmt, ")")
+	}
+}
+
+#[derive(Debug)]
+pub struct ContentFetcherHandler {
+	fetch_control: FetchControl,
+	status: FetchState,
+	errors: Errors,
+}
+
+impl ContentFetcherHandler {
+	pub fn fetch_control(&self) -> FetchControl {
+		self.fetch_control.clone()
+	}
+
+	pub fn new<H: ContentValidator, F: Fetch>(
+		method: &hyper::Method,
+		url: &str,
+		path: EndpointPath,
+		installer: H,
+		embeddable_on: Embeddable,
+		fetch: F,
+		pool: CpuPool,
+	) -> Self {
+		let fetch_control = FetchControl::default();
+		let errors = Errors { embeddable_on };
+
+		// Validation of method
+		let status = match *method {
+			// Start fetching content
+			hyper::Method::Get => {
+				trace!(target: "dapps", "Fetching content from: {:?}", url);
+				FetchState::InProgress(Self::fetch_content(
+						pool,
+						fetch,
+						url,
+						fetch_control.abort.clone(),
+						path,
+						errors.clone(),
+						installer,
+				))
+			},
+			// or return error
+			_ => FetchState::Error(errors.method_not_allowed()),
+		};
+
+		ContentFetcherHandler {
+			fetch_control,
+			status,
+			errors,
+		}
+	}
+
+	fn fetch_content<H: ContentValidator, F: Fetch>(
+		pool: CpuPool,
+		fetch: F,
+		url: &str,
+		abort: Arc<AtomicBool>,
+		path: EndpointPath,
+		errors: Errors,
+		installer: H,
+	) -> Box<Future<Item=FetchState, Error=()> + Send> {
+		// Start fetching the content
+		let pool2 = pool.clone();
+		let future = fetch.get(url, abort.into()).then(move |result| {
+			trace!(target: "dapps", "Fetching content finished. Starting validation: {:?}", result);
+			Ok(match result {
+				Ok(response) => match installer.validate_and_install(response) {
+					Ok(ValidatorResponse::Local(endpoint)) => {
+						trace!(target: "dapps", "Validation OK. Returning response.");
+						let response = endpoint.to_response(&path);
+						FetchState::Done(endpoint, response)
+					},
+					Ok(ValidatorResponse::Streaming(stream)) => {
+						trace!(target: "dapps", "Validation OK. Streaming response.");
+						let (reading, response) = stream.into_response();
+						pool.spawn(reading).forget();
+						FetchState::Streaming(response)
+					},
+					Err(e) => {
+						trace!(target: "dapps", "Error while validating content: {:?}", e);
+						FetchState::Error(errors.invalid_content(e))
+					},
+				},
+				Err(e) => {
+					warn!(target: "dapps", "Unable to fetch content: {:?}", e);
+					FetchState::Error(errors.download_error(e))
+				},
+			})
+		});
+
+		// make sure to run within fetch thread pool.
+		Box::new(pool2.spawn(future))
+	}
+}
+
+impl Future for ContentFetcherHandler {
+	type Item = hyper::Response;
+	type Error = hyper::Error;
+
+	fn poll(&mut self) -> futures::Poll<Self::Item, Self::Error> {
+		loop {
+			trace!(target: "dapps", "Polling status: {:?}", self.status);
+			self.status = match mem::replace(&mut self.status, FetchState::Empty) {
+				FetchState::Error(error) => {
+					return Ok(futures::Async::Ready(error.into()));
+				},
+				FetchState::Streaming(response) => {
+					return Ok(futures::Async::Ready(response));
+				},
+				any => any,
+			};
+
+			let status = match self.status {
+				// Request may time out
+				FetchState::InProgress(_) if self.fetch_control.is_deadline_reached() => {
+					trace!(target: "dapps", "Fetching dapp failed because of timeout.");
+					FetchState::Error(self.errors.timeout_error())
+				},
+				FetchState::InProgress(ref mut receiver) => {
+					// Check if there is a response
+					trace!(target: "dapps", "Polling streaming response.");
+					try_ready!(receiver.poll().map_err(|err| {
+						warn!(target: "dapps", "Error while fetching response: {:?}", err);
+						hyper::Error::Timeout
+					}))
+				},
+				FetchState::Done(_, ref mut response) => {
+					return response.poll()
+				},
+				FetchState::Empty => panic!("Future polled twice."),
+				_ => unreachable!(),
+			};
+
+			trace!(target: "dapps", "New status: {:?}", status);
+			self.fetch_control.set_status(&status);
+			self.status = status;
+		}
+	}
+}

dapps/src/handlers/mod.rs

@@ -0,0 +1,121 @@
+// Copyright 2015-2018 Parity Technologies (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Hyper handlers implementations.
+
+mod content;
+mod echo;
+mod fetch;
+mod reader;
+mod redirect;
+mod streaming;
+
+pub use self::content::ContentHandler;
+pub use self::echo::EchoHandler;
+pub use self::fetch::{ContentFetcherHandler, ContentValidator, FetchControl, ValidatorResponse};
+pub use self::reader::Reader;
+pub use self::redirect::Redirection;
+pub use self::streaming::StreamingHandler;
+
+use std::iter;
+use itertools::Itertools;
+use hyper::header;
+use {apps, address, Embeddable};
+
+/// Adds security-related headers to the Response.
+pub fn add_security_headers(headers: &mut header::Headers, embeddable_on: Embeddable, allow_js_eval: bool) {
+	headers.set_raw("X-XSS-Protection", "1; mode=block");
+	headers.set_raw("X-Content-Type-Options", "nosniff");
+
+	// Embedding header:
+	if let None = embeddable_on {
+		headers.set_raw("X-Frame-Options",  "SAMEORIGIN");
+	}
+
+	// Content Security Policy headers
+	headers.set_raw("Content-Security-Policy", String::new()
+		// Restrict everything to the same origin by default.
+		+ "default-src 'self';"
+		// Allow connecting to WS servers and HTTP(S) servers.
+		// We could be more restrictive and allow only RPC server URL.
+		+ "connect-src http: https: ws: wss:;"
+		// Allow framing any content from HTTP(S).
+		// Again we could only allow embedding from RPC server URL.
+		// (deprecated)
+		+ "frame-src 'self' http: https:;"
+		// Allow framing and web workers from HTTP(S).
+		+ "child-src 'self' http: https:;"
+		// We allow data: blob: and HTTP(s) images.
+		// We could get rid of wildcarding HTTP and only allow RPC server URL.
+		// (http required for local dapps icons)
+		+ "img-src 'self' 'unsafe-inline' data: blob: http: https:;"
+		// Allow style from data: blob: and HTTPS.
+		+ "style-src 'self' 'unsafe-inline' data: blob: https:;"
+		// Allow fonts from data: and HTTPS.
+		+ "font-src 'self' data: https:;"
+		// Disallow objects
+		+ "object-src 'none';"
+		// Allow scripts
+		+ {
+			let script_src = embeddable_on.as_ref()
+				.map(|e| e.extra_script_src.iter()
+					 .map(|&(ref host, port)| address(host, port))
+					 .join(" ")
+				).unwrap_or_default();
+			let eval = if allow_js_eval { " 'unsafe-eval'" } else { "" };
+
+			&format!(
+				"script-src 'self' {}{};",
+				script_src,
+				eval
+			)
+		}
+		// Same restrictions as script-src with additional
+		// blob: that is required for camera access (worker)
+		+ "worker-src 'self' https: blob:;"
+		// Run in sandbox mode (although it's not fully safe since we allow same-origin and script)
+		+ "sandbox allow-same-origin allow-forms allow-modals allow-popups allow-presentation allow-scripts;"
+		// Disallow submitting forms from any dapps
+		+ "form-action 'none';"
+		// Never allow mixed content
+		+ "block-all-mixed-content;"
+		// Specify if the site can be embedded.
+		+ &match embeddable_on {
+			Some(ref embed) => {
+				let std = address(&embed.host, embed.port);
+				let proxy = format!("{}.{}", apps::HOME_PAGE, embed.dapps_domain);
+				let domain = format!("*.{}:{}", embed.dapps_domain, embed.port);
+
+				let mut ancestors = vec![std, domain, proxy]
+					.into_iter()
+					.chain(embed.extra_embed_on
+						.iter()
+						.map(|&(ref host, port)| address(host, port))
+					);
+
+				let ancestors = if embed.host == "127.0.0.1" {
+					let localhost = address("localhost", embed.port);
+					ancestors.chain(iter::once(localhost)).join(" ")
+				} else {
+					ancestors.join(" ")
+				};
+
+				format!("frame-ancestors {};", ancestors)
+			},
+			None => format!("frame-ancestors 'self';"),
+		}
+	);
+}

dapps/src/handlers/reader.rs

@@ -0,0 +1,73 @@
+// Copyright 2015-2018 Parity Technologies (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+//! A chunk-producing io::Read wrapper.
+
+use std::io::{self, Read};
+
+use futures::{self, sink, Sink, Future};
+use futures::sync::mpsc;
+use hyper;
+
+type Sender = mpsc::Sender<Result<hyper::Chunk, hyper::Error>>;
+
+const MAX_CHUNK_SIZE: usize = 32 * 1024;
+
+/// A Reader is essentially a stream of `hyper::Chunks`.
+/// The chunks are read from given `io::Read` instance.
+///
+/// Unfortunately `hyper` doesn't allow you to pass `Stream`
+/// directly to the response, so you need to create
+/// a `Body::pair()` and send over chunks using `sink::Send`.
+/// Also `Chunks` need to take `Vec` by value, so we need
+/// to allocate it for each chunk being sent.
+pub struct Reader<R: io::Read> {
+	buffer: [u8; MAX_CHUNK_SIZE],
+	content: io::BufReader<R>,
+	sending: sink::Send<Sender>,
+}
+
+impl<R: io::Read> Reader<R> {
+	pub fn pair(content: R, initial: Vec<u8>) -> (Self, hyper::Body) {
+		let (tx, rx) = hyper::Body::pair();
+		let reader = Reader {
+			buffer: [0; MAX_CHUNK_SIZE],
+			content: io::BufReader::new(content),
+			sending: tx.send(Ok(initial.into())),
+		};
+
+		(reader, rx)
+	}
+}
+
+impl<R: io::Read> Future for Reader<R> {
+	type Item = ();
+	type Error = ();
+
+	fn poll(&mut self) -> futures::Poll<Self::Item, Self::Error> {
+		loop {
+			let next = try_ready!(self.sending.poll().map_err(|err| {
+				warn!(target: "dapps", "Unable to send next chunk: {:?}", err);
+			}));
+
+			self.sending = match self.content.read(&mut self.buffer) {
+				Ok(0) => return Ok(futures::Async::Ready(())),
+				Ok(read) => next.send(Ok(self.buffer[..read].to_vec().into())),
+				Err(err) => next.send(Err(hyper::Error::Io(err))),
+			}
+		}
+	}
+}

dapps/src/handlers/redirect.rs

@@ -0,0 +1,41 @@
+// Copyright 2015-2018 Parity Technologies (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+//! HTTP Redirection hyper handler
+
+use hyper::{self, header, StatusCode};
+
+#[derive(Clone)]
+pub struct Redirection {
+	to_url: String
+}
+
+impl Redirection {
+	pub fn new<T: Into<String>>(url: T) -> Self {
+		Redirection {
+			to_url: url.into()
+		}
+	}
+}
+
+impl Into<hyper::Response> for Redirection {
+	fn into(self) -> hyper::Response {
+		// Don't use `MovedPermanently` here to prevent browser from caching the redirections.
+		hyper::Response::new()
+			.with_status(StatusCode::Found)
+			.with_header(header::Location::new(self.to_url))
+	}
+}

dapps/src/handlers/streaming.rs

@@ -0,0 +1,58 @@
+// Copyright 2015-2018 Parity Technologies (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Content Stream Response
+
+use std::io;
+use hyper::{self, header, mime, StatusCode};
+
+use handlers::{add_security_headers, Reader};
+use Embeddable;
+
+pub struct StreamingHandler<R> {
+	initial: Vec<u8>,
+	content: R,
+	status: StatusCode,
+	mimetype: mime::Mime,
+	safe_to_embed_on: Embeddable,
+}
+
+impl<R: io::Read> StreamingHandler<R> {
+	pub fn new(content: R, status: StatusCode, mimetype: mime::Mime, safe_to_embed_on: Embeddable) -> Self {
+		StreamingHandler {
+			initial: Vec::new(),
+			content,
+			status,
+			mimetype,
+			safe_to_embed_on,
+		}
+	}
+
+	pub fn set_initial_content(&mut self, content: &str) {
+		self.initial = content.as_bytes().to_vec();
+	}
+
+	pub fn into_response(self) -> (Reader<R>, hyper::Response) {
+		let (reader, body) = Reader::pair(self.content, self.initial);
+		let mut res = hyper::Response::new()
+			.with_status(self.status)
+			.with_header(header::ContentType(self.mimetype))
+			.with_body(body);
+		add_security_headers(&mut res.headers_mut(), self.safe_to_embed_on, false);
+
+		(reader, res)
+	}
+}

dapps/src/lib.rs

@@ -0,0 +1,339 @@
+// Copyright 2015-2018 Parity Technologies (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Ethcore Webapplications for Parity
+#![warn(missing_docs)]
+
+extern crate base32;
+extern crate futures_cpupool;
+extern crate itertools;
+extern crate linked_hash_map;
+extern crate mime_guess;
+extern crate parking_lot;
+extern crate rand;
+extern crate rustc_hex;
+extern crate serde;
+extern crate serde_json;
+extern crate unicase;
+extern crate zip;
+
+extern crate jsonrpc_http_server;
+
+extern crate ethcore_bytes as bytes;
+extern crate ethereum_types;
+extern crate fetch;
+extern crate node_health;
+extern crate parity_dapps_glue as parity_dapps;
+extern crate parity_hash_fetch as hash_fetch;
+extern crate parity_ui;
+extern crate parity_ui_deprecation;
+extern crate keccak_hash as hash;
+extern crate parity_version;
+extern crate registrar;
+
+#[macro_use]
+extern crate futures;
+#[macro_use]
+extern crate log;
+#[macro_use]
+extern crate serde_derive;
+
+#[cfg(test)]
+extern crate env_logger;
+#[cfg(test)]
+extern crate ethcore_devtools as devtools;
+#[cfg(test)]
+extern crate jsonrpc_core;
+#[cfg(test)]
+extern crate parity_reactor;
+
+mod endpoint;
+mod apps;
+mod page;
+mod router;
+mod handlers;
+mod api;
+mod proxypac;
+mod web;
+#[cfg(test)]
+mod tests;
+
+use std::collections::HashMap;
+use std::mem;
+use std::path::PathBuf;
+use std::sync::Arc;
+use futures_cpupool::CpuPool;
+use jsonrpc_http_server::{self as http, hyper, Origin};
+use parking_lot::RwLock;
+
+use fetch::Fetch;
+use node_health::NodeHealth;
+
+pub use registrar::{RegistrarClient, Asynchronous};
+pub use node_health::SyncStatus;
+
+/// Validates Web Proxy tokens
+pub trait WebProxyTokens: Send + Sync {
+	/// Should return a domain allowed to be accessed by this token or `None` if the token is not valid
+	fn domain(&self, token: &str) -> Option<Origin>;
+}
+
+impl<F> WebProxyTokens for F where F: Fn(String) -> Option<Origin> + Send + Sync {
+	fn domain(&self, token: &str) -> Option<Origin> { self(token.to_owned()) }
+}
+
+/// Current supported endpoints.
+#[derive(Default, Clone)]
+pub struct Endpoints {
+	local_endpoints: Arc<RwLock<Vec<String>>>,
+	endpoints: Arc<RwLock<endpoint::Endpoints>>,
+	dapps_path: PathBuf,
+	embeddable: Option<ParentFrameSettings>,
+	pool: Option<CpuPool>,
+}
+
+impl Endpoints {
+	/// Returns a current list of app endpoints.
+	pub fn list(&self) -> Vec<apps::App> {
+		self.endpoints.read().iter().filter_map(|(ref k, ref e)| {
+			e.info().map(|ref info| info.with_id(k))
+		}).collect()
+	}
+
+	/// Check for any changes in the local dapps folder and update.
+	pub fn refresh_local_dapps(&self) {
+		let pool = match self.pool.as_ref() {
+			None => return,
+			Some(pool) => pool,
+		};
+		let new_local = apps::fs::local_endpoints(&self.dapps_path, self.embeddable.clone(), pool.clone());
+		let old_local = mem::replace(&mut *self.local_endpoints.write(), new_local.keys().cloned().collect());
+		let (_, to_remove): (_, Vec<_>) = old_local
+			.into_iter()
+			.partition(|k| new_local.contains_key(&k.clone()));
+
+		let mut endpoints = self.endpoints.write();
+		// remove the dead dapps
+		for k in to_remove {
+			endpoints.remove(&k);
+		}
+		// new dapps to be added
+		for (k, v) in new_local {
+			if !endpoints.contains_key(&k) {
+				endpoints.insert(k, v);
+			}
+		}
+	}
+}
+
+/// Dapps server as `jsonrpc-http-server` request middleware.
+pub struct Middleware {
+	endpoints: Endpoints,
+	router: router::Router,
+}
+
+impl Middleware {
+	/// Get local endpoints handle.
+	pub fn endpoints(&self) -> &Endpoints {
+		&self.endpoints
+	}
+
+	/// Creates new middleware for UI server.
+	pub fn ui<F: Fetch>(
+		pool: CpuPool,
+		health: NodeHealth,
+		dapps_domain: &str,
+		registrar: Arc<RegistrarClient<Call=Asynchronous>>,
+		sync_status: Arc<SyncStatus>,
+		fetch: F,
+		info_page_only: bool,
+	) -> Self {
+		let content_fetcher = Arc::new(apps::fetcher::ContentFetcher::new(
+			hash_fetch::urlhint::URLHintContract::new(registrar),
+			sync_status.clone(),
+			fetch.clone(),
+			pool.clone(),
+		).embeddable_on(None).allow_dapps(false));
+
+		if info_page_only {
+			let mut special = HashMap::default();
+			special.insert(router::SpecialEndpoint::Home, Some(apps::ui_deprecation(pool.clone())));
+
+			return Middleware {
+				endpoints: Default::default(),
+				router: router::Router::new(
+					content_fetcher,
+					None,
+					special,
+					None,
+					dapps_domain.to_owned(),
+				),
+			}
+		}
+
+		let special = {
+			let mut special = special_endpoints(
+				pool.clone(),
+				health,
+				content_fetcher.clone(),
+			);
+			special.insert(router::SpecialEndpoint::Home, Some(apps::ui(pool.clone())));
+			special
+		};
+		let router = router::Router::new(
+			content_fetcher,
+			None,
+			special,
+			None,
+			dapps_domain.to_owned(),
+		);
+
+		Middleware {
+			endpoints: Default::default(),
+			router: router,
+		}
+	}
+
+	/// Creates new Dapps server middleware.
+	pub fn dapps<F: Fetch>(
+		pool: CpuPool,
+		health: NodeHealth,
+		ui_address: Option<(String, u16)>,
+		extra_embed_on: Vec<(String, u16)>,
+		extra_script_src: Vec<(String, u16)>,
+		dapps_path: PathBuf,
+		extra_dapps: Vec<PathBuf>,
+		dapps_domain: &str,
+		registrar: Arc<RegistrarClient<Call=Asynchronous>>,
+		sync_status: Arc<SyncStatus>,
+		web_proxy_tokens: Arc<WebProxyTokens>,
+		fetch: F,
+	) -> Self {
+		let embeddable = as_embeddable(ui_address, extra_embed_on, extra_script_src, dapps_domain);
+		let content_fetcher = Arc::new(apps::fetcher::ContentFetcher::new(
+			hash_fetch::urlhint::URLHintContract::new(registrar),
+			sync_status.clone(),
+			fetch.clone(),
+			pool.clone(),
+		).embeddable_on(embeddable.clone()).allow_dapps(true));
+		let (local_endpoints, endpoints) = apps::all_endpoints(
+			dapps_path.clone(),
+			extra_dapps,
+			dapps_domain,
+			embeddable.clone(),
+			web_proxy_tokens,
+			fetch.clone(),
+			pool.clone(),
+		);
+		let endpoints = Endpoints {
+			endpoints: Arc::new(RwLock::new(endpoints)),
+			dapps_path,
+			local_endpoints: Arc::new(RwLock::new(local_endpoints)),
+			embeddable: embeddable.clone(),
+			pool: Some(pool.clone()),
+		};
+
+		let special = {
+			let mut special = special_endpoints(
+				pool.clone(),
+				health,
+				content_fetcher.clone(),
+			);
+			special.insert(
+				router::SpecialEndpoint::Home,
+				Some(apps::ui_redirection(embeddable.clone())),
+			);
+			special
+		};
+
+		let router = router::Router::new(
+			content_fetcher,
+			Some(endpoints.clone()),
+			special,
+			embeddable,
+			dapps_domain.to_owned(),
+		);
+
+		Middleware {
+			endpoints,
+			router,
+		}
+	}
+}
+
+impl http::RequestMiddleware for Middleware {
+	fn on_request(&self, req: hyper::Request) -> http::RequestMiddlewareAction {
+		self.router.on_request(req)
+	}
+}
+
+fn special_endpoints(
+	pool: CpuPool,
+	health: NodeHealth,
+	content_fetcher: Arc<apps::fetcher::Fetcher>,
+) -> HashMap<router::SpecialEndpoint, Option<Box<endpoint::Endpoint>>> {
+	let mut special = HashMap::new();
+	special.insert(router::SpecialEndpoint::Rpc, None);
+	special.insert(router::SpecialEndpoint::Utils, Some(apps::utils(pool)));
+	special.insert(router::SpecialEndpoint::Api, Some(api::RestApi::new(
+		content_fetcher,
+		health,
+	)));
+	special
+}
+
+fn address(host: &str, port: u16) -> String {
+	format!("{}:{}", host, port)
+}
+
+fn as_embeddable(
+	ui_address: Option<(String, u16)>,
+	extra_embed_on: Vec<(String, u16)>,
+	extra_script_src: Vec<(String, u16)>,
+	dapps_domain: &str,
+) -> Option<ParentFrameSettings> {
+	ui_address.map(|(host, port)| ParentFrameSettings {
+		host,
+		port,
+		extra_embed_on,
+		extra_script_src,
+		dapps_domain: dapps_domain.to_owned(),
+	})
+}
+
+/// Random filename
+fn random_filename() -> String {
+	use ::rand::Rng;
+	let mut rng = ::rand::OsRng::new().unwrap();
+	rng.gen_ascii_chars().take(12).collect()
+}
+
+type Embeddable = Option<ParentFrameSettings>;
+
+/// Parent frame host and port allowed to embed the content.
+#[derive(Debug, Clone)]
+pub struct ParentFrameSettings {
+	/// Hostname
+	pub host: String,
+	/// Port
+	pub port: u16,
+	/// Additional URLs the dapps can be embedded on.
+	pub extra_embed_on: Vec<(String, u16)>,
+	/// Additional URLs the dapp scripts can be loaded from.
+	pub extra_script_src: Vec<(String, u16)>,
+	/// Dapps Domain (web3.site)
+	pub dapps_domain: String,
+}

dapps/src/page/builtin.rs

@@ -0,0 +1,164 @@
+// Copyright 2015-2018 Parity Technologies (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+use std::io;
+use futures::future;
+use futures_cpupool::CpuPool;
+use hyper::mime::{self, Mime};
+use itertools::Itertools;
+use parity_dapps::{WebApp, Info};
+
+use endpoint::{Endpoint, EndpointInfo, EndpointPath, Request, Response};
+use page::{handler, PageCache};
+use Embeddable;
+
+pub struct Dapp<T: WebApp + 'static> {
+	/// futures cpu pool
+	pool: CpuPool,
+	/// Content of the files
+	app: T,
+	/// Safe to be loaded in frame by other origin. (use wisely!)
+	safe_to_embed_on: Embeddable,
+	info: EndpointInfo,
+	fallback_to_index_html: bool,
+}
+
+impl<T: WebApp + 'static> Dapp<T> {
+	/// Creates new `Dapp` for builtin (compile time) Dapp.
+	pub fn new(pool: CpuPool, app: T) -> Self {
+		let info = app.info();
+		Dapp {
+			pool,
+			app,
+			safe_to_embed_on: None,
+			info: EndpointInfo::from(info),
+			fallback_to_index_html: false,
+		}
+	}
+
+	/// Creates a new `Dapp` for builtin (compile time) Dapp.
+	/// Instead of returning 404 this endpoint will always server index.html.
+	pub fn with_fallback_to_index(pool: CpuPool, app: T) -> Self {
+		let info = app.info();
+		Dapp {
+			pool,
+			app,
+			safe_to_embed_on: None,
+			info: EndpointInfo::from(info),
+			fallback_to_index_html: true,
+		}
+	}
+
+	/// Creates new `Dapp` which can be safely used in iframe
+	/// even from different origin. It might be dangerous (clickjacking).
+	/// Use wisely!
+	pub fn new_safe_to_embed(pool: CpuPool, app: T, address: Embeddable) -> Self {
+		let info = app.info();
+		Dapp {
+			pool,
+			app,
+			safe_to_embed_on: address,
+			info: EndpointInfo::from(info),
+			fallback_to_index_html: false,
+		}
+	}
+
+	/// Allow the dapp to use `unsafe-eval` to run JS.
+	pub fn allow_js_eval(&mut self) {
+		self.info.allow_js_eval = Some(true);
+	}
+}
+
+impl<T: WebApp> Endpoint for Dapp<T> {
+	fn info(&self) -> Option<&EndpointInfo> {
+		Some(&self.info)
+	}
+
+	fn respond(&self, path: EndpointPath, _req: Request) -> Response {
+		trace!(target: "dapps", "Builtin file path: {:?}", path);
+		let file_path = if path.has_no_params() {
+			"index.html".to_owned()
+		} else {
+			path.app_params.into_iter().filter(|x| !x.is_empty()).join("/")
+		};
+		trace!(target: "dapps", "Builtin file: {:?}", file_path);
+
+		let file = {
+			let file = |path| self.app.file(path).map(|file| {
+				let content_type = match file.content_type.parse() {
+					Ok(mime) => mime,
+					Err(_) => {
+						warn!(target: "dapps", "invalid MIME type: {}", file.content_type);
+						mime::TEXT_HTML
+					},
+				};
+				BuiltinFile {
+					content_type,
+					content: io::Cursor::new(file.content),
+				}
+			});
+			let res = file(&file_path);
+			if self.fallback_to_index_html {
+				res.or_else(|| file("index.html"))
+			} else {
+				res
+			}
+		};
+
+		let (reader, response) = handler::PageHandler {
+			file,
+			cache: PageCache::Disabled,
+			safe_to_embed_on: self.safe_to_embed_on.clone(),
+			allow_js_eval: self.info.allow_js_eval.clone().unwrap_or(false),
+		}.into_response();
+
+		self.pool.spawn(reader).forget();
+
+		Box::new(future::ok(response))
+	}
+}
+
+impl From<Info> for EndpointInfo {
+	fn from(info: Info) -> Self {
+		EndpointInfo {
+			id: None,
+			name: info.name.into(),
+			description: info.description.into(),
+			author: info.author.into(),
+			icon_url: info.icon_url.into(),
+			local_url: None,
+			version: info.version.into(),
+			allow_js_eval: None,
+		}
+	}
+}
+
+struct BuiltinFile {
+	content_type: Mime,
+	content: io::Cursor<&'static [u8]>,
+}
+
+impl handler::DappFile for BuiltinFile {
+	type Reader = io::Cursor<&'static [u8]>;
+
+	fn content_type(&self) -> &Mime {
+		&self.content_type
+	}
+
+	fn into_reader(self) -> Self::Reader {
+		self.content
+	}
+}

dapps/src/page/handler.rs

@@ -0,0 +1,104 @@
+// Copyright 2015-2018 Parity Technologies (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+use std::io;
+use std::time::{Duration, SystemTime};
+use hyper::{self, header, StatusCode};
+use hyper::mime::{Mime};
+
+use handlers::{Reader, ContentHandler, add_security_headers};
+use {Embeddable};
+
+/// Represents a file that can be sent to client.
+/// Implementation should keep track of bytes already sent internally.
+pub trait DappFile {
+	/// A reader type returned by this file.
+	type Reader: io::Read;
+
+	/// Returns a content-type of this file.
+	fn content_type(&self) -> &Mime;
+
+	/// Convert this file into io::Read instance.
+	fn into_reader(self) -> Self::Reader where Self: Sized;
+}
+
+/// Defines what cache headers should be appended to returned resources.
+#[derive(Debug, Copy, Clone, PartialEq)]
+pub enum PageCache {
+	Enabled,
+	Disabled,
+}
+
+impl Default for PageCache {
+	fn default() -> Self {
+		PageCache::Disabled
+	}
+}
+
+/// A handler for a single webapp.
+/// Resolves correct paths and serves as a plumbing code between
+/// hyper server and dapp.
+pub struct PageHandler<T: DappFile> {
+	/// File currently being served
+	pub file: Option<T>,
+	/// Flag indicating if the file can be safely embeded (put in iframe).
+	pub safe_to_embed_on: Embeddable,
+	/// Cache settings for this page.
+	pub cache: PageCache,
+	/// Allow JS unsafe-eval.
+	pub allow_js_eval: bool,
+}
+
+impl<T: DappFile> PageHandler<T> {
+	pub fn into_response(self) -> (Option<Reader<T::Reader>>, hyper::Response) {
+		let file = match self.file {
+			None => return (None, ContentHandler::error(
+				StatusCode::NotFound,
+				"File not found",
+				"Requested file has not been found.",
+				None,
+				self.safe_to_embed_on,
+			).into()),
+			Some(file) => file,
+		};
+
+		let mut res = hyper::Response::new()
+			.with_status(StatusCode::Ok);
+
+		// headers
+		{
+			let mut headers = res.headers_mut();
+
+			if let PageCache::Enabled = self.cache {
+				let validity_secs = 365u32 * 24 * 3600;
+				let validity = Duration::from_secs(validity_secs as u64);
+				headers.set(header::CacheControl(vec![
+					header::CacheDirective::Public,
+					header::CacheDirective::MaxAge(validity_secs),
+				]));
+				headers.set(header::Expires(header::HttpDate::from(SystemTime::now() + validity)));
+			}
+
+			headers.set(header::ContentType(file.content_type().to_owned()));
+
+			add_security_headers(&mut headers, self.safe_to_embed_on, self.allow_js_eval);
+		}
+
+		let (reader, body) = Reader::pair(file.into_reader(), Vec::new());
+		res.set_body(body);
+		(Some(reader), res)
+	}
+}

dapps/src/page/local.rs

@@ -0,0 +1,147 @@
+// Copyright 2015-2018 Parity Technologies (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+use mime_guess;
+use std::{fs, fmt};
+use std::path::{Path, PathBuf};
+use futures::{future};
+use futures_cpupool::CpuPool;
+use page::handler::{self, PageCache};
+use endpoint::{Endpoint, EndpointInfo, EndpointPath, Request, Response};
+use hyper::mime::Mime;
+use Embeddable;
+
+#[derive(Clone)]
+pub struct Dapp {
+	pool: CpuPool,
+	path: PathBuf,
+	mime: Option<Mime>,
+	info: Option<EndpointInfo>,
+	cache: PageCache,
+	embeddable_on: Embeddable,
+}
+
+impl fmt::Debug for Dapp {
+	fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+		fmt.debug_struct("Dapp")
+			.field("path", &self.path)
+			.field("mime", &self.mime)
+			.field("info", &self.info)
+			.field("cache", &self.cache)
+			.field("embeddable_on", &self.embeddable_on)
+			.finish()
+	}
+}
+
+impl Dapp {
+	pub fn new(pool: CpuPool, path: PathBuf, info: EndpointInfo, cache: PageCache, embeddable_on: Embeddable) -> Self {
+		Dapp {
+			pool,
+			path,
+			mime: None,
+			info: Some(info),
+			cache,
+			embeddable_on,
+		}
+	}
+
+	pub fn single_file(pool: CpuPool, path: PathBuf, mime: Mime, cache: PageCache) -> Self {
+		Dapp {
+			pool,
+			path,
+			mime: Some(mime),
+			info: None,
+			cache,
+			embeddable_on: None,
+		}
+	}
+
+	pub fn path(&self) -> PathBuf {
+		self.path.clone()
+	}
+
+	fn get_file(&self, path: &EndpointPath) -> Option<LocalFile> {
+		if let Some(ref mime) = self.mime {
+			return LocalFile::from_path(&self.path, mime.to_owned());
+		}
+
+		let mut file_path = self.path.to_owned();
+
+		if path.has_no_params() {
+			file_path.push("index.html");
+		} else {
+			for part in &path.app_params {
+				file_path.push(part);
+			}
+		}
+
+		let mime = mime_guess::guess_mime_type(&file_path);
+		LocalFile::from_path(&file_path, mime)
+	}
+
+	pub fn to_response(&self, path: &EndpointPath) -> Response {
+		let (reader, response) = handler::PageHandler {
+			file: self.get_file(path),
+			cache: self.cache,
+			safe_to_embed_on: self.embeddable_on.clone(),
+			allow_js_eval: self.info.as_ref().and_then(|x| x.allow_js_eval).unwrap_or(false),
+		}.into_response();
+
+		self.pool.spawn(reader).forget();
+
+		Box::new(future::ok(response))
+	}
+}
+
+impl Endpoint for Dapp {
+	fn info(&self) -> Option<&EndpointInfo> {
+		self.info.as_ref()
+	}
+
+	fn respond(&self, path: EndpointPath, _req: Request) -> Response {
+		self.to_response(&path)
+	}
+}
+
+struct LocalFile {
+	content_type: Mime,
+	file: fs::File,
+}
+
+impl LocalFile {
+	fn from_path<P: AsRef<Path>>(path: P, content_type: Mime) -> Option<Self> {
+		trace!(target: "dapps", "Local file: {:?}", path.as_ref());
+		// Check if file exists
+		fs::File::open(&path).ok().map(|file| {
+			LocalFile {
+				content_type,
+				file,
+			}
+		})
+	}
+}
+
+impl handler::DappFile for LocalFile {
+	type Reader = fs::File;
+
+	fn content_type(&self) -> &Mime {
+		&self.content_type
+	}
+
+	fn into_reader(self) -> Self::Reader {
+		self.file
+	}
+}

dapps/src/page/mod.rs

@@ -0,0 +1,21 @@
+// Copyright 2015-2018 Parity Technologies (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+pub mod builtin;
+pub mod local;
+mod handler;
+
+pub use self::handler::PageCache;

dapps/src/proxypac.rs

@@ -0,0 +1,66 @@
+// Copyright 2015-2018 Parity Technologies (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Serving ProxyPac file
+
+use apps::HOME_PAGE;
+use endpoint::{Endpoint, Request, Response, EndpointPath};
+use futures::future;
+use handlers::ContentHandler;
+use hyper::mime;
+use {address, Embeddable};
+
+pub struct ProxyPac {
+	embeddable: Embeddable,
+	dapps_domain: String,
+}
+
+impl ProxyPac {
+	pub fn boxed(embeddable: Embeddable, dapps_domain: String) -> Box<Endpoint> {
+		Box::new(ProxyPac { embeddable, dapps_domain })
+	}
+}
+
+impl Endpoint for ProxyPac {
+	fn respond(&self, path: EndpointPath, _req: Request) -> Response {
+		let ui = self.embeddable
+			.as_ref()
+			.map(|ref parent| address(&parent.host, parent.port))
+			.unwrap_or_else(|| format!("{}:{}", path.host, path.port));
+
+		let content = format!(
+r#"
+function FindProxyForURL(url, host) {{
+	if (shExpMatch(host, "{0}.{1}"))
+	{{
+		return "PROXY {4}";
+	}}
+
+	if (shExpMatch(host, "*.{1}"))
+	{{
+		return "PROXY {2}:{3}";
+	}}
+
+	return "DIRECT";
+}}
+"#,
+		HOME_PAGE, self.dapps_domain, path.host, path.port, ui);
+
+		Box::new(future::ok(
+			ContentHandler::ok(content, mime::TEXT_JAVASCRIPT).into()
+		))
+	}
+}

dapps/src/router.rs

@@ -0,0 +1,417 @@
+// Copyright 2015-2018 Parity Technologies (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Router implementation
+//! Dispatch requests to proper application.
+
+use std::sync::Arc;
+use std::collections::HashMap;
+
+use futures::future;
+use hyper::{self, header, Uri};
+use jsonrpc_http_server as http;
+
+use apps;
+use apps::fetcher::Fetcher;
+use endpoint::{self, Endpoint, EndpointPath};
+use Endpoints;
+use handlers;
+use Embeddable;
+
+/// Special endpoints are accessible on every domain (every dapp)
+#[derive(Debug, PartialEq, Hash, Eq)]
+pub enum SpecialEndpoint {
+	Rpc,
+	Api,
+	Utils,
+	Home,
+	None,
+}
+
+enum Response {
+	Some(endpoint::Response),
+	None(hyper::Request),
+}
+
+/// An endpoint router.
+/// Dispatches the request to particular Endpoint by requested uri/path.
+pub struct Router {
+	endpoints: Option<Endpoints>,
+	fetch: Arc<Fetcher>,
+	special: HashMap<SpecialEndpoint, Option<Box<Endpoint>>>,
+	embeddable_on: Embeddable,
+	dapps_domain: String,
+}
+
+impl Router {
+	fn resolve_request(&self, req: hyper::Request, refresh_dapps: bool) -> (bool, Response) {
+		// Choose proper handler depending on path / domain
+		let endpoint = extract_endpoint(req.uri(), req.headers().get(), &self.dapps_domain);
+		let referer = extract_referer_endpoint(&req, &self.dapps_domain);
+		let is_utils = endpoint.1 == SpecialEndpoint::Utils;
+		let is_get_request = *req.method() == hyper::Method::Get;
+		let is_head_request = *req.method() == hyper::Method::Head;
+		let has_dapp = |dapp: &str| self.endpoints
+			.as_ref()
+			.map_or(false, |endpoints| endpoints.endpoints.read().contains_key(dapp));
+
+		trace!(target: "dapps", "Routing request to {:?}. Details: {:?}", req.uri(), req);
+		debug!(target: "dapps", "Handling endpoint request: {:?}, referer: {:?}", endpoint, referer);
+
+		(is_utils, match (endpoint.0, endpoint.1, referer) {
+			// Handle invalid web requests that we can recover from
+			(ref path, SpecialEndpoint::None, Some(ref referer))
+				if referer.app_id == apps::WEB_PATH
+					&& has_dapp(apps::WEB_PATH)
+					&& !is_web_endpoint(path)
+				=>
+			{
+				let token = referer.app_params.get(0).map(String::as_str).unwrap_or("");
+				let requested = req.uri().path();
+				let query = req.uri().query().map_or_else(String::new, |query| format!("?{}", query));
+				let redirect_url = format!("/{}/{}{}{}", apps::WEB_PATH, token, requested, query);
+				trace!(target: "dapps", "Redirecting to correct web request: {:?}", redirect_url);
+				Response::Some(Box::new(future::ok(
+					handlers::Redirection::new(redirect_url).into()
+				)))
+			},
+			// First check special endpoints
+			(ref path, ref endpoint, _) if self.special.contains_key(endpoint) => {
+				trace!(target: "dapps", "Resolving to special endpoint.");
+				let special = self.special.get(endpoint).expect("special known to contain key; qed");
+				match *special {
+					Some(ref special) => Response::Some(special.respond(path.clone().unwrap_or_default(), req)),
+					None => Response::None(req),
+				}
+			},
+			// Then delegate to dapp
+			(Some(ref path), _, _) if has_dapp(&path.app_id) => {
+				trace!(target: "dapps", "Resolving to local/builtin dapp.");
+				Response::Some(self.endpoints
+					.as_ref()
+					.expect("endpoints known to be set; qed")
+					.endpoints
+					.read()
+					.get(&path.app_id)
+					.expect("endpoints known to contain key; qed")
+					.respond(path.clone(), req))
+			},
+			// Try to resolve and fetch the dapp
+			(Some(ref path), _, _) if self.fetch.contains(&path.app_id) => {
+				trace!(target: "dapps", "Resolving to fetchable content.");
+				Response::Some(self.fetch.respond(path.clone(), req))
+			},
+			// 404 for non-existent content (only if serving endpoints and not homepage)
+			(Some(ref path), _, _)
+				if (is_get_request || is_head_request)
+					&& self.endpoints.is_some()
+					&& path.app_id != apps::HOME_PAGE
+				=>
+			{
+				trace!(target: "dapps", "Resolving to 404.");
+				if refresh_dapps {
+					debug!(target: "dapps", "Refreshing dapps and re-trying.");
+					self.endpoints.as_ref().map(|endpoints| endpoints.refresh_local_dapps());
+					return self.resolve_request(req, false);
+				} else {
+					Response::Some(Box::new(future::ok(handlers::ContentHandler::error(
+						hyper::StatusCode::NotFound,
+						"404 Not Found",
+						"Requested content was not found.",
+						None,
+						self.embeddable_on.clone(),
+					).into())))
+				}
+			},
+			// Any other GET|HEAD requests to home page.
+			_ if (is_get_request || is_head_request) && self.special.contains_key(&SpecialEndpoint::Home) => {
+				trace!(target: "dapps", "Resolving to home page.");
+				let special = self.special.get(&SpecialEndpoint::Home).expect("special known to contain key; qed");
+				match *special {
+					Some(ref special) => {
+						let mut endpoint = EndpointPath::default();
+						endpoint.app_params = req.uri().path().split('/').map(str::to_owned).collect();
+						Response::Some(special.respond(endpoint, req))
+					},
+					None => Response::None(req),
+				}
+			},
+			// RPC by default
+			_ if self.special.contains_key(&SpecialEndpoint::Rpc) => {
+				trace!(target: "dapps", "Resolving to RPC call.");
+				Response::None(req)
+			},
+			// 404 otherwise
+			_ => {
+				Response::Some(Box::new(future::ok(handlers::ContentHandler::error(
+					hyper::StatusCode::NotFound,
+					"404 Not Found",
+					"Requested content was not found.",
+					None,
+					self.embeddable_on.clone(),
+				).into())))
+			},
+		})
+	}
+}
+
+impl http::RequestMiddleware for Router {
+	fn on_request(&self, req: hyper::Request) -> http::RequestMiddlewareAction {
+		let is_origin_set = req.headers().get::<header::Origin>().is_some();
+		let (is_utils, response) = self.resolve_request(req, self.endpoints.is_some());
+		match response {
+			Response::Some(response) => http::RequestMiddlewareAction::Respond {
+				should_validate_hosts: !is_utils,
+				response,
+			},
+			Response::None(request) => http::RequestMiddlewareAction::Proceed {
+				should_continue_on_invalid_cors: !is_origin_set,
+				request,
+			},
+		}
+	}
+}
+
+impl Router {
+	pub fn new(
+		content_fetcher: Arc<Fetcher>,
+		endpoints: Option<Endpoints>,
+		special: HashMap<SpecialEndpoint, Option<Box<Endpoint>>>,
+		embeddable_on: Embeddable,
+		dapps_domain: String,
+	) -> Self {
+		Router {
+			endpoints: endpoints,
+			fetch: content_fetcher,
+			special: special,
+			embeddable_on: embeddable_on,
+			dapps_domain: format!(".{}", dapps_domain),
+		}
+	}
+}
+
+fn is_web_endpoint(path: &Option<EndpointPath>) -> bool {
+	match *path {
+		Some(ref path) if path.app_id == apps::WEB_PATH => true,
+		_ => false,
+	}
+}
+
+fn extract_referer_endpoint(req: &hyper::Request, dapps_domain: &str) -> Option<EndpointPath> {
+	let referer = req.headers().get::<header::Referer>();
+
+	let url = referer.and_then(|referer| referer.parse().ok());
+	url.and_then(|url| {
+		extract_url_referer_endpoint(&url, dapps_domain).or_else(|| {
+			extract_endpoint(&url, None, dapps_domain).0
+		})
+	})
+}
+
+fn extract_url_referer_endpoint(url: &Uri, dapps_domain: &str) -> Option<EndpointPath> {
+	let query = url.query();
+	match query {
+		Some(query) if query.starts_with(apps::URL_REFERER) => {
+			let scheme = url.scheme().unwrap_or("http");
+			let host = url.host().unwrap_or("unknown");
+			let port = default_port(url, None);
+			let referer_url = format!("{}://{}:{}/{}", scheme, host, port, &query[apps::URL_REFERER.len()..]);
+			debug!(target: "dapps", "Recovering referer from query parameter: {}", referer_url);
+
+			if let Some(referer_url) = referer_url.parse().ok() {
+				extract_endpoint(&referer_url, None, dapps_domain).0
+			} else {
+				None
+			}
+		},
+		_ => None,
+	}
+}
+
+fn extract_endpoint(url: &Uri, extra_host: Option<&header::Host>, dapps_domain: &str) -> (Option<EndpointPath>, SpecialEndpoint) {
+	fn special_endpoint(path: &[&str]) -> SpecialEndpoint {
+		if path.len() <= 1 {
+			return SpecialEndpoint::None;
+		}
+
+		match path[0].as_ref() {
+			apps::RPC_PATH => SpecialEndpoint::Rpc,
+			apps::API_PATH => SpecialEndpoint::Api,
+			apps::UTILS_PATH => SpecialEndpoint::Utils,
+			apps::HOME_PAGE => SpecialEndpoint::Home,
+			_ => SpecialEndpoint::None,
+		}
+	}
+
+	let port = default_port(url, extra_host.as_ref().and_then(|h| h.port()));
+	let host = url.host().or_else(|| extra_host.as_ref().map(|h| h.hostname()));
+	let query = url.query().map(str::to_owned);
+	let mut path_segments = url.path().split('/').skip(1).collect::<Vec<_>>();
+	trace!(
+		target: "dapps",
+		"Extracting endpoint from: {:?} (dapps: {}). Got host {:?}:{} with path {:?}",
+		url, dapps_domain, host, port, path_segments
+	);
+	match host {
+		Some(host) if host.ends_with(dapps_domain) => {
+			let id = &host[0..(host.len() - dapps_domain.len())];
+			let special = special_endpoint(&path_segments);
+
+			// remove special endpoint id from params
+			if special != SpecialEndpoint::None {
+				path_segments.remove(0);
+			}
+
+			let (app_id, app_params) = if let Some(split) = id.rfind('.') {
+				let (params, id) = id.split_at(split);
+				path_segments.insert(0, params);
+				(id[1..].to_owned(), path_segments)
+			} else {
+				(id.to_owned(), path_segments)
+			};
+
+			(Some(EndpointPath {
+				app_id,
+				app_params: app_params.into_iter().map(Into::into).collect(),
+				query,
+				host: host.to_owned(),
+				port,
+				using_dapps_domains: true,
+			}), special)
+		},
+		Some(host) if path_segments.len() > 1 => {
+			let special = special_endpoint(&path_segments);
+			let id = path_segments.remove(0);
+			(Some(EndpointPath {
+				app_id: id.to_owned(),
+				app_params: path_segments.into_iter().map(Into::into).collect(),
+				query,
+				host: host.to_owned(),
+				port,
+				using_dapps_domains: false,
+			}), special)
+		},
+		_ => (None, special_endpoint(&path_segments)),
+	}
+}
+
+fn default_port(url: &Uri, extra_port: Option<u16>) -> u16 {
+	let scheme = url.scheme().unwrap_or("http");
+	url.port().or(extra_port).unwrap_or_else(|| match scheme {
+		"http" => 80,
+		"https" => 443,
+		_ => 80,
+	})
+}
+
+#[cfg(test)]
+mod tests {
+	use super::{SpecialEndpoint, EndpointPath, extract_endpoint};
+
+	#[test]
+	fn should_extract_endpoint() {
+		let dapps_domain = ".web3.site";
+
+		// With path prefix
+		assert_eq!(
+			extract_endpoint(&"http://localhost:8080/status/index.html?q=1".parse().unwrap(), None, dapps_domain),
+			(Some(EndpointPath {
+				app_id: "status".to_owned(),
+				app_params: vec!["index.html".to_owned()],
+				query: Some("q=1".into()),
+				host: "localhost".to_owned(),
+				port: 8080,
+				using_dapps_domains: false,
+			}), SpecialEndpoint::None)
+		);
+
+		// With path prefix
+		assert_eq!(
+			extract_endpoint(&"http://localhost:8080/rpc/".parse().unwrap(), None, dapps_domain),
+			(Some(EndpointPath {
+				app_id: "rpc".to_owned(),
+				app_params: vec!["".to_owned()],
+				query: None,
+				host: "localhost".to_owned(),
+				port: 8080,
+				using_dapps_domains: false,
+			}), SpecialEndpoint::Rpc)
+		);
+
+		assert_eq!(
+			extract_endpoint(&"http://my.status.web3.site/parity-utils/inject.js".parse().unwrap(), None, dapps_domain),
+			(Some(EndpointPath {
+				app_id: "status".to_owned(),
+				app_params: vec!["my".into(), "inject.js".into()],
+				query: None,
+				host: "my.status.web3.site".to_owned(),
+				port: 80,
+				using_dapps_domains: true,
+			}), SpecialEndpoint::Utils)
+		);
+
+		assert_eq!(
+			extract_endpoint(&"http://my.status.web3.site/inject.js".parse().unwrap(), None, dapps_domain),
+			(Some(EndpointPath {
+				app_id: "status".to_owned(),
+				app_params: vec!["my".into(), "inject.js".into()],
+				query: None,
+				host: "my.status.web3.site".to_owned(),
+				port: 80,
+				using_dapps_domains: true,
+			}), SpecialEndpoint::None)
+		);
+
+		// By Subdomain
+		assert_eq!(
+			extract_endpoint(&"http://status.web3.site/test.html".parse().unwrap(), None, dapps_domain),
+			(Some(EndpointPath {
+				app_id: "status".to_owned(),
+				app_params: vec!["test.html".to_owned()],
+				query: None,
+				host: "status.web3.site".to_owned(),
+				port: 80,
+				using_dapps_domains: true,
+			}), SpecialEndpoint::None)
+		);
+
+		// RPC by subdomain
+		assert_eq!(
+			extract_endpoint(&"http://my.status.web3.site/rpc/".parse().unwrap(), None, dapps_domain),
+			(Some(EndpointPath {
+				app_id: "status".to_owned(),
+				app_params: vec!["my".into(), "".into()],
+				query: None,
+				host: "my.status.web3.site".to_owned(),
+				port: 80,
+				using_dapps_domains: true,
+			}), SpecialEndpoint::Rpc)
+		);
+
+		// API by subdomain
+		assert_eq!(
+			extract_endpoint(&"http://my.status.web3.site/api/".parse().unwrap(), None, dapps_domain),
+			(Some(EndpointPath {
+				app_id: "status".to_owned(),
+				app_params: vec!["my".into(), "".into()],
+				query: None,
+				host: "my.status.web3.site".to_owned(),
+				port: 80,
+				using_dapps_domains: true,
+			}), SpecialEndpoint::Api)
+		);
+	}
+}

dapps/src/tests/api.rs

@@ -0,0 +1,85 @@
+// Copyright 2015-2018 Parity Technologies (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+use tests::helpers::{serve, serve_with_registrar, request, assert_security_headers};
+
+#[test]
+fn should_return_error() {
+	// given
+	let server = serve();
+
+	// when
+	let response = request(server,
+		"\
+			GET /api/empty HTTP/1.1\r\n\
+			Host: 127.0.0.1:8080\r\n\
+			Connection: close\r\n\
+			\r\n\
+			{}
+		"
+	);
+
+	// then
+	response.assert_status("HTTP/1.1 404 Not Found");
+	response.assert_header("Content-Type", "application/json");
+	assert_eq!(response.body, format!("58\n{}\n0\n\n", r#"{"code":"404","title":"Not Found","detail":"Resource you requested has not been found."}"#));
+	assert_security_headers(&response.headers);
+}
+
+#[test]
+fn should_handle_ping() {
+	// given
+	let server = serve();
+
+	// when
+	let response = request(server,
+		"\
+			POST /api/ping HTTP/1.1\r\n\
+			Host: home.parity\r\n\
+			Content-Type: application/json\r\n\
+			Connection: close\r\n\
+			\r\n\
+			{}
+		"
+	);
+
+	// then
+	response.assert_status("HTTP/1.1 200 OK");
+	response.assert_header("Content-Type", "application/json");
+	assert_eq!(response.body, "0\n\n".to_owned());
+	assert_security_headers(&response.headers);
+}
+
+#[test]
+fn should_try_to_resolve_dapp() {
+	// given
+	let (server, registrar) = serve_with_registrar();
+
+	// when
+	let response = request(server,
+		"\
+			GET /api/content/1472a9e190620cdf6b31f383373e45efcfe869a820c91f9ccd7eb9fb45e4985d HTTP/1.1\r\n\
+			Host: home.parity\r\n\
+			Connection: close\r\n\
+			\r\n\
+		"
+	);
+
+	// then
+	response.assert_status("HTTP/1.1 404 Not Found");
+	assert_eq!(registrar.calls.lock().len(), 2);
+	assert_security_headers(&response.headers);
+}

dapps/src/tests/fetch.rs

@@ -0,0 +1,544 @@
+// Copyright 2015-2018 Parity Technologies (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+use devtools::http_client;
+use rustc_hex::FromHex;
+use tests::helpers::{
+	serve_with_registrar, serve_with_registrar_and_sync, serve_with_fetch,
+	serve_with_registrar_and_fetch,
+	request, assert_security_headers_for_embed,
+};
+
+#[test]
+fn should_resolve_dapp() {
+	// given
+	let (server, registrar) = serve_with_registrar();
+
+	// when
+	let response = request(server,
+		"\
+			GET / HTTP/1.1\r\n\
+			Host: 1472a9e190620cdf6b31f383373e45efcfe869a820c91f9ccd7eb9fb45e4985d.web3.site\r\n\
+			Connection: close\r\n\
+			\r\n\
+		"
+	);
+
+	// then
+	response.assert_status("HTTP/1.1 404 Not Found");
+	assert_eq!(registrar.calls.lock().len(), 4);
+	assert_security_headers_for_embed(&response.headers);
+}
+
+#[test]
+fn should_return_503_when_syncing_but_should_make_the_calls() {
+	// given
+	let (server, registrar) = serve_with_registrar_and_sync();
+
+	// when
+	let response = request(server,
+		"\
+			GET / HTTP/1.1\r\n\
+			Host: 1472a9e190620cdf6b31f383373e45efcfe869a820c91f9ccd7eb9fb45e4985d.web3.site\r\n\
+			Connection: close\r\n\
+			\r\n\
+		"
+	);
+
+	// then
+	response.assert_status("HTTP/1.1 503 Service Unavailable");
+	assert_eq!(registrar.calls.lock().len(), 2);
+	assert_security_headers_for_embed(&response.headers);
+}
+
+const GAVCOIN_DAPP: &'static str = "00000000000000000000000000000000000000000000000000000000000000609faf32e1e3845e237cc6efd27187cee13b3b99db000000000000000000000000000000000000000000000000d8bd350823e28ff75e74a34215faefdc8a52fd8e00000000000000000000000000000000000000000000000000000000000000116761766f66796f726b2f676176636f696e000000000000000000000000000000";
+const GAVCOIN_ICON: &'static str = "00000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000d8bd350823e28ff75e74a34215faefdc8a52fd8e000000000000000000000000000000000000000000000000000000000000007768747470733a2f2f7261772e67697468756275736572636f6e74656e742e636f6d2f657468636f72652f646170702d6173736574732f623838653938336162616131613661363334356238643934343863313562313137646462353430652f746f6b656e732f676176636f696e2d36347836342e706e67000000000000000000";
+
+#[test]
+fn should_return_502_on_hash_mismatch() {
+	// given
+	let (server, fetch, registrar) = serve_with_registrar_and_fetch();
+	let gavcoin = GAVCOIN_DAPP.from_hex().unwrap();
+	registrar.set_result(
+		"94f093625c06887d94d9fee0d5f9cc4aaa46f33d24d1c7e4b5237e7c37d547dd".parse().unwrap(),
+		Ok(gavcoin.clone())
+	);
+
+	// when
+	let response = request(server,
+		"\
+			GET / HTTP/1.1\r\n\
+			Host: 94f093625c06887d94d9fee0d5f9cc4aaa46f33d24d1c7e4b5237e7c37d547dd.web3.site\r\n\
+			Connection: close\r\n\
+			\r\n\
+		"
+	);
+
+	// then
+	assert_eq!(registrar.calls.lock().len(), 4);
+
+	fetch.assert_requested("https://codeload.github.com/gavofyork/gavcoin/zip/9faf32e1e3845e237cc6efd27187cee13b3b99db");
+	fetch.assert_no_more_requests();
+
+	response.assert_status("HTTP/1.1 502 Bad Gateway");
+	assert!(response.body.contains("HashMismatch"), "Expected hash mismatch response, got: {:?}", response.body);
+	assert_security_headers_for_embed(&response.headers);
+}
+
+#[test]
+fn should_return_error_for_invalid_dapp_zip() {
+	// given
+	let (server, fetch, registrar) = serve_with_registrar_and_fetch();
+	let gavcoin = GAVCOIN_DAPP.from_hex().unwrap();
+	registrar.set_result(
+		"2be00befcf008bc0e7d9cdefc194db9c75352e8632f48498b5a6bfce9f02c88e".parse().unwrap(),
+		Ok(gavcoin.clone())
+	);
+
+	// when
+	let response = request(server,
+		"\
+			GET / HTTP/1.1\r\n\
+			Host: 2be00befcf008bc0e7d9cdefc194db9c75352e8632f48498b5a6bfce9f02c88e.web3.site\r\n\
+			Connection: close\r\n\
+			\r\n\
+		"
+	);
+
+	// then
+	assert_eq!(registrar.calls.lock().len(), 4);
+
+	fetch.assert_requested("https://codeload.github.com/gavofyork/gavcoin/zip/9faf32e1e3845e237cc6efd27187cee13b3b99db");
+	fetch.assert_no_more_requests();
+
+	response.assert_status("HTTP/1.1 502 Bad Gateway");
+	assert!(response.body.contains("InvalidArchive"), "Expected invalid zip response, got: {:?}", response.body);
+	assert_security_headers_for_embed(&response.headers);
+}
+
+#[test]
+fn should_return_fetched_dapp_content() {
+	// given
+	let (server, fetch, registrar) = serve_with_registrar_and_fetch();
+	let gavcoin = GAVCOIN_DAPP.from_hex().unwrap();
+	registrar.set_result(
+		"9c94e154dab8acf859b30ee80fc828fb1d38359d938751b65db71d460588d82a".parse().unwrap(),
+		Ok(gavcoin.clone())
+	);
+	fetch.set_response(include_bytes!("../../res/gavcoin.zip"));
+
+	// when
+	let response1 = http_client::request(server.addr(),
+		"\
+			GET /index.html HTTP/1.1\r\n\
+			Host: 9c94e154dab8acf859b30ee80fc828fb1d38359d938751b65db71d460588d82a.web3.site\r\n\
+			Connection: close\r\n\
+			\r\n\
+		"
+	);
+	let response2 = http_client::request(server.addr(),
+		"\
+			GET /manifest.json HTTP/1.1\r\n\
+			Host: 9c94e154dab8acf859b30ee80fc828fb1d38359d938751b65db71d460588d82a.web3.site\r\n\
+			Connection: close\r\n\
+			\r\n\
+		"
+	);
+
+	// then
+	assert_eq!(registrar.calls.lock().len(), 4);
+
+	fetch.assert_requested("https://codeload.github.com/gavofyork/gavcoin/zip/9faf32e1e3845e237cc6efd27187cee13b3b99db");
+	fetch.assert_no_more_requests();
+
+	response1.assert_status("HTTP/1.1 200 OK");
+	assert_security_headers_for_embed(&response1.headers);
+	assert!(
+		response1.body.contains(r#"18
+<h1>Hello Gavcoin!</h1>
+
+0
+
+"#),
+		"Expected Gavcoin body: {}",
+		response1.body
+	);
+
+	response2.assert_status("HTTP/1.1 200 OK");
+	assert_security_headers_for_embed(&response2.headers);
+	assert_eq!(
+		response2.body,
+		r#"EA
+{
+  "id": "9c94e154dab8acf859b30ee80fc828fb1d38359d938751b65db71d460588d82a",
+  "name": "Gavcoin",
+  "description": "Gavcoin",
+  "version": "1.0.0",
+  "author": "",
+  "iconUrl": "icon.png",
+  "localUrl": null,
+  "allowJsEval": false
+}
+0
+
+"#
+	);
+}
+
+#[test]
+fn should_return_fetched_content() {
+	// given
+	let (server, fetch, registrar) = serve_with_registrar_and_fetch();
+	let gavcoin = GAVCOIN_ICON.from_hex().unwrap();
+	registrar.set_result(
+		"2be00befcf008bc0e7d9cdefc194db9c75352e8632f48498b5a6bfce9f02c88e".parse().unwrap(),
+		Ok(gavcoin.clone())
+	);
+
+	// when
+	let response = request(server,
+		"\
+			GET / HTTP/1.1\r\n\
+			Host: 2be00befcf008bc0e7d9cdefc194db9c75352e8632f48498b5a6bfce9f02c88e.web3.site\r\n\
+			Connection: close\r\n\
+			\r\n\
+		"
+	);
+
+	// then
+	assert_eq!(registrar.calls.lock().len(), 4);
+
+	fetch.assert_requested("https://raw.githubusercontent.com/ethcore/dapp-assets/b88e983abaa1a6a6345b8d9448c15b117ddb540e/tokens/gavcoin-64x64.png");
+	fetch.assert_no_more_requests();
+
+	response.assert_status("HTTP/1.1 200 OK");
+	response.assert_security_headers_present(None);
+}
+
+#[test]
+fn should_cache_content() {
+	// given
+	let (server, fetch, registrar) = serve_with_registrar_and_fetch();
+	let gavcoin = GAVCOIN_ICON.from_hex().unwrap();
+	registrar.set_result(
+		"2be00befcf008bc0e7d9cdefc194db9c75352e8632f48498b5a6bfce9f02c88e".parse().unwrap(),
+		Ok(gavcoin.clone())
+	);
+	let request_str = "\
+		GET / HTTP/1.1\r\n\
+		Host: 2be00befcf008bc0e7d9cdefc194db9c75352e8632f48498b5a6bfce9f02c88e.web3.site\r\n\
+		Connection: close\r\n\
+		\r\n\
+	";
+
+	let response = http_client::request(server.addr(), request_str);
+	fetch.assert_requested("https://raw.githubusercontent.com/ethcore/dapp-assets/b88e983abaa1a6a6345b8d9448c15b117ddb540e/tokens/gavcoin-64x64.png");
+	fetch.assert_no_more_requests();
+	response.assert_status("HTTP/1.1 200 OK");
+
+	// when
+	let response = http_client::request(server.addr(), request_str);
+
+	// then
+	fetch.assert_no_more_requests();
+	response.assert_status("HTTP/1.1 200 OK");
+}
+
+#[test]
+fn should_not_request_content_twice() {
+	use std::thread;
+
+	// given
+	let (server, fetch, registrar) = serve_with_registrar_and_fetch();
+	let gavcoin = GAVCOIN_ICON.from_hex().unwrap();
+	registrar.set_result(
+		"2be00befcf008bc0e7d9cdefc194db9c75352e8632f48498b5a6bfce9f02c88e".parse().unwrap(),
+		Ok(gavcoin.clone())
+	);
+	let request_str = "\
+		GET / HTTP/1.1\r\n\
+		Host: 2be00befcf008bc0e7d9cdefc194db9c75352e8632f48498b5a6bfce9f02c88e.web3.site\r\n\
+		Connection: close\r\n\
+		\r\n\
+	";
+	let fire_request = || {
+		let addr = server.addr().to_owned();
+		let req = request_str.to_owned();
+		thread::spawn(move || {
+			http_client::request(&addr, &req)
+		})
+	};
+	let control = fetch.manual();
+
+	// when
+
+	// Fire two requests at the same time
+	let r1 = fire_request();
+	let r2 = fire_request();
+
+	// wait for single request in fetch, the second one should go into waiting state.
+	control.wait_for_requests(1);
+	control.respond();
+
+	let response1 = r1.join().unwrap();
+	let response2 = r2.join().unwrap();
+
+	// then
+	fetch.assert_requested("https://raw.githubusercontent.com/ethcore/dapp-assets/b88e983abaa1a6a6345b8d9448c15b117ddb540e/tokens/gavcoin-64x64.png");
+	fetch.assert_no_more_requests();
+	response1.assert_status("HTTP/1.1 200 OK");
+	response2.assert_status("HTTP/1.1 200 OK");
+}
+
+#[test]
+fn should_encode_and_decode_base32() {
+	use base32;
+
+	let encoded = base32::encode(base32::Alphabet::Crockford, "token+https://parity.io".as_bytes());
+	assert_eq!("EHQPPSBE5DM78X3GECX2YBVGC5S6JX3S5SMPY", &encoded);
+
+	let data = base32::decode(base32::Alphabet::Crockford, "EHQPPSBE5DM78X3GECX2YBVGC5S6JX3S5SMPY").unwrap();
+	assert_eq!("token+https://parity.io", &String::from_utf8(data).unwrap());
+}
+
+#[test]
+fn should_stream_web_content() {
+	// given
+	let (server, fetch) = serve_with_fetch("token", "https://parity.io");
+
+	// when
+	let response = request(server,
+		"\
+			GET / HTTP/1.1\r\n\
+			Host: EHQPPSBE5DM78X3GECX2YBVGC5S6JX3S5SMPY.web.web3.site\r\n\
+			Connection: close\r\n\
+			\r\n\
+		"
+	);
+
+	// then
+	response.assert_status("HTTP/1.1 200 OK");
+	assert_security_headers_for_embed(&response.headers);
+
+	fetch.assert_requested("https://parity.io/");
+	fetch.assert_no_more_requests();
+}
+
+#[test]
+fn should_support_base32_encoded_web_urls() {
+	// given
+	let (server, fetch) = serve_with_fetch("token", "https://parity.io");
+
+	// when
+	let response = request(server,
+		"\
+			GET /styles.css?test=123 HTTP/1.1\r\n\
+			Host: EHQPPSBE5DM78X3GECX2YBVGC5S6JX3S5SMPY.web.web3.site\r\n\
+			Connection: close\r\n\
+			\r\n\
+		"
+	);
+
+	// then
+	response.assert_status("HTTP/1.1 200 OK");
+	assert_security_headers_for_embed(&response.headers);
+
+	fetch.assert_requested("https://parity.io/styles.css?test=123");
+	fetch.assert_no_more_requests();
+}
+
+#[test]
+fn should_correctly_handle_long_label_when_splitted() {
+	// given
+	let (server, fetch) = serve_with_fetch("xolrg9fePeQyKLnL", "https://contribution.melonport.com");
+
+	// when
+	let response = request(server,
+		"\
+			GET /styles.css?test=123 HTTP/1.1\r\n\
+			Host: f1qprwk775k6am35a5wmpk3e9gnpgx3me1sk.mbsfcdqpwx3jd5h7ax39dxq2wvb5dhqpww3fe9t2wrvfdm.web.web3.site\r\n\
+			Connection: close\r\n\
+			\r\n\
+		"
+	);
+
+	// then
+	response.assert_status("HTTP/1.1 200 OK");
+	assert_security_headers_for_embed(&response.headers);
+
+	fetch.assert_requested("https://contribution.melonport.com/styles.css?test=123");
+	fetch.assert_no_more_requests();
+}
+
+#[test]
+fn should_support_base32_encoded_web_urls_as_path() {
+	// given
+	let (server, fetch) = serve_with_fetch("token", "https://parity.io");
+
+	// when
+	let response = request(server,
+		"\
+			GET /web/EHQPPSBE5DM78X3GECX2YBVGC5S6JX3S5SMPY/styles.css?test=123 HTTP/1.1\r\n\
+			Host: localhost:8080\r\n\
+			Connection: close\r\n\
+			\r\n\
+		"
+	);
+
+	// then
+	response.assert_status("HTTP/1.1 200 OK");
+	assert_security_headers_for_embed(&response.headers);
+
+	fetch.assert_requested("https://parity.io/styles.css?test=123");
+	fetch.assert_no_more_requests();
+}
+
+#[test]
+fn should_return_error_on_non_whitelisted_domain() {
+	// given
+	let (server, fetch) = serve_with_fetch("token", "https://ethcore.io");
+
+	// when
+	let response = request(server,
+		"\
+			GET / HTTP/1.1\r\n\
+			Host: EHQPPSBE5DM78X3GECX2YBVGC5S6JX3S5SMPY.web.web3.site\r\n\
+			Connection: close\r\n\
+			\r\n\
+		"
+	);
+
+	// then
+	response.assert_status("HTTP/1.1 400 Bad Request");
+	assert_security_headers_for_embed(&response.headers);
+
+	fetch.assert_no_more_requests();
+}
+
+#[test]
+fn should_return_error_on_invalid_token() {
+	// given
+	let (server, fetch) = serve_with_fetch("test", "https://parity.io");
+
+	// when
+	let response = request(server,
+		"\
+			GET / HTTP/1.1\r\n\
+			Host: EHQPPSBE5DM78X3GECX2YBVGC5S6JX3S5SMPY.web.web3.site\r\n\
+			Connection: close\r\n\
+			\r\n\
+		"
+	);
+
+	// then
+	response.assert_status("HTTP/1.1 400 Bad Request");
+	assert_security_headers_for_embed(&response.headers);
+
+	fetch.assert_no_more_requests();
+}
+
+#[test]
+fn should_return_error_on_invalid_protocol() {
+	// given
+	let (server, fetch) = serve_with_fetch("token", "ftp://parity.io");
+
+	// when
+	let response = request(server,
+		"\
+			GET /web/token/ftp/parity.io/ HTTP/1.1\r\n\
+			Host: localhost:8080\r\n\
+			Connection: close\r\n\
+			\r\n\
+		"
+	);
+
+	// then
+	response.assert_status("HTTP/1.1 400 Bad Request");
+	assert_security_headers_for_embed(&response.headers);
+
+	fetch.assert_no_more_requests();
+}
+
+#[test]
+fn should_disallow_non_get_requests() {
+	// given
+	let (server, fetch) = serve_with_fetch("token", "https://parity.io");
+
+	// when
+	let response = request(server,
+		"\
+			POST / HTTP/1.1\r\n\
+			Host: EHQPPSBE5DM78X3GECX2YBVGC5S6JX3S5SMPY.web.web3.site\r\n\
+			Content-Type: application/json\r\n\
+			Connection: close\r\n\
+			\r\n\
+			123\r\n\
+			\r\n\
+		"
+	);
+
+	// then
+	response.assert_status("HTTP/1.1 405 Method Not Allowed");
+	assert_security_headers_for_embed(&response.headers);
+
+	fetch.assert_no_more_requests();
+}
+
+#[test]
+fn should_fix_absolute_requests_based_on_referer() {
+	// given
+	let (server, fetch) = serve_with_fetch("token", "https://parity.io");
+
+	// when
+	let response = request(server,
+		"\
+			GET /styles.css HTTP/1.1\r\n\
+			Host: localhost:8080\r\n\
+			Connection: close\r\n\
+			Referer: http://localhost:8080/web/EHQPPSBE5DM78X3GECX2YBVGC5S6JX3S5SMPY/\r\n\
+			\r\n\
+		"
+	);
+
+	// then
+	response.assert_status("HTTP/1.1 302 Found");
+	response.assert_header("Location", "/web/EHQPPSBE5DM78X3GECX2YBVGC5S6JX3S5SMPY/styles.css");
+
+	fetch.assert_no_more_requests();
+}
+
+#[test]
+fn should_fix_absolute_requests_based_on_referer_in_url() {
+	// given
+	let (server, fetch) = serve_with_fetch("token", "https://parity.io");
+
+	// when
+	let response = request(server,
+		"\
+			GET /styles.css HTTP/1.1\r\n\
+			Host: localhost:8080\r\n\
+			Connection: close\r\n\
+			Referer: http://localhost:8080/?__referer=web/EHQPPSBE5DM78X3GECX2YBVGC5S6JX3S5SMPY/\r\n\
+			\r\n\
+		"
+	);
+
+	// then
+	response.assert_status("HTTP/1.1 302 Found");
+	response.assert_header("Location", "/web/EHQPPSBE5DM78X3GECX2YBVGC5S6JX3S5SMPY/styles.css");
+
+	fetch.assert_no_more_requests();
+}

dapps/src/tests/helpers/fetch.rs

@@ -0,0 +1,134 @@
+// Copyright 2015-2018 Parity Technologies (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+use std::{thread, time};
+use std::sync::{atomic, mpsc, Arc};
+use parking_lot::Mutex;
+use hyper;
+
+use futures::{self, future, Future};
+use fetch::{self, Fetch, Url, Request, Abort};
+
+pub struct FetchControl {
+	sender: mpsc::Sender<()>,
+	fetch: FakeFetch,
+}
+
+impl FetchControl {
+	pub fn respond(self) {
+		self.sender.send(())
+			.expect("Fetch cannot be finished without sending a response at least once.");
+	}
+
+	pub fn wait_for_requests(&self, len: usize) {
+		const MAX_TIMEOUT: time::Duration = time::Duration::from_millis(5000);
+		const ATTEMPTS: u32 = 10;
+		let mut attempts_left = ATTEMPTS;
+		loop {
+			let current = self.fetch.requested.lock().len();
+
+			if current == len {
+				break;
+			} else if attempts_left == 0 {
+				panic!(
+					"Timeout reached when waiting for pending requests. Expected: {}, current: {}",
+					len, current
+				);
+			} else {
+				attempts_left -= 1;
+				// Should we handle spurious timeouts better?
+				thread::park_timeout(MAX_TIMEOUT / ATTEMPTS);
+			}
+		}
+	}
+}
+
+#[derive(Clone, Default)]
+pub struct FakeFetch {
+	manual: Arc<Mutex<Option<mpsc::Receiver<()>>>>,
+	response: Arc<Mutex<Option<&'static [u8]>>>,
+	asserted: Arc<atomic::AtomicUsize>,
+	requested: Arc<Mutex<Vec<String>>>,
+}
+
+impl FakeFetch {
+	pub fn set_response(&self, data: &'static [u8]) {
+		*self.response.lock() = Some(data);
+	}
+
+	pub fn manual(&self) -> FetchControl {
+		assert!(self.manual.lock().is_none(), "Only one manual control may be active.");
+		let (tx, rx) = mpsc::channel();
+		*self.manual.lock() = Some(rx);
+
+		FetchControl {
+			sender: tx,
+			fetch: self.clone(),
+		}
+	}
+
+	pub fn assert_requested(&self, url: &str) {
+		let requests = self.requested.lock();
+		let idx = self.asserted.fetch_add(1, atomic::Ordering::SeqCst);
+
+		assert_eq!(requests.get(idx), Some(&url.to_owned()), "Expected fetch from specific URL.");
+	}
+
+	pub fn assert_no_more_requests(&self) {
+		let requests = self.requested.lock();
+		let len = self.asserted.load(atomic::Ordering::SeqCst);
+		assert_eq!(requests.len(), len, "Didn't expect any more requests, got: {:?}", &requests[len..]);
+	}
+}
+
+impl Fetch for FakeFetch {
+	type Result = Box<Future<Item = fetch::Response, Error = fetch::Error> + Send>;
+
+	fn fetch(&self, request: Request, abort: fetch::Abort) -> Self::Result {
+		let u = request.url().clone();
+		self.requested.lock().push(u.as_str().into());
+		let manual = self.manual.clone();
+		let response = self.response.clone();
+
+		let (tx, rx) = futures::oneshot();
+		thread::spawn(move || {
+			if let Some(rx) = manual.lock().take() {
+				// wait for manual resume
+				let _ = rx.recv();
+			}
+			let data = response.lock().take().unwrap_or(b"Some content");
+			tx.send(fetch::Response::new(u, hyper::Response::new().with_body(data), abort)).unwrap();
+		});
+
+		Box::new(rx.map_err(|_| fetch::Error::Aborted))
+	}
+
+	fn get(&self, url: &str, abort: Abort) -> Self::Result {
+		let url: Url = match url.parse() {
+			Ok(u) => u,
+			Err(e) => return Box::new(future::err(e.into()))
+		};
+		self.fetch(Request::get(url), abort)
+	}
+
+	fn post(&self, url: &str, abort: Abort) -> Self::Result {
+		let url: Url = match url.parse() {
+			Ok(u) => u,
+			Err(e) => return Box::new(future::err(e.into()))
+		};
+		self.fetch(Request::post(url), abort)
+	}
+}

dapps/src/tests/helpers/mod.rs

@@ -0,0 +1,289 @@
+// Copyright 2015-2018 Parity Technologies (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+use std::{env, io, str};
+use std::net::SocketAddr;
+use std::path::{Path, PathBuf};
+use std::sync::Arc;
+use env_logger::LogBuilder;
+use jsonrpc_core::IoHandler;
+use jsonrpc_http_server::{self as http, Host, DomainsValidation};
+use parity_reactor::Remote;
+
+use devtools::http_client;
+use registrar::{RegistrarClient, Asynchronous};
+use fetch::{Fetch, Client as FetchClient};
+use node_health::{NodeHealth, TimeChecker, CpuPool};
+
+use {Middleware, SyncStatus, WebProxyTokens};
+
+mod registrar;
+mod fetch;
+
+use self::registrar::FakeRegistrar;
+use self::fetch::FakeFetch;
+
+const SIGNER_PORT: u16 = 18180;
+
+#[derive(Debug)]
+struct FakeSync(bool);
+impl SyncStatus for FakeSync {
+	fn is_major_importing(&self) -> bool { self.0 }
+	fn peers(&self) -> (usize, usize) { (0, 5) }
+}
+
+fn init_logger() {
+	// Initialize logger
+	if let Ok(log) = env::var("RUST_LOG") {
+		let mut builder = LogBuilder::new();
+		builder.parse(&log);
+		let _ = builder.init();	// ignore errors since ./test.sh will call this multiple times.
+	}
+}
+
+pub fn init_server<F, B>(process: F, io: IoHandler) -> (Server, Arc<FakeRegistrar>) where
+	F: FnOnce(ServerBuilder) -> ServerBuilder<B>,
+	B: Fetch,
+{
+	init_logger();
+	let registrar = Arc::new(FakeRegistrar::new());
+	let mut dapps_path = env::temp_dir();
+	dapps_path.push("non-existent-dir-to-prevent-fs-files-from-loading");
+
+	let mut builder = ServerBuilder::new(FetchClient::new().unwrap(), &dapps_path, registrar.clone());
+	builder.signer_address = Some(("127.0.0.1".into(), SIGNER_PORT));
+	let server = process(builder).start_unsecured_http(&"127.0.0.1:0".parse().unwrap(), io).unwrap();
+	(
+		server,
+		registrar,
+	)
+}
+
+pub fn serve_with_rpc(io: IoHandler) -> Server {
+	init_server(|builder| builder, io).0
+}
+
+pub fn serve_hosts(hosts: Option<Vec<String>>) -> Server {
+	let hosts = hosts.map(|hosts| hosts.into_iter().map(Into::into).collect());
+	init_server(|mut builder| {
+		builder.allowed_hosts = hosts.into();
+		builder
+	}, Default::default()).0
+}
+
+pub fn serve_with_registrar() -> (Server, Arc<FakeRegistrar>) {
+	init_server(|builder| builder, Default::default())
+}
+
+pub fn serve_with_registrar_and_sync() -> (Server, Arc<FakeRegistrar>) {
+	init_server(|mut builder| {
+		builder.sync_status = Arc::new(FakeSync(true));
+		builder
+	}, Default::default())
+}
+
+pub fn serve_with_registrar_and_fetch() -> (Server, FakeFetch, Arc<FakeRegistrar>) {
+	let fetch = FakeFetch::default();
+	let f = fetch.clone();
+	let (server, reg) = init_server(move |builder| {
+		builder.fetch(f.clone())
+	}, Default::default());
+
+	(server, fetch, reg)
+}
+
+pub fn serve_with_fetch(web_token: &'static str, domain: &'static str) -> (Server, FakeFetch) {
+	let fetch = FakeFetch::default();
+	let f = fetch.clone();
+	let (server, _) = init_server(move |mut builder| {
+		builder.web_proxy_tokens = Arc::new(move |token| {
+			if &token == web_token { Some(domain.into()) } else { None }
+		});
+		builder.fetch(f.clone())
+	}, Default::default());
+
+	(server, fetch)
+}
+
+pub fn serve() -> Server {
+	init_server(|builder| builder, Default::default()).0
+}
+
+pub fn serve_ui() -> Server {
+	init_server(|mut builder| {
+		builder.serve_ui = true;
+		builder
+	}, Default::default()).0
+}
+
+pub fn request(server: Server, request: &str) -> http_client::Response {
+	http_client::request(server.addr(), request)
+}
+
+pub fn assert_security_headers(headers: &[String]) {
+	http_client::assert_security_headers_present(headers, None)
+}
+pub fn assert_security_headers_for_embed(headers: &[String]) {
+	http_client::assert_security_headers_present(headers, Some(SIGNER_PORT))
+}
+
+/// Webapps HTTP+RPC server build.
+pub struct ServerBuilder<T: Fetch = FetchClient> {
+	dapps_path: PathBuf,
+	registrar: Arc<RegistrarClient<Call=Asynchronous>>,
+	sync_status: Arc<SyncStatus>,
+	web_proxy_tokens: Arc<WebProxyTokens>,
+	signer_address: Option<(String, u16)>,
+	allowed_hosts: DomainsValidation<Host>,
+	fetch: T,
+	serve_ui: bool,
+}
+
+impl ServerBuilder {
+	/// Construct new dapps server
+	pub fn new<P: AsRef<Path>>(fetch: FetchClient, dapps_path: P, registrar: Arc<RegistrarClient<Call=Asynchronous>>) -> Self {
+		ServerBuilder {
+			dapps_path: dapps_path.as_ref().to_owned(),
+			registrar: registrar,
+			sync_status: Arc::new(FakeSync(false)),
+			web_proxy_tokens: Arc::new(|_| None),
+			signer_address: None,
+			allowed_hosts: DomainsValidation::Disabled,
+			fetch: fetch,
+			serve_ui: false,
+		}
+	}
+}
+
+impl<T: Fetch> ServerBuilder<T> {
+	/// Set a fetch client to use.
+	pub fn fetch<X: Fetch>(self, fetch: X) -> ServerBuilder<X> {
+		ServerBuilder {
+			dapps_path: self.dapps_path,
+			registrar: self.registrar,
+			sync_status: self.sync_status,
+			web_proxy_tokens: self.web_proxy_tokens,
+			signer_address: self.signer_address,
+			allowed_hosts: self.allowed_hosts,
+			fetch: fetch,
+			serve_ui: self.serve_ui,
+		}
+	}
+
+	/// Asynchronously start server with no authentication,
+	/// returns result with `Server` handle on success or an error.
+	pub fn start_unsecured_http(self, addr: &SocketAddr, io: IoHandler) -> io::Result<Server> {
+		Server::start_http(
+			addr,
+			io,
+			self.allowed_hosts,
+			self.signer_address,
+			self.dapps_path,
+			vec![],
+			self.registrar,
+			self.sync_status,
+			self.web_proxy_tokens,
+			Remote::new_sync(),
+			self.fetch,
+			self.serve_ui,
+		)
+	}
+}
+
+const DAPPS_DOMAIN: &'static str = "web3.site";
+
+/// Webapps HTTP server.
+pub struct Server {
+	server: Option<http::Server>,
+}
+
+impl Server {
+	fn start_http<F: Fetch>(
+		addr: &SocketAddr,
+		io: IoHandler,
+		allowed_hosts: DomainsValidation<Host>,
+		signer_address: Option<(String, u16)>,
+		dapps_path: PathBuf,
+		extra_dapps: Vec<PathBuf>,
+		registrar: Arc<RegistrarClient<Call=Asynchronous>>,
+		sync_status: Arc<SyncStatus>,
+		web_proxy_tokens: Arc<WebProxyTokens>,
+		remote: Remote,
+		fetch: F,
+		serve_ui: bool,
+	) -> io::Result<Server> {
+		let health = NodeHealth::new(
+			sync_status.clone(),
+			TimeChecker::new::<String>(&[], CpuPool::new(1)),
+			remote.clone(),
+		);
+		let pool = ::futures_cpupool::CpuPool::new(1);
+		let middleware = if serve_ui {
+			Middleware::ui(
+				pool,
+				health,
+				DAPPS_DOMAIN.into(),
+				registrar,
+				sync_status,
+				fetch,
+				false,
+			)
+		} else {
+			Middleware::dapps(
+				pool,
+				health,
+				signer_address,
+				vec![],
+				vec![],
+				dapps_path,
+				extra_dapps,
+				DAPPS_DOMAIN.into(),
+				registrar,
+				sync_status,
+				web_proxy_tokens,
+				fetch,
+			)
+		};
+
+		let mut allowed_hosts: Option<Vec<Host>> = allowed_hosts.into();
+		allowed_hosts.as_mut().map(|hosts| {
+			hosts.push(format!("http://*.{}:*", DAPPS_DOMAIN).into());
+			hosts.push(format!("http://*.{}", DAPPS_DOMAIN).into());
+		});
+
+		http::ServerBuilder::new(io)
+			.request_middleware(middleware)
+			.allowed_hosts(allowed_hosts.into())
+			.cors(http::DomainsValidation::Disabled)
+			.start_http(addr)
+			.map(|server| Server {
+				server: Some(server),
+			})
+	}
+
+	/// Returns address that this server is bound to.
+	pub fn addr(&self) -> &SocketAddr {
+		self.server.as_ref()
+			.expect("server is always Some at the start; it's consumed only when object is dropped; qed")
+			.address()
+	}
+}
+
+impl Drop for Server {
+	fn drop(&mut self) {
+		self.server.take().unwrap().close()
+	}
+}

dapps/src/tests/helpers/registrar.rs

@@ -0,0 +1,77 @@
+// Copyright 2015-2018 Parity Technologies (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+use std::str;
+use std::sync::Arc;
+use std::collections::HashMap;
+
+use ethereum_types::{H256, Address};
+use bytes::{Bytes, ToPretty};
+use registrar::{RegistrarClient, Asynchronous};
+use parking_lot::Mutex;
+use rustc_hex::FromHex;
+
+const REGISTRAR: &'static str = "8e4e9b13d4b45cb0befc93c3061b1408f67316b2";
+const URLHINT: &'static str = "deadbeefcafe0000000000000000000000000000";
+const URLHINT_RESOLVE: &'static str = "267b6922";
+const DEFAULT_HASH: &'static str = "1472a9e190620cdf6b31f383373e45efcfe869a820c91f9ccd7eb9fb45e4985d";
+
+pub struct FakeRegistrar {
+	pub calls: Arc<Mutex<Vec<(String, String)>>>,
+	pub responses: Mutex<HashMap<(String, String), Result<Bytes, String>>>,
+}
+
+impl FakeRegistrar {
+	pub fn new() -> Self {
+		FakeRegistrar {
+			calls: Arc::new(Mutex::new(Vec::new())),
+			responses: Mutex::new({
+				let mut map = HashMap::new();
+				map.insert(
+					(REGISTRAR.into(), "6795dbcd058740ee9a5a3fb9f1cfa10752baec87e09cc45cd7027fd54708271aca300c75000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000014100000000000000000000000000000000000000000000000000000000000000".into()),
+					Ok(format!("000000000000000000000000{}", URLHINT).from_hex().unwrap()),
+				);
+				map.insert(
+					(URLHINT.into(), format!("{}{}", URLHINT_RESOLVE, DEFAULT_HASH)),
+					Ok(vec![])
+				);
+				map
+			}),
+		}
+	}
+
+	pub fn set_result(&self, hash: H256, result: Result<Bytes, String>) {
+		self.responses.lock().insert(
+			(URLHINT.into(), format!("{}{:x}", URLHINT_RESOLVE, hash)),
+			result
+		);
+	}
+}
+
+impl RegistrarClient for FakeRegistrar {
+	type Call = Asynchronous;
+
+	fn registrar_address(&self) -> Result<Address, String> {
+		Ok(REGISTRAR.parse().unwrap())
+	}
+
+	fn call_contract(&self, address: Address, data: Bytes) -> Self::Call {
+		let call = (address.to_hex(), data.to_hex());
+		self.calls.lock().push(call.clone());
+		let res = self.responses.lock().get(&call).cloned().expect(&format!("No response for call: {:?}", call));
+		Box::new(::futures::future::done(res))
+	}
+}

dapps/src/tests/home.rs

@@ -0,0 +1,62 @@
+// Copyright 2015-2018 Parity Technologies (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+use tests::helpers::{serve_ui, request, assert_security_headers};
+
+#[test]
+fn should_serve_home_js() {
+	// given
+	let server = serve_ui();
+
+	// when
+	let response = request(server,
+		"\
+			GET /inject.js HTTP/1.1\r\n\
+			Host: 127.0.0.1:8080\r\n\
+			Connection: close\r\n\
+			\r\n\
+			{}
+		"
+	);
+
+	// then
+	response.assert_status("HTTP/1.1 200 OK");
+	response.assert_header("Content-Type", "application/javascript");
+	assert_eq!(response.body.contains("function(){"), true, "Expected function in: {}", response.body);
+	assert_security_headers(&response.headers);
+}
+
+#[test]
+fn should_serve_home() {
+	// given
+	let server = serve_ui();
+
+	// when
+	let response = request(server,
+		"\
+			GET / HTTP/1.1\r\n\
+			Host: 127.0.0.1:8080\r\n\
+			Connection: close\r\n\
+			\r\n\
+			{}
+		"
+	);
+
+	// then
+	response.assert_status("HTTP/1.1 200 OK");
+	response.assert_header("Content-Type", "text/html");
+	assert_security_headers(&response.headers);
+}

dapps/src/tests/mod.rs

@@ -0,0 +1,26 @@
+// Copyright 2015-2018 Parity Technologies (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Dapps server test suite
+
+mod helpers;
+
+mod api;
+mod fetch;
+mod home;
+mod redirection;
+mod rpc;
+mod validation;

dapps/src/tests/redirection.rs

@@ -0,0 +1,206 @@
+// Copyright 2015-2018 Parity Technologies (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+use tests::helpers::{serve, request, assert_security_headers, assert_security_headers_for_embed};
+
+#[test]
+fn should_redirect_to_home() {
+	// given
+	let server = serve();
+
+	// when
+	let response = request(server,
+		"\
+			GET / HTTP/1.1\r\n\
+			Host: 127.0.0.1:8080\r\n\
+			Connection: close\r\n\
+			\r\n\
+		"
+	);
+
+	// then
+	response.assert_status("HTTP/1.1 302 Found");
+	assert_eq!(response.headers.get(0).unwrap(), "Location: http://127.0.0.1:18180");
+}
+
+#[test]
+fn should_redirect_to_home_with_domain() {
+	// given
+	let server = serve();
+
+	// when
+	let response = request(server,
+		"\
+			GET / HTTP/1.1\r\n\
+			Host: home.web3.site\r\n\
+			Connection: close\r\n\
+			\r\n\
+		"
+	);
+
+	// then
+	response.assert_status("HTTP/1.1 302 Found");
+	assert_eq!(response.headers.get(0).unwrap(), "Location: http://127.0.0.1:18180");
+}
+
+#[test]
+fn should_redirect_to_home_when_trailing_slash_is_missing() {
+	// given
+	let server = serve();
+
+	// when
+	let response = request(server,
+		"\
+			GET /app HTTP/1.1\r\n\
+			Host: 127.0.0.1:8080\r\n\
+			Connection: close\r\n\
+			\r\n\
+		"
+	);
+
+	// then
+	response.assert_status("HTTP/1.1 302 Found");
+	assert_eq!(response.headers.get(0).unwrap(), "Location: http://127.0.0.1:18180");
+}
+
+#[test]
+fn should_display_404_on_invalid_dapp() {
+	// given
+	let server = serve();
+
+	// when
+	let response = request(server,
+		"\
+			GET /invaliddapp/ HTTP/1.1\r\n\
+			Host: 127.0.0.1:8080\r\n\
+			Connection: close\r\n\
+			\r\n\
+		"
+	);
+
+	// then
+	response.assert_status("HTTP/1.1 404 Not Found");
+	assert_security_headers_for_embed(&response.headers);
+}
+
+#[test]
+fn should_display_404_on_invalid_dapp_with_domain() {
+	// given
+	let server = serve();
+
+	// when
+	let response = request(server,
+		"\
+			GET / HTTP/1.1\r\n\
+			Host: invaliddapp.web3.site\r\n\
+			Connection: close\r\n\
+			\r\n\
+		"
+	);
+
+	// then
+	response.assert_status("HTTP/1.1 404 Not Found");
+	assert_security_headers_for_embed(&response.headers);
+}
+
+#[test]
+fn should_serve_rpc() {
+	// given
+	let server = serve();
+
+	// when
+	let response = request(server,
+		"\
+			POST / HTTP/1.1\r\n\
+			Host: 127.0.0.1:8080\r\n\
+			Connection: close\r\n\
+			Content-Type: application/json\r\n
+			\r\n\
+			{}
+		"
+	);
+
+	// then
+	response.assert_status("HTTP/1.1 200 OK");
+	assert_eq!(response.body, format!("4C\n{}\n\n0\n\n", r#"{"jsonrpc":"2.0","error":{"code":-32700,"message":"Parse error"},"id":null}"#));
+}
+
+#[test]
+fn should_serve_rpc_at_slash_rpc() {
+	// given
+	let server = serve();
+
+	// when
+	let response = request(server,
+		"\
+			POST /rpc HTTP/1.1\r\n\
+			Host: 127.0.0.1:8080\r\n\
+			Connection: close\r\n\
+			Content-Type: application/json\r\n
+			\r\n\
+			{}
+		"
+	);
+
+	// then
+	response.assert_status("HTTP/1.1 200 OK");
+	assert_eq!(response.body, format!("4C\n{}\n\n0\n\n", r#"{"jsonrpc":"2.0","error":{"code":-32700,"message":"Parse error"},"id":null}"#));
+}
+
+#[test]
+fn should_serve_proxy_pac() {
+	// given
+	let server = serve();
+
+	// when
+	let response = request(server,
+		"\
+			GET /proxy/proxy.pac HTTP/1.1\r\n\
+			Host: 127.0.0.1:8080\r\n\
+			Connection: close\r\n\
+			\r\n\
+			{}
+		"
+	);
+
+	// then
+	response.assert_status("HTTP/1.1 200 OK");
+	assert_eq!(response.body, "DB\n\nfunction FindProxyForURL(url, host) {\n\tif (shExpMatch(host, \"home.web3.site\"))\n\t{\n\t\treturn \"PROXY 127.0.0.1:18180\";\n\t}\n\n\tif (shExpMatch(host, \"*.web3.site\"))\n\t{\n\t\treturn \"PROXY 127.0.0.1:8080\";\n\t}\n\n\treturn \"DIRECT\";\n}\n\n0\n\n".to_owned());
+	assert_security_headers(&response.headers);
+}
+
+#[test]
+fn should_serve_utils() {
+	// given
+	let server = serve();
+
+	// when
+	let response = request(server,
+		"\
+			GET /parity-utils/inject.js HTTP/1.1\r\n\
+			Host: 127.0.0.1:8080\r\n\
+			Connection: close\r\n\
+			\r\n\
+			{}
+		"
+	);
+
+	// then
+	response.assert_status("HTTP/1.1 200 OK");
+	response.assert_header("Content-Type", "application/javascript");
+	assert_eq!(response.body.contains("function(){"), true, "Expected function in: {}", response.body);
+	assert_security_headers(&response.headers);
+}

dapps/src/tests/rpc.rs

@@ -0,0 +1,49 @@
+// Copyright 2015-2018 Parity Technologies (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+use jsonrpc_core::{IoHandler, Value};
+
+use tests::helpers::{serve_with_rpc, request};
+
+#[test]
+fn should_serve_rpc() {
+	// given
+	let mut io = IoHandler::default();
+	io.add_method("rpc_test", |_| {
+		Ok(Value::String("Hello World!".into()))
+	});
+	let server = serve_with_rpc(io);
+
+	// when
+	let req = r#"{"jsonrpc":"2.0","id":1,"method":"rpc_test","params":[]}"#;
+	let response = request(server, &format!(
+		"\
+			POST /rpc/ HTTP/1.1\r\n\
+			Host: 127.0.0.1:8080\r\n\
+			Connection: close\r\n\
+			Content-Type: application/json\r\n\
+			Content-Length: {}\r\n\
+			\r\n\
+			{}\r\n\
+		",
+		req.as_bytes().len(),
+		req,
+	));
+
+	// then
+	response.assert_status("HTTP/1.1 200 OK");
+	assert_eq!(response.body, "31\n{\"jsonrpc\":\"2.0\",\"result\":\"Hello World!\",\"id\":1}\n\n0\n\n".to_owned());
+}

dapps/src/tests/validation.rs

@@ -0,0 +1,99 @@
+// Copyright 2015-2018 Parity Technologies (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+use tests::helpers::{serve_hosts, request};
+
+#[test]
+fn should_reject_invalid_host() {
+	// given
+	let server = serve_hosts(Some(vec!["localhost:8080".into()]));
+
+	// when
+	let response = request(server,
+		"\
+			GET / HTTP/1.1\r\n\
+			Host: 127.0.0.1:8080\r\n\
+			Connection: close\r\n\
+			\r\n\
+			{}
+		"
+	);
+
+	// then
+	response.assert_status("HTTP/1.1 403 Forbidden");
+	assert!(response.body.contains("Provided Host header is not whitelisted."), response.body);
+}
+
+#[test]
+fn should_allow_valid_host() {
+	// given
+	let server = serve_hosts(Some(vec!["localhost:8080".into()]));
+
+	// when
+	let response = request(server,
+		"\
+			GET /ui/ HTTP/1.1\r\n\
+			Host: localhost:8080\r\n\
+			Connection: close\r\n\
+			\r\n\
+			{}
+		"
+	);
+
+	// then
+	response.assert_status("HTTP/1.1 200 OK");
+}
+
+#[test]
+fn should_serve_dapps_domains() {
+	// given
+	let server = serve_hosts(Some(vec!["localhost:8080".into()]));
+
+	// when
+	let response = request(server,
+		"\
+			GET / HTTP/1.1\r\n\
+			Host: ui.web3.site\r\n\
+			Connection: close\r\n\
+			\r\n\
+			{}
+		"
+	);
+
+	// then
+	response.assert_status("HTTP/1.1 200 OK");
+}
+
+#[test]
+// NOTE [todr] This is required for error pages to be styled properly.
+fn should_allow_parity_utils_even_on_invalid_domain() {
+	// given
+	let server = serve_hosts(Some(vec!["localhost:8080".into()]));
+
+	// when
+	let response = request(server,
+		"\
+			GET /parity-utils/styles.css HTTP/1.1\r\n\
+			Host: 127.0.0.1:8080\r\n\
+			Connection: close\r\n\
+			\r\n\
+			{}
+		"
+	);
+
+	// then
+	response.assert_status("HTTP/1.1 200 OK");
+}

dapps/src/web.rs

@@ -0,0 +1,170 @@
+// Copyright 2015-2018 Parity Technologies (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Serving web-based content (proxying)
+
+use std::sync::Arc;
+
+use base32;
+use fetch::{self, Fetch};
+use hyper::{mime, StatusCode};
+
+use apps;
+use endpoint::{Endpoint, EndpointPath, Request, Response};
+use futures::future;
+use futures_cpupool::CpuPool;
+use handlers::{
+	ContentFetcherHandler, ContentHandler, ContentValidator, ValidatorResponse,
+	StreamingHandler,
+};
+use {Embeddable, WebProxyTokens};
+
+pub struct Web<F> {
+	embeddable_on: Embeddable,
+	web_proxy_tokens: Arc<WebProxyTokens>,
+	fetch: F,
+	pool: CpuPool,
+}
+
+impl<F: Fetch> Web<F> {
+	pub fn boxed(
+		embeddable_on: Embeddable,
+		web_proxy_tokens: Arc<WebProxyTokens>,
+		fetch: F,
+		pool: CpuPool,
+	) -> Box<Endpoint> {
+		Box::new(Web {
+			embeddable_on,
+			web_proxy_tokens,
+			fetch,
+			pool,
+		})
+	}
+
+	fn extract_target_url(&self, path: &EndpointPath) -> Result<String, ContentHandler> {
+		let token_and_url = path.app_params.get(0)
+			.map(|encoded| encoded.replace('.', ""))
+			.and_then(|encoded| base32::decode(base32::Alphabet::Crockford, &encoded.to_uppercase()))
+			.and_then(|data| String::from_utf8(data).ok())
+			.ok_or_else(|| ContentHandler::error(
+				StatusCode::BadRequest,
+				"Invalid parameter",
+				"Couldn't parse given parameter:",
+				path.app_params.get(0).map(String::as_str),
+				self.embeddable_on.clone()
+			))?;
+
+		let mut token_it = token_and_url.split('+');
+		let token = token_it.next();
+		let target_url = token_it.next();
+
+		// Check if token supplied in URL is correct.
+		let domain = match token.and_then(|token| self.web_proxy_tokens.domain(token)) {
+			Some(domain) => domain,
+			_ => {
+				return Err(ContentHandler::error(
+					StatusCode::BadRequest, "Invalid Access Token", "Invalid or old web proxy access token supplied.", Some("Try refreshing the page."), self.embeddable_on.clone()
+				));
+			}
+		};
+
+		// Validate protocol
+		let mut target_url = match target_url {
+			Some(url) if url.starts_with("http://") || url.starts_with("https://") => url.to_owned(),
+			_ => {
+				return Err(ContentHandler::error(
+					StatusCode::BadRequest, "Invalid Protocol", "Invalid protocol used.", None, self.embeddable_on.clone()
+				));
+			}
+		};
+
+		if !target_url.starts_with(&*domain) {
+			return Err(ContentHandler::error(
+				StatusCode::BadRequest, "Invalid Domain", "Dapp attempted to access invalid domain.", Some(&target_url), self.embeddable_on.clone(),
+			));
+		}
+
+		if !target_url.ends_with("/") {
+			target_url = format!("{}/", target_url);
+		}
+
+		// Skip the token
+		let query = path.query.as_ref().map_or_else(String::new, |query| format!("?{}", query));
+		let path = path.app_params[1..].join("/");
+
+		Ok(format!("{}{}{}", target_url, path, query))
+	}
+}
+
+impl<F: Fetch> Endpoint for Web<F> {
+	fn respond(&self, path: EndpointPath, req: Request) -> Response {
+		// First extract the URL (reject invalid URLs)
+		let target_url = match self.extract_target_url(&path) {
+			Ok(url) => url,
+			Err(response) => {
+				return Box::new(future::ok(response.into()));
+			}
+		};
+
+		let token = path.app_params.get(0)
+			.expect("`target_url` is valid; app_params is not empty;qed")
+			.to_owned();
+
+		Box::new(ContentFetcherHandler::new(
+			req.method(),
+			&target_url,
+			path,
+			WebInstaller {
+				embeddable_on: self.embeddable_on.clone(),
+				token,
+			},
+			self.embeddable_on.clone(),
+			self.fetch.clone(),
+			self.pool.clone(),
+		))
+	}
+}
+
+struct WebInstaller {
+	embeddable_on: Embeddable,
+	token: String,
+}
+
+impl ContentValidator for WebInstaller {
+	type Error = String;
+
+	fn validate_and_install(self, response: fetch::Response) -> Result<ValidatorResponse, String> {
+		let status = response.status();
+		let is_html = response.is_html();
+		let mime = response.content_type().unwrap_or(mime::TEXT_HTML);
+		let mut handler = StreamingHandler::new(
+			fetch::BodyReader::new(response),
+			status,
+			mime,
+			self.embeddable_on,
+		);
+		if is_html {
+			handler.set_initial_content(&format!(
+				r#"<script src="/{}/inject.js"></script><script>history.replaceState({{}}, "", "/?{}{}/{}")</script>"#,
+				apps::UTILS_PATH,
+				apps::URL_REFERER,
+				apps::WEB_PATH,
+				&self.token,
+			));
+		}
+		Ok(ValidatorResponse::Streaming(handler))
+	}
+}

dapps/ui-deprecation/Cargo.toml

@@ -0,0 +1,18 @@
+[package]
+description = "Parity UI deprecation notice."
+name = "parity-ui-deprecation"
+version = "1.10.0"
+license = "GPL-3.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+build = "build.rs"
+
+[features]
+default = ["with-syntex", "use-precompiled-js"]
+use-precompiled-js = ["parity-dapps-glue/use-precompiled-js"]
+with-syntex = ["parity-dapps-glue/with-syntex"]
+
+[build-dependencies]
+parity-dapps-glue = "1.9"
+
+[dependencies]
+parity-dapps-glue = "1.9"

dapps/ui-deprecation/build.rs

@@ -0,0 +1,21 @@
+// Copyright 2015-2018 Parity Technologies (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+extern crate parity_dapps_glue;
+
+fn main() {
+	parity_dapps_glue::generate();
+}

dapps/ui-deprecation/build/index.html

@@ -0,0 +1,119 @@
+<!DOCTYPE html>
+<html>
+	<head>
+		<meta charset="utf-8">
+		<meta name="viewport" content="width=device-width">
+		<title>Parity</title>
+		<style>
+		/* Copyright 2015-2018 Parity Technologies (UK) Ltd.
+		/* This file is part of Parity.
+		/*
+		/* Parity is free software: you can redistribute it and/or modify
+		/* it under the terms of the GNU General Public License as published by
+		/* the Free Software Foundation, either version 3 of the License, or
+		/* (at your option) any later version.
+		/*
+		/* Parity is distributed in the hope that it will be useful,
+		/* but WITHOUT ANY WARRANTY; without even the implied warranty of
+		/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+		/* GNU General Public License for more details.
+		/*
+		/* You should have received a copy of the GNU General Public License
+		/* along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+		*/
+		:root, :root body {
+		  margin: 0;
+		  padding: 0;
+		  border: 0;
+		  font-size: 100%;
+		  font: inherit;
+		  vertical-align: baseline;
+		  background: rgb(95, 95, 95);
+		  color: rgba(255, 255, 255, 0.75);
+		  font-size: 16px;
+		  font-family: 'Roboto', sans-serif;
+		  font-weight: 300;
+		}
+
+		:root a, :root a:visited {
+		  text-decoration: none;
+		  cursor: pointer;
+		  color: rgb(0, 151, 167); /* #f80 */
+		}
+
+		:root a:hover {
+		  color: rgb(0, 174, 193);
+		}
+
+		h1,h2,h3,h4,h5,h6 {
+		  font-weight: 300;
+		  text-transform: uppercase;
+		  text-decoration: none;
+		}
+
+		h1 {
+		  font-size: 24px;
+		  line-height: 36px;
+		  color: rgb(0, 151, 167);
+		}
+
+		h2 {
+		  font-size: 20px;
+		  line-height: 34px;
+		}
+
+		code,kbd,pre,samp {
+		  font-family: 'Roboto Mono', monospace;
+		}
+
+		.parity-navbar {
+		  background: rgb(65, 65, 65);
+		  height: 72px;
+		  padding: 0 1rem;
+		  display: flex;
+		  justify-content: space-between;
+		}
+
+		.parity-status {
+		  clear: both;
+		  padding: 1rem;
+		  margin: 1rem 0;
+		  text-align: right;
+		  opacity: 0.75;
+		}
+
+		.parity-box {
+		  margin: 1rem;
+		  padding: 1rem;
+		  background-color: rgb(48, 48, 48);
+		  box-sizing: border-box;
+		  box-shadow: rgba(0, 0, 0, 0.117647) 0px 1px 6px, rgba(0, 0, 0, 0.117647) 0px 1px 4px;
+		  border-radius: 2px;
+		  z-index: 1;
+		  color: #aaa;
+		}
+
+		.parity-box h1,
+		.parity-box h2,
+		.parity-box h3,
+		.parity-box h4,
+		.parity-box h5,
+		.parity-box h6 {
+		  margin: 0;
+		}
+		</style>
+	</head>
+	<body>
+		<div class="parity-navbar">
+		</div>
+		<div class="parity-box">
+			<h1>The Parity UI has been split off into a standalone project.</h1>
+			<h3>Get the standalone Parity UI from <a href="https://github.com/Parity-JS/shell/releases">here</a></h3>
+			<p>
+
+			</p>
+		</div>
+		<div class="parity-status">
+		</div>
+	</body>
+</html>

dapps/ui-deprecation/src/lib.rs

@@ -0,0 +1,21 @@
+// Copyright 2015-2018 Parity Technologies (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+#[cfg(feature = "with-syntex")]
+include!(concat!(env!("OUT_DIR"), "/lib.rs"));
+
+#[cfg(not(feature = "with-syntex"))]
+include!("lib.rs.in");

dapps/ui-deprecation/src/lib.rs.in

@@ -0,0 +1,55 @@
+// Copyright 2015-2018 Parity Technologies (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+extern crate parity_dapps_glue;
+
+use std::collections::HashMap;
+use parity_dapps_glue::{WebApp, File, Info};
+
+#[derive(WebAppFiles)]
+#[webapp(path = "../build")]
+pub struct App {
+	pub files: HashMap<&'static str, File>,
+}
+
+impl Default for App {
+	fn default() -> App {
+		App {
+			files: Self::files(),
+		}
+	}
+}
+
+impl WebApp for App {
+	fn file(&self, path: &str) -> Option<&File> {
+		self.files.get(path)
+	}
+
+	fn info(&self) -> Info {
+		Info {
+			name: "Parity Wallet info page",
+			version: env!("CARGO_PKG_VERSION"),
+			author: "Parity <admin@parity.io>",
+			description: "Deprecation notice for Parity Wallet",
+			icon_url: "icon.png",
+		}
+	}
+}
+
+#[test]
+fn test_js() {
+	parity_dapps_glue::js::build(env!("CARGO_MANIFEST_DIR"), "build");
+}

dapps/ui/Cargo.toml

@@ -0,0 +1,20 @@
+[package]
+description = "Ethcore Parity UI"
+homepage = "http://parity.io"
+license = "GPL-3.0"
+name = "parity-ui"
+version = "1.12.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+
+[build-dependencies]
+rustc_version = "0.2"
+
+[dependencies]
+parity-ui-dev = { git = "https://github.com/parity-js/shell.git", rev = "eecaadcb9e421bce31e91680d14a20bbd38f92a2", optional = true }
+parity-ui-old-dev = { git = "https://github.com/parity-js/dapp-wallet.git", rev = "65deb02e7c007a0fd8aab0c089c93e3fd1de6f87", optional = true }
+parity-ui-precompiled = { git = "https://github.com/js-dist-paritytech/parity-master-1-10-shell.git", rev="bd25b41cd642c6b822d820dded3aa601a29aa079", optional = true }
+parity-ui-old-precompiled = { git = "https://github.com/js-dist-paritytech/parity-master-1-10-wallet.git", rev="4b6f112412716cd05123d32eeb7fda448288a6c6", optional = true }
+
+[features]
+no-precompiled-js = ["parity-ui-dev", "parity-ui-old-dev"]
+use-precompiled-js = ["parity-ui-precompiled", "parity-ui-old-precompiled"]

dapps/ui/src/lib.rs

@@ -0,0 +1,45 @@
+// Copyright 2015-2018 Parity Technologies (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+#[cfg(feature = "parity-ui-dev")]
+mod inner {
+	extern crate parity_ui_dev;
+
+	pub use self::parity_ui_dev::*;
+}
+
+#[cfg(feature = "parity-ui-precompiled")]
+mod inner {
+	extern crate parity_ui_precompiled;
+
+	pub use self::parity_ui_precompiled::*;
+}
+
+#[cfg(feature = "parity-ui-old-dev")]
+pub mod old {
+	extern crate parity_ui_old_dev;
+
+	pub use self::parity_ui_old_dev::*;
+}
+
+#[cfg(feature = "parity-ui-old-precompiled")]
+pub mod old {
+	extern crate parity_ui_old_precompiled;
+
+	pub use self::parity_ui_old_precompiled::*;
+}
+
+pub use self::inner::*;

docker/alpine/Dockerfile

@@ -1,11 +1,11 @@
-FROM alpine:edge
+FROM alpine:3.7
 
 WORKDIR /build
 
 # install tools and dependencies
-RUN apk add --no-cache gcc musl-dev pkgconfig g++ make curl \
-						eudev-dev rust cargo git file binutils \
-						libusb-dev linux-headers perl cmake
+RUN apk add --no-cache gcc musl-dev openssl-dev pkgconfig g++ make curl \
+					   eudev-dev rust cargo git file binutils libusb-dev \
+					   linux-headers
 
 # show backtraces
 ENV RUST_BACKTRACE 1

docker/android/Dockerfile

@@ -23,6 +23,24 @@ RUN /usr/local/android-ndk-r16b/build/tools/make-standalone-toolchain.sh \
     --arch=arm --install-dir=/opt/ndk-standalone --stl=libc++ --platform=android-26
 ENV PATH $PATH:/opt/ndk-standalone/bin
 
+# Compiling OpenSSL for Android
+RUN cd /root && \
+    git clone git://git.openssl.org/openssl.git && \
+    cd openssl && \
+    git checkout OpenSSL_1_1_0-stable
+ENV CROSS_SYSROOT /opt/ndk-standalone/sysroot
+RUN cd /root/openssl && \
+    ./Configure android-armeabi --cross-compile-prefix=arm-linux-androideabi- \
+    -static no-stdio no-ui \
+    -I/usr/local/android-ndk-r16b/sysroot/usr/include \
+    -I/usr/local/android-ndk-r16b/sysroot/usr/include/arm-linux-androideabi \
+    -L/usr/local/android-ndk-r16b/sysroot/usr/lib \
+    --prefix=/opt/ndk-standalone/sysroot/usr
+RUN cd /root/openssl && \
+    make build_libs && \
+    make install_dev
+RUN rm -rf /root/openssl
+
 # Compiling libudev for Android
 # This is the most hacky part of the process, as we need to apply a patch and pass specific
 # options that the compiler environment doesn't define.

docker/centos/Dockerfile

@@ -3,7 +3,7 @@ WORKDIR /build
 
 # install tools and dependencies
 RUN yum -y update&& \
-    yum install -y git make gcc-c++ gcc file binutils cmake
+    yum install -y git make gcc-c++ gcc file binutils
 
 # install rustup
 RUN curl -sSf https://static.rust-lang.org/rustup.sh -o rustup.sh &&\

docker/hub/Dockerfile

@@ -1,4 +1,4 @@
-FROM ubuntu:xenial
+FROM ubuntu:14.04
 MAINTAINER Parity Technologies <devops@parity.io>
 WORKDIR /build
 #ENV for build TAG
@@ -13,7 +13,6 @@ RUN apt-get update && \
         # add-apt-repository
         software-properties-common \
         make \
-        cmake \
         curl \
         wget \
         git \
@@ -23,6 +22,8 @@ RUN apt-get update && \
         libc6-dev \
         binutils \
         file \
+        openssl \
+        libssl-dev \
         libudev-dev \
         pkg-config \
         dpkg-dev \
@@ -34,13 +35,14 @@ RUN apt-get update && \
 # show backtraces
  RUST_BACKTRACE=1 && \
 # build parity
-cd /build&&git clone https://github.com/paritytech/parity-ethereum && \
-        cd parity-ethereum && \
+cd /build&&git clone https://github.com/paritytech/parity && \
+        cd parity && \
 	git pull&& \
 	git checkout $BUILD_TAG && \
         cargo build --verbose --release --features final && \
-        strip /build/parity-ethereum/target/release/parity && \
- file /build/parity-ethereum/target/release/parity&&mkdir -p /parity&& cp /build/parity-ethereum/target/release/parity /parity&&\
+        #ls /build/parity/target/release/parity && \
+        strip /build/parity/target/release/parity && \
+ file /build/parity/target/release/parity&&mkdir -p /parity&& cp /build/parity/target/release/parity /parity&&\
 #cleanup Docker image
  rm -rf /root/.cargo&&rm -rf /root/.multirust&&rm -rf /root/.rustup&&rm -rf /build&&\
  apt-get purge -y  \
@@ -49,7 +51,6 @@ cd /build&&git clone https://github.com/paritytech/parity-ethereum && \
         # add-apt-repository
         software-properties-common \
         make \
-        cmake \
         curl \
         wget \
         git \

docker/ubuntu-aarch64/Dockerfile

@@ -6,7 +6,7 @@ RUN apt-get -y update && \
         apt-get install -y --force-yes --no-install-recommends \
         curl git make g++ gcc-aarch64-linux-gnu g++-aarch64-linux-gnu \
         libc6-arm64-cross libc6-dev-arm64-cross wget file ca-certificates \
-        binutils-aarch64-linux-gnu cmake \
+        binutils-aarch64-linux-gnu \
         && \
     apt-get clean
 

docker/ubuntu-arm/Dockerfile

@@ -6,7 +6,7 @@ RUN apt-get -y update && \
         apt-get install -y --force-yes --no-install-recommends \
         curl git make g++ gcc-arm-linux-gnueabihf g++-arm-linux-gnueabihf \
         libc6-dev-armhf-cross wget file ca-certificates \
-        binutils-arm-linux-gnueabihf cmake \
+        binutils-arm-linux-gnueabihf \
         && \
     apt-get clean
 

docker/ubuntu/Dockerfile

@@ -6,11 +6,11 @@ RUN apt-get update && \
         apt-get install -y \
         g++ \
         build-essential \
-        cmake \
         curl \
         git \
         file \
         binutils \
+        libssl-dev \
         pkg-config \
         libudev-dev
 

docs/CHANGELOG-1.10.md

@@ -1,122 +1,3 @@
-## Parity [v1.10.9](https://github.com/paritytech/parity/releases/tag/v1.10.9) (2018-07-07)
-
-Parity 1.10.9 is a bug-fix release to improve performance and stability.
-
-The full list of included changes:
-
-- Stable: 1.10.9 backports ([#9016](https://github.com/paritytech/parity/pull/9016))
-  - Parity-version: bump stable to 1.10.9
-  - Scripts: remove md5 checksums ([#8884](https://github.com/paritytech/parity/pull/8884))
-  - Add support for --chain tobalaba ([#8870](https://github.com/paritytech/parity/pull/8870))
-    - Add support for --chain tobalaba
-  - Only return error log for rustls ([#9025](https://github.com/paritytech/parity/pull/9025))
-  - Fixes for misbehavior reporting in AuthorityRound ([#8998](https://github.com/paritytech/parity/pull/8998))
-    - Aura: only report after checking for repeated skipped primaries
-    - Aura: refactor duplicate code for getting epoch validator set
-    - Aura: verify_external: report on validator set contract instance
-    - Aura: use correct validator set epoch number when reporting
-    - Aura: use epoch set when verifying blocks
-    - Aura: report skipped primaries when generating seal
-    - Aura: handle immediate transitions
-    - Aura: don't report skipped steps from genesis to first block
-    - Aura: fix reporting test
-    - Aura: refactor duplicate code to handle immediate_transitions
-    - Aura: let reporting fail on verify_block_basic
-    - Aura: add comment about possible failure of reporting
-
-## Parity [v1.10.8](https://github.com/paritytech/parity/releases/tag/v1.10.8) (2018-06-29)
-
-Parity 1.10.8 is a bug-fix release to improve performance and stability.
-
-The full list of included changes:
-
-- Backports ([#8986](https://github.com/paritytech/parity/pull/8986))
-  - Snap: downgrade rust to revision 1.26.2, ref snapcraft/+bug/1778530 ([#8984](https://github.com/paritytech/parity/pull/8984))
-    - Snap: downgrade rust to revision 1.26.2, ref snapcraft/+bug/1778530
-    - Snap: use plugin rust
-  - Fix deadlock in blockchain. ([#8977](https://github.com/paritytech/parity/pull/8977))
-  - Remove js-glue from workspace
-- Bump stable to 1.10.8 ([#8951](https://github.com/paritytech/parity/pull/8951))
-  - Parity-version: bump stable to 1.10.8
-  - Update ropsten.json ([#8926](https://github.com/paritytech/parity/pull/8926))
-  - Scripts: minor improvements ([#8930](https://github.com/paritytech/parity/pull/8930))
-    - CI: enable 'latest' docker tag on master pipeline
-    - CI: mark both beta and stable as stable snap.
-    - CI: sign all windows binaries
-    - Scripts: remove whisper target not available in stable
-  - Scripts: fix gitlab strip binaries
-  - Scripts: fix docker build tag on latest using master ([#8952](https://github.com/paritytech/parity/pull/8952))
-  - Rpc: cap gas limit of local calls ([#8943](https://github.com/paritytech/parity/pull/8943))
-
-## Parity [v1.10.7](https://github.com/paritytech/parity/releases/tag/v1.10.7) (2018-06-20)
-
-Parity 1.10.7 is a bug-fix release to improve performance and stability.
-
-The full list of included changes:
-
-- Backports ([#8919](https://github.com/paritytech/parity/pull/8919))
-  - Fixed AuthorityRound deadlock on shutdown, closes [#8088](https://github.com/paritytech/parity/issues/8088) ([#8803](https://github.com/paritytech/parity/pull/8803))
-  - CI: Fix docker tags ([#8822](https://github.com/paritytech/parity/pull/8822))
-    - Scripts: enable docker builds for beta and stable
-    - Scripts: docker latest should be beta not master
-    - Scripts: docker latest is master
-  - Fix concurrent access to signer queue ([#8854](https://github.com/paritytech/parity/pull/8854))
-    - Fix concurrent access to signer queue
-    - Put request back to the queue if confirmation failed
-    - Typo: fix docs and rename functions to be more specific
-    - Change trace info "Transaction" -> "Request"
-  - Add new ovh bootnodes and fix port for foundation bootnode 3.2 ([#8886](https://github.com/paritytech/parity/pull/8886))
-    - Add new ovh bootnodes and fix port for foundation bootnode 3.2
-    - Remove old bootnodes.
-    - Remove duplicate 1118980bf48b0a3640bdba04e0fe78b1add18e1cd99bf22d53daac1fd9972ad650df52176e7c7d89d1114cfef2bc23a2959aa54998a46afcf7d91809f0855082
-  - Block 0 is valid in queries ([#8891](https://github.com/paritytech/parity/pull/8891))
-  - Update jsonrpc libs, fixed ipc leak, closes [#8774](https://github.com/paritytech/parity/issues/8774) ([#8876](https://github.com/paritytech/parity/pull/8876))
-  - Add ETC Cooperative-run load balanced parity node ([#8892](https://github.com/paritytech/parity/pull/8892))
-  - Minor fix in chain supplier and light provider ([#8906](https://github.com/paritytech/parity/pull/8906))
-    - Fix chain supplier increment
-    - Fix light provider block_headers
-- Parity-version: stable release 1.10.7 ([#8855](https://github.com/paritytech/parity/pull/8855))
-  - Cherry-pick network-specific release flag ([#8821](https://github.com/paritytech/parity/pull/8821))
-  - Parity-version: bump stable to 1.10.7
-
-## Parity [v1.10.6](https://github.com/paritytech/parity/releases/tag/v1.10.6) (2018-06-05)
-
-Parity 1.10.6 is a security-relevant release. Please upgrade your nodes as soon as possible.
-
-If you can not upgrade to 1.10+ yet, please use the following branches and build your own binaries from source:
-
-- git checkout [old-stable-1.9](https://github.com/paritytech/parity/tree/old-stable-1.9) # `v1.9.8` (EOL)
-- git checkout [old-stable-1.8](https://github.com/paritytech/parity/tree/old-stable-1.8) # `v1.8.12` (EOL)
-- git checkout [old-stable-1.7](https://github.com/paritytech/parity/tree/old-stable-1.7) # `v1.7.14` (EOL)
-
-The full list of included changes:
-
-- Parity-version: bump stable to 1.10.6 ([#8805](https://github.com/paritytech/parity/pull/8805))
-  - Parity-version: bump stable to 1.10.6
-  - Disallow unsigned transactions in case EIP-86 is disabled ([#8802](https://github.com/paritytech/parity/pull/8802))
-- Update shell32-sys to fix windows build ([#8793](https://github.com/paritytech/parity/pull/8793))
-- Backports ([#8782](https://github.com/paritytech/parity/pull/8782))
-  - Fix light sync with initial validator-set contract ([#8528](https://github.com/paritytech/parity/pull/8528))
-    - Fix #8468
-    - Use U256::max_value() instead
-    - Fix again
-    - Also change initial transaction gas
-  - Don't open Browser post-install on Mac ([#8641](https://github.com/paritytech/parity/pull/8641))
-  - Prefix uint fmt with `0x` with alternate flag
-  - Set the request index to that of the current request ([#8683](https://github.com/paritytech/parity/pull/8683))
-    - Set the request index to that of the current request
-  - Node table sorting according to last contact data ([#8541](https://github.com/paritytech/parity/pull/8541))
-    - Network-devp2p: sort nodes in node table using last contact data
-    - Network-devp2p: rename node contact types in node table json output
-    - Network-devp2p: fix node table tests
-    - Network-devp2p: note node failure when failed to establish connection
-    - Network-devp2p: handle UselessPeer error
-    - Network-devp2p: note failure when marking node as useless
-  - Network-devp2p: handle UselessPeer disconnect ([#8686](https://github.com/paritytech/parity/pull/8686))
-- Parity: bump stable version to 1.10.5 ([#8749](https://github.com/paritytech/parity/pull/8749))
-  - Parity: bump stable version to 1.10.5
-  - Fix failing doc tests running on non-code
-
 ## Parity [v1.10.4](https://github.com/paritytech/parity/releases/tag/v1.10.4) (2018-05-15)
 
 Parity 1.10.4 is a bug-fix release to improve performance and stability.
@@ -306,61 +187,61 @@ The full list of included changes:
 - Beta Backports ([#8136](https://github.com/paritytech/parity/pull/8136))
   - Support parity protocol. ([#8035](https://github.com/paritytech/parity/pull/8035))
   - updater: apply exponential backoff after download failure ([#8059](https://github.com/paritytech/parity/pull/8059))
-    - updater: apply exponential backoff after download failure
-    - updater: reset backoff on new release
+	  - updater: apply exponential backoff after download failure
+	  - updater: reset backoff on new release
   - Max code size on Kovan ([#8067](https://github.com/paritytech/parity/pull/8067))
-    - Enable code size limit on kovan
-    - Fix formatting.
+	  - Enable code size limit on kovan
+	  - Fix formatting.
   - Limit incoming connections.  ([#8060](https://github.com/paritytech/parity/pull/8060))
-    - Limit ingress connections
-    - Optimized handshakes logging
+	  - Limit ingress connections
+	  - Optimized handshakes logging
   - WASM libraries bump ([#7970](https://github.com/paritytech/parity/pull/7970))
-    - update wasmi, parity-wasm, wasm-utils to latest version
-    - Update to new wasmi & error handling
-    - also utilize new stack limiter
-    - fix typo
-    - replace dependency url
-    - Cargo.lock update
+	  - update wasmi, parity-wasm, wasm-utils to latest version
+	  - Update to new wasmi & error handling
+	  - also utilize new stack limiter
+	  - fix typo
+	  - replace dependency url
+	  - Cargo.lock update
   - add some dos protection ([#8084](https://github.com/paritytech/parity/pull/8084))
   - revert removing blooms ([#8066](https://github.com/paritytech/parity/pull/8066))
   - Revert "fix traces, removed bloomchain crate, closes [#7228](https://github.com/paritytech/parity/issues/7228), closes [#7167](https://github.com/paritytech/parity/issues/7167)"
   - Revert "fixed broken logs ([#7934](https://github.com/paritytech/parity/pull/7934))"
-    - fixed broken logs
-    - bring back old lock order
-    - remove migration v13
-    - revert CURRENT_VERSION to 12 in migration.rs
+	  - fixed broken logs
+	  - bring back old lock order
+	  - remove migration v13
+	  - revert CURRENT_VERSION to 12 in migration.rs
   - more dos protection ([#8104](https://github.com/paritytech/parity/pull/8104))
   - Const time comparison ([#8113](https://github.com/paritytech/parity/pull/8113))
-    - Use `subtle::slices_equal` for constant time comparison.
-    - Also update the existing version of subtle in `ethcrypto` from 0.1 to 0.5
-    - Test specifically for InvalidPassword error.
+	  - Use `subtle::slices_equal` for constant time comparison.
+	  - Also update the existing version of subtle in `ethcrypto` from 0.1 to 0.5
+	  - Test specifically for InvalidPassword error.
   - fix trace filter returning returning unrelated reward calls, closes #8070 ([#8098](https://github.com/paritytech/parity/pull/8098))
   - network: init discovery using healthy nodes ([#8061](https://github.com/paritytech/parity/pull/8061))
-    - network: init discovery using healthy nodes
-    - network: fix style grumble
-    - network: fix typo
+	  - network: init discovery using healthy nodes
+	  - network: fix style grumble
+	  - network: fix typo
   - Postpone Kovan hard fork ([#8137](https://github.com/paritytech/parity/pull/8137))
-    - ethcore: postpone Kovan hard fork
-    - util: update version fork metadata
+	  - ethcore: postpone Kovan hard fork
+	  - util: update version fork metadata
   - Disable UI by default. ([#8105](https://github.com/paritytech/parity/pull/8105))
   - dapps: update parity-ui dependencies ([#8160](https://github.com/paritytech/parity/pull/8160))
 - Probe changes one step deeper ([#8134](https://github.com/paritytech/parity/pull/8134)) ([#8135](https://github.com/paritytech/parity/pull/8135))
 - Beta backports ([#8053](https://github.com/paritytech/parity/pull/8053))
   - CI: Fix cargo cache ([#7968](https://github.com/paritytech/parity/pull/7968))
-    - Fix cache
-    - Only clean locked cargo cache on windows
+	  - Fix cache
+	  - Only clean locked cargo cache on windows
   - fixed ethstore sign ([#8026](https://github.com/paritytech/parity/pull/8026))
   - fixed parsing ethash seals and verify_block_undordered ([#8031](https://github.com/paritytech/parity/pull/8031))
   - fix for verify_block_basic crashing on invalid transaction rlp ([#8032](https://github.com/paritytech/parity/pull/8032))
   - fix cache & snapcraft CI build ([#8052](https://github.com/paritytech/parity/pull/8052))
   - Add MCIP-6 Byzyantium transition to Musicoin spec ([#7841](https://github.com/paritytech/parity/pull/7841))
-    - Add test chain spec for musicoin byzantium testnet
-    - Add MCIP-6 Byzyantium transition to Musicoin spec
-    - Update mcip6_byz.json
-    - ethcore: update musicoin byzantium block number
-    - ethcore: update musicoin bootnodes
-    - Update musicoin.json
-    - More bootnodes.
+	  - Add test chain spec for musicoin byzantium testnet
+	  - Add MCIP-6 Byzyantium transition to Musicoin spec
+	  - Update mcip6_byz.json
+	  - ethcore: update musicoin byzantium block number
+	  - ethcore: update musicoin bootnodes
+	  - Update musicoin.json
+	  - More bootnodes.
 - Make 1.10 beta ([#8022](https://github.com/paritytech/parity/pull/8022))
   - Make 1.10 beta
   - Fix gitlab builds

ethash/Cargo.toml

@@ -6,14 +6,13 @@ authors = ["Parity Technologies <admin@parity.io>"]
 [lib]
 
 [dependencies]
-crunchy = "0.1.0"
-either = "1.0.0"
-ethereum-types = "0.3"
-keccak-hash = { git = "https://github.com/paritytech/parity-common" }
-log = "0.4"
-memmap = "0.6"
-parking_lot = "0.6"
+log = "0.3"
+keccak-hash = { path = "../util/hash" }
 primal = "0.2.3"
+parking_lot = "0.5"
+crunchy = "0.1.0"
+memmap = "0.6"
+either = "1.0.0"
 
 [dev-dependencies]
 tempdir = "0.3"

ethash/src/cache.rs

@@ -91,7 +91,7 @@ impl NodeCacheBuilder {
 
 	pub fn new<T: Into<Option<OptimizeFor>>>(optimize_for: T) -> Self {
 		NodeCacheBuilder {
-			seedhash: Arc::new(Mutex::new(SeedHashCompute::default())),
+			seedhash: Arc::new(Mutex::new(SeedHashCompute::new())),
 			optimize_for: optimize_for.into().unwrap_or_default(),
 		}
 	}

ethash/src/compute.rs

@@ -137,11 +137,11 @@ fn hash_compute(light: &Light, full_size: usize, header_hash: &H256, nonce: u64)
 		($n:expr, $value:expr) => {{
 			// We use explicit lifetimes to ensure that val's borrow is invalidated until the
 			// transmuted val dies.
-			unsafe fn make_const_array<T, U>(val: &mut [T]) -> &mut [U; $n] {
+			unsafe fn make_const_array<'a, T, U>(val: &'a mut [T]) -> &'a mut [U; $n] {
 				use ::std::mem;
 
 				debug_assert_eq!(val.len() * mem::size_of::<T>(), $n * mem::size_of::<U>());
- 				&mut *(val.as_mut_ptr() as *mut [U; $n])
+				mem::transmute(val.as_mut_ptr())
 			}
 
 			make_const_array($value)
@@ -177,7 +177,7 @@ fn hash_compute(light: &Light, full_size: usize, header_hash: &H256, nonce: u64)
 
 			ptr::copy_nonoverlapping(header_hash.as_ptr(), out.as_mut_ptr(), header_hash.len());
 			ptr::copy_nonoverlapping(
-				&nonce as *const u64 as *const u8,
+				mem::transmute(&nonce),
 				out[header_hash.len()..].as_mut_ptr(),
 				mem::size_of::<u64>(),
 			);
@@ -266,20 +266,18 @@ fn hash_compute(light: &Light, full_size: usize, header_hash: &H256, nonce: u64)
 
 	let mix_hash = buf.compress_bytes;
 
-	let value: H256 = {
+	let value: H256 = unsafe {
 		// We can interpret the buffer as an array of `u8`s, since it's `repr(C)`.
-		let read_ptr: *const u8 = &buf as *const MixBuf as *const u8;
+		let read_ptr: *const u8 = mem::transmute(&buf);
 		// We overwrite the second half since `keccak_256` has an internal buffer and so allows
 		// overlapping arrays as input.
-		let write_ptr: *mut u8 = &mut buf.compress_bytes as *mut [u8; 32] as *mut u8;
-		unsafe { 
-			keccak_256::unchecked(
-				write_ptr,
-				buf.compress_bytes.len(),
-				read_ptr,
-				buf.half_mix.bytes.len() + buf.compress_bytes.len(),
-			);
-		}
+		let write_ptr: *mut u8 = mem::transmute(&mut buf.compress_bytes);
+		keccak_256::unchecked(
+			write_ptr,
+			buf.compress_bytes.len(),
+			read_ptr,
+			buf.half_mix.bytes.len() + buf.compress_bytes.len(),
+		);
 		buf.compress_bytes
 	};
 

ethash/src/lib.rs

@@ -16,11 +16,10 @@
 
 #![cfg_attr(feature = "benches", feature(test))]
 
-extern crate either;
-extern crate ethereum_types;
-extern crate memmap;
-extern crate parking_lot;
 extern crate primal;
+extern crate parking_lot;
+extern crate either;
+extern crate memmap;
 
 #[macro_use]
 extern crate crunchy;
@@ -39,7 +38,6 @@ mod shared;
 pub use cache::{NodeCacheBuilder, OptimizeFor};
 pub use compute::{ProofOfWork, quick_get_difficulty, slow_hash_block_number};
 use compute::Light;
-use ethereum_types::{U256, U512};
 use keccak::H256;
 use parking_lot::Mutex;
 pub use seed_compute::SeedHashCompute;
@@ -138,29 +136,6 @@ impl EthashManager {
 	}
 }
 
-/// Convert an Ethash boundary to its original difficulty. Basically just `f(x) = 2^256 / x`.
-pub fn boundary_to_difficulty(boundary: &ethereum_types::H256) -> U256 {
-	difficulty_to_boundary_aux(&**boundary)
-}
-
-/// Convert an Ethash difficulty to the target boundary. Basically just `f(x) = 2^256 / x`.
-pub fn difficulty_to_boundary(difficulty: &U256) -> ethereum_types::H256 {
-	difficulty_to_boundary_aux(difficulty).into()
-}
-
-fn difficulty_to_boundary_aux<T: Into<U512>>(difficulty: T) -> ethereum_types::U256 {
-	let difficulty = difficulty.into();
-
-	assert!(!difficulty.is_zero());
-
-	if difficulty == U512::one() {
-		U256::max_value()
-	} else {
-		// difficulty > 1, so result should never overflow 256 bits
-		U256::from((U512::one() << 256) / difficulty)
-	}
-}
-
 #[test]
 fn test_lru() {
 	use tempdir::TempDir;
@@ -180,43 +155,6 @@ fn test_lru() {
 	assert_eq!(ethash.cache.lock().prev_epoch.unwrap(), 0);
 }
 
-#[test]
-fn test_difficulty_to_boundary() {
-	use ethereum_types::H256;
-	use std::str::FromStr;
-
-	assert_eq!(difficulty_to_boundary(&U256::from(1)), H256::from(U256::max_value()));
-	assert_eq!(difficulty_to_boundary(&U256::from(2)), H256::from_str("8000000000000000000000000000000000000000000000000000000000000000").unwrap());
-	assert_eq!(difficulty_to_boundary(&U256::from(4)), H256::from_str("4000000000000000000000000000000000000000000000000000000000000000").unwrap());
-	assert_eq!(difficulty_to_boundary(&U256::from(32)), H256::from_str("0800000000000000000000000000000000000000000000000000000000000000").unwrap());
-}
-
-#[test]
-fn test_difficulty_to_boundary_regression() {
-	use ethereum_types::H256;
-
-	// the last bit was originally being truncated when performing the conversion
-	// https://github.com/paritytech/parity-ethereum/issues/8397
-	for difficulty in 1..9 {
-		assert_eq!(U256::from(difficulty), boundary_to_difficulty(&difficulty_to_boundary(&difficulty.into())));
-		assert_eq!(H256::from(difficulty), difficulty_to_boundary(&boundary_to_difficulty(&difficulty.into())));
-		assert_eq!(U256::from(difficulty), boundary_to_difficulty(&boundary_to_difficulty(&difficulty.into()).into()));
-		assert_eq!(H256::from(difficulty), difficulty_to_boundary(&difficulty_to_boundary(&difficulty.into()).into()));
-	}
-}
-
-#[test]
-#[should_panic]
-fn test_difficulty_to_boundary_panics_on_zero() {
-	difficulty_to_boundary(&U256::from(0));
-}
-
-#[test]
-#[should_panic]
-fn test_boundary_to_difficulty_panics_on_zero() {
-	boundary_to_difficulty(&ethereum_types::H256::from(0));
-}
-
 #[cfg(feature = "benches")]
 mod benchmarks {
 	extern crate test;

ethash/src/seed_compute.rs

@@ -19,13 +19,20 @@ use keccak::{keccak_256, H256};
 
 use std::cell::Cell;
 
-#[derive(Default)]
 pub struct SeedHashCompute {
 	prev_epoch: Cell<u64>,
 	prev_seedhash: Cell<H256>,
 }
 
 impl SeedHashCompute {
+	#[inline]
+	pub fn new() -> SeedHashCompute {
+		SeedHashCompute {
+			prev_epoch: Cell::new(0),
+			prev_seedhash: Cell::new([0u8; 32]),
+		}
+	}
+
 	#[inline]
 	fn reset_cache(&self) {
 		self.prev_epoch.set(0);
@@ -70,20 +77,20 @@ mod tests {
 
 	#[test]
 	fn test_seed_compute_once() {
-		let seed_compute = SeedHashCompute::default();
+		let seed_compute = SeedHashCompute::new();
 		let hash = [241, 175, 44, 134, 39, 121, 245, 239, 228, 236, 43, 160, 195, 152, 46, 7, 199, 5, 253, 147, 241, 206, 98, 43, 3, 104, 17, 40, 192, 79, 106, 162];
 		assert_eq!(seed_compute.hash_block_number(486382), hash);
 	}
 
 	#[test]
 	fn test_seed_compute_zero() {
-		let seed_compute = SeedHashCompute::default();
+		let seed_compute = SeedHashCompute::new();
 		assert_eq!(seed_compute.hash_block_number(0), [0u8; 32]);
 	}
 
 	#[test]
 	fn test_seed_compute_after_older() {
-		let seed_compute = SeedHashCompute::default();
+		let seed_compute = SeedHashCompute::new();
 		// calculating an older value first shouldn't affect the result
 		let _ = seed_compute.hash_block_number(50000);
 		let hash = [241, 175, 44, 134, 39, 121, 245, 239, 228, 236, 43, 160, 195, 152, 46, 7, 199, 5, 253, 147, 241, 206, 98, 43, 3, 104, 17, 40, 192, 79, 106, 162];
@@ -92,7 +99,7 @@ mod tests {
 
 	#[test]
 	fn test_seed_compute_after_newer() {
-		let seed_compute = SeedHashCompute::default();
+		let seed_compute = SeedHashCompute::new();
 		// calculating an newer value first shouldn't affect the result
 		let _ = seed_compute.hash_block_number(972764);
 		let hash = [241, 175, 44, 134, 39, 121, 245, 239, 228, 236, 43, 160, 195, 152, 46, 7, 199, 5, 253, 147, 241, 206, 98, 43, 3, 104, 17, 40, 192, 79, 106, 162];

ethcore/Cargo.toml

@@ -8,24 +8,24 @@ authors = ["Parity Technologies <admin@parity.io>"]
 
 [dependencies]
 ansi_term = "0.10"
-blooms-db = { path = "../util/blooms-db" }
+bloomchain = { path = "../util/bloomchain" }
 bn = { git = "https://github.com/paritytech/bn", default-features = false }
 byteorder = "1.0"
 common-types = { path = "types" }
 crossbeam = "0.3"
 ethash = { path = "../ethash" }
 ethcore-bloom-journal = { path = "../util/bloom" }
-parity-bytes = { git = "https://github.com/paritytech/parity-common" }
-hashdb = { git = "https://github.com/paritytech/parity-common" }
-memorydb = { git = "https://github.com/paritytech/parity-common" }
-patricia-trie = { git = "https://github.com/paritytech/parity-common" }
-patricia-trie-ethereum = { path = "../util/patricia-trie-ethereum" }
-parity-crypto = { git = "https://github.com/paritytech/parity-common" }
-error-chain = { version = "0.12", default-features = false }
+ethcore-bytes = { path = "../util/bytes" }
+fetch = { path = "../util/fetch" }
+hashdb = { path = "../util/hashdb" }
+memorydb = { path = "../util/memorydb" }
+patricia-trie = { path = "../util/patricia_trie" }
+ethcore-crypto = { path = "crypto" }
+error-chain = { version = "0.11", default-features = false }
 ethcore-io = { path = "../util/io" }
 ethcore-logger = { path = "../logger" }
 ethcore-miner = { path = "../miner" }
-ethcore-stratum = { path = "./stratum", optional = true }
+ethcore-stratum = { path = "./stratum" }
 ethcore-transaction = { path = "./transaction" }
 ethereum-types = "0.3"
 memory-cache = { path = "../util/memory_cache" }
@@ -36,6 +36,7 @@ ethjson = { path = "../json" }
 ethkey = { path = "../ethkey" }
 ethstore = { path = "../ethstore" }
 evm = { path = "evm" }
+hardware-wallet = { path = "../hw" }
 heapsize = "0.4"
 itertools = "0.5"
 lazy_static = "1.0"
@@ -44,14 +45,15 @@ lru-cache = "0.1"
 num = { version = "0.1", default-features = false, features = ["bigint"] }
 num_cpus = "1.2"
 parity-machine = { path = "../machine" }
-parking_lot = "0.6"
+parking_lot = "0.5"
 rayon = "1.0"
 rand = "0.4"
-rlp = { git = "https://github.com/paritytech/parity-common" }
+rlp = { path = "../util/rlp" }
 rlp_compress = { path = "../util/rlp_compress" }
 rlp_derive = { path = "../util/rlp_derive" }
-kvdb = { git = "https://github.com/paritytech/parity-common" }
-kvdb-memorydb = { git = "https://github.com/paritytech/parity-common" }
+kvdb = { path = "../util/kvdb" }
+kvdb-memorydb = { path = "../util/kvdb-memorydb" }
+util-error = { path = "../util/error" }
 snappy = { git = "https://github.com/paritytech/rust-snappy" }
 stop-guard = { path = "../util/stop-guard" }
 macros = { path = "../util/macros" }
@@ -61,38 +63,19 @@ trace-time = { path = "../util/trace-time" }
 using_queue = { path = "../util/using_queue" }
 vm = { path = "vm" }
 wasm = { path = "wasm" }
-keccak-hash = { git = "https://github.com/paritytech/parity-common" }
-triehash-ethereum = { version = "0.2",  path = "../util/triehash-ethereum" }
+keccak-hash = { path = "../util/hash" }
+triehash = { path = "../util/triehash" }
 unexpected = { path = "../util/unexpected" }
 journaldb = { path = "../util/journaldb" }
-keccak-hasher = { path = "../util/keccak-hasher" }
-kvdb-rocksdb = { git = "https://github.com/paritytech/parity-common" }
-tempdir = {version="0.3", optional = true}
-
-[target.'cfg(any(target_os = "linux", target_os = "macos", target_os = "windows", target_os = "android"))'.dependencies]
-hardware-wallet = { path = "../hw" }
-
-[target.'cfg(not(any(target_os = "linux", target_os = "macos", target_os = "windows", target_os = "android")))'.dependencies]
-fake-hardware-wallet = { path = "../util/fake-hardware-wallet" }
 
 [dev-dependencies]
 tempdir = "0.3"
-trie-standardmap = { git = "https://github.com/paritytech/parity-common" }
+trie-standardmap = { path = "../util/trie-standardmap" }
+kvdb-rocksdb = { path = "../util/kvdb-rocksdb" }
 
 [features]
-parity = ["work-notify", "price-info", "stratum"]
-# Large optional features that are enabled by default for Parity,
-# but might be omitted for other dependent crates.
-work-notify = ["ethcore-miner/work-notify"]
-price-info = ["ethcore-miner/price-info"]
-stratum = ["ethcore-stratum"]
-
-# Disables seal verification for mined blocks.
-# This allows you to submit any seal via RPC to test and benchmark
-# how fast pending block get's created while running on the mainnet.
-miner-debug = []
 # Display EVM debug traces.
-evm-debug = ["evm/evm-debug"]
+evm-debug = ["slow-blocks"]
 # Display EVM debug traces when running tests.
 evm-debug-tests = ["evm-debug", "evm/evm-debug-tests"]
 # Measure time of transaction execution.
@@ -101,10 +84,8 @@ evm-debug-tests = ["evm-debug", "evm/evm-debug-tests"]
 # EVM debug traces are printed.
 slow-blocks = []
 # Run JSON consensus tests.
-json-tests = ["ethcore-transaction/json-tests", "test-helpers", "tempdir"]
+json-tests = ["ethcore-transaction/json-tests"]
 # Run memory/cpu heavy tests.
 test-heavy = []
 # Compile benches
 benches = []
-# Compile test helpers
-test-helpers = ["tempdir"]

ethcore/benches/evm.rs

@@ -16,16 +16,17 @@
 
 #![feature(test)]
 
-extern crate bn;
-extern crate ethereum_types;
-extern crate ethkey;
-extern crate parity_crypto;
-extern crate rand;
-extern crate rustc_hex;
 extern crate test;
+extern crate ethcore_util as util;
+extern crate rand;
+extern crate bn;
+extern crate ethcore_crypto;
+extern crate ethkey;
+extern crate rustc_hex;
+extern crate ethcore_bigint;
 
-use self::test::Bencher;
-use rand::StdRng;
+use self::test::{Bencher};
+use rand::{StdRng};
 
 #[bench]
 fn bn_128_pairing(b: &mut Bencher) {
@@ -59,9 +60,10 @@ fn bn_128_mul(b: &mut Bencher) {
 
 #[bench]
 fn sha256(b: &mut Bencher) {
-	use parity_crypto::digest::sha256;
+	use ethcore_crypto::digest::sha256;
 
-	let input = [0_u8; 256];
+	let mut input: [u8; 256] = [0; 256];
+	let mut out = [0; 32];
 
 	b.iter(|| {
 		sha256(&input);
@@ -72,7 +74,7 @@ fn sha256(b: &mut Bencher) {
 fn ecrecover(b: &mut Bencher) {
 	use rustc_hex::FromHex;
 	use ethkey::{Signature, recover as ec_recover};
-	use ethereum_types::H256;
+	use ethcore_bigint::hash::H256;
 	let input = FromHex::from_hex("47173285a8d7341e5e972fc677286384f802f8ef42a5ec5f03bbfa254cb01fad000000000000000000000000000000000000000000000000000000000000001b650acf9d3f5f0a2c799776a1254355d5f4061762a237396a99a0e0e3fc2bcd6729514a0dacb2e623ac4abd157cb18163ff942280db4d5caad66ddf941ba12e03").unwrap();
 	let hash = H256::from_slice(&input[0..32]);
 	let v = H256::from_slice(&input[32..64]);

ethcore/crypto/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "ethcore-crypto"
+version = "0.1.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+
+[dependencies]
+ethereum-types = "0.3"
+quick-error = "1.2"
+ring = "0.12"
+rust-crypto = "0.2.36"
+tiny-keccak = "1.4"
+

ethcore/crypto/README.md

@@ -0,0 +1,5 @@
+# Ethcrypto
+
+General cryptographic utilities for Ethereum.
+
+By default, this library is compiled with the `secp256k1` feature, which provides ECDH and ECIES capability on that curve. It can be compiled without to avoid a dependency on the `libsecp256k1` library.

ethcore/crypto/src/aes.rs

@@ -0,0 +1,53 @@
+// Copyright 2015-2018 Parity Technologies (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+use error::SymmError;
+use rcrypto::blockmodes::{CtrMode, CbcDecryptor, PkcsPadding};
+use rcrypto::aessafe::{AesSafe128Encryptor, AesSafe128Decryptor};
+use rcrypto::symmetriccipher::{Encryptor, Decryptor};
+use rcrypto::buffer::{RefReadBuffer, RefWriteBuffer, WriteBuffer};
+
+/// Encrypt a message (CTR mode).
+///
+/// Key (`k`) length and initialisation vector (`iv`) length have to be 16 bytes each.
+/// An error is returned if the input lengths are invalid.
+pub fn encrypt_128_ctr(k: &[u8], iv: &[u8], plain: &[u8], dest: &mut [u8]) -> Result<(), SymmError> {
+	let mut encryptor = CtrMode::new(AesSafe128Encryptor::new(k), iv.to_vec());
+	encryptor.encrypt(&mut RefReadBuffer::new(plain), &mut RefWriteBuffer::new(dest), true)?;
+	Ok(())
+}
+
+/// Decrypt a message (CTR mode).
+///
+/// Key (`k`) length and initialisation vector (`iv`) length have to be 16 bytes each.
+/// An error is returned if the input lengths are invalid.
+pub fn decrypt_128_ctr(k: &[u8], iv: &[u8], encrypted: &[u8], dest: &mut [u8]) -> Result<(), SymmError> {
+	let mut encryptor = CtrMode::new(AesSafe128Encryptor::new(k), iv.to_vec());
+	encryptor.decrypt(&mut RefReadBuffer::new(encrypted), &mut RefWriteBuffer::new(dest), true)?;
+	Ok(())
+}
+
+/// Decrypt a message (CBC mode).
+///
+/// Key (`k`) length and initialisation vector (`iv`) length have to be 16 bytes each.
+/// An error is returned if the input lengths are invalid.
+pub fn decrypt_128_cbc(k: &[u8], iv: &[u8], encrypted: &[u8], dest: &mut [u8]) -> Result<usize, SymmError> {
+	let mut encryptor = CbcDecryptor::new(AesSafe128Decryptor::new(k), PkcsPadding, iv.to_vec());
+	let len = dest.len();
+	let mut buffer = RefWriteBuffer::new(dest);
+	encryptor.decrypt(&mut RefReadBuffer::new(encrypted), &mut buffer, true)?;
+	Ok(len - buffer.remaining())
+}

ethcore/crypto/src/aes_gcm.rs

@@ -0,0 +1,198 @@
+// Copyright 2015-2018 Parity Technologies (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+use error::SymmError;
+use ring;
+
+enum Mode { Aes128Gcm, Aes256Gcm }
+
+/// AES GCM encryptor.
+pub struct Encryptor<'a> {
+	mode: Mode,
+	key: ring::aead::SealingKey,
+	ad: &'a [u8],
+	offset: usize,
+}
+
+impl<'a> Encryptor<'a> {
+	pub fn aes_128_gcm(key: &[u8; 16]) -> Result<Encryptor<'a>, SymmError> {
+		let sk = ring::aead::SealingKey::new(&ring::aead::AES_128_GCM, key)?;
+		Ok(Encryptor {
+			mode: Mode::Aes128Gcm,
+			key: sk,
+			ad: &[],
+			offset: 0,
+		})
+	}
+
+	pub fn aes_256_gcm(key: &[u8; 32]) -> Result<Encryptor<'a>, SymmError> {
+		let sk = ring::aead::SealingKey::new(&ring::aead::AES_256_GCM, key)?;
+		Ok(Encryptor {
+			mode: Mode::Aes256Gcm,
+			key: sk,
+			ad: &[],
+			offset: 0,
+		})
+	}
+
+	/// Optional associated data which is not encrypted but authenticated.
+	pub fn associate(&mut self, data: &'a [u8]) -> &mut Self {
+		self.ad = data;
+		self
+	}
+
+	/// Optional offset value. Only the slice `[offset..]` will be encrypted.
+	pub fn offset(&mut self, off: usize) -> &mut Self {
+		self.offset = off;
+		self
+	}
+
+	/// Please note that the pair (key, nonce) must never be reused. Using random nonces
+	/// limits the number of messages encrypted with the same key to 2^32 (cf. [[1]])
+	///
+	/// [1]: https://nvlpubs.nist.gov/nistpubs/Legacy/SP/nistspecialpublication800-38d.pdf
+	pub fn encrypt(&self, nonce: &[u8; 12], mut data: Vec<u8>) -> Result<Vec<u8>, SymmError> {
+		if self.offset > data.len() {
+			return Err(SymmError::offset_error(self.offset))
+		}
+		let tag_len = match self.mode {
+			Mode::Aes128Gcm => ring::aead::AES_128_GCM.tag_len(),
+			Mode::Aes256Gcm => ring::aead::AES_256_GCM.tag_len(),
+		};
+		data.extend(::std::iter::repeat(0).take(tag_len));
+		let len = ring::aead::seal_in_place(&self.key, nonce, self.ad, &mut data[self.offset ..], tag_len)?;
+		data.truncate(self.offset + len);
+		Ok(data)
+	}
+}
+
+/// AES GCM decryptor.
+pub struct Decryptor<'a> {
+	key: ring::aead::OpeningKey,
+	ad: &'a [u8],
+	offset: usize,
+}
+
+impl<'a> Decryptor<'a> {
+	pub fn aes_128_gcm(key: &[u8; 16]) -> Result<Decryptor<'a>, SymmError> {
+		let ok = ring::aead::OpeningKey::new(&ring::aead::AES_128_GCM, key)?;
+		Ok(Decryptor {
+			key: ok,
+			ad: &[],
+			offset: 0,
+		})
+	}
+
+	pub fn aes_256_gcm(key: &[u8; 32]) -> Result<Decryptor<'a>, SymmError> {
+		let ok = ring::aead::OpeningKey::new(&ring::aead::AES_256_GCM, key)?;
+		Ok(Decryptor {
+			key: ok,
+			ad: &[],
+			offset: 0,
+		})
+	}
+
+	/// Optional associated data which is not encrypted but authenticated.
+	pub fn associate(&mut self, data: &'a [u8]) -> &mut Self {
+		self.ad = data;
+		self
+	}
+
+	/// Optional offset value. Only the slice `[offset..]` will be decrypted.
+	pub fn offset(&mut self, off: usize) -> &mut Self {
+		self.offset = off;
+		self
+	}
+
+	pub fn decrypt(&self, nonce: &[u8; 12], mut data: Vec<u8>) -> Result<Vec<u8>, SymmError> {
+		if self.offset > data.len() {
+			return Err(SymmError::offset_error(self.offset))
+		}
+		let len = ring::aead::open_in_place(&self.key, nonce, self.ad, 0, &mut data[self.offset ..])?.len();
+		data.truncate(self.offset + len);
+		Ok(data)
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::{Encryptor, Decryptor};
+
+	#[test]
+	fn aes_gcm_128() {
+		let secret = b"1234567890123456";
+		let nonce = b"123456789012";
+		let message = b"So many books, so little time";
+
+		let ciphertext = Encryptor::aes_128_gcm(secret)
+			.unwrap()
+			.encrypt(nonce, message.to_vec())
+			.unwrap();
+
+		assert!(ciphertext != message);
+
+		let plaintext = Decryptor::aes_128_gcm(secret)
+			.unwrap()
+			.decrypt(nonce, ciphertext)
+			.unwrap();
+
+		assert_eq!(plaintext, message)
+	}
+
+	#[test]
+	fn aes_gcm_256() {
+		let secret = b"12345678901234567890123456789012";
+		let nonce = b"123456789012";
+		let message = b"So many books, so little time";
+
+		let ciphertext = Encryptor::aes_256_gcm(secret)
+			.unwrap()
+			.encrypt(nonce, message.to_vec())
+			.unwrap();
+
+		assert!(ciphertext != message);
+
+		let plaintext = Decryptor::aes_256_gcm(secret)
+			.unwrap()
+			.decrypt(nonce, ciphertext)
+			.unwrap();
+
+		assert_eq!(plaintext, message)
+	}
+
+	#[test]
+	fn aes_gcm_256_offset() {
+		let secret = b"12345678901234567890123456789012";
+		let nonce = b"123456789012";
+		let message = b"prefix data; So many books, so little time";
+
+		let ciphertext = Encryptor::aes_256_gcm(secret)
+			.unwrap()
+			.offset(13) // length of "prefix data; "
+			.encrypt(nonce, message.to_vec())
+			.unwrap();
+
+		assert!(ciphertext != &message[..]);
+
+		let plaintext = Decryptor::aes_256_gcm(secret)
+			.unwrap()
+			.offset(13) // length of "prefix data; "
+			.decrypt(nonce, ciphertext)
+			.unwrap();
+
+		assert_eq!(plaintext, &message[..])
+	}
+}

ethcore/crypto/src/digest.rs

@@ -0,0 +1,109 @@
+// Copyright 2015-2018 Parity Technologies (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+use rcrypto::ripemd160;
+use ring::digest::{self, Context, SHA256, SHA512};
+use std::marker::PhantomData;
+use std::ops::Deref;
+
+/// The message digest.
+pub struct Digest<T>(InnerDigest, PhantomData<T>);
+
+enum InnerDigest {
+	Ring(digest::Digest),
+	Ripemd160([u8; 20]),
+}
+
+impl<T> Deref for Digest<T> {
+	type Target = [u8];
+	fn deref(&self) -> &Self::Target {
+		match self.0 {
+			InnerDigest::Ring(ref d) => d.as_ref(),
+			InnerDigest::Ripemd160(ref d) => &d[..]
+		}
+	}
+}
+
+/// Single-step sha256 digest computation.
+pub fn sha256(data: &[u8]) -> Digest<Sha256> {
+	Digest(InnerDigest::Ring(digest::digest(&SHA256, data)), PhantomData)
+}
+
+/// Single-step sha512 digest computation.
+pub fn sha512(data: &[u8]) -> Digest<Sha512> {
+	Digest(InnerDigest::Ring(digest::digest(&SHA512, data)), PhantomData)
+}
+
+/// Single-step ripemd160 digest computation.
+pub fn ripemd160(data: &[u8]) -> Digest<Ripemd160> {
+	let mut hasher = Hasher::ripemd160();
+	hasher.update(data);
+	hasher.finish()
+}
+
+pub enum Sha256 {}
+pub enum Sha512 {}
+pub enum Ripemd160 {}
+
+/// Stateful digest computation.
+pub struct Hasher<T>(Inner, PhantomData<T>);
+
+enum Inner {
+	Ring(Context),
+	Ripemd160(ripemd160::Ripemd160)
+}
+
+impl Hasher<Sha256> {
+	pub fn sha256() -> Hasher<Sha256> {
+		Hasher(Inner::Ring(Context::new(&SHA256)), PhantomData)
+	}
+}
+
+impl Hasher<Sha512> {
+	pub fn sha512() -> Hasher<Sha512> {
+		Hasher(Inner::Ring(Context::new(&SHA512)), PhantomData)
+	}
+}
+
+impl Hasher<Ripemd160> {
+	pub fn ripemd160() -> Hasher<Ripemd160> {
+		Hasher(Inner::Ripemd160(ripemd160::Ripemd160::new()), PhantomData)
+	}
+}
+
+impl<T> Hasher<T> {
+	pub fn update(&mut self, data: &[u8]) {
+		match self.0 {
+			Inner::Ring(ref mut ctx) => ctx.update(data),
+			Inner::Ripemd160(ref mut ctx) => {
+				use rcrypto::digest::Digest;
+				ctx.input(data)
+			}
+		}
+	}
+
+	pub fn finish(self) -> Digest<T> {
+		match self.0 {
+			Inner::Ring(ctx) => Digest(InnerDigest::Ring(ctx.finish()), PhantomData),
+			Inner::Ripemd160(mut ctx) => {
+				use rcrypto::digest::Digest;
+				let mut d = [0; 20];
+				ctx.result(&mut d);
+				Digest(InnerDigest::Ripemd160(d), PhantomData)
+			}
+		}
+	}
+}

ethcore/crypto/src/error.rs

@@ -0,0 +1,82 @@
+// Copyright 2015-2018 Parity Technologies (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+use rcrypto;
+use ring;
+
+quick_error! {
+	#[derive(Debug)]
+	pub enum Error {
+		Scrypt(e: ScryptError) {
+			cause(e)
+			from()
+		}
+		Symm(e: SymmError) {
+			cause(e)
+			from()
+		}
+	}
+}
+
+quick_error! {
+	#[derive(Debug)]
+	pub enum ScryptError {
+		// log(N) < r / 16
+		InvalidN {
+			display("Invalid N argument of the scrypt encryption")
+		}
+		// p <= (2^31-1 * 32)/(128 * r)
+		InvalidP {
+			display("Invalid p argument of the scrypt encryption")
+		}
+	}
+}
+
+quick_error! {
+	#[derive(Debug)]
+	pub enum SymmError wraps PrivSymmErr {
+		RustCrypto(e: rcrypto::symmetriccipher::SymmetricCipherError) {
+			display("symmetric crypto error")
+			from()
+		}
+		Ring(e: ring::error::Unspecified) {
+			display("symmetric crypto error")
+			cause(e)
+			from()
+		}
+		Offset(x: usize) {
+			display("offset {} greater than slice length", x)
+		}
+	}
+}
+
+impl SymmError {
+	pub(crate) fn offset_error(x: usize) -> SymmError {
+		SymmError(PrivSymmErr::Offset(x))
+	}
+}
+
+impl From<ring::error::Unspecified> for SymmError {
+	fn from(e: ring::error::Unspecified) -> SymmError {
+		SymmError(PrivSymmErr::Ring(e))
+	}
+}
+
+impl From<rcrypto::symmetriccipher::SymmetricCipherError> for SymmError {
+	fn from(e: rcrypto::symmetriccipher::SymmetricCipherError) -> SymmError {
+		SymmError(PrivSymmErr::RustCrypto(e))
+	}
+}

ethcore/crypto/src/hmac.rs

@@ -0,0 +1,88 @@
+// Copyright 2015-2018 Parity Technologies (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+use digest;
+use ring::digest::{SHA256, SHA512};
+use ring::hmac::{self, SigningContext};
+use std::marker::PhantomData;
+use std::ops::Deref;
+
+/// HMAC signature.
+pub struct Signature<T>(hmac::Signature, PhantomData<T>);
+
+impl<T> Deref for Signature<T> {
+	type Target = [u8];
+	fn deref(&self) -> &Self::Target {
+		self.0.as_ref()
+	}
+}
+
+/// HMAC signing key.
+pub struct SigKey<T>(hmac::SigningKey, PhantomData<T>);
+
+impl SigKey<digest::Sha256> {
+	pub fn sha256(key: &[u8]) -> SigKey<digest::Sha256> {
+		SigKey(hmac::SigningKey::new(&SHA256, key), PhantomData)
+	}
+}
+
+impl SigKey<digest::Sha512> {
+	pub fn sha512(key: &[u8]) -> SigKey<digest::Sha512> {
+		SigKey(hmac::SigningKey::new(&SHA512, key), PhantomData)
+	}
+}
+
+/// Compute HMAC signature of `data`.
+pub fn sign<T>(k: &SigKey<T>, data: &[u8]) -> Signature<T> {
+	Signature(hmac::sign(&k.0, data), PhantomData)
+}
+
+/// Stateful HMAC computation.
+pub struct Signer<T>(SigningContext, PhantomData<T>);
+
+impl<T> Signer<T> {
+	pub fn with(key: &SigKey<T>) -> Signer<T> {
+		Signer(hmac::SigningContext::with_key(&key.0), PhantomData)
+	}
+
+	pub fn update(&mut self, data: &[u8]) {
+		self.0.update(data)
+	}
+
+	pub fn sign(self) -> Signature<T> {
+		Signature(self.0.sign(), PhantomData)
+	}
+}
+
+/// HMAC signature verification key.
+pub struct VerifyKey<T>(hmac::VerificationKey, PhantomData<T>);
+
+impl VerifyKey<digest::Sha256> {
+	pub fn sha256(key: &[u8]) -> VerifyKey<digest::Sha256> {
+		VerifyKey(hmac::VerificationKey::new(&SHA256, key), PhantomData)
+	}
+}
+
+impl VerifyKey<digest::Sha512> {
+	pub fn sha512(key: &[u8]) -> VerifyKey<digest::Sha512> {
+		VerifyKey(hmac::VerificationKey::new(&SHA512, key), PhantomData)
+	}
+}
+
+/// Verify HMAC signature of `data`.
+pub fn verify<T>(k: &VerifyKey<T>, data: &[u8], sig: &[u8]) -> bool {
+	hmac::verify(&k.0, data, sig).is_ok()
+}

ethcore/crypto/src/lib.rs

@@ -0,0 +1,76 @@
+// Copyright 2015-2018 Parity Technologies (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Crypto utils used ethstore and network.
+
+extern crate crypto as rcrypto;
+extern crate ethereum_types;
+#[macro_use]
+extern crate quick_error;
+extern crate ring;
+extern crate tiny_keccak;
+
+pub mod aes;
+pub mod aes_gcm;
+pub mod error;
+pub mod scrypt;
+pub mod digest;
+pub mod hmac;
+pub mod pbkdf2;
+
+pub use error::Error;
+
+use tiny_keccak::Keccak;
+
+pub const KEY_LENGTH: usize = 32;
+pub const KEY_ITERATIONS: usize = 10240;
+pub const KEY_LENGTH_AES: usize = KEY_LENGTH / 2;
+
+/// Default authenticated data to use (in RPC).
+pub const DEFAULT_MAC: [u8; 2] = [0, 0];
+
+pub trait Keccak256<T> {
+	fn keccak256(&self) -> T where T: Sized;
+}
+
+impl<T> Keccak256<[u8; 32]> for T where T: AsRef<[u8]> {
+	fn keccak256(&self) -> [u8; 32] {
+		let mut keccak = Keccak::new_keccak256();
+		let mut result = [0u8; 32];
+		keccak.update(self.as_ref());
+		keccak.finalize(&mut result);
+		result
+	}
+}
+
+pub fn derive_key_iterations(password: &str, salt: &[u8; 32], c: u32) -> (Vec<u8>, Vec<u8>) {
+	let mut derived_key = [0u8; KEY_LENGTH];
+	pbkdf2::sha256(c, pbkdf2::Salt(salt), pbkdf2::Secret(password.as_bytes()), &mut derived_key);
+	let derived_right_bits = &derived_key[0..KEY_LENGTH_AES];
+	let derived_left_bits = &derived_key[KEY_LENGTH_AES..KEY_LENGTH];
+	(derived_right_bits.to_vec(), derived_left_bits.to_vec())
+}
+
+pub fn derive_mac(derived_left_bits: &[u8], cipher_text: &[u8]) -> Vec<u8> {
+	let mut mac = vec![0u8; KEY_LENGTH_AES + cipher_text.len()];
+	mac[0..KEY_LENGTH_AES].copy_from_slice(derived_left_bits);
+	mac[KEY_LENGTH_AES..cipher_text.len() + KEY_LENGTH_AES].copy_from_slice(cipher_text);
+	mac
+}
+
+pub fn is_equal(a: &[u8], b: &[u8]) -> bool {
+	ring::constant_time::verify_slices_are_equal(a, b).is_ok()
+}

ethcore/crypto/src/pbkdf2.rs

@@ -0,0 +1,28 @@
+// Copyright 2015-2018 Parity Technologies (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+use ring;
+
+pub struct Salt<'a>(pub &'a [u8]);
+pub struct Secret<'a>(pub &'a [u8]);
+
+pub fn sha256(iter: u32, salt: Salt, sec: Secret, out: &mut [u8; 32]) {
+	ring::pbkdf2::derive(&ring::digest::SHA256, iter, salt.0, sec.0, &mut out[..])
+}
+
+pub fn sha512(iter: u32, salt: Salt, sec: Secret, out: &mut [u8; 64]) {
+	ring::pbkdf2::derive(&ring::digest::SHA512, iter, salt.0, sec.0, &mut out[..])
+}

ethcore/crypto/src/scrypt.rs

@@ -0,0 +1,38 @@
+// Copyright 2015-2018 Parity Technologies (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+use error::ScryptError;
+use rcrypto::scrypt::{scrypt, ScryptParams};
+use super::{KEY_LENGTH_AES, KEY_LENGTH};
+
+pub fn derive_key(pass: &str, salt: &[u8; 32], n: u32, p: u32, r: u32) -> Result<(Vec<u8>, Vec<u8>), ScryptError> {
+	// sanity checks
+	let log_n = (32 - n.leading_zeros() - 1) as u8;
+	if log_n as u32 >= r * 16 {
+		return Err(ScryptError::InvalidN);
+	}
+
+	if p as u64 > ((u32::max_value() as u64 - 1) * 32)/(128 * (r as u64)) {
+		return Err(ScryptError::InvalidP);
+	}
+
+	let mut derived_key = vec![0u8; KEY_LENGTH];
+	let scrypt_params = ScryptParams::new(log_n, r, p);
+	scrypt(pass.as_bytes(), salt, &scrypt_params, &mut derived_key);
+	let derived_right_bits = &derived_key[0..KEY_LENGTH_AES];
+	let derived_left_bits = &derived_key[KEY_LENGTH_AES..KEY_LENGTH];
+	Ok((derived_right_bits.to_vec(), derived_left_bits.to_vec()))
+}

ethcore/evm/Cargo.toml

@@ -10,8 +10,8 @@ heapsize = "0.4"
 lazy_static = "1.0"
 log = "0.3"
 vm = { path = "../vm" }
-keccak-hash = { git = "https://github.com/paritytech/parity-common" }
-parking_lot = "0.6"
+keccak-hash = { path = "../../util/hash" }
+parking_lot = "0.5"
 memory-cache = { path = "../../util/memory_cache" }
 
 [dev-dependencies]

ethcore/evm/src/interpreter/gasometer.rs

@@ -113,7 +113,7 @@ impl<Gas: evm::CostType> Gasometer<Gas> {
 		current_mem_size: usize,
 	) -> vm::Result<InstructionRequirements<Gas>> {
 		let schedule = ext.schedule();
-		let tier = info.tier.idx();
+		let tier = instructions::get_tier_idx(info.tier);
 		let default_gas = Gas::from(schedule.tier_step_gas[tier]);
 
 		let cost = match instruction {
@@ -179,8 +179,8 @@ impl<Gas: evm::CostType> Gasometer<Gas> {
 			instructions::EXTCODECOPY => {
 				Request::GasMemCopy(schedule.extcodecopy_base_gas.into(), mem_needed(stack.peek(1), stack.peek(3))?, Gas::from_u256(*stack.peek(3))?)
 			},
-			instructions::LOG0 | instructions::LOG1 | instructions::LOG2 | instructions::LOG3 | instructions::LOG4 => {
-				let no_of_topics = instruction.log_topics().expect("log_topics always return some for LOG* instructions; qed");
+			instructions::LOG0...instructions::LOG4 => {
+				let no_of_topics = instructions::get_log_topics(instruction);
 				let log_gas = schedule.log_gas + schedule.log_topic_gas * no_of_topics;
 
 				let data_gas = overflowing!(Gas::from_u256(*stack.peek(1))?.overflow_mul(Gas::from(schedule.log_data_gas)));

ethcore/evm/src/interpreter/informant.rs

@@ -39,7 +39,7 @@ mod inner {
 	use std::collections::HashMap;
 	use std::time::{Instant, Duration};
 
-	use ethereum_types::U256;
+	use bigint::prelude::U256;
 
 	use interpreter::stack::Stack;
 	use instructions::{Instruction, InstructionInfo, INSTRUCTIONS};

ethcore/evm/src/interpreter/mod.rs

@@ -64,6 +64,7 @@ struct CodeReader<'a> {
 }
 
 impl<'a> CodeReader<'a> {
+
 	/// Create new code reader - starting at position 0.
 	fn new(code: &'a [u8]) -> Self {
 		CodeReader {
@@ -80,7 +81,7 @@ impl<'a> CodeReader<'a> {
 		U256::from(&self.code[pos..max])
 	}
 
-	fn len(&self) -> usize {
+	fn len (&self) -> usize {
 		self.code.len()
 	}
 }
@@ -123,31 +124,24 @@ impl<Cost: CostType> vm::Vm for Interpreter<Cost> {
 		let mut gasometer = Gasometer::<Cost>::new(Cost::from_u256(params.gas)?);
 		let mut stack = VecStack::with_capacity(ext.schedule().stack_limit, U256::zero());
 		let mut reader = CodeReader::new(code);
+		let infos = &*instructions::INSTRUCTIONS;
 
 		while reader.position < code.len() {
-			let opcode = code[reader.position];
-			let instruction = Instruction::from_u8(opcode);
+			let instruction = code[reader.position];
 			reader.position += 1;
 
 			// TODO: make compile-time removable if too much of a performance hit.
 			do_trace = do_trace && ext.trace_next_instruction(
-				reader.position - 1, opcode, gasometer.current_gas.as_u256(),
+				reader.position - 1, instruction, gasometer.current_gas.as_u256(),
 			);
 
-			if instruction.is_none() {
-				return Err(vm::Error::BadInstruction {
-					instruction: opcode
-				});
-			}
-			let instruction = instruction.expect("None case is checked above; qed");
-
-			let info = instruction.info();
+			let info = &infos[instruction as usize];
 			self.verify_instruction(ext, instruction, info, &stack)?;
 
 			// Calculate gas cost
 			let requirements = gasometer.requirements(ext, instruction, info, &stack, self.mem.size())?;
 			if do_trace {
-				ext.trace_prepare_execute(reader.position - 1, opcode, requirements.gas_cost.as_u256());
+				ext.trace_prepare_execute(reader.position - 1, instruction, requirements.gas_cost.as_u256());
 			}
 
 			gasometer.verify_gas(&requirements.gas_cost)?;
@@ -233,7 +227,13 @@ impl<Cost: CostType> Interpreter<Cost> {
 			((instruction == instructions::SHL || instruction == instructions::SHR || instruction == instructions::SAR) && !schedule.have_bitwise_shifting) {
 
 			return Err(vm::Error::BadInstruction {
-				instruction: instruction as u8
+				instruction: instruction
+			});
+		}
+
+		if info.tier == instructions::GasPriceTier::Invalid {
+			return Err(vm::Error::BadInstruction {
+				instruction: instruction
 			});
 		}
 
@@ -396,7 +396,7 @@ impl<Cost: CostType> Interpreter<Cost> {
 					},
 					instructions::DELEGATECALL => (&params.sender, &params.address, true, CallType::DelegateCall),
 					instructions::STATICCALL => (&params.address, &code_address, true, CallType::StaticCall),
-					_ => panic!(format!("Unexpected instruction {:?} in CALL branch.", instruction))
+					_ => panic!(format!("Unexpected instruction {} in CALL branch.", instruction))
 				};
 
 				// clear return data buffer before creating new call frame.
@@ -453,8 +453,8 @@ impl<Cost: CostType> Interpreter<Cost> {
 				ext.suicide(&u256_to_address(&address))?;
 				return Ok(InstructionResult::StopExecution);
 			},
-			instructions::LOG0 | instructions::LOG1 | instructions::LOG2 | instructions::LOG3 | instructions::LOG4 => {
-				let no_of_topics = instruction.log_topics().expect("log_topics always return some for LOG* instructions; qed");
+			instructions::LOG0...instructions::LOG4 => {
+				let no_of_topics = instructions::get_log_topics(instruction);
 
 				let offset = stack.pop_back();
 				let size = stack.pop_back();
@@ -464,15 +464,8 @@ impl<Cost: CostType> Interpreter<Cost> {
 					.collect();
 				ext.log(topics, self.mem.read_slice(offset, size))?;
 			},
-			instructions::PUSH1 | instructions::PUSH2 | instructions::PUSH3 | instructions::PUSH4 |
-			instructions::PUSH5 | instructions::PUSH6 | instructions::PUSH7 | instructions::PUSH8 |
-			instructions::PUSH9 | instructions::PUSH10 | instructions::PUSH11 | instructions::PUSH12 |
-			instructions::PUSH13 | instructions::PUSH14 | instructions::PUSH15 | instructions::PUSH16 |
-			instructions::PUSH17 | instructions::PUSH18 | instructions::PUSH19 | instructions::PUSH20 |
-			instructions::PUSH21 | instructions::PUSH22 | instructions::PUSH23 | instructions::PUSH24 |
-			instructions::PUSH25 | instructions::PUSH26 | instructions::PUSH27 | instructions::PUSH28 |
-			instructions::PUSH29 | instructions::PUSH30 | instructions::PUSH31 | instructions::PUSH32 => {
-				let bytes = instruction.push_bytes().expect("push_bytes always return some for PUSH* instructions");
+			instructions::PUSH1...instructions::PUSH32 => {
+				let bytes = instructions::get_push_bytes(instruction);
 				let val = code.read(bytes);
 				stack.push(val);
 			},
@@ -616,22 +609,73 @@ impl<Cost: CostType> Interpreter<Cost> {
 			instructions::GASLIMIT => {
 				stack.push(ext.env_info().gas_limit.clone());
 			},
+			_ => {
+				self.exec_stack_instruction(instruction, stack)?;
+			}
+		};
+		Ok(InstructionResult::Ok)
+	}
 
-			// Stack instructions
+	fn copy_data_to_memory(mem: &mut Vec<u8>, stack: &mut Stack<U256>, source: &[u8]) {
+		let dest_offset = stack.pop_back();
+		let source_offset = stack.pop_back();
+		let size = stack.pop_back();
+		let source_size = U256::from(source.len());
 
-			instructions::DUP1 | instructions::DUP2 | instructions::DUP3 | instructions::DUP4 |
-			instructions::DUP5 | instructions::DUP6 | instructions::DUP7 | instructions::DUP8 |
-			instructions::DUP9 | instructions::DUP10 | instructions::DUP11 | instructions::DUP12 |
-			instructions::DUP13 | instructions::DUP14 | instructions::DUP15 | instructions::DUP16 => {
-				let position = instruction.dup_position().expect("dup_position always return some for DUP* instructions");
+		let output_end = match source_offset > source_size || size > source_size || source_offset + size > source_size {
+			true => {
+				let zero_slice = if source_offset > source_size {
+					mem.writeable_slice(dest_offset, size)
+				} else {
+					mem.writeable_slice(dest_offset + source_size - source_offset, source_offset + size - source_size)
+				};
+				for i in zero_slice.iter_mut() {
+					*i = 0;
+				}
+				source.len()
+			},
+			false => (size.low_u64() + source_offset.low_u64()) as usize
+		};
+
+		if source_offset < source_size {
+			let output_begin = source_offset.low_u64() as usize;
+			mem.write_slice(dest_offset, &source[output_begin..output_end]);
+		}
+	}
+
+	fn verify_jump(&self, jump_u: U256, valid_jump_destinations: &BitSet) -> vm::Result<usize> {
+		let jump = jump_u.low_u64() as usize;
+
+		if valid_jump_destinations.contains(jump) && U256::from(jump) == jump_u {
+			Ok(jump)
+		} else {
+			Err(vm::Error::BadJumpDestination {
+				destination: jump
+			})
+		}
+	}
+
+	fn is_zero(&self, val: &U256) -> bool {
+		val.is_zero()
+	}
+
+	fn bool_to_u256(&self, val: bool) -> U256 {
+		if val {
+			U256::one()
+		} else {
+			U256::zero()
+		}
+	}
+
+	fn exec_stack_instruction(&self, instruction: Instruction, stack: &mut Stack<U256>) -> vm::Result<()> {
+		match instruction {
+			instructions::DUP1...instructions::DUP16 => {
+				let position = instructions::get_dup_position(instruction);
 				let val = stack.peek(position).clone();
 				stack.push(val);
 			},
-			instructions::SWAP1 | instructions::SWAP2 | instructions::SWAP3 | instructions::SWAP4 |
-			instructions::SWAP5 | instructions::SWAP6 | instructions::SWAP7 | instructions::SWAP8 |
-			instructions::SWAP9 | instructions::SWAP10 | instructions::SWAP11 | instructions::SWAP12 |
-			instructions::SWAP13 | instructions::SWAP14 | instructions::SWAP15 | instructions::SWAP16 => {
-				let position = instruction.swap_position().expect("swap_position always return some for SWAP* instructions");
+			instructions::SWAP1...instructions::SWAP16 => {
+				let position = instructions::get_swap_position(instruction);
 				stack.swap_with_top(position)
 			},
 			instructions::POP => {
@@ -879,60 +923,15 @@ impl<Cost: CostType> Interpreter<Cost> {
 				};
 				stack.push(result);
 			},
-		};
-		Ok(InstructionResult::Ok)
-	}
-
-	fn copy_data_to_memory(mem: &mut Vec<u8>, stack: &mut Stack<U256>, source: &[u8]) {
-		let dest_offset = stack.pop_back();
-		let source_offset = stack.pop_back();
-		let size = stack.pop_back();
-		let source_size = U256::from(source.len());
-
-		let output_end = match source_offset > source_size || size > source_size || source_offset + size > source_size {
-			true => {
-				let zero_slice = if source_offset > source_size {
-					mem.writeable_slice(dest_offset, size)
-				} else {
-					mem.writeable_slice(dest_offset + source_size - source_offset, source_offset + size - source_size)
-				};
-				for i in zero_slice.iter_mut() {
-					*i = 0;
-				}
-				source.len()
-			},
-			false => (size.low_u64() + source_offset.low_u64()) as usize
-		};
-
-		if source_offset < source_size {
-			let output_begin = source_offset.low_u64() as usize;
-			mem.write_slice(dest_offset, &source[output_begin..output_end]);
+			_ => {
+				return Err(vm::Error::BadInstruction {
+					instruction: instruction
+				});
+			}
 		}
+		Ok(())
 	}
 
-	fn verify_jump(&self, jump_u: U256, valid_jump_destinations: &BitSet) -> vm::Result<usize> {
-		let jump = jump_u.low_u64() as usize;
-
-		if valid_jump_destinations.contains(jump) && U256::from(jump) == jump_u {
-			Ok(jump)
-		} else {
-			Err(vm::Error::BadJumpDestination {
-				destination: jump
-			})
-		}
-	}
-
-	fn is_zero(&self, val: &U256) -> bool {
-		val.is_zero()
-	}
-
-	fn bool_to_u256(&self, val: bool) -> U256 {
-		if val {
-			U256::one()
-		} else {
-			U256::zero()
-		}
-	}
 }
 
 fn get_and_reset_sign(value: U256) -> (U256, bool) {

ethcore/evm/src/interpreter/shared_cache.rs

@@ -21,7 +21,7 @@ use ethereum_types::H256;
 use parking_lot::Mutex;
 use memory_cache::MemoryLruCache;
 use bit_set::BitSet;
-use super::super::instructions::{self, Instruction};
+use super::super::instructions;
 
 const DEFAULT_CACHE_SIZE: usize = 4 * 1024 * 1024;
 
@@ -70,14 +70,12 @@ impl SharedCache {
 		let mut position = 0;
 
 		while position < code.len() {
-			let instruction = Instruction::from_u8(code[position]);
+			let instruction = code[position];
 
-			if let Some(instruction) = instruction {
-				if instruction == instructions::JUMPDEST {
-					jump_dests.insert(position);
-				} else if let Some(push_bytes) = instruction.push_bytes() {
-					position += push_bytes;
-				}
+			if instruction == instructions::JUMPDEST {
+				jump_dests.insert(position);
+			} else if instructions::is_push(instruction) {
+				position += instructions::get_push_bytes(instruction);
 			}
 			position += 1;
 		}

ethcore/evm/src/lib.rs

@@ -43,7 +43,7 @@ mod instructions;
 
 #[cfg(test)]
 mod tests;
-#[cfg(all(feature = "benches", test))]
+#[cfg(all(feature="benches", test))]
 mod benches;
 
 pub use vm::{
@@ -52,6 +52,6 @@ pub use vm::{
     GasLeft, ReturnData
 };
 pub use self::evm::{Finalize, FinalizationResult, CostType};
-pub use self::instructions::{InstructionInfo, Instruction};
+pub use self::instructions::{InstructionInfo, INSTRUCTIONS, push_bytes};
 pub use self::vmtype::VMType;
 pub use self::factory::Factory;

ethcore/light/Cargo.toml

@@ -9,19 +9,18 @@ authors = ["Parity Technologies <admin@parity.io>"]
 [dependencies]
 log = "0.3"
 ethcore = { path = ".."}
-parity-bytes = { git = "https://github.com/paritytech/parity-common" }
+ethcore-bytes = { path = "../../util/bytes" }
 ethcore-transaction = { path = "../transaction" }
 ethereum-types = "0.3"
-memorydb = { git = "https://github.com/paritytech/parity-common" }
-patricia-trie = { git = "https://github.com/paritytech/parity-common" }
-patricia-trie-ethereum = { path = "../../util/patricia-trie-ethereum" }
+memorydb = { path = "../../util/memorydb" }
+patricia-trie = { path = "../../util/patricia_trie" }
 ethcore-network = { path = "../../util/network" }
 ethcore-io = { path = "../../util/io" }
-hashdb = { git = "https://github.com/paritytech/parity-common" }
+hashdb = { path = "../../util/hashdb" }
 heapsize = "0.4"
 vm = { path = "../vm" }
-plain_hasher = { git = "https://github.com/paritytech/parity-common" }
-rlp = { git = "https://github.com/paritytech/parity-common" }
+plain_hasher = { path = "../../util/plain_hasher" }
+rlp = { path = "../../util/rlp" }
 rlp_derive = { path = "../../util/rlp_derive" }
 smallvec = "0.4"
 futures = "0.1"
@@ -30,18 +29,16 @@ itertools = "0.5"
 bincode = "0.8.0"
 serde = "1.0"
 serde_derive = "1.0"
-parking_lot = "0.6"
+parking_lot = "0.5"
 stats = { path = "../../util/stats" }
-keccak-hash = { git = "https://github.com/paritytech/parity-common" }
-keccak-hasher = { path = "../../util/keccak-hasher" }
-triehash-ethereum = { version = "0.2",  path = "../../util/triehash-ethereum" }
-kvdb = { git = "https://github.com/paritytech/parity-common" }
+keccak-hash = { path = "../../util/hash" }
+triehash = { path = "../../util/triehash" }
+kvdb = { path = "../../util/kvdb" }
 memory-cache = { path = "../../util/memory_cache" }
-error-chain = { version = "0.12", default-features = false }
+error-chain = { version = "0.11", default-features = false }
 
 [dev-dependencies]
-ethcore = { path = "..", features = ["test-helpers"] }
-kvdb-memorydb = { git = "https://github.com/paritytech/parity-common" }
+kvdb-memorydb = { path = "../../util/kvdb-memorydb" }
 tempdir = "0.3"
 
 [features]