Implement PIP messages, request builder, and handlers (#4945)

* return errors on database corruption

* fix tests, json tests

* fix remainder of build

* buffer flow -> request credits

* proving state backend

* generate transaction proofs from provider

* network messages for transaction proof

* transaction proof test

* test for transaction proof message

* fix call bug

* request transaction proofs from on_demand

* most of proved_execution rpc

* proved execution future

* initial request definitions

* RLP encoding and decoding for requests

* proofs of non-existance in ProvingBlockChainClient

* new requests in provider.

* encode and decode responses

* complete initial request changes

* handle request packet in LightProtocol

* handle response packets

* implement requesting from

* re-do cost table

* get tests compiling

* fix cost table RLP encoding

* roundtrip tests for request types

* request builder tests

* move request_builder -> request::builder

* get network tests working

* return only complete headers responses

* request builder improvements

* New version of jsonrpc.

* split request filling into fill,complete

* Better invalid encoding messages

* Fixing deprecated methods of tokio_core

* use PIP messages in on_demand, old API

* migrate oneshot::complete to send in on_demand

* get on_demand tests to compile

* port ethsync to PIP messages

* adjust to minor on_demand API changes in RPC

* Using dedicated branch for jsonrpc

* Bump

ethcore/src/client/client.rs

@@ -1607,23 +1607,14 @@ impl MayPanic for Client {
 }
 
 impl ::client::ProvingBlockChainClient for Client {
-	fn prove_storage(&self, key1: H256, key2: H256, from_level: u32, id: BlockId) -> Vec<Bytes> {
+	fn prove_storage(&self, key1: H256, key2: H256, id: BlockId) -> Option<(Vec<Bytes>, H256)> {
 		self.state_at(id)
-			.and_then(move |state| state.prove_storage(key1, key2, from_level).ok())
-			.unwrap_or_else(Vec::new)
+			.and_then(move |state| state.prove_storage(key1, key2).ok())
 	}
 
-	fn prove_account(&self, key1: H256, from_level: u32, id: BlockId) -> Vec<Bytes> {
+	fn prove_account(&self, key1: H256, id: BlockId) -> Option<(Vec<Bytes>, ::types::basic_account::BasicAccount)> {
 		self.state_at(id)
-			.and_then(move |state| state.prove_account(key1, from_level).ok())
-			.unwrap_or_else(Vec::new)
-	}
-
-	fn code_by_hash(&self, account_key: H256, id: BlockId) -> Bytes {
-		self.state_at(id)
-			.and_then(move |state| state.code_by_address_hash(account_key).ok())
-			.and_then(|x| x)
-			.unwrap_or_else(Vec::new)
+			.and_then(move |state| state.prove_account(key1).ok())
 	}
 
 	fn prove_transaction(&self, transaction: SignedTransaction, id: BlockId) -> Option<Vec<DBValue>> {
@@ -1643,7 +1634,6 @@ impl ::client::ProvingBlockChainClient for Client {
 			_ => return Some(state.drop().1.extract_proof()),
 		}
 	}
-
 }
 
 impl Drop for Client {

ethcore/src/client/test_client.rs

@@ -38,6 +38,7 @@ use error::{ImportResult, Error as EthcoreError};
 use evm::{Factory as EvmFactory, VMType, Schedule};
 use miner::{Miner, MinerService, TransactionImportResult};
 use spec::Spec;
+use types::basic_account::BasicAccount;
 use types::mode::Mode;
 use types::pruning_info::PruningInfo;
 
@@ -758,16 +759,12 @@ impl BlockChainClient for TestBlockChainClient {
 }
 
 impl ProvingBlockChainClient for TestBlockChainClient {
-	fn prove_storage(&self, _: H256, _: H256, _: u32, _: BlockId) -> Vec<Bytes> {
-		Vec::new()
+	fn prove_storage(&self, _: H256, _: H256, _: BlockId) -> Option<(Vec<Bytes>, H256)> {
+		None
 	}
 
-	fn prove_account(&self, _: H256, _: u32, _: BlockId) -> Vec<Bytes> {
-		Vec::new()
-	}
-
-	fn code_by_hash(&self, _: H256, _: BlockId) -> Bytes {
-		Vec::new()
+	fn prove_account(&self, _: H256, _: BlockId) -> Option<(Vec<Bytes>, BasicAccount)> {
+		None
 	}
 
 	fn prove_transaction(&self, _: SignedTransaction, _: BlockId) -> Option<Vec<DBValue>> {

ethcore/src/client/traits.rs

@@ -34,6 +34,7 @@ use env_info::LastHashes;
 use block_import_error::BlockImportError;
 use ipc::IpcConfig;
 use types::ids::*;
+use types::basic_account::BasicAccount;
 use types::trace_filter::Filter as TraceFilter;
 use types::call_analytics::CallAnalytics;
 use types::blockchain_info::BlockChainInfo;
@@ -315,19 +316,12 @@ pub trait ProvingBlockChainClient: BlockChainClient {
 	///
 	/// Both provided keys assume a secure trie.
 	/// Returns a vector of raw trie nodes (in order from the root) proving the storage query.
-	/// Nodes after `from_level` may be omitted.
-	/// An empty vector indicates unservable query.
-	fn prove_storage(&self, key1: H256, key2: H256, from_level: u32, id: BlockId) -> Vec<Bytes>;
+	fn prove_storage(&self, key1: H256, key2: H256, id: BlockId) -> Option<(Vec<Bytes>, H256)>;
 
 	/// Prove account existence at a specific block id.
 	/// The key is the keccak hash of the account's address.
 	/// Returns a vector of raw trie nodes (in order from the root) proving the query.
-	/// Nodes after `from_level` may be omitted.
-	/// An empty vector indicates unservable query.
-	fn prove_account(&self, key1: H256, from_level: u32, id: BlockId) -> Vec<Bytes>;
-
-	/// Get code by address hash.
-	fn code_by_hash(&self, account_key: H256, id: BlockId) -> Bytes;
+	fn prove_account(&self, key1: H256, id: BlockId) -> Option<(Vec<Bytes>, BasicAccount)>;
 
 	/// Prove execution of a transaction at the given block.
 	fn prove_transaction(&self, transaction: SignedTransaction, id: BlockId) -> Option<Vec<DBValue>>;