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/state/account.rs

@@ -438,18 +438,19 @@ impl Account {
 	/// trie.
 	/// `storage_key` is the hash of the desired storage key, meaning
 	/// this will only work correctly under a secure trie.
-	/// Returns a merkle proof of the storage trie node with all nodes before `from_level`
-	/// omitted.
-	pub fn prove_storage(&self, db: &HashDB, storage_key: H256, from_level: u32) -> Result<Vec<Bytes>, Box<TrieError>> {
+	pub fn prove_storage(&self, db: &HashDB, storage_key: H256) -> Result<(Vec<Bytes>, H256), Box<TrieError>> {
 		use util::trie::{Trie, TrieDB};
 		use util::trie::recorder::Recorder;
 
-		let mut recorder = Recorder::with_depth(from_level);
+		let mut recorder = Recorder::new();
 
 		let trie = TrieDB::new(db, &self.storage_root)?;
-		let _ = trie.get_with(&storage_key, &mut recorder)?;
+		let item: U256 = {
+			let query = (&mut recorder, ::rlp::decode);
+			trie.get_with(&storage_key, query)?.unwrap_or_else(U256::zero)
+		};
 
-		Ok(recorder.drain().into_iter().map(|r| r.data).collect())
+		Ok((recorder.drain().into_iter().map(|r| r.data).collect(), item.into()))
 	}
 }
 

ethcore/src/state/mod.rs

@@ -31,6 +31,7 @@ use factory::Factories;
 use trace::FlatTrace;
 use pod_account::*;
 use pod_state::{self, PodState};
+use types::basic_account::BasicAccount;
 use types::executed::{Executed, ExecutionError};
 use types::state_diff::StateDiff;
 use transaction::SignedTransaction;
@@ -857,47 +858,43 @@ impl<B: Backend> State<B> {
 // State proof implementations; useful for light client protocols.
 impl<B: Backend> State<B> {
 	/// Prove an account's existence or nonexistence in the state trie.
-	/// Returns a merkle proof of the account's trie node with all nodes before `from_level`
-	/// omitted or an encountered trie error.
+	/// Returns a merkle proof of the account's trie node omitted or an encountered trie error.
+	/// If the account doesn't exist in the trie, prove that and return defaults.
 	/// Requires a secure trie to be used for accurate results.
 	/// `account_key` == sha3(address)
-	pub fn prove_account(&self, account_key: H256, from_level: u32) -> trie::Result<Vec<Bytes>> {
-		let mut recorder = Recorder::with_depth(from_level);
+	pub fn prove_account(&self, account_key: H256) -> trie::Result<(Vec<Bytes>, BasicAccount)> {
+		let mut recorder = Recorder::new();
 		let trie = TrieDB::new(self.db.as_hashdb(), &self.root)?;
-		trie.get_with(&account_key, &mut recorder)?;
+		let maybe_account: Option<BasicAccount> = {
+			let query = (&mut recorder, ::rlp::decode);
+			trie.get_with(&account_key, query)?
+		};
+		let account = maybe_account.unwrap_or_else(|| BasicAccount {
+			balance: 0.into(),
+			nonce: self.account_start_nonce,
+			code_hash: SHA3_EMPTY,
+			storage_root: ::util::sha3::SHA3_NULL_RLP,
+		});
 
-		Ok(recorder.drain().into_iter().map(|r| r.data).collect())
+		Ok((recorder.drain().into_iter().map(|r| r.data).collect(), account))
 	}
 
 	/// Prove an account's storage key's existence or nonexistence in the state.
-	/// Returns a merkle proof of the account's storage trie with all nodes before
-	/// `from_level` omitted. Requires a secure trie to be used for correctness.
+	/// Returns a merkle proof of the account's storage trie.
+	/// Requires a secure trie to be used for correctness.
 	/// `account_key` == sha3(address)
 	/// `storage_key` == sha3(key)
-	pub fn prove_storage(&self, account_key: H256, storage_key: H256, from_level: u32) -> trie::Result<Vec<Bytes>> {
+	pub fn prove_storage(&self, account_key: H256, storage_key: H256) -> trie::Result<(Vec<Bytes>, H256)> {
 		// TODO: probably could look into cache somehow but it's keyed by
 		// address, not sha3(address).
 		let trie = TrieDB::new(self.db.as_hashdb(), &self.root)?;
 		let acc = match trie.get_with(&account_key, Account::from_rlp)? {
 			Some(acc) => acc,
-			None => return Ok(Vec::new()),
+			None => return Ok((Vec::new(), H256::new())),
 		};
 
 		let account_db = self.factories.accountdb.readonly(self.db.as_hashdb(), account_key);
-		acc.prove_storage(account_db.as_hashdb(), storage_key, from_level)
-	}
-
-	/// Get code by address hash.
-	/// Only works when backed by a secure trie.
-	pub fn code_by_address_hash(&self, account_key: H256) -> trie::Result<Option<Bytes>> {
-		let trie = TrieDB::new(self.db.as_hashdb(), &self.root)?;
-		let mut acc = match trie.get_with(&account_key, Account::from_rlp)? {
-			Some(acc) => acc,
-			None => return Ok(None),
-		};
-
-		let account_db = self.factories.accountdb.readonly(self.db.as_hashdb(), account_key);
-		Ok(acc.cache_code(account_db.as_hashdb()).map(|c| (&*c).clone()))
+		acc.prove_storage(account_db.as_hashdb(), storage_key)
 	}
 }