Merge branch 'master' into child_trie_w3_change

client/network/src/chain.rs

@@ -25,62 +25,11 @@ pub trait Client<Block: BlockT>: HeaderBackend<Block> + ProofProvider<Block> + B
 	+ BlockBackend<Block> + HeaderMetadata<Block, Error = Error> + Send + Sync
 {}
 
-	/// Get block status.
-	fn block_status(&self, id: &BlockId<Block>) -> Result<BlockStatus, Error>;
-
-	/// Get block hash by number.
-	fn block_hash(&self, block_number: NumberFor<Block>) -> Result<Option<Block::Hash>, Error>;
-
-	/// Get block header.
-	fn header(&self, id: &BlockId<Block>) -> Result<Option<Block::Header>, Error>;
-
-	/// Get block body.
-	fn body(&self, id: &BlockId<Block>) -> Result<Option<Vec<Block::Extrinsic>>, Error>;
-
-	/// Get block justification.
-	fn justification(&self, id: &BlockId<Block>) -> Result<Option<Justification>, Error>;
-
-	/// Get block header proof.
-	fn header_proof(&self, block_number: NumberFor<Block>)
-		-> Result<(Block::Header, StorageProof), Error>;
-
-	/// Get storage read execution proof.
-	fn read_proof(
-		&self,
-		block: &Block::Hash,
-		keys: &mut dyn Iterator<Item=&[u8]>,
-	) -> Result<StorageProof, Error>;
-
-	/// Get child storage read execution proof.
-	fn read_child_proof(
-		&self,
-		block: &Block::Hash,
-		child_info: &ChildInfo,
-		keys: &mut dyn Iterator<Item=&[u8]>,
-	) -> Result<StorageProof, Error>;
-
-	/// Get method execution proof.
-	fn execution_proof(
-		&self,
-		block: &Block::Hash,
-		method: &str,
-		data: &[u8],
-	) -> Result<(Vec<u8>, StorageProof), Error>;
-
-	/// Get key changes proof.
-	fn key_changes_proof(
-		&self,
-		first: Block::Hash,
-		last: Block::Hash,
-		min: Block::Hash,
-		max: Block::Hash,
-		storage_key: Option<&StorageKey>,
-		key: &StorageKey
-	) -> Result<ChangesProof<Block::Header>, Error>;
-
-	/// Returns `true` if the given `block` is a descendent of `base`.
-	fn is_descendent_of(&self, base: &Block::Hash, block: &Block::Hash) -> Result<bool, Error>;
-}
+impl<Block: BlockT, T> Client<Block> for T
+	where
+		T: HeaderBackend<Block> + ProofProvider<Block> + BlockIdTo<Block, Error = Error>
+			+ BlockBackend<Block> + HeaderMetadata<Block, Error = Error> + Send + Sync
+{}
 
 /// Finality proof provider.
 pub trait FinalityProofProvider<Block: BlockT>: Send + Sync {
@@ -93,98 +42,3 @@ impl<Block: BlockT> FinalityProofProvider<Block> for () {
 		Ok(None)
 	}
 }
