Implement EIP234 block_hash for eth_getLogs (#9256)

* Implement EIP234

* Make filter conversion returns error if both blockHash and from/toBlock is found

This also changes PollFilter to store the EthFilter type, instead of the jsonrpc one, saving repeated conversion.

* Return error if block filtering target is not found in eth_getLogs

Use the old behavior (unwrap_or_default) for anywhere else.

* fix test: secret_store

* Fix weird indentation

* Make client log filter return error in case a block cannot be found

* Return blockId error in rpc

* test_client: allow return error on logs

* Add a mocked test for eth_getLogs error

* fix: should return error if from_block/to_block greater than best block number

* Add notes on pending

* Add comment for UNSUPPORTED_REQUEST

* Address grumbles

* Return err if from > to

rpc/src/v1/impls/eth.rs

@@ -708,11 +708,17 @@ impl<C, SN: ?Sized, S: ?Sized, M, EM, T: StateInfo + 'static> Eth for EthClient<
 
 	fn logs(&self, filter: Filter) -> BoxFuture<Vec<Log>> {
 		let include_pending = filter.to_block == Some(BlockNumber::Pending);
-		let filter: EthcoreFilter = filter.into();
-		let mut logs = self.client.logs(filter.clone())
-			.into_iter()
-			.map(From::from)
-			.collect::<Vec<Log>>();
+		let filter: EthcoreFilter = match filter.try_into() {
+			Ok(value) => value,
+			Err(err) => return Box::new(future::err(err)),
+		};
+		let mut logs = match self.client.logs(filter.clone()) {
+			Ok(logs) => logs
+				.into_iter()
+				.map(From::from)
+				.collect::<Vec<Log>>(),
+			Err(id) => return Box::new(future::err(errors::filter_block_not_found(id))),
+		};
 
 		if include_pending {
 			let best_block = self.client.chain_info().best_block_number;

rpc/src/v1/impls/eth_filter.rs

@@ -92,7 +92,7 @@ impl<C, M> Filterable for EthFilterClient<C, M> where
 	}
 
 	fn logs(&self, filter: EthcoreFilter) -> BoxFuture<Vec<Log>> {
-		Box::new(future::ok(self.client.logs(filter).into_iter().map(Into::into).collect()))
+		Box::new(future::ok(self.client.logs(filter).unwrap_or_default().into_iter().map(Into::into).collect()))
 	}
 
 	fn pending_logs(&self, block_number: u64, filter: &EthcoreFilter) -> Vec<Log> {
@@ -125,7 +125,7 @@ impl<C, M> Filterable for EthFilterClient<C, M> where
 			filter.from_block = BlockId::Hash(block_hash);
 			filter.to_block = filter.from_block;
 
-			self.client.logs(filter).into_iter().map(|log| {
+			self.client.logs(filter).unwrap_or_default().into_iter().map(|log| {
 				let mut log: Log = log.into();
 				log.log_type = "removed".into();
 				log.removed = true;
@@ -140,7 +140,13 @@ impl<T: Filterable + Send + Sync + 'static> EthFilter for T {
 	fn new_filter(&self, filter: Filter) -> Result<RpcU256> {
 		let mut polls = self.polls().lock();
 		let block_number = self.best_block_number();
-		let id = polls.create_poll(SyncPollFilter::new(PollFilter::Logs(block_number, None, Default::default(), filter)));
+		let include_pending = filter.to_block == Some(BlockNumber::Pending);
+		let filter = filter.try_into()?;
+		let id = polls.create_poll(SyncPollFilter::new(PollFilter::Logs {
+			block_number, filter, include_pending,
+			last_block_hash: None,
+			previous_logs: Default::default()
+		}));
 		Ok(id.into())
 	}
 
@@ -195,15 +201,17 @@ impl<T: Filterable + Send + Sync + 'static> EthFilter for T {
 				// return new hashes
 				Either::A(future::ok(FilterChanges::Hashes(new_hashes)))
 			},
-			PollFilter::Logs(ref mut block_number, ref mut last_block_hash, ref mut previous_logs, ref filter) => {
+			PollFilter::Logs {
+				ref mut block_number,
+				ref mut last_block_hash,
+				ref mut previous_logs,
+				ref filter,
+				include_pending,
+			} => {
 				// retrive the current block number
 				let current_number = self.best_block_number();
 
-				// check if we need to check pending hashes
-				let include_pending = filter.to_block == Some(BlockNumber::Pending);
-
-				// build appropriate filter
-				let mut filter: EthcoreFilter = filter.clone().into();
+				let mut filter = filter.clone();
 
 				// retrieve reorg logs
 				let (mut reorg, reorg_len) = last_block_hash.map_or_else(|| (Vec::new(), 0), |h| self.removed_logs(h, &filter));
@@ -250,21 +258,19 @@ impl<T: Filterable + Send + Sync + 'static> EthFilter for T {
 	}
 
 	fn filter_logs(&self, index: Index) -> BoxFuture<Vec<Log>> {
-		let filter = {
+		let (filter, include_pending) = {
 			let mut polls = self.polls().lock();
 
 			match polls.poll(&index.value()).and_then(|f| f.modify(|filter| match *filter {
-				PollFilter::Logs(.., ref filter) => Some(filter.clone()),
+				PollFilter::Logs { ref filter, include_pending, .. } =>
+					Some((filter.clone(), include_pending)),
 				_ => None,
 			})) {
-				Some(filter) => filter,
+				Some((filter, include_pending)) => (filter, include_pending),
 				None => return Box::new(future::err(errors::filter_not_found())),
 			}
 		};
 
-		let include_pending = filter.to_block == Some(BlockNumber::Pending);
-		let filter: EthcoreFilter = filter.into();
-
 		// fetch pending logs.
 		let pending = if include_pending {
 			let best_block = self.best_block_number();

rpc/src/v1/impls/eth_pubsub.rs

@@ -252,9 +252,9 @@ impl<C: BlockChainClient> ChainNotify for ChainNotificationHandler<C> {
 		self.notify_logs(route.route(), |filter, ex| {
 			match ex {
 				&ChainRouteType::Enacted =>
-					Ok(self.client.logs(filter).into_iter().map(Into::into).collect()),
+					Ok(self.client.logs(filter).unwrap_or_default().into_iter().map(Into::into).collect()),
 				&ChainRouteType::Retracted =>
-					Ok(self.client.logs(filter).into_iter().map(Into::into).map(|mut log: Log| {
+					Ok(self.client.logs(filter).unwrap_or_default().into_iter().map(Into::into).map(|mut log: Log| {
 						log.log_type = "removed".into();
 						log.removed = true;
 						log
@@ -283,8 +283,13 @@ impl<C: Send + Sync + 'static> EthPubSub for EthPubSubClient<C> {
 				errors::invalid_params("newHeads", "Expected no parameters.")
 			},
 			(pubsub::Kind::Logs, Some(pubsub::Params::Logs(filter))) => {
-				self.logs_subscribers.write().push(subscriber, filter.into());
-				return;
+				match filter.try_into() {
+					Ok(filter) => {
+						self.logs_subscribers.write().push(subscriber, filter);
+						return;
+					},
+					Err(err) => err,
+				}
 			},
 			(pubsub::Kind::Logs, _) => {
 				errors::invalid_params("logs", "Expected a filter object.")

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

@@ -502,8 +502,11 @@ impl<T: LightChainClient + 'static> Eth for EthClient<T> {
 	fn logs(&self, filter: Filter) -> BoxFuture<Vec<Log>> {
 		let limit = filter.limit;
 
-		Box::new(Filterable::logs(self, filter.into())
-			.map(move|logs| limit_logs(logs, limit)))
+		Box::new(
+			Filterable::logs(self, match filter.try_into() {
+				Ok(value) => value,
+				Err(err) => return Box::new(future::err(err)),
+			}).map(move |logs| limit_logs(logs, limit)))
 	}
 
 	fn work(&self, _timeout: Trailing<u64>) -> Result<Work> {