Adding Bridges code as git subtree. (#2515)

* Add instructions.

* Squashed 'bridges/' content from commit 345e84a21

git-subtree-dir: bridges
git-subtree-split: 345e84a2146b56628e9888c9f5e129cb40e868a9

* Remove bridges workspace file to avoid confusing Cargo.

* Add some bridges primitives to Polkadot workspace.

* Improve docs.

polkadot/bridges/relays/substrate/src/headers_target.rs

@@ -0,0 +1,168 @@
+// Copyright 2019-2020 Parity Technologies (UK) Ltd.
+// This file is part of Parity Bridges Common.
+
+// Parity Bridges Common is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity Bridges Common is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity Bridges Common.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Substrate client as Substrate headers target. The chain we connect to should have
+//! runtime that implements `<BridgedChainName>HeaderApi` to allow bridging with
+//! <BridgedName> chain.
+
+use crate::headers_pipeline::SubstrateHeadersSyncPipeline;
+
+use async_trait::async_trait;
+use codec::{Decode, Encode};
+use futures::TryFutureExt;
+use headers_relay::{
+	sync_loop::TargetClient,
+	sync_types::{HeaderIdOf, QueuedHeader, SubmittedHeaders},
+};
+use relay_substrate_client::{Chain, Client, Error as SubstrateError};
+use relay_utils::{relay_loop::Client as RelayClient, HeaderId};
+use sp_core::Bytes;
+use sp_runtime::Justification;
+use std::collections::HashSet;
+
+/// Substrate client as Substrate headers target.
+pub struct SubstrateHeadersTarget<C: Chain, P> {
+	client: Client<C>,
+	pipeline: P,
+}
+
+impl<C: Chain, P> SubstrateHeadersTarget<C, P> {
+	/// Create new Substrate headers target.
+	pub fn new(client: Client<C>, pipeline: P) -> Self {
+		SubstrateHeadersTarget { client, pipeline }
+	}
+}
+
+impl<C: Chain, P: SubstrateHeadersSyncPipeline> Clone for SubstrateHeadersTarget<C, P> {
+	fn clone(&self) -> Self {
+		SubstrateHeadersTarget {
+			client: self.client.clone(),
+			pipeline: self.pipeline.clone(),
+		}
+	}
+}
+
+#[async_trait]
+impl<C: Chain, P: SubstrateHeadersSyncPipeline> RelayClient for SubstrateHeadersTarget<C, P> {
+	type Error = SubstrateError;
+
+	async fn reconnect(&mut self) -> Result<(), SubstrateError> {
+		self.client.reconnect().await
+	}
+}
+
+#[async_trait]
+impl<C, P> TargetClient<P> for SubstrateHeadersTarget<C, P>
+where
+	C: Chain,
+	P::Number: Decode,
+	P::Hash: Decode + Encode,
+	P: SubstrateHeadersSyncPipeline<Completion = Justification, Extra = ()>,
+{
+	async fn best_header_id(&self) -> Result<HeaderIdOf<P>, SubstrateError> {
+		// we can't continue to relay headers if target node is out of sync, because
+		// it may have already received (some of) headers that we're going to relay
+		self.client.ensure_synced().await?;
+
+		let call = P::BEST_BLOCK_METHOD.into();
+		let data = Bytes(Vec::new());
+
+		let encoded_response = self.client.state_call(call, data, None).await?;
+		let decoded_response: Vec<(P::Number, P::Hash)> =
+			Decode::decode(&mut &encoded_response.0[..]).map_err(SubstrateError::ResponseParseFailed)?;
+
+		// If we parse an empty list of headers it means that bridge pallet has not been initalized
+		// yet. Otherwise we expect to always have at least one header.
+		decoded_response
+			.last()
+			.ok_or(SubstrateError::UninitializedBridgePallet)
+			.map(|(num, hash)| HeaderId(*num, *hash))
+	}
+
+	async fn is_known_header(&self, id: HeaderIdOf<P>) -> Result<(HeaderIdOf<P>, bool), SubstrateError> {
+		let call = P::IS_KNOWN_BLOCK_METHOD.into();
+		let data = Bytes(id.1.encode());
+
+		let encoded_response = self.client.state_call(call, data, None).await?;
+		let is_known_block: bool =
+			Decode::decode(&mut &encoded_response.0[..]).map_err(SubstrateError::ResponseParseFailed)?;
+
+		Ok((id, is_known_block))
+	}
+
+	async fn submit_headers(
+		&self,
+		mut headers: Vec<QueuedHeader<P>>,
+	) -> SubmittedHeaders<HeaderIdOf<P>, SubstrateError> {
+		debug_assert_eq!(
+			headers.len(),
+			1,
+			"Substrate pallet only supports single header / transaction"
+		);
+
+		let header = headers.remove(0);
+		let id = header.id();
+		let submit_transaction_result = self
+			.pipeline
+			.make_submit_header_transaction(header)
+			.and_then(|tx| self.client.submit_extrinsic(Bytes(tx.encode())))
+			.await;
+
+		match submit_transaction_result {
+			Ok(_) => SubmittedHeaders {
+				submitted: vec![id],
+				incomplete: Vec::new(),
+				rejected: Vec::new(),
+				fatal_error: None,
+			},
+			Err(error) => SubmittedHeaders {
+				submitted: Vec::new(),
+				incomplete: Vec::new(),
+				rejected: vec![id],
+				fatal_error: Some(error),
+			},
+		}
+	}
+
+	async fn incomplete_headers_ids(&self) -> Result<HashSet<HeaderIdOf<P>>, SubstrateError> {
+		let call = P::INCOMPLETE_HEADERS_METHOD.into();
+		let data = Bytes(Vec::new());
+
+		let encoded_response = self.client.state_call(call, data, None).await?;
+		let decoded_response: Vec<(P::Number, P::Hash)> =
+			Decode::decode(&mut &encoded_response.0[..]).map_err(SubstrateError::ResponseParseFailed)?;
+
+		let incomplete_headers = decoded_response
+			.into_iter()
+			.map(|(number, hash)| HeaderId(number, hash))
+			.collect();
+		Ok(incomplete_headers)
+	}
+
+	async fn complete_header(
+		&self,
+		id: HeaderIdOf<P>,
+		completion: Justification,
+	) -> Result<HeaderIdOf<P>, SubstrateError> {
+		let tx = self.pipeline.make_complete_header_transaction(id, completion).await?;
+		self.client.submit_extrinsic(Bytes(tx.encode())).await?;
+		Ok(id)
+	}
+
+	async fn requires_extra(&self, header: QueuedHeader<P>) -> Result<(HeaderIdOf<P>, bool), SubstrateError> {
+		Ok((header.id(), false))
+	}
+}