-
-impl<B, E, Block, RA> Client<Block> for SubstrateClient<B, E, Block, RA> where
-	B: sc_client_api::backend::Backend<Block> + Send + Sync + 'static,
-	E: CallExecutor<Block> + Send + Sync + 'static,
-	Self: BlockImport<Block, Error=ConsensusError>,
-	Block: BlockT,
-	RA: Send + Sync
-{
-	fn info(&self) -> BlockchainInfo<Block> {
-		(self as &SubstrateClient<B, E, Block, RA>).chain_info()
-	}
-
-	fn block_status(&self, id: &BlockId<Block>) -> Result<BlockStatus, Error> {
-		(self as &SubstrateClient<B, E, Block, RA>).block_status(id)
-	}
-
-	fn block_hash(
-		&self,
-		block_number: <Block::Header as HeaderT>::Number,
-	) -> Result<Option<Block::Hash>, Error> {
-		(self as &SubstrateClient<B, E, Block, RA>).block_hash(block_number)
-	}
-
-	fn header(&self, id: &BlockId<Block>) -> Result<Option<Block::Header>, Error> {
-		(self as &SubstrateClient<B, E, Block, RA>).header(id)
-	}
-
-	fn body(&self, id: &BlockId<Block>) -> Result<Option<Vec<Block::Extrinsic>>, Error> {
-		(self as &SubstrateClient<B, E, Block, RA>).body(id)
-	}
-
-	fn justification(&self, id: &BlockId<Block>) -> Result<Option<Justification>, Error> {
-		(self as &SubstrateClient<B, E, Block, RA>).justification(id)
-	}
-
-	fn header_proof(
-		&self,
-		block_number: <Block::Header as HeaderT>::Number,
-	)-> Result<(Block::Header, StorageProof), Error> {
-		ProofProvider::<Block>::header_proof(self, &BlockId::Number(block_number))
-	}
-
-	fn read_proof(
-		&self,
-		block: &Block::Hash,
-		keys: &mut dyn Iterator<Item=&[u8]>,
-	) -> Result<StorageProof, Error> {
-		ProofProvider::<Block>::read_proof(self, &BlockId::Hash(block.clone()), keys)
-	}
-
-	fn read_child_proof(
-		&self,
-		block: &Block::Hash,
-		child_info: &ChildInfo,
-		keys: &mut dyn Iterator<Item=&[u8]>,
-	) -> Result<StorageProof, Error> {
-		ProofProvider::<Block>::read_child_proof(self, &BlockId::Hash(block.clone()), child_info, keys)
-	}
-
-	fn execution_proof(
-		&self,
-		block: &Block::Hash,
-		method: &str,
-		data: &[u8],
-	) -> Result<(Vec<u8>, StorageProof), Error> {
-		ProofProvider::<Block>::execution_proof(
-			self,
-			&BlockId::Hash(block.clone()),
-			method,
-			data,
-		)
-	}
-
-	fn key_changes_proof(
-		&self,
-		first: Block::Hash,
-		last: Block::Hash,
-		min: Block::Hash,
-		max: Block::Hash,
-		storage_key: Option<&StorageKey>,
-		key: &StorageKey,
-	) -> Result<ChangesProof<Block::Header>, Error> {
-		ProofProvider::<Block>::key_changes_proof(self, first, last, min, max, storage_key, key)
-	}
-
-	fn is_descendent_of(&self, base: &Block::Hash, block: &Block::Hash) -> Result<bool, Error> {
-		if base == block {
-			return Ok(false);
-		}
-
-		let ancestor = sp_blockchain::lowest_common_ancestor(self, *block, *base)?;
-
-		Ok(ancestor.hash == *base)
-	}
-}

client/network/src/protocol.rs

@@ -1603,6 +1603,7 @@ impl<B: BlockT, H: ExHashT> Protocol<B, H> {
 
 		trace!(target: "sync", "Remote read child request {} from {} ({} {} at {})",
 			request.id, who, request.storage_key.to_hex::<String>(), keys_str(), request.block);
+<<<<<<< HEAD
 		let child_info = match ChildType::from_prefixed_key(&request.storage_key) {
 			Some((ChildType::ParentKeyId, storage_key)) => Ok(ChildInfo::new_default(storage_key)),
 			None => Err("Invalid child storage key".into()),
@@ -1623,6 +1624,27 @@ impl<B: BlockT, H: ExHashT> Protocol<B, H> {
 					error
 				);
 				StorageProof::empty()
+=======
+		let proof = if let Some(child_info) = ChildInfo::resolve_child_info(request.child_type, &request.child_info[..]) {
+			match self.context_data.chain.read_child_proof(
+				&BlockId::Hash(request.block),
+				&request.storage_key,
+				child_info,
+				&mut request.keys.iter().map(AsRef::as_ref),
+			) {
+				Ok(proof) => proof,
+				Err(error) => {
+					trace!(target: "sync", "Remote read child request {} from {} ({} {} at {}) failed with: {}",
+						request.id,
+						who,
+						request.storage_key.to_hex::<String>(),
+						keys_str(),
+						request.block,
+						error
+					);
+					StorageProof::empty()
+				}
+>>>>>>> master
 			}
 		};
 		self.send_message(

client/network/src/protocol/light_client_handler.rs

@@ -515,7 +515,7 @@ where
 			None => Err("Invalid child storage key".into()),
 		};
 		let proof =	match child_info.and_then(|child_info| self.chain.read_child_proof(
-			&block,
+			&BlockId::Hash(block),
 			&child_info,
 			&mut request.keys.iter().map(AsRef::as_ref)
 		)) {

primitives/state-machine/src/ext.rs

@@ -561,7 +561,6 @@ mod tests {
 	type TestBackend = InMemoryBackend<Blake2Hasher>;
 	type TestExt<'a> = Ext<'a, Blake2Hasher, u64, TestBackend>;
 
-
 	fn prepare_overlay_with_changes() -> OverlayedChanges {
 		OverlayedChanges {
 			prospective: vec![