Merge branch 'master' into rh-grandpa-dynamic2

substrate/core/client/src/light/call_executor.rs

@@ -21,6 +21,7 @@ use std::marker::PhantomData;
 use std::sync::Arc;
 use futures::{IntoFuture, Future};
 
+use primitives::convert_hash;
 use runtime_primitives::generic::BlockId;
 use runtime_primitives::traits::{Block as BlockT, Header as HeaderT};
 use state_machine::{Backend as StateBackend, CodeExecutor, OverlayedChanges,
@@ -136,8 +137,7 @@ pub fn check_execution_proof<Header, E, H>(
 
 {
 	let local_state_root = request.header.state_root();
-	let mut root: H::Out = Default::default();
-	root.as_mut().copy_from_slice(local_state_root.as_ref());
+	let root: H::Out = convert_hash(&local_state_root);
 
 	let mut changes = OverlayedChanges::default();
 	let local_result = execution_proof_check::<H, _>(

substrate/core/client/src/light/fetcher.rs

@@ -21,10 +21,10 @@ use futures::IntoFuture;
 
 use hash_db::Hasher;
 use heapsize::HeapSizeOf;
-use primitives::ChangesTrieConfiguration;
+use primitives::{ChangesTrieConfiguration, convert_hash};
 use runtime_primitives::traits::{As, Block as BlockT, Header as HeaderT, NumberFor};
-use state_machine::{CodeExecutor, ChangesTrieRootsStorage, read_proof_check,
-	key_changes_proof_check};
+use state_machine::{CodeExecutor, ChangesTrieRootsStorage, ChangesTrieAnchorBlockId,
+	read_proof_check, key_changes_proof_check};
 
 use call_executor::CallResult;
 use cht;
@@ -192,9 +192,8 @@ impl<E, Block, H> FetchChecker<Block> for LightDataChecker<E, H>
 		request: &RemoteReadRequest<Block::Header>,
 		remote_proof: Vec<Vec<u8>>
 	) -> ClientResult<Option<Vec<u8>>> {
-		let mut root: H::Out = Default::default();
-		root.as_mut().copy_from_slice(request.header.state_root().as_ref());
-		read_proof_check::<H>(root, remote_proof, &request.key).map_err(Into::into)
+		read_proof_check::<H>(convert_hash(request.header.state_root()), remote_proof, &request.key)
+			.map_err(Into::into)
 	}
 
 	fn check_execution_proof(
@@ -229,7 +228,10 @@ impl<E, Block, H> FetchChecker<Block> for LightDataChecker<E, H>
 			},
 			remote_proof,
 			first_number,
-			request.last_block.0.as_(),
+			&ChangesTrieAnchorBlockId {
+				hash: convert_hash(&request.last_block.1),
+				number: request.last_block.0.as_(),
+			},
 			remote_max.as_(),
 			&request.key)
 		.map(|pairs| pairs.into_iter().map(|(b, x)| (As::sa(b), x)).collect())
@@ -248,15 +250,12 @@ impl<'a, H, Hash> ChangesTrieRootsStorage<H> for RootsStorage<'a, Hash>
 		H: Hasher,
 		Hash: 'a + Send + Sync + Clone + AsRef<[u8]>,
 {
-	fn root(&self, block: u64) -> Result<Option<H::Out>, String> {
+	fn root(&self, _anchor: &ChangesTrieAnchorBlockId<H::Out>, block: u64) -> Result<Option<H::Out>, String> {
+		// we can't ask for roots from parallel forks here => ignore anchor
 		Ok(block.checked_sub(self.first)
 			.and_then(|index| self.roots.get(index as usize))
 			.cloned()
-			.map(|root| {
-				let mut hasher_root: H::Out = Default::default();
-				hasher_root.as_mut().copy_from_slice(root.as_ref());
-				hasher_root
-			}))
+			.map(|root| convert_hash(&root)))
 	}
 }
 
@@ -478,7 +477,7 @@ pub mod tests {
 		assert!(local_checker.check_changes_proof(&request, remote_max + 1, remote_proof.clone()).is_err());
 
 		// check proof on local client using broken proof
-		remote_proof = local_roots_range.into_iter().map(|v| v.to_vec()).collect();
+		remote_proof = local_roots_range.into_iter().map(|v| v.as_bytes().to_vec()).collect();
 		assert!(local_checker.check_changes_proof(&request, remote_max, remote_proof).is_err());
 	}
 }

substrate/core/client/src/light/mod.rs

@@ -48,11 +48,11 @@ pub fn new_light_backend<B: BlockT, S: BlockchainStorage<B>, F: Fetcher<B>>(bloc
 }
 
 /// Create an instance of light client.
-pub fn new_light<B, S, F, GS>(
+pub fn new_light<B, S, F, GS, RA>(
 	backend: Arc<Backend<S, F>>,
 	fetcher: Arc<F>,
 	genesis_storage: GS,
-) -> ClientResult<Client<Backend<S, F>, RemoteCallExecutor<Blockchain<S, F>, F, Blake2Hasher>, B>>
+) -> ClientResult<Client<Backend<S, F>, RemoteCallExecutor<Blockchain<S, F>, F, Blake2Hasher>, B, RA>>
 where
 	B: BlockT<Hash=H256>,
 	S: BlockchainStorage<B>,