EIP-1186: add eth_getProof RPC-Method

rpc/src/v1/impls/eth.rs

@@ -21,12 +21,12 @@ use std::time::{Instant, Duration, SystemTime, UNIX_EPOCH};
 use std::sync::Arc;
 
 use rlp::Rlp;
-use ethereum_types::{U256, H256, Address};
+use ethereum_types::{U256, H256, H160, Address};
 use parking_lot::Mutex;
 
 use ethash::{self, SeedHashCompute};
 use ethcore::account_provider::AccountProvider;
-use ethcore::client::{BlockChainClient, BlockId, TransactionId, UncleId, StateOrBlock, StateClient, StateInfo, Call, EngineInfo};
+use ethcore::client::{BlockChainClient, BlockId, TransactionId, UncleId, StateOrBlock, StateClient, StateInfo, Call, EngineInfo, ProvingBlockChainClient};
 use ethcore::filter::Filter as EthcoreFilter;
 use ethcore::header::{BlockNumber as EthBlockNumber};
 use ethcore::miner::{self, MinerService};
@@ -35,6 +35,7 @@ use ethcore::encoded;
 use sync::SyncProvider;
 use miner::external::ExternalMinerService;
 use transaction::{SignedTransaction, LocalizedTransaction};
+use hash::keccak;
 
 use jsonrpc_core::{BoxFuture, Result};
 use jsonrpc_core::futures::future;
@@ -46,7 +47,7 @@ use v1::helpers::block_import::is_major_importing;
 use v1::traits::Eth;
 use v1::types::{
 	RichBlock, Block, BlockTransactions, BlockNumber, Bytes, SyncStatus, SyncInfo,
-	Transaction, CallRequest, Index, Filter, Log, Receipt, Work,
+	Transaction, CallRequest, Index, Filter, Log, Receipt, Work, EthAccount, StorageProof,
 	H64 as RpcH64, H256 as RpcH256, H160 as RpcH160, U256 as RpcU256, block_number_to_id,
 };
 use v1::metadata::Metadata;
@@ -452,7 +453,7 @@ fn check_known<C>(client: &C, number: BlockNumber) -> Result<()> where C: BlockC
 const MAX_QUEUE_SIZE_TO_MINE_ON: usize = 4;	// because uncles go back 6.
 
 impl<C, SN: ?Sized, S: ?Sized, M, EM, T: StateInfo + 'static> Eth for EthClient<C, SN, S, M, EM> where
-	C: miner::BlockChainClient + BlockChainClient + StateClient<State=T> + Call<State=T> + EngineInfo + 'static,
+  C: miner::BlockChainClient + StateClient<State=T> + ProvingBlockChainClient + Call<State=T> + EngineInfo + 'static,
 	SN: SnapshotService + 'static,
 	S: SyncProvider + 'static,
 	M: MinerService<State=T> + 'static,
@@ -545,6 +546,55 @@ impl<C, SN: ?Sized, S: ?Sized, M, EM, T: StateInfo + 'static> Eth for EthClient<
 		Box::new(future::done(res))
 	}
 
+	fn proof(&self, _address: RpcH160, values:Vec<RpcH256>, num: Trailing<BlockNumber>) -> BoxFuture<EthAccount> {
+		let a : H160 = _address.clone().into();
+		let key1 = keccak(a);
+
+		let num = num.unwrap_or_default();
+		let id = match num {
+			BlockNumber::Num(n) => BlockId::Number(n),
+			BlockNumber::Earliest => BlockId::Earliest,
+			BlockNumber::Latest => BlockId::Latest,
+			BlockNumber::Pending => {
+				warn!("`Pending` is deprecated and may be removed in future versions. Falling back to `Latest`");
+				BlockId::Latest
+			}
+		};
+
+		try_bf!(check_known(&*self.client, num.clone()));
+		let res = match self.client.prove_account(key1, id) {
+			Some(p) => Ok(EthAccount {
+				 address : _address.into(),
+				 balance : p.1.balance.into(),
+				 nonce : p.1.nonce.into(),
+				 code_hash : p.1.code_hash.into(),
+				 storage_hash : p.1.storage_root.into(),
+				 account_proof: Some(p.0.iter().map(|b| Bytes::new(b.clone())).collect::<Vec<Bytes>>()),
+				 storage_proof: Some(
+					 values.iter().map(|storage_index| { 
+						 let key2 : H256 = storage_index.clone().into();
+					   match self.client.prove_storage(key1, keccak(key2), id) {
+						  	Some(sp) =>  StorageProof {
+									key : key2.into(),
+									value: sp.1.into(),
+									proof: sp.0.iter().map(|b| Bytes::new(b.clone())).collect::<Vec<Bytes>>()
+								},
+							  None => StorageProof {
+									key : key2.into(),
+									value : 0.into(),
+									proof : Vec::new()
+								}
+				     }
+					 }).collect::<Vec<StorageProof>>()
+				 )
+			}),
+			None => Err(errors::state_pruned()),
+		};
+
+		Box::new(future::done(res))
+	}
+
+
 	fn storage_at(&self, address: RpcH160, pos: RpcU256, num: Trailing<BlockNumber>) -> BoxFuture<RpcH256> {
 		let address: Address = RpcH160::into(address);
 		let position: U256 = RpcU256::into(pos);

rpc/src/v1/impls/light/eth.rs

@@ -47,7 +47,7 @@ use v1::helpers::light_fetch::{self, LightFetch};
 use v1::traits::Eth;
 use v1::types::{
 	RichBlock, Block, BlockTransactions, BlockNumber, LightBlockNumber, Bytes, SyncStatus, SyncInfo,
-	Transaction, CallRequest, Index, Filter, Log, Receipt, Work,
+	Transaction, CallRequest, Index, Filter, Log, Receipt, Work,EthAccount,
 	H64 as RpcH64, H256 as RpcH256, H160 as RpcH160, U256 as RpcU256,
 };
 use v1::metadata::Metadata;
@@ -470,6 +470,12 @@ impl<T: LightChainClient + 'static> Eth for EthClient<T> {
 		}))
 	}
 
+
+	fn proof(&self, _address: RpcH160, _values:Vec<RpcH256>, _num: Trailing<BlockNumber>) -> BoxFuture<EthAccount> {
+		Box::new(future::err(errors::unimplemented(None)))
+	}
+
+
 	fn compilers(&self) -> Result<Vec<String>> {
 		Err(errors::deprecated("Compilation functionality is deprecated.".to_string()))
 	}

rpc/src/v1/traits/eth.rs

@@ -18,7 +18,7 @@
 use jsonrpc_core::{Result, BoxFuture};
 use jsonrpc_macros::Trailing;
 
-use v1::types::{RichBlock, BlockNumber, Bytes, CallRequest, Filter, FilterChanges, Index};
+use v1::types::{RichBlock, BlockNumber, Bytes, CallRequest, Filter, FilterChanges, Index, EthAccount};
 use v1::types::{Log, Receipt, SyncStatus, Transaction, Work};
 use v1::types::{H64, H160, H256, U256};
 
@@ -63,6 +63,10 @@ build_rpc_trait! {
 		#[rpc(name = "eth_getBalance")]
 		fn balance(&self, H160, Trailing<BlockNumber>) -> BoxFuture<U256>;
 
+		/// Returns balance of the given account.
+		#[rpc(name = "eth_getProof")]
+		fn proof(&self, H160, Vec<H256>, Trailing<BlockNumber>) -> BoxFuture<EthAccount>;
+
 		/// Returns content of the storage at given address.
 		#[rpc(name = "eth_getStorageAt")]
 		fn storage_at(&self, H160, U256, Trailing<BlockNumber>) -> BoxFuture<H256>;

rpc/src/v1/types/account_info.rs

@@ -13,13 +13,44 @@
 
 // You should have received a copy of the GNU General Public License
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+use v1::types::{ H160, H256, U256, Bytes};
 
 /// Account information.
 #[derive(Debug, Default, Clone, PartialEq, Serialize)]
 pub struct AccountInfo {
 	/// Account name
 	pub name: String,
 }
+/// Datastructure with proof for one single storage-entry
+#[derive(Debug, Default, Clone, PartialEq, Serialize)]
+pub struct StorageProof{
+	#[serde(rename="key")]
+	pub key: U256,
+	#[serde(rename="value")]
+	pub value: U256,
+	#[serde(rename="proof")]
+	pub proof: Vec<Bytes>
+}
+
+/// Account information.
+#[derive(Debug, Default, Clone, PartialEq, Serialize)]
+pub struct EthAccount{
+	#[serde(rename="address")]
+	pub address: H160,
+	#[serde(rename="balance")]
+	pub balance: U256,
+	#[serde(rename="nonce")]
+	pub nonce: U256,
+	#[serde(rename="codeHash")]
+	pub code_hash: H256,
+	#[serde(rename="storageHash")]
+	pub storage_hash: H256,
+  #[serde(rename="accountProof")]
+	pub account_proof: Option<Vec<Bytes>>,
+  #[serde(rename="storageProof")]
+	pub storage_proof: Option<Vec<StorageProof>>,
+
+}
 
 /// Extended account information (used by `parity_allAccountInfo`).
 #[derive(Debug, Default, Clone, PartialEq, Serialize)]

rpc/src/v1/types/mod.rs

@@ -46,7 +46,7 @@ mod private_receipt;
 
 pub mod pubsub;
 
-pub use self::account_info::{AccountInfo, ExtAccountInfo, HwAccountInfo};
+pub use self::account_info::{AccountInfo, ExtAccountInfo, HwAccountInfo, EthAccount, StorageProof};
 pub use self::bytes::Bytes;
 pub use self::block::{RichBlock, Block, BlockTransactions, Header, RichHeader, Rich};
 pub use self::block_number::{BlockNumber, LightBlockNumber, block_number_to_id};

scripts/docker/alpine/Dockerfile

@@ -33,7 +33,7 @@ RUN addgroup -g 1000 parity \
 
 USER parity
 
-EXPOSE 8080 8545 8180
+EXPOSE 5001 8080 8082 8083 8545 8546 8180 30303/tcp 30303/udp
 
 WORKDIR /home/parity