Extract (headers, exchange, messages) relay loops into separate crates (#357)

* extracted relay crates

* moved metrics to utils

* exchange-relay compilation

* fix compilation of headers-relay

* fixed messages-relay compilation

* fixed ethereum-poa-relay compilation

* cargo lock

* cargo fmt --all

* clippy

* cargo fmt --all

* fix tests compilation

* clippy

* eof

* module level docs

* removed obsolete comment

* #![warn(missing_docs)]

* .0 -> Deref

* post-merge fix

* cargo fmt

* Update relays/headers-relay/src/headers.rs

Co-authored-by: Hernando Castano <HCastano@users.noreply.github.com>

* Update relays/headers-relay/src/headers.rs

Co-authored-by: Hernando Castano <HCastano@users.noreply.github.com>

* Update relays/headers-relay/src/lib.rs

Co-authored-by: Hernando Castano <HCastano@users.noreply.github.com>

Co-authored-by: Hernando Castano <HCastano@users.noreply.github.com>

bridges/relays/ethereum/src/ethereum_client.rs

@@ -21,17 +21,16 @@ use crate::ethereum_types::{
 use crate::rpc::{Ethereum, EthereumRpc};
 use crate::rpc_errors::{EthereumNodeError, RpcError};
 use crate::substrate_types::{GrandpaJustification, Hash as SubstrateHash, QueuedSubstrateHeader, SubstrateHeaderId};
-use crate::sync_types::SubmittedHeaders;
-use crate::utils::{HeaderId, MaybeConnectionError};
 
 use async_trait::async_trait;
 use codec::{Decode, Encode};
 use ethabi::FunctionOutputDecoder;
+use headers_relay::sync_types::SubmittedHeaders;
 use jsonrpsee::raw::RawClient;
 use jsonrpsee::transport::http::HttpTransportClient;
 use jsonrpsee::Client;
 use parity_crypto::publickey::KeyPair;
-
+use relay_utils::{HeaderId, MaybeConnectionError};
 use std::collections::HashSet;
 
 // to encode/decode contract calls
@@ -693,17 +692,20 @@ mod tests {
 	}
 
 	fn header(number: SubstrateBlockNumber) -> QueuedSubstrateHeader {
-		QueuedSubstrateHeader::new(SubstrateHeader::new(
-			number,
-			Default::default(),
-			Default::default(),
-			if number == 0 {
-				Default::default()
-			} else {
-				header(number - 1).id().1
-			},
-			Default::default(),
-		))
+		QueuedSubstrateHeader::new(
+			SubstrateHeader::new(
+				number,
+				Default::default(),
+				Default::default(),
+				if number == 0 {
+					Default::default()
+				} else {
+					header(number - 1).id().1
+				},
+				Default::default(),
+			)
+			.into(),
+		)
 	}
 
 	#[test]

bridges/relays/ethereum/src/ethereum_deploy_contract.rs

@@ -21,10 +21,10 @@ use crate::instances::BridgeInstance;
 use crate::rpc::SubstrateRpc;
 use crate::substrate_client::{SubstrateConnectionParams, SubstrateRpcClient};
 use crate::substrate_types::{Hash as SubstrateHash, Header as SubstrateHeader, SubstrateHeaderId};
-use crate::utils::HeaderId;
 
 use codec::{Decode, Encode};
 use num_traits::Zero;
+use relay_utils::HeaderId;
 
 /// Ethereum synchronization parameters.
 #[derive(Debug)]

bridges/relays/ethereum/src/ethereum_exchange.rs

@@ -21,23 +21,22 @@ use crate::ethereum_types::{
 	EthereumHeaderId, HeaderWithTransactions as EthereumHeaderWithTransactions, Transaction as EthereumTransaction,
 	TransactionHash as EthereumTransactionHash, H256,
 };
-use crate::exchange::{
-	relay_single_transaction_proof, SourceBlock, SourceClient, SourceTransaction, TargetClient,
-	TransactionProofPipeline,
-};
-use crate::exchange_loop::{run as run_loop, InMemoryStorage};
 use crate::instances::BridgeInstance;
-use crate::metrics::MetricsParams;
 use crate::rpc::{EthereumRpc, SubstrateRpc};
 use crate::rpc_errors::RpcError;
 use crate::substrate_client::{
 	SubmitEthereumExchangeTransactionProof, SubstrateConnectionParams, SubstrateRpcClient, SubstrateSigningParams,
 };
 use crate::substrate_types::into_substrate_ethereum_receipt;
-use crate::utils::HeaderId;
 
 use async_trait::async_trait;
 use bp_currency_exchange::MaybeLockFundsTransaction;
+use exchange_relay::exchange::{
+	relay_single_transaction_proof, SourceBlock, SourceClient, SourceTransaction, TargetClient,
+	TransactionProofPipeline,
+};
+use exchange_relay::exchange_loop::{run as run_loop, InMemoryStorage};
+use relay_utils::{metrics::MetricsParams, HeaderId};
 use rialto_runtime::exchange::EthereumTransactionInclusionProof;
 use std::time::Duration;
 

bridges/relays/ethereum/src/ethereum_sync_loop.rs

@@ -17,20 +17,24 @@
 //! Ethereum PoA -> Substrate synchronization.
 
 use crate::ethereum_client::{EthereumConnectionParams, EthereumHighLevelRpc, EthereumRpcClient};
-use crate::ethereum_types::{EthereumHeaderId, EthereumHeadersSyncPipeline, Header, QueuedEthereumHeader, Receipt};
+use crate::ethereum_types::{
+	EthereumHeaderId, EthereumHeadersSyncPipeline, EthereumSyncHeader as Header, QueuedEthereumHeader, Receipt,
+};
 use crate::instances::BridgeInstance;
-use crate::metrics::MetricsParams;
 use crate::rpc::{EthereumRpc, SubstrateRpc};
 use crate::rpc_errors::RpcError;
 use crate::substrate_client::{
 	SubmitEthereumHeaders, SubstrateConnectionParams, SubstrateRpcClient, SubstrateSigningParams,
 };
 use crate::substrate_types::into_substrate_ethereum_header;
-use crate::sync::{HeadersSyncParams, TargetTransactionMode};
-use crate::sync_loop::{SourceClient, TargetClient};
-use crate::sync_types::{SourceHeader, SubmittedHeaders};
 
 use async_trait::async_trait;
+use headers_relay::{
+	sync::{HeadersSyncParams, TargetTransactionMode},
+	sync_loop::{SourceClient, TargetClient},
+	sync_types::{SourceHeader, SubmittedHeaders},
+};
+use relay_utils::metrics::MetricsParams;
 use web3::types::H256;
 
 use std::fmt::Debug;
@@ -95,11 +99,11 @@ impl SourceClient<EthereumHeadersSyncPipeline> for EthereumHeadersSource {
 	}
 
 	async fn header_by_hash(&self, hash: H256) -> Result<Header, Self::Error> {
-		self.client.header_by_hash(hash).await
+		self.client.header_by_hash(hash).await.map(Into::into)
 	}
 
 	async fn header_by_number(&self, number: u64) -> Result<Header, Self::Error> {
-		self.client.header_by_number(number).await
+		self.client.header_by_number(number).await.map(Into::into)
 	}
 
 	async fn header_completion(&self, id: EthereumHeaderId) -> Result<(EthereumHeaderId, Option<()>), Self::Error> {
@@ -199,7 +203,7 @@ pub fn run(params: EthereumSyncParams) -> Result<(), RpcError> {
 	let source = EthereumHeadersSource::new(eth_client);
 	let target = SubstrateHeadersTarget::new(sub_client, sign_sub_transactions, sub_sign);
 
-	crate::sync_loop::run(
+	headers_relay::sync_loop::run(
 		source,
 		consts::ETHEREUM_TICK_INTERVAL,
 		target,

bridges/relays/ethereum/src/ethereum_types.rs

@@ -15,9 +15,10 @@
 // along with Parity Bridges Common.  If not, see <http://www.gnu.org/licenses/>.
 
 use crate::substrate_types::{into_substrate_ethereum_header, into_substrate_ethereum_receipts};
-use crate::sync_types::{HeadersSyncPipeline, QueuedHeader, SourceHeader};
-use crate::utils::HeaderId;
+
 use codec::Encode;
+use headers_relay::sync_types::{HeadersSyncPipeline, QueuedHeader, SourceHeader};
+use relay_utils::HeaderId;
 
 pub use web3::types::{Address, Bytes, CallRequest, H256, U128, U256, U64};
 
@@ -34,6 +35,17 @@ pub type Transaction = web3::types::Transaction;
 /// Ethereum header type.
 pub type Header = web3::types::Block<H256>;
 
+/// Ethereum header type used in headers sync.
+#[derive(Clone, Debug, PartialEq)]
+pub struct EthereumSyncHeader(Header);
+
+impl std::ops::Deref for EthereumSyncHeader {
+	type Target = Header;
+	fn deref(&self) -> &Self::Target {
+		&self.0
+	}
+}
+
 /// Ethereum header with transactions type.
 pub type HeaderWithTransactions = web3::types::Block<Transaction>;
 
@@ -60,7 +72,7 @@ impl HeadersSyncPipeline for EthereumHeadersSyncPipeline {
 
 	type Hash = H256;
 	type Number = u64;
-	type Header = Header;
+	type Header = EthereumSyncHeader;
 	type Extra = Vec<Receipt>;
 	type Completion = ();
 
@@ -72,7 +84,13 @@ impl HeadersSyncPipeline for EthereumHeadersSyncPipeline {
 	}
 }
 
-impl SourceHeader<H256, u64> for Header {
+impl From<Header> for EthereumSyncHeader {
+	fn from(header: Header) -> Self {
+		Self(header)
+	}
+}
+
+impl SourceHeader<H256, u64> for EthereumSyncHeader {
 	fn id(&self) -> EthereumHeaderId {
 		HeaderId(
 			self.number.expect(HEADER_ID_PROOF).as_u64(),

bridges/relays/ethereum/src/exchange.rs

@@ -1,898 +0,0 @@
-// 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/>.
-
-//! Relaying proofs of exchange transaction.
-
-use crate::utils::{MaybeConnectionError, StringifiedMaybeConnectionError};
-
-use async_trait::async_trait;
-use std::{
-	fmt::{Debug, Display},
-	string::ToString,
-};
-
-/// Transaction proof pipeline.
-pub trait TransactionProofPipeline {
-	/// Name of the transaction proof source.
-	const SOURCE_NAME: &'static str;
-	/// Name of the transaction proof target.
-	const TARGET_NAME: &'static str;
-
-	/// Block type.
-	type Block: SourceBlock;
-	/// Transaction inclusion proof type.
-	type TransactionProof;
-}
-
-/// Block that is participating in exchange.
-pub trait SourceBlock {
-	/// Block hash type.
-	type Hash: Clone + Debug + Display;
-	/// Block number type.
-	type Number: Debug
-		+ Display
-		+ Clone
-		+ Copy
-		+ Into<u64>
-		+ std::cmp::Ord
-		+ std::ops::Add<Output = Self::Number>
-		+ num_traits::One;
-	/// Block transaction.
-	type Transaction: SourceTransaction;
-
-	/// Return hash of the block.
-	fn id(&self) -> crate::utils::HeaderId<Self::Hash, Self::Number>;
-	/// Return block transactions iterator.
-	fn transactions(&self) -> Vec<Self::Transaction>;
-}
-
-/// Transaction that is participating in exchange.
-pub trait SourceTransaction {
-	/// Transaction hash type.
-	type Hash: Debug + Display;
-
-	/// Return transaction hash.
-	fn hash(&self) -> Self::Hash;
-}
-
-/// Block hash for given pipeline.
-pub type BlockHashOf<P> = <<P as TransactionProofPipeline>::Block as SourceBlock>::Hash;
-
-/// Block number for given pipeline.
-pub type BlockNumberOf<P> = <<P as TransactionProofPipeline>::Block as SourceBlock>::Number;
-
-/// Transaction hash for given pipeline.
-pub type TransactionOf<P> = <<P as TransactionProofPipeline>::Block as SourceBlock>::Transaction;
-
-/// Transaction hash for given pipeline.
-pub type TransactionHashOf<P> = <TransactionOf<P> as SourceTransaction>::Hash;
-
-/// Header id.
-pub type HeaderId<P> = crate::utils::HeaderId<BlockHashOf<P>, BlockNumberOf<P>>;
-
-/// Source client API.
-#[async_trait]
-pub trait SourceClient<P: TransactionProofPipeline> {
-	/// Error type.
-	type Error: Debug + MaybeConnectionError;
-
-	/// Sleep until exchange-related data is (probably) updated.
-	async fn tick(&self);
-	/// Get block by hash.
-	async fn block_by_hash(&self, hash: BlockHashOf<P>) -> Result<P::Block, Self::Error>;
-	/// Get canonical block by number.
-	async fn block_by_number(&self, number: BlockNumberOf<P>) -> Result<P::Block, Self::Error>;
-	/// Return block + index where transaction has been **mined**. May return `Ok(None)` if transaction
-	/// is unknown to the source node.
-	async fn transaction_block(&self, hash: &TransactionHashOf<P>)
-		-> Result<Option<(HeaderId<P>, usize)>, Self::Error>;
-	/// Prepare transaction proof.
-	async fn transaction_proof(&self, block: &P::Block, tx_index: usize) -> Result<P::TransactionProof, Self::Error>;
-}
-
-/// Target client API.
-#[async_trait]
-pub trait TargetClient<P: TransactionProofPipeline> {
-	/// Error type.
-	type Error: Debug + MaybeConnectionError;
-
-	/// Sleep until exchange-related data is (probably) updated.
-	async fn tick(&self);
-	/// Returns `Ok(true)` if header is known to the target node.
-	async fn is_header_known(&self, id: &HeaderId<P>) -> Result<bool, Self::Error>;
-	/// Returns `Ok(true)` if header is finalized by the target node.
-	async fn is_header_finalized(&self, id: &HeaderId<P>) -> Result<bool, Self::Error>;
-	/// Returns best finalized header id.
-	async fn best_finalized_header_id(&self) -> Result<HeaderId<P>, Self::Error>;
-	/// Returns `Ok(true)` if transaction proof is need to be relayed.
-	async fn filter_transaction_proof(&self, proof: &P::TransactionProof) -> Result<bool, Self::Error>;
-	/// Submits transaction proof to the target node.
-	async fn submit_transaction_proof(&self, proof: P::TransactionProof) -> Result<(), Self::Error>;
-}
-
-/// Block transaction statistics.
-#[derive(Debug, Default)]
-#[cfg_attr(test, derive(PartialEq))]
-pub struct RelayedBlockTransactions {
-	/// Total number of transactions processed (either relayed or ignored) so far.
-	pub processed: usize,
-	/// Total number of transactions successfully relayed so far.
-	pub relayed: usize,
-	/// Total number of transactions that we have failed to relay so far.
-	pub failed: usize,
-}
-
-/// Relay all suitable transactions from single block.
-///
-/// If connection error occurs, returns Err with number of successfully processed transactions.
-/// If some other error occurs, it is ignored and other transactions are processed.
-///
-/// All transaction-level traces are written by this function. This function is not tracing
-/// any information about block.
-pub async fn relay_block_transactions<P: TransactionProofPipeline>(
-	source_client: &impl SourceClient<P>,
-	target_client: &impl TargetClient<P>,
-	source_block: &P::Block,
-	mut relayed_transactions: RelayedBlockTransactions,
-) -> Result<RelayedBlockTransactions, RelayedBlockTransactions> {
-	let transactions_to_process = source_block
-		.transactions()
-		.into_iter()
-		.enumerate()
-		.skip(relayed_transactions.processed);
-	for (source_tx_index, source_tx) in transactions_to_process {
-		let result = async {
-			let source_tx_id = format!("{}/{}", source_block.id().1, source_tx_index);
-			let source_tx_proof =
-				prepare_transaction_proof(source_client, &source_tx_id, source_block, source_tx_index).await?;
-
-			let needs_to_be_relayed =
-				target_client
-					.filter_transaction_proof(&source_tx_proof)
-					.await
-					.map_err(|err| {
-						StringifiedMaybeConnectionError::new(
-							err.is_connection_error(),
-							format!("Transaction filtering has failed with {:?}", err),
-						)
-					})?;
-
-			if !needs_to_be_relayed {
-				return Ok(false);
-			}
-
-			relay_ready_transaction_proof(target_client, &source_tx_id, source_tx_proof)
-				.await
-				.map(|_| true)
-		}
-		.await;
-
-		// We have two options here:
-		// 1) retry with the same transaction later;
-		// 2) report error and proceed with next transaction.
-		//
-		// Option#1 may seems better, but:
-		// 1) we do not track if transaction is mined (without an error) by the target node;
-		// 2) error could be irrecoverable (e.g. when block is already pruned by bridge module or tx
-		//    has invalid format) && we'll end up in infinite loop of retrying the same transaction proof.
-		//
-		// So we're going with option#2 here (the only exception are connection errors).
-		match result {
-			Ok(false) => {
-				relayed_transactions.processed += 1;
-			}
-			Ok(true) => {
-				log::info!(
-					target: "bridge",
-					"{} transaction {} proof has been successfully submitted to {} node",
-					P::SOURCE_NAME,
-					source_tx.hash(),
-					P::TARGET_NAME,
-				);
-
-				relayed_transactions.processed += 1;
-				relayed_transactions.relayed += 1;
-			}
-			Err(err) => {
-				log::error!(
-					target: "bridge",
-					"Error relaying {} transaction {} proof to {} node: {}. {}",
-					P::SOURCE_NAME,
-					source_tx.hash(),
-					P::TARGET_NAME,
-					err.to_string(),
-					if err.is_connection_error() {
-						"Going to retry after delay..."
-					} else {
-						"You may need to submit proof of this transaction manually"
-					},
-				);
-
-				if err.is_connection_error() {
-					return Err(relayed_transactions);
-				}
-
-				relayed_transactions.processed += 1;
-				relayed_transactions.failed += 1;
-			}
-		}
-	}
-
-	Ok(relayed_transactions)
-}
-
-/// Relay single transaction proof.
-pub async fn relay_single_transaction_proof<P: TransactionProofPipeline>(
-	source_client: &impl SourceClient<P>,
-	target_client: &impl TargetClient<P>,
-	source_tx_hash: TransactionHashOf<P>,
-) -> Result<(), String> {
-	// wait for transaction and header on source node
-	let (source_header_id, source_tx_index) = wait_transaction_mined(source_client, &source_tx_hash).await?;
-	let source_block = source_client.block_by_hash(source_header_id.1.clone()).await;
-	let source_block = source_block.map_err(|err| {
-		format!(
-			"Error retrieving block {} from {} node: {:?}",
-			source_header_id.1,
-			P::SOURCE_NAME,
-			err,
-		)
-	})?;
-
-	// wait for transaction and header on target node
-	wait_header_imported(target_client, &source_header_id).await?;
-	wait_header_finalized(target_client, &source_header_id).await?;
-
-	// and finally - prepare and submit transaction proof to target node
-	let source_tx_id = format!("{}", source_tx_hash);
-	relay_ready_transaction_proof(
-		target_client,
-		&source_tx_id,
-		prepare_transaction_proof(source_client, &source_tx_id, &source_block, source_tx_index)
-			.await
-			.map_err(|err| err.to_string())?,
-	)
-	.await
-	.map_err(|err| err.to_string())
-}
-
-/// Prepare transaction proof.
-async fn prepare_transaction_proof<P: TransactionProofPipeline>(
-	source_client: &impl SourceClient<P>,
-	source_tx_id: &str,
-	source_block: &P::Block,
-	source_tx_index: usize,
-) -> Result<P::TransactionProof, StringifiedMaybeConnectionError> {
-	source_client
-		.transaction_proof(source_block, source_tx_index)
-		.await
-		.map_err(|err| {
-			StringifiedMaybeConnectionError::new(
-				err.is_connection_error(),
-				format!(
-					"Error building transaction {} proof on {} node: {:?}",
-					source_tx_id,
-					P::SOURCE_NAME,
-					err,
-				),
-			)
-		})
-}
-
-/// Relay prepared proof of transaction.
-async fn relay_ready_transaction_proof<P: TransactionProofPipeline>(
-	target_client: &impl TargetClient<P>,
-	source_tx_id: &str,
-	source_tx_proof: P::TransactionProof,
-) -> Result<(), StringifiedMaybeConnectionError> {
-	target_client
-		.submit_transaction_proof(source_tx_proof)
-		.await
-		.map_err(|err| {
-			StringifiedMaybeConnectionError::new(
-				err.is_connection_error(),
-				format!(
-					"Error submitting transaction {} proof to {} node: {:?}",
-					source_tx_id,
-					P::TARGET_NAME,
-					err,
-				),
-			)
-		})
-}
-
-/// Wait until transaction is mined by source node.
-async fn wait_transaction_mined<P: TransactionProofPipeline>(
-	source_client: &impl SourceClient<P>,
-	source_tx_hash: &TransactionHashOf<P>,
-) -> Result<(HeaderId<P>, usize), String> {
-	loop {
-		let source_header_and_tx = source_client.transaction_block(&source_tx_hash).await.map_err(|err| {
-			format!(
-				"Error retrieving transaction {} from {} node: {:?}",
-				source_tx_hash,
-				P::SOURCE_NAME,
-				err,
-			)
-		})?;
-		match source_header_and_tx {
-			Some((source_header_id, source_tx)) => {
-				log::info!(
-					target: "bridge",
-					"Transaction {} is retrieved from {} node. Continuing...",
-					source_tx_hash,
-					P::SOURCE_NAME,
-				);
-
-				return Ok((source_header_id, source_tx));
-			}
-			None => {
-				log::info!(
-					target: "bridge",
-					"Waiting for transaction {} to be mined by {} node...",
-					source_tx_hash,
-					P::SOURCE_NAME,
-				);
-
-				source_client.tick().await;
-			}
-		}
-	}
-}
-
-/// Wait until target node imports required header.
-async fn wait_header_imported<P: TransactionProofPipeline>(
-	target_client: &impl TargetClient<P>,
-	source_header_id: &HeaderId<P>,
-) -> Result<(), String> {
-	loop {
-		let is_header_known = target_client.is_header_known(&source_header_id).await.map_err(|err| {
-			format!(
-				"Failed to check existence of header {}/{} on {} node: {:?}",
-				source_header_id.0,
-				source_header_id.1,
-				P::TARGET_NAME,
-				err,
-			)
-		})?;
-		match is_header_known {
-			true => {
-				log::info!(
-					target: "bridge",
-					"Header {}/{} is known to {} node. Continuing.",
-					source_header_id.0,
-					source_header_id.1,
-					P::TARGET_NAME,
-				);
-
-				return Ok(());
-			}
-			false => {
-				log::info!(
-					target: "bridge",
-					"Waiting for header {}/{} to be imported by {} node...",
-					source_header_id.0,
-					source_header_id.1,
-					P::TARGET_NAME,
-				);
-
-				target_client.tick().await;
-			}
-		}
-	}
-}
-
-/// Wait until target node finalizes required header.
-async fn wait_header_finalized<P: TransactionProofPipeline>(
-	target_client: &impl TargetClient<P>,
-	source_header_id: &HeaderId<P>,
-) -> Result<(), String> {
-	loop {
-		let is_header_finalized = target_client
-			.is_header_finalized(&source_header_id)
-			.await
-			.map_err(|err| {
-				format!(
-					"Failed to check finality of header {}/{} on {} node: {:?}",
-					source_header_id.0,
-					source_header_id.1,
-					P::TARGET_NAME,
-					err,
-				)
-			})?;
-		match is_header_finalized {
-			true => {
-				log::info!(
-					target: "bridge",
-					"Header {}/{} is finalizd by {} node. Continuing.",
-					source_header_id.0,
-					source_header_id.1,
-					P::TARGET_NAME,
-				);
-
-				return Ok(());
-			}
-			false => {
-				log::info!(
-					target: "bridge",
-					"Waiting for header {}/{} to be finalized by {} node...",
-					source_header_id.0,
-					source_header_id.1,
-					P::TARGET_NAME,
-				);
-
-				target_client.tick().await;
-			}
-		}
-	}
-}
-
-#[cfg(test)]
-pub(crate) mod tests {
-	use super::*;
-	use crate::utils::HeaderId;
-
-	use parking_lot::Mutex;
-	use std::{
-		collections::{HashMap, HashSet},
-		sync::Arc,
-	};
-
-	pub fn test_block_id() -> TestHeaderId {
-		HeaderId(1, 1)
-	}
-
-	pub fn test_next_block_id() -> TestHeaderId {
-		HeaderId(2, 2)
-	}
-
-	pub fn test_transaction_hash(tx_index: u64) -> TestTransactionHash {
-		200 + tx_index
-	}
-
-	pub fn test_transaction(tx_index: u64) -> TestTransaction {
-		TestTransaction(test_transaction_hash(tx_index))
-	}
-
-	pub fn test_block() -> TestBlock {
-		TestBlock(test_block_id(), vec![test_transaction(0)])
-	}
-
-	pub fn test_next_block() -> TestBlock {
-		TestBlock(test_next_block_id(), vec![test_transaction(1)])
-	}
-
-	pub type TestBlockNumber = u64;
-	pub type TestBlockHash = u64;
-	pub type TestTransactionHash = u64;
-	pub type TestHeaderId = HeaderId<TestBlockHash, TestBlockNumber>;
-
-	#[derive(Debug, Clone, PartialEq)]
-	pub struct TestError(pub bool);
-
-	impl MaybeConnectionError for TestError {
-		fn is_connection_error(&self) -> bool {
-			self.0
-		}
-	}
-
-	pub struct TestTransactionProofPipeline;
-
-	impl TransactionProofPipeline for TestTransactionProofPipeline {
-		const SOURCE_NAME: &'static str = "TestSource";
-		const TARGET_NAME: &'static str = "TestTarget";
-
-		type Block = TestBlock;
-		type TransactionProof = TestTransactionProof;
-	}
-
-	#[derive(Debug, Clone)]
-	pub struct TestBlock(pub TestHeaderId, pub Vec<TestTransaction>);
-
-	impl SourceBlock for TestBlock {
-		type Hash = TestBlockHash;
-		type Number = TestBlockNumber;
-		type Transaction = TestTransaction;
-
-		fn id(&self) -> TestHeaderId {
-			self.0
-		}
-
-		fn transactions(&self) -> Vec<TestTransaction> {
-			self.1.clone()
-		}
-	}
-
-	#[derive(Debug, Clone)]
-	pub struct TestTransaction(pub TestTransactionHash);
-
-	impl SourceTransaction for TestTransaction {
-		type Hash = TestTransactionHash;
-
-		fn hash(&self) -> Self::Hash {
-			self.0
-		}
-	}
-
-	#[derive(Debug, Clone, PartialEq)]
-	pub struct TestTransactionProof(pub TestTransactionHash);
-
-	pub struct TestTransactionsSource {
-		pub on_tick: Box<dyn Fn(&mut TestTransactionsSourceData) + Send + Sync>,
-		pub data: Arc<Mutex<TestTransactionsSourceData>>,
-	}
-
-	pub struct TestTransactionsSourceData {
-		pub block: Result<TestBlock, TestError>,
-		pub transaction_block: Result<Option<(TestHeaderId, usize)>, TestError>,
-		pub proofs_to_fail: HashMap<TestTransactionHash, TestError>,
-	}
-
-	impl TestTransactionsSource {
-		pub fn new(on_tick: Box<dyn Fn(&mut TestTransactionsSourceData) + Send + Sync>) -> Self {
-			Self {
-				on_tick,
-				data: Arc::new(Mutex::new(TestTransactionsSourceData {
-					block: Ok(test_block()),
-					transaction_block: Ok(Some((test_block_id(), 0))),
-					proofs_to_fail: HashMap::new(),
-				})),
-			}
-		}
-	}
-
-	#[async_trait]
-	impl SourceClient<TestTransactionProofPipeline> for TestTransactionsSource {
-		type Error = TestError;
-
-		async fn tick(&self) {
-			(self.on_tick)(&mut *self.data.lock())
-		}
-
-		async fn block_by_hash(&self, _: TestBlockHash) -> Result<TestBlock, TestError> {
-			self.data.lock().block.clone()
-		}
-
-		async fn block_by_number(&self, _: TestBlockNumber) -> Result<TestBlock, TestError> {
-			self.data.lock().block.clone()
-		}
-
-		async fn transaction_block(&self, _: &TestTransactionHash) -> Result<Option<(TestHeaderId, usize)>, TestError> {
-			self.data.lock().transaction_block.clone()
-		}
-
-		async fn transaction_proof(&self, block: &TestBlock, index: usize) -> Result<TestTransactionProof, TestError> {
-			let tx_hash = block.1[index].hash();
-			let proof_error = self.data.lock().proofs_to_fail.get(&tx_hash).cloned();
-			if let Some(err) = proof_error {
-				return Err(err);
-			}
-
-			Ok(TestTransactionProof(tx_hash))
-		}
-	}
-
-	pub struct TestTransactionsTarget {
-		pub on_tick: Box<dyn Fn(&mut TestTransactionsTargetData) + Send + Sync>,
-		pub data: Arc<Mutex<TestTransactionsTargetData>>,
-	}
-
-	pub struct TestTransactionsTargetData {
-		pub is_header_known: Result<bool, TestError>,
-		pub is_header_finalized: Result<bool, TestError>,
-		pub best_finalized_header_id: Result<TestHeaderId, TestError>,
-		pub transactions_to_accept: HashSet<TestTransactionHash>,
-		pub submitted_proofs: Vec<TestTransactionProof>,
-	}
-
-	impl TestTransactionsTarget {
-		pub fn new(on_tick: Box<dyn Fn(&mut TestTransactionsTargetData) + Send + Sync>) -> Self {
-			Self {
-				on_tick,
-				data: Arc::new(Mutex::new(TestTransactionsTargetData {
-					is_header_known: Ok(true),
-					is_header_finalized: Ok(true),
-					best_finalized_header_id: Ok(test_block_id()),
-					transactions_to_accept: vec![test_transaction_hash(0)].into_iter().collect(),
-					submitted_proofs: Vec::new(),
-				})),
-			}
-		}
-	}
-
-	#[async_trait]
-	impl TargetClient<TestTransactionProofPipeline> for TestTransactionsTarget {
-		type Error = TestError;
-
-		async fn tick(&self) {
-			(self.on_tick)(&mut *self.data.lock())
-		}
-
-		async fn is_header_known(&self, _: &TestHeaderId) -> Result<bool, TestError> {
-			self.data.lock().is_header_known.clone()
-		}
-
-		async fn is_header_finalized(&self, _: &TestHeaderId) -> Result<bool, TestError> {
-			self.data.lock().is_header_finalized.clone()
-		}
-
-		async fn best_finalized_header_id(&self) -> Result<TestHeaderId, TestError> {
-			self.data.lock().best_finalized_header_id.clone()
-		}
-
-		async fn filter_transaction_proof(&self, proof: &TestTransactionProof) -> Result<bool, TestError> {
-			Ok(self.data.lock().transactions_to_accept.contains(&proof.0))
-		}
-
-		async fn submit_transaction_proof(&self, proof: TestTransactionProof) -> Result<(), TestError> {
-			self.data.lock().submitted_proofs.push(proof);
-			Ok(())
-		}
-	}
-
-	fn ensure_relay_single_success(source: &TestTransactionsSource, target: &TestTransactionsTarget) {
-		assert_eq!(
-			async_std::task::block_on(relay_single_transaction_proof(source, target, test_transaction_hash(0),)),
-			Ok(()),
-		);
-		assert_eq!(
-			target.data.lock().submitted_proofs,
-			vec![TestTransactionProof(test_transaction_hash(0))],
-		);
-	}
-
-	fn ensure_relay_single_failure(source: TestTransactionsSource, target: TestTransactionsTarget) {
-		assert!(async_std::task::block_on(relay_single_transaction_proof(
-			&source,
-			&target,
-			test_transaction_hash(0),
-		))
-		.is_err(),);
-		assert!(target.data.lock().submitted_proofs.is_empty());
-	}
-
-	#[test]
-	fn ready_transaction_proof_relayed_immediately() {
-		let source = TestTransactionsSource::new(Box::new(|_| unreachable!("no ticks allowed")));
-		let target = TestTransactionsTarget::new(Box::new(|_| unreachable!("no ticks allowed")));
-		ensure_relay_single_success(&source, &target)
-	}
-
-	#[test]
-	fn relay_transaction_proof_waits_for_transaction_to_be_mined() {
-		let source = TestTransactionsSource::new(Box::new(|source_data| {
-			assert_eq!(source_data.transaction_block, Ok(None));
-			source_data.transaction_block = Ok(Some((test_block_id(), 0)));
-		}));
-		let target = TestTransactionsTarget::new(Box::new(|_| unreachable!("no ticks allowed")));
-
-		// transaction is not yet mined, but will be available after first wait (tick)
-		source.data.lock().transaction_block = Ok(None);
-
-		ensure_relay_single_success(&source, &target)
-	}
-
-	#[test]
-	fn relay_transaction_fails_when_transaction_retrieval_fails() {
-		let source = TestTransactionsSource::new(Box::new(|_| unreachable!("no ticks allowed")));
-		let target = TestTransactionsTarget::new(Box::new(|_| unreachable!("no ticks allowed")));
-
-		source.data.lock().transaction_block = Err(TestError(false));
-
-		ensure_relay_single_failure(source, target)
-	}
-
-	#[test]
-	fn relay_transaction_fails_when_proof_retrieval_fails() {
-		let source = TestTransactionsSource::new(Box::new(|_| unreachable!("no ticks allowed")));
-		let target = TestTransactionsTarget::new(Box::new(|_| unreachable!("no ticks allowed")));
-
-		source
-			.data
-			.lock()
-			.proofs_to_fail
-			.insert(test_transaction_hash(0), TestError(false));
-
-		ensure_relay_single_failure(source, target)
-	}
-
-	#[test]
-	fn relay_transaction_proof_waits_for_header_to_be_imported() {
-		let source = TestTransactionsSource::new(Box::new(|_| unreachable!("no ticks allowed")));
-		let target = TestTransactionsTarget::new(Box::new(|target_data| {
-			assert_eq!(target_data.is_header_known, Ok(false));
-			target_data.is_header_known = Ok(true);
-		}));
-
-		// header is not yet imported, but will be available after first wait (tick)
-		target.data.lock().is_header_known = Ok(false);
-
-		ensure_relay_single_success(&source, &target)
-	}
-
-	#[test]
-	fn relay_transaction_proof_fails_when_is_header_known_fails() {
-		let source = TestTransactionsSource::new(Box::new(|_| unreachable!("no ticks allowed")));
-		let target = TestTransactionsTarget::new(Box::new(|_| unreachable!("no ticks allowed")));
-
-		target.data.lock().is_header_known = Err(TestError(false));
-
-		ensure_relay_single_failure(source, target)
-	}
-
-	#[test]
-	fn relay_transaction_proof_waits_for_header_to_be_finalized() {
-		let source = TestTransactionsSource::new(Box::new(|_| unreachable!("no ticks allowed")));
-		let target = TestTransactionsTarget::new(Box::new(|target_data| {
-			assert_eq!(target_data.is_header_finalized, Ok(false));
-			target_data.is_header_finalized = Ok(true);
-		}));
-
-		// header is not yet finalized, but will be available after first wait (tick)
-		target.data.lock().is_header_finalized = Ok(false);
-
-		ensure_relay_single_success(&source, &target)
-	}
-
-	#[test]
-	fn relay_transaction_proof_fails_when_is_header_finalized_fails() {
-		let source = TestTransactionsSource::new(Box::new(|_| unreachable!("no ticks allowed")));
-		let target = TestTransactionsTarget::new(Box::new(|_| unreachable!("no ticks allowed")));
-
-		target.data.lock().is_header_finalized = Err(TestError(false));
-
-		ensure_relay_single_failure(source, target)
-	}
-
-	#[test]
-	fn relay_transaction_proof_fails_when_target_node_rejects_proof() {
-		let source = TestTransactionsSource::new(Box::new(|_| unreachable!("no ticks allowed")));
-		let target = TestTransactionsTarget::new(Box::new(|_| unreachable!("no ticks allowed")));
-
-		target
-			.data
-			.lock()
-			.transactions_to_accept
-			.remove(&test_transaction_hash(0));
-
-		ensure_relay_single_success(&source, &target)
-	}
-
-	fn test_relay_block_transactions(
-		source: &TestTransactionsSource,
-		target: &TestTransactionsTarget,
-		pre_relayed: RelayedBlockTransactions,
-	) -> Result<RelayedBlockTransactions, RelayedBlockTransactions> {
-		async_std::task::block_on(relay_block_transactions(
-			source,
-			target,
-			&TestBlock(
-				test_block_id(),
-				vec![test_transaction(0), test_transaction(1), test_transaction(2)],
-			),
-			pre_relayed,
-		))
-	}
-
-	#[test]
-	fn relay_block_transactions_process_all_transactions() {
-		let source = TestTransactionsSource::new(Box::new(|_| unreachable!("no ticks allowed")));
-		let target = TestTransactionsTarget::new(Box::new(|_| unreachable!("no ticks allowed")));
-
-		// let's only accept tx#1
-		target
-			.data
-			.lock()
-			.transactions_to_accept
-			.remove(&test_transaction_hash(0));
-		target
-			.data
-			.lock()
-			.transactions_to_accept
-			.insert(test_transaction_hash(1));
-
-		let relayed_transactions = test_relay_block_transactions(&source, &target, Default::default());
-		assert_eq!(
-			relayed_transactions,
-			Ok(RelayedBlockTransactions {
-				processed: 3,
-				relayed: 1,
-				failed: 0,
-			}),
-		);
-		assert_eq!(
-			target.data.lock().submitted_proofs,
-			vec![TestTransactionProof(test_transaction_hash(1))],
-		);
-	}
-
-	#[test]
-	fn relay_block_transactions_ignores_transaction_failure() {
-		let source = TestTransactionsSource::new(Box::new(|_| unreachable!("no ticks allowed")));
-		let target = TestTransactionsTarget::new(Box::new(|_| unreachable!("no ticks allowed")));
-
-		// let's reject proof for tx#0
-		source
-			.data
-			.lock()
-			.proofs_to_fail
-			.insert(test_transaction_hash(0), TestError(false));
-
-		let relayed_transactions = test_relay_block_transactions(&source, &target, Default::default());
-		assert_eq!(
-			relayed_transactions,
-			Ok(RelayedBlockTransactions {
-				processed: 3,
-				relayed: 0,
-				failed: 1,
-			}),
-		);
-		assert_eq!(target.data.lock().submitted_proofs, vec![],);
-	}
-
-	#[test]
-	fn relay_block_transactions_fails_on_connection_error() {
-		let source = TestTransactionsSource::new(Box::new(|_| unreachable!("no ticks allowed")));
-		let target = TestTransactionsTarget::new(Box::new(|_| unreachable!("no ticks allowed")));
-
-		// fail with connection error when preparing proof for tx#1
-		source
-			.data
-			.lock()
-			.proofs_to_fail
-			.insert(test_transaction_hash(1), TestError(true));
-
-		let relayed_transactions = test_relay_block_transactions(&source, &target, Default::default());
-		assert_eq!(
-			relayed_transactions,
-			Err(RelayedBlockTransactions {
-				processed: 1,
-				relayed: 1,
-				failed: 0,
-			}),
-		);
-		assert_eq!(
-			target.data.lock().submitted_proofs,
-			vec![TestTransactionProof(test_transaction_hash(0))],
-		);
-
-		// now do not fail on tx#2
-		source.data.lock().proofs_to_fail.clear();
-		// and also relay tx#3
-		target
-			.data
-			.lock()
-			.transactions_to_accept
-			.insert(test_transaction_hash(2));
-
-		let relayed_transactions = test_relay_block_transactions(&source, &target, relayed_transactions.unwrap_err());
-		assert_eq!(
-			relayed_transactions,
-			Ok(RelayedBlockTransactions {
-				processed: 3,
-				relayed: 2,
-				failed: 0,
-			}),
-		);
-		assert_eq!(
-			target.data.lock().submitted_proofs,
-			vec![
-				TestTransactionProof(test_transaction_hash(0)),
-				TestTransactionProof(test_transaction_hash(2))
-			],
-		);
-	}
-}

bridges/relays/ethereum/src/exchange_loop.rs

@@ -1,300 +0,0 @@
-// 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/>.
-
-//! Relaying proofs of exchange transactions.
-
-use crate::exchange::{
-	relay_block_transactions, BlockNumberOf, RelayedBlockTransactions, SourceClient, TargetClient,
-	TransactionProofPipeline,
-};
-use crate::exchange_loop_metrics::ExchangeLoopMetrics;
-use crate::metrics::{start as metrics_start, GlobalMetrics, MetricsParams};
-use crate::utils::retry_backoff;
-
-use backoff::backoff::Backoff;
-use futures::{future::FutureExt, select};
-use num_traits::One;
-use std::{future::Future, time::Duration};
-
-/// Delay after connection-related error happened before we'll try
-/// reconnection again.
-const CONNECTION_ERROR_DELAY: Duration = Duration::from_secs(10);
-
-/// Transactions proofs relay state.
-#[derive(Debug)]
-pub struct TransactionProofsRelayState<BlockNumber> {
-	/// Number of last header we have processed so far.
-	pub best_processed_header_number: BlockNumber,
-}
-
-/// Transactions proofs relay storage.
-pub trait TransactionProofsRelayStorage {
-	/// Associated block number.
-	type BlockNumber;
-
-	/// Get relay state.
-	fn state(&self) -> TransactionProofsRelayState<Self::BlockNumber>;
-	/// Update relay state.
-	fn set_state(&mut self, state: &TransactionProofsRelayState<Self::BlockNumber>);
-}
-
-/// In-memory storage for auto-relay loop.
-#[derive(Debug)]
-pub struct InMemoryStorage<BlockNumber> {
-	best_processed_header_number: BlockNumber,
-}
-
-impl<BlockNumber> InMemoryStorage<BlockNumber> {
-	/// Created new in-memory storage with given best processed block number.
-	pub fn new(best_processed_header_number: BlockNumber) -> Self {
-		InMemoryStorage {
-			best_processed_header_number,
-		}
-	}
-}
-
-impl<BlockNumber: Clone + Copy> TransactionProofsRelayStorage for InMemoryStorage<BlockNumber> {
-	type BlockNumber = BlockNumber;
-
-	fn state(&self) -> TransactionProofsRelayState<BlockNumber> {
-		TransactionProofsRelayState {
-			best_processed_header_number: self.best_processed_header_number,
-		}
-	}
-
-	fn set_state(&mut self, state: &TransactionProofsRelayState<BlockNumber>) {
-		self.best_processed_header_number = state.best_processed_header_number;
-	}
-}
-
-/// Run proofs synchronization.
-pub fn run<P: TransactionProofPipeline>(
-	mut storage: impl TransactionProofsRelayStorage<BlockNumber = BlockNumberOf<P>>,
-	source_client: impl SourceClient<P>,
-	target_client: impl TargetClient<P>,
-	metrics_params: Option<MetricsParams>,
-	exit_signal: impl Future<Output = ()>,
-) {
-	let mut local_pool = futures::executor::LocalPool::new();
-
-	local_pool.run_until(async move {
-		let mut retry_backoff = retry_backoff();
-		let mut state = storage.state();
-		let mut current_finalized_block = None;
-
-		let mut metrics_global = GlobalMetrics::new();
-		let mut metrics_exch = ExchangeLoopMetrics::new();
-		let metrics_enabled = metrics_params.is_some();
-		metrics_start(
-			format!("{}_to_{}_Exchange", P::SOURCE_NAME, P::TARGET_NAME),
-			metrics_params,
-			&metrics_global,
-			&metrics_exch,
-		);
-
-		let exit_signal = exit_signal.fuse();
-
-		futures::pin_mut!(exit_signal);
-
-		loop {
-			let iteration_result = run_loop_iteration(
-				&mut storage,
-				&source_client,
-				&target_client,
-				&mut state,
-				&mut current_finalized_block,
-				if metrics_enabled { Some(&mut metrics_exch) } else { None },
-			)
-			.await;
-
-			if metrics_enabled {
-				metrics_global.update();
-			}
-
-			match iteration_result {
-				Ok(_) => {
-					retry_backoff.reset();
-
-					select! {
-						_ = source_client.tick().fuse() => {},
-						_ = exit_signal => return,
-					}
-				}
-				Err(_) => {
-					let retry_timeout = retry_backoff.next_backoff().unwrap_or(CONNECTION_ERROR_DELAY);
-
-					select! {
-						_ = async_std::task::sleep(retry_timeout).fuse() => {},
-						_ = exit_signal => return,
-					}
-				}
-			}
-		}
-	});
-}
-
-/// Run exchange loop until we need to break.
-async fn run_loop_iteration<P: TransactionProofPipeline>(
-	storage: &mut impl TransactionProofsRelayStorage<BlockNumber = BlockNumberOf<P>>,
-	source_client: &impl SourceClient<P>,
-	target_client: &impl TargetClient<P>,
-	state: &mut TransactionProofsRelayState<BlockNumberOf<P>>,
-	current_finalized_block: &mut Option<(P::Block, RelayedBlockTransactions)>,
-	mut exchange_loop_metrics: Option<&mut ExchangeLoopMetrics>,
-) -> Result<(), ()> {
-	let best_finalized_header_id = match target_client.best_finalized_header_id().await {
-		Ok(best_finalized_header_id) => {
-			log::debug!(
-				target: "bridge",
-				"Got best finalized {} block from {} node: {:?}",
-				P::SOURCE_NAME,
-				P::TARGET_NAME,
-				best_finalized_header_id,
-			);
-
-			best_finalized_header_id
-		}
-		Err(err) => {
-			log::error!(
-				target: "bridge",
-				"Failed to retrieve best {} header id from {} node: {:?}. Going to retry...",
-				P::SOURCE_NAME,
-				P::TARGET_NAME,
-				err,
-			);
-
-			return Err(());
-		}
-	};
-
-	loop {
-		// if we already have some finalized block body, try to relay its transactions
-		if let Some((block, relayed_transactions)) = current_finalized_block.take() {
-			let result = relay_block_transactions(source_client, target_client, &block, relayed_transactions).await;
-
-			match result {
-				Ok(relayed_transactions) => {
-					log::info!(
-						target: "bridge",
-						"Relay has processed {} block #{}. Total/Relayed/Failed transactions: {}/{}/{}",
-						P::SOURCE_NAME,
-						state.best_processed_header_number,
-						relayed_transactions.processed,
-						relayed_transactions.relayed,
-						relayed_transactions.failed,
-					);
-
-					state.best_processed_header_number = state.best_processed_header_number + One::one();
-					storage.set_state(state);
-
-					if let Some(exchange_loop_metrics) = exchange_loop_metrics.as_mut() {
-						exchange_loop_metrics.update::<P>(
-							state.best_processed_header_number,
-							best_finalized_header_id.0,
-							relayed_transactions,
-						);
-					}
-
-					// we have just updated state => proceed to next block retrieval
-				}
-				Err(relayed_transactions) => {
-					*current_finalized_block = Some((block, relayed_transactions));
-					return Err(());
-				}
-			}
-		}
-
-		// we may need to retrieve finalized block body from source node
-		if best_finalized_header_id.0 > state.best_processed_header_number {
-			let next_block_number = state.best_processed_header_number + One::one();
-			let result = source_client.block_by_number(next_block_number).await;
-
-			match result {
-				Ok(block) => {
-					*current_finalized_block = Some((block, RelayedBlockTransactions::default()));
-
-					// we have received new finalized block => go back to relay its transactions
-					continue;
-				}
-				Err(err) => {
-					log::error!(
-						target: "bridge",
-						"Failed to retrieve canonical block #{} from {} node: {:?}. Going to retry...",
-						next_block_number,
-						P::SOURCE_NAME,
-						err,
-					);
-
-					return Err(());
-				}
-			}
-		}
-
-		// there are no any transactions we need to relay => wait for new data
-		return Ok(());
-	}
-}
-
-#[cfg(test)]
-mod tests {
-	use super::*;
-	use crate::exchange::tests::{
-		test_next_block, test_next_block_id, test_transaction_hash, TestTransactionProof, TestTransactionsSource,
-		TestTransactionsTarget,
-	};
-	use futures::{future::FutureExt, stream::StreamExt};
-
-	#[test]
-	fn exchange_loop_is_able_to_relay_proofs() {
-		let storage = InMemoryStorage {
-			best_processed_header_number: 0,
-		};
-		let target = TestTransactionsTarget::new(Box::new(|_| unreachable!("no target ticks allowed")));
-		let target_data = target.data.clone();
-		let (exit_sender, exit_receiver) = futures::channel::mpsc::unbounded();
-
-		let source = TestTransactionsSource::new(Box::new(move |data| {
-			let transaction1_relayed = target_data
-				.lock()
-				.submitted_proofs
-				.contains(&TestTransactionProof(test_transaction_hash(0)));
-			let transaction2_relayed = target_data
-				.lock()
-				.submitted_proofs
-				.contains(&TestTransactionProof(test_transaction_hash(1)));
-			match (transaction1_relayed, transaction2_relayed) {
-				(true, true) => exit_sender.unbounded_send(()).unwrap(),
-				(true, false) => {
-					data.block = Ok(test_next_block());
-					target_data.lock().best_finalized_header_id = Ok(test_next_block_id());
-					target_data
-						.lock()
-						.transactions_to_accept
-						.insert(test_transaction_hash(1));
-				}
-				_ => (),
-			}
-		}));
-
-		run(
-			storage,
-			source,
-			target,
-			None,
-			exit_receiver.into_future().map(|(_, _)| ()),
-		);
-	}
-}

bridges/relays/ethereum/src/exchange_loop_metrics.rs

@@ -1,84 +0,0 @@
-// 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/>.
-
-use crate::exchange::{BlockNumberOf, RelayedBlockTransactions, TransactionProofPipeline};
-use crate::metrics::{register, Counter, CounterVec, GaugeVec, Metrics, Opts, Registry, U64};
-
-/// Exchange transactions relay metrics.
-pub struct ExchangeLoopMetrics {
-	/// Best finalized block numbers - "processed" and "known".
-	best_block_numbers: GaugeVec<U64>,
-	/// Number of processed blocks ("total").
-	processed_blocks: Counter<U64>,
-	/// Number of processed transactions ("total", "relayed" and "failed").
-	processed_transactions: CounterVec<U64>,
-}
-
-impl Metrics for ExchangeLoopMetrics {
-	fn register(&self, registry: &Registry) -> Result<(), String> {
-		register(self.best_block_numbers.clone(), registry).map_err(|e| e.to_string())?;
-		register(self.processed_blocks.clone(), registry).map_err(|e| e.to_string())?;
-		register(self.processed_transactions.clone(), registry).map_err(|e| e.to_string())?;
-		Ok(())
-	}
-}
-
-impl ExchangeLoopMetrics {
-	/// Creates sync loop metrics.
-	pub fn new() -> Self {
-		ExchangeLoopMetrics {
-			best_block_numbers: GaugeVec::new(
-				Opts::new("best_block_numbers", "Best finalized block numbers"),
-				&["type"],
-			)
-			.expect("metric is static and thus valid; qed"),
-			processed_blocks: Counter::new("processed_blocks", "Total number of processed blocks")
-				.expect("metric is static and thus valid; qed"),
-			processed_transactions: CounterVec::new(
-				Opts::new("processed_transactions", "Total number of processed transactions"),
-				&["type"],
-			)
-			.expect("metric is static and thus valid; qed"),
-		}
-	}
-
-	/// Update metrics when single block is relayed.
-	pub fn update<P: TransactionProofPipeline>(
-		&mut self,
-		best_processed_block_number: BlockNumberOf<P>,
-		best_known_block_number: BlockNumberOf<P>,
-		relayed_transactions: RelayedBlockTransactions,
-	) {
-		self.best_block_numbers
-			.with_label_values(&["processed"])
-			.set(best_processed_block_number.into());
-		self.best_block_numbers
-			.with_label_values(&["known"])
-			.set(best_known_block_number.into());
-
-		self.processed_blocks.inc();
-
-		self.processed_transactions
-			.with_label_values(&["total"])
-			.inc_by(relayed_transactions.processed as _);
-		self.processed_transactions
-			.with_label_values(&["relayed"])
-			.inc_by(relayed_transactions.relayed as _);
-		self.processed_transactions
-			.with_label_values(&["failed"])
-			.inc_by(relayed_transactions.failed as _);
-	}
-}

bridges/relays/ethereum/src/instances.rs

@@ -53,7 +53,7 @@ impl BridgeInstance for Rialto {
 				.into_iter()
 				.map(|header| {
 					(
-						into_substrate_ethereum_header(header.header()),
+						into_substrate_ethereum_header(&header.header()),
 						into_substrate_ethereum_receipts(header.extra()),
 					)
 				})
@@ -65,7 +65,7 @@ impl BridgeInstance for Rialto {
 
 	fn build_unsigned_header_call(&self, header: QueuedEthereumHeader) -> Call {
 		let pallet_call = rialto_runtime::BridgeEthPoACall::import_unsigned_header(
-			into_substrate_ethereum_header(header.header()),
+			into_substrate_ethereum_header(&header.header()),
 			into_substrate_ethereum_receipts(header.extra()),
 		);
 

bridges/relays/ethereum/src/main.rs

@@ -22,42 +22,28 @@ mod ethereum_exchange;
 mod ethereum_exchange_submit;
 mod ethereum_sync_loop;
 mod ethereum_types;
-mod exchange;
-mod exchange_loop;
-mod exchange_loop_metrics;
-mod headers;
 mod instances;
-mod message_lane;
-mod message_lane_loop;
-mod message_race_delivery;
-mod message_race_loop;
-mod message_race_receiving;
-mod metrics;
 mod rpc;
 mod rpc_errors;
 mod substrate_client;
 mod substrate_sync_loop;
 mod substrate_types;
-mod sync;
-mod sync_loop;
-mod sync_loop_metrics;
-mod sync_loop_tests;
-mod sync_types;
-mod utils;
 
 use ethereum_client::{EthereumConnectionParams, EthereumSigningParams};
 use ethereum_deploy_contract::EthereumDeployContractParams;
 use ethereum_exchange::EthereumExchangeParams;
 use ethereum_exchange_submit::EthereumExchangeSubmitParams;
 use ethereum_sync_loop::EthereumSyncParams;
+use headers_relay::sync::TargetTransactionMode;
 use hex_literal::hex;
 use instances::{BridgeInstance, Kovan, Rialto};
 use parity_crypto::publickey::{KeyPair, Secret};
+use relay_utils::metrics::MetricsParams;
 use sp_core::crypto::Pair;
 use substrate_client::{SubstrateConnectionParams, SubstrateSigningParams};
 use substrate_sync_loop::SubstrateSyncParams;
-use sync::HeadersSyncParams;
 
+use headers_relay::sync::HeadersSyncParams;
 use std::io::Write;
 
 fn main() {
@@ -223,19 +209,28 @@ fn substrate_signing_params(matches: &clap::ArgMatches) -> Result<SubstrateSigni
 }
 
 fn ethereum_sync_params(matches: &clap::ArgMatches) -> Result<EthereumSyncParams, String> {
-	let mut sync_params = HeadersSyncParams::ethereum_sync_default();
+	use crate::ethereum_sync_loop::consts::*;
+
+	let mut sync_params = HeadersSyncParams {
+		max_future_headers_to_download: MAX_FUTURE_HEADERS_TO_DOWNLOAD,
+		max_headers_in_submitted_status: MAX_SUBMITTED_HEADERS,
+		max_headers_in_single_submit: MAX_HEADERS_IN_SINGLE_SUBMIT,
+		max_headers_size_in_single_submit: MAX_HEADERS_SIZE_IN_SINGLE_SUBMIT,
+		prune_depth: PRUNE_DEPTH,
+		target_tx_mode: TargetTransactionMode::Signed,
+	};
 
 	match matches.value_of("sub-tx-mode") {
-		Some("signed") => sync_params.target_tx_mode = sync::TargetTransactionMode::Signed,
+		Some("signed") => sync_params.target_tx_mode = TargetTransactionMode::Signed,
 		Some("unsigned") => {
-			sync_params.target_tx_mode = sync::TargetTransactionMode::Unsigned;
+			sync_params.target_tx_mode = TargetTransactionMode::Unsigned;
 
 			// tx pool won't accept too much unsigned transactions
 			sync_params.max_headers_in_submitted_status = 10;
 		}
-		Some("backup") => sync_params.target_tx_mode = sync::TargetTransactionMode::Backup,
+		Some("backup") => sync_params.target_tx_mode = TargetTransactionMode::Backup,
 		Some(mode) => return Err(format!("Invalid sub-tx-mode: {}", mode)),
-		None => sync_params.target_tx_mode = sync::TargetTransactionMode::Signed,
+		None => sync_params.target_tx_mode = TargetTransactionMode::Signed,
 	}
 
 	let params = EthereumSyncParams {
@@ -253,6 +248,8 @@ fn ethereum_sync_params(matches: &clap::ArgMatches) -> Result<EthereumSyncParams
 }
 
 fn substrate_sync_params(matches: &clap::ArgMatches) -> Result<SubstrateSyncParams, String> {
+	use crate::substrate_sync_loop::consts::*;
+
 	let eth_contract_address: ethereum_types::Address = if let Some(eth_contract) = matches.value_of("eth-contract") {
 		eth_contract.parse().map_err(|e| format!("{}", e))?
 	} else {
@@ -267,7 +264,14 @@ fn substrate_sync_params(matches: &clap::ArgMatches) -> Result<SubstrateSyncPara
 		eth_sign: ethereum_signing_params(matches)?,
 		metrics_params: metrics_params(matches)?,
 		instance: instance_params(matches)?,
-		sync_params: HeadersSyncParams::substrate_sync_default(),
+		sync_params: HeadersSyncParams {
+			max_future_headers_to_download: MAX_FUTURE_HEADERS_TO_DOWNLOAD,
+			max_headers_in_submitted_status: MAX_SUBMITTED_HEADERS,
+			max_headers_in_single_submit: 4,
+			max_headers_size_in_single_submit: std::usize::MAX,
+			prune_depth: PRUNE_DEPTH,
+			target_tx_mode: TargetTransactionMode::Signed,
+		},
 		eth_contract_address,
 	};
 
@@ -388,12 +392,12 @@ fn ethereum_exchange_params(matches: &clap::ArgMatches) -> Result<EthereumExchan
 	Ok(params)
 }
 
-fn metrics_params(matches: &clap::ArgMatches) -> Result<Option<metrics::MetricsParams>, String> {
+fn metrics_params(matches: &clap::ArgMatches) -> Result<Option<MetricsParams>, String> {
 	if matches.is_present("no-prometheus") {
 		return Ok(None);
 	}
 
-	let mut metrics_params = metrics::MetricsParams::default();
+	let mut metrics_params = MetricsParams::default();
 
 	if let Some(prometheus_host) = matches.value_of("prometheus-host") {
 		metrics_params.host = prometheus_host.into();

bridges/relays/ethereum/src/message_lane.rs

@@ -1,65 +0,0 @@
-// 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/>.
-
-//! One-way message lane types. Within single one-way lane we have three 'races' where we try to:
-//!
-//! 1) relay new messages from source to target node;
-//! 2) relay proof-of-receiving from target to source node.
-
-use crate::utils::HeaderId;
-
-use num_traits::{One, Zero};
-use std::fmt::Debug;
-
-/// One-way message lane.
-pub trait MessageLane {
-	/// Name of the messages source.
-	const SOURCE_NAME: &'static str;
-	/// Name of the messages target.
-	const TARGET_NAME: &'static str;
-
-	/// Message nonce type.
-	type MessageNonce: Clone
-		+ Copy
-		+ Debug
-		+ Default
-		+ From<u32>
-		+ Ord
-		+ std::ops::Add<Output = Self::MessageNonce>
-		+ One
-		+ Zero;
-
-	/// Messages proof.
-	type MessagesProof: Clone;
-	/// Messages receiving proof.
-	type MessagesReceivingProof: Clone;
-
-	/// Number of the source header.
-	type SourceHeaderNumber: Clone + Debug + Default + Ord + PartialEq;
-	/// Hash of the source header.
-	type SourceHeaderHash: Clone + Debug + Default + PartialEq;
-
-	/// Number of the target header.
-	type TargetHeaderNumber: Clone + Debug + Default + Ord + PartialEq;
-	/// Hash of the target header.
-	type TargetHeaderHash: Clone + Debug + Default + PartialEq;
-}
-
-/// Source header id within given one-way message lane.
-pub type SourceHeaderIdOf<P> = HeaderId<<P as MessageLane>::SourceHeaderHash, <P as MessageLane>::SourceHeaderNumber>;
-
-/// Target header id within given one-way message lane.
-pub type TargetHeaderIdOf<P> = HeaderId<<P as MessageLane>::TargetHeaderHash, <P as MessageLane>::TargetHeaderNumber>;

bridges/relays/ethereum/src/message_lane_loop.rs

@@ -1,670 +0,0 @@
-// 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/>.
-
-//! Message delivery loop. Designed to work with message-lane pallet.
-//!
-//! Single relay instance delivers messages of single lane in single direction.
-//! To serve two-way lane, you would need two instances of relay.
-//! To serve N two-way lanes, you would need N*2 instances of relay.
-//!
-//! Please keep in mind that the best header in this file is actually best
-//! finalized header. I.e. when talking about headers in lane context, we
-//! only care about finalized headers.
-
-// Until there'll be actual message-lane in the runtime.
-#![allow(dead_code)]
-
-use crate::message_lane::{MessageLane, SourceHeaderIdOf, TargetHeaderIdOf};
-use crate::message_race_delivery::run as run_message_delivery_race;
-use crate::message_race_receiving::run as run_message_receiving_race;
-use crate::utils::{interval, process_future_result, retry_backoff, FailedClient, MaybeConnectionError};
-
-use async_trait::async_trait;
-use futures::{channel::mpsc::unbounded, future::FutureExt, stream::StreamExt};
-use std::{fmt::Debug, future::Future, ops::RangeInclusive, time::Duration};
-
-/// Source client trait.
-#[async_trait(?Send)]
-pub trait SourceClient<P: MessageLane>: Clone {
-	/// Type of error this clients returns.
-	type Error: std::fmt::Debug + MaybeConnectionError;
-
-	/// Try to reconnect to source node.
-	fn reconnect(self) -> Self;
-
-	/// Returns state of the client.
-	async fn state(&self) -> Result<SourceClientState<P>, Self::Error>;
-
-	/// Get nonce of instance of latest generated message.
-	async fn latest_generated_nonce(
-		&self,
-		id: SourceHeaderIdOf<P>,
-	) -> Result<(SourceHeaderIdOf<P>, P::MessageNonce), Self::Error>;
-	/// Get nonce of the latest message, which receiving has been confirmed by the target chain.
-	async fn latest_confirmed_received_nonce(
-		&self,
-		id: SourceHeaderIdOf<P>,
-	) -> Result<(SourceHeaderIdOf<P>, P::MessageNonce), Self::Error>;
-
-	/// Prove messages in inclusive range [begin; end].
-	async fn prove_messages(
-		&self,
-		id: SourceHeaderIdOf<P>,
-		nonces: RangeInclusive<P::MessageNonce>,
-	) -> Result<(SourceHeaderIdOf<P>, RangeInclusive<P::MessageNonce>, P::MessagesProof), Self::Error>;
-
-	/// Submit messages receiving proof.
-	async fn submit_messages_receiving_proof(
-		&self,
-		generated_at_block: TargetHeaderIdOf<P>,
-		proof: P::MessagesReceivingProof,
-	) -> Result<RangeInclusive<P::MessageNonce>, Self::Error>;
-}
-
-/// Target client trait.
-#[async_trait(?Send)]
-pub trait TargetClient<P: MessageLane>: Clone {
-	/// Type of error this clients returns.
-	type Error: std::fmt::Debug + MaybeConnectionError;
-
-	/// Try to reconnect to source node.
-	fn reconnect(self) -> Self;
-
-	/// Returns state of the client.
-	async fn state(&self) -> Result<TargetClientState<P>, Self::Error>;
-
-	/// Get nonce of latest received message.
-	async fn latest_received_nonce(
-		&self,
-		id: TargetHeaderIdOf<P>,
-	) -> Result<(TargetHeaderIdOf<P>, P::MessageNonce), Self::Error>;
-
-	/// Prove messages receiving at given block.
-	async fn prove_messages_receiving(
-		&self,
-		id: TargetHeaderIdOf<P>,
-	) -> Result<(TargetHeaderIdOf<P>, P::MessagesReceivingProof), Self::Error>;
-
-	/// Submit messages proof.
-	async fn submit_messages_proof(
-		&self,
-		generated_at_header: SourceHeaderIdOf<P>,
-		nonces: RangeInclusive<P::MessageNonce>,
-		proof: P::MessagesProof,
-	) -> Result<RangeInclusive<P::MessageNonce>, Self::Error>;
-}
-
-/// State of the client.
-#[derive(Clone, Debug, Default, PartialEq)]
-pub struct ClientState<SelfHeaderId, PeerHeaderId> {
-	/// Best header id of this chain.
-	pub best_self: SelfHeaderId,
-	/// Best header id of the peer chain.
-	pub best_peer: PeerHeaderId,
-}
-
-/// State of source client in one-way message lane.
-pub type SourceClientState<P> = ClientState<SourceHeaderIdOf<P>, TargetHeaderIdOf<P>>;
-
-/// State of target client in one-way message lane.
-pub type TargetClientState<P> = ClientState<TargetHeaderIdOf<P>, SourceHeaderIdOf<P>>;
-
-/// Both clients state.
-#[derive(Debug, Default)]
-pub struct ClientsState<P: MessageLane> {
-	/// Source client state.
-	pub source: Option<SourceClientState<P>>,
-	/// Target client state.
-	pub target: Option<TargetClientState<P>>,
-}
-
-/// Run message lane service loop.
-pub fn run<P: MessageLane>(
-	mut source_client: impl SourceClient<P>,
-	source_tick: Duration,
-	mut target_client: impl TargetClient<P>,
-	target_tick: Duration,
-	reconnect_delay: Duration,
-	stall_timeout: Duration,
-	exit_signal: impl Future<Output = ()>,
-) {
-	let mut local_pool = futures::executor::LocalPool::new();
-	let exit_signal = exit_signal.shared();
-
-	local_pool.run_until(async move {
-		loop {
-			let result = run_until_connection_lost(
-				source_client.clone(),
-				source_tick,
-				target_client.clone(),
-				target_tick,
-				stall_timeout,
-				exit_signal.clone(),
-			)
-			.await;
-
-			match result {
-				Ok(()) => break,
-				Err(failed_client) => {
-					async_std::task::sleep(reconnect_delay).await;
-					if failed_client == FailedClient::Both || failed_client == FailedClient::Source {
-						source_client = source_client.reconnect();
-					}
-					if failed_client == FailedClient::Both || failed_client == FailedClient::Target {
-						target_client = target_client.reconnect();
-					}
-				}
-			}
-
-			log::debug!(
-				target: "bridge",
-				"Restarting lane {} -> {}",
-				P::SOURCE_NAME,
-				P::TARGET_NAME,
-			);
-		}
-	});
-}
-
-/// Run one-way message delivery loop until connection with target or source node is lost, or exit signal is received.
-async fn run_until_connection_lost<P: MessageLane, SC: SourceClient<P>, TC: TargetClient<P>>(
-	source_client: SC,
-	source_tick: Duration,
-	target_client: TC,
-	target_tick: Duration,
-	stall_timeout: Duration,
-	exit_signal: impl Future<Output = ()>,
-) -> Result<(), FailedClient> {
-	let mut source_retry_backoff = retry_backoff();
-	let mut source_client_is_online = false;
-	let mut source_state_required = true;
-	let source_state = source_client.state().fuse();
-	let source_go_offline_future = futures::future::Fuse::terminated();
-	let source_tick_stream = interval(source_tick).fuse();
-
-	let mut target_retry_backoff = retry_backoff();
-	let mut target_client_is_online = false;
-	let mut target_state_required = true;
-	let target_state = target_client.state().fuse();
-	let target_go_offline_future = futures::future::Fuse::terminated();
-	let target_tick_stream = interval(target_tick).fuse();
-
-	let (
-		(delivery_source_state_sender, delivery_source_state_receiver),
-		(delivery_target_state_sender, delivery_target_state_receiver),
-	) = (unbounded(), unbounded());
-	let delivery_race_loop = run_message_delivery_race(
-		source_client.clone(),
-		delivery_source_state_receiver,
-		target_client.clone(),
-		delivery_target_state_receiver,
-		stall_timeout,
-	)
-	.fuse();
-
-	let (
-		(receiving_source_state_sender, receiving_source_state_receiver),
-		(receiving_target_state_sender, receiving_target_state_receiver),
-	) = (unbounded(), unbounded());
-	let receiving_race_loop = run_message_receiving_race(
-		source_client.clone(),
-		receiving_source_state_receiver,
-		target_client.clone(),
-		receiving_target_state_receiver,
-		stall_timeout,
-	)
-	.fuse();
-
-	let exit_signal = exit_signal.fuse();
-
-	futures::pin_mut!(
-		source_state,
-		source_go_offline_future,
-		source_tick_stream,
-		target_state,
-		target_go_offline_future,
-		target_tick_stream,
-		delivery_race_loop,
-		receiving_race_loop,
-		exit_signal
-	);
-
-	loop {
-		futures::select! {
-			new_source_state = source_state => {
-				source_state_required = false;
-
-				source_client_is_online = process_future_result(
-					new_source_state,
-					&mut source_retry_backoff,
-					|new_source_state| {
-						log::debug!(
-							target: "bridge",
-							"Received state from {} node: {:?}",
-							P::SOURCE_NAME,
-							new_source_state,
-						);
-						let _ = delivery_source_state_sender.unbounded_send(new_source_state.clone());
-						let _ = receiving_source_state_sender.unbounded_send(new_source_state.clone());
-					},
-					&mut source_go_offline_future,
-					|delay| async_std::task::sleep(delay),
-					|| format!("Error retrieving state from {} node", P::SOURCE_NAME),
-				).fail_if_connection_error(FailedClient::Source)?;
-			},
-			_ = source_go_offline_future => {
-				source_client_is_online = true;
-			},
-			_ = source_tick_stream.next() => {
-				source_state_required = true;
-			},
-			new_target_state = target_state => {
-				target_state_required = false;
-
-				target_client_is_online = process_future_result(
-					new_target_state,
-					&mut target_retry_backoff,
-					|new_target_state| {
-						log::debug!(
-							target: "bridge",
-							"Received state from {} node: {:?}",
-							P::TARGET_NAME,
-							new_target_state,
-						);
-						let _ = delivery_target_state_sender.unbounded_send(new_target_state.clone());
-						let _ = receiving_target_state_sender.unbounded_send(new_target_state.clone());
-					},
-					&mut target_go_offline_future,
-					|delay| async_std::task::sleep(delay),
-					|| format!("Error retrieving state from {} node", P::TARGET_NAME),
-				).fail_if_connection_error(FailedClient::Target)?;
-			},
-			_ = target_go_offline_future => {
-				target_client_is_online = true;
-			},
-			_ = target_tick_stream.next() => {
-				target_state_required = true;
-			},
-
-			delivery_error = delivery_race_loop => {
-				match delivery_error {
-					Ok(_) => unreachable!("only ends with error; qed"),
-					Err(err) => return Err(err),
-				}
-			},
-			receiving_error = receiving_race_loop => {
-				match receiving_error {
-					Ok(_) => unreachable!("only ends with error; qed"),
-					Err(err) => return Err(err),
-				}
-			},
-
-			() = exit_signal => {
-				return Ok(());
-			}
-		}
-
-		if source_client_is_online && source_state_required {
-			log::debug!(target: "bridge", "Asking {} node about its state", P::SOURCE_NAME);
-			source_state.set(source_client.state().fuse());
-			source_client_is_online = false;
-		}
-
-		if target_client_is_online && target_state_required {
-			log::debug!(target: "bridge", "Asking {} node about its state", P::TARGET_NAME);
-			target_state.set(target_client.state().fuse());
-			target_client_is_online = false;
-		}
-	}
-}
-
-#[cfg(test)]
-pub(crate) mod tests {
-	use super::*;
-	use crate::utils::HeaderId;
-	use futures::stream::StreamExt;
-	use parking_lot::Mutex;
-	use std::sync::Arc;
-
-	pub fn header_id(number: TestSourceHeaderNumber) -> HeaderId<TestSourceHeaderNumber, TestSourceHeaderHash> {
-		HeaderId(number, number)
-	}
-
-	pub type TestMessageNonce = u64;
-	pub type TestMessagesProof = RangeInclusive<TestMessageNonce>;
-	pub type TestMessagesReceivingProof = TestMessageNonce;
-
-	pub type TestSourceHeaderNumber = u64;
-	pub type TestSourceHeaderHash = u64;
-
-	pub type TestTargetHeaderNumber = u64;
-	pub type TestTargetHeaderHash = u64;
-
-	#[derive(Debug)]
-	pub enum TestError {
-		Logic,
-		Connection,
-	}
-
-	impl MaybeConnectionError for TestError {
-		fn is_connection_error(&self) -> bool {
-			match *self {
-				TestError::Logic => false,
-				TestError::Connection => true,
-			}
-		}
-	}
-
-	pub struct TestMessageLane;
-
-	impl MessageLane for TestMessageLane {
-		const SOURCE_NAME: &'static str = "TestSource";
-		const TARGET_NAME: &'static str = "TestTarget";
-
-		type MessageNonce = TestMessageNonce;
-
-		type MessagesProof = TestMessagesProof;
-		type MessagesReceivingProof = TestMessagesReceivingProof;
-
-		type SourceHeaderNumber = TestSourceHeaderNumber;
-		type SourceHeaderHash = TestSourceHeaderHash;
-
-		type TargetHeaderNumber = TestTargetHeaderNumber;
-		type TargetHeaderHash = TestTargetHeaderHash;
-	}
-
-	#[derive(Debug, Default, Clone)]
-	pub struct TestClientData {
-		is_source_fails: bool,
-		is_source_reconnected: bool,
-		source_state: SourceClientState<TestMessageLane>,
-		source_latest_generated_nonce: TestMessageNonce,
-		source_latest_confirmed_received_nonce: TestMessageNonce,
-		submitted_messages_receiving_proofs: Vec<TestMessagesReceivingProof>,
-		is_target_fails: bool,
-		is_target_reconnected: bool,
-		target_state: SourceClientState<TestMessageLane>,
-		target_latest_received_nonce: TestMessageNonce,
-		submitted_messages_proofs: Vec<TestMessagesProof>,
-	}
-
-	#[derive(Clone)]
-	pub struct TestSourceClient {
-		data: Arc<Mutex<TestClientData>>,
-		tick: Arc<dyn Fn(&mut TestClientData)>,
-	}
-
-	#[async_trait(?Send)]
-	impl SourceClient<TestMessageLane> for TestSourceClient {
-		type Error = TestError;
-
-		fn reconnect(self) -> Self {
-			{
-				let mut data = self.data.lock();
-				(self.tick)(&mut *data);
-				data.is_source_reconnected = true;
-			}
-			self
-		}
-
-		async fn state(&self) -> Result<SourceClientState<TestMessageLane>, Self::Error> {
-			let mut data = self.data.lock();
-			(self.tick)(&mut *data);
-			if data.is_source_fails {
-				return Err(TestError::Connection);
-			}
-			Ok(data.source_state.clone())
-		}
-
-		async fn latest_generated_nonce(
-			&self,
-			id: SourceHeaderIdOf<TestMessageLane>,
-		) -> Result<(SourceHeaderIdOf<TestMessageLane>, TestMessageNonce), Self::Error> {
-			let mut data = self.data.lock();
-			(self.tick)(&mut *data);
-			if data.is_source_fails {
-				return Err(TestError::Connection);
-			}
-			Ok((id, data.source_latest_generated_nonce))
-		}
-
-		async fn latest_confirmed_received_nonce(
-			&self,
-			id: SourceHeaderIdOf<TestMessageLane>,
-		) -> Result<(SourceHeaderIdOf<TestMessageLane>, TestMessageNonce), Self::Error> {
-			let mut data = self.data.lock();
-			(self.tick)(&mut *data);
-			Ok((id, data.source_latest_confirmed_received_nonce))
-		}
-
-		async fn prove_messages(
-			&self,
-			id: SourceHeaderIdOf<TestMessageLane>,
-			nonces: RangeInclusive<TestMessageNonce>,
-		) -> Result<
-			(
-				SourceHeaderIdOf<TestMessageLane>,
-				RangeInclusive<TestMessageNonce>,
-				TestMessagesProof,
-			),
-			Self::Error,
-		> {
-			Ok((id, nonces.clone(), nonces))
-		}
-
-		async fn submit_messages_receiving_proof(
-			&self,
-			_generated_at_block: TargetHeaderIdOf<TestMessageLane>,
-			proof: TestMessagesReceivingProof,
-		) -> Result<RangeInclusive<TestMessageNonce>, Self::Error> {
-			let mut data = self.data.lock();
-			(self.tick)(&mut *data);
-			data.submitted_messages_receiving_proofs.push(proof);
-			data.source_latest_confirmed_received_nonce = proof;
-			Ok(proof..=proof)
-		}
-	}
-
-	#[derive(Clone)]
-	pub struct TestTargetClient {
-		data: Arc<Mutex<TestClientData>>,
-		tick: Arc<dyn Fn(&mut TestClientData)>,
-	}
-
-	#[async_trait(?Send)]
-	impl TargetClient<TestMessageLane> for TestTargetClient {
-		type Error = TestError;
-
-		fn reconnect(self) -> Self {
-			{
-				let mut data = self.data.lock();
-				(self.tick)(&mut *data);
-				data.is_target_reconnected = true;
-			}
-			self
-		}
-
-		async fn state(&self) -> Result<TargetClientState<TestMessageLane>, Self::Error> {
-			let mut data = self.data.lock();
-			(self.tick)(&mut *data);
-			if data.is_target_fails {
-				return Err(TestError::Connection);
-			}
-			Ok(data.target_state.clone())
-		}
-
-		async fn latest_received_nonce(
-			&self,
-			id: TargetHeaderIdOf<TestMessageLane>,
-		) -> Result<(TargetHeaderIdOf<TestMessageLane>, TestMessageNonce), Self::Error> {
-			let mut data = self.data.lock();
-			(self.tick)(&mut *data);
-			if data.is_target_fails {
-				return Err(TestError::Connection);
-			}
-			Ok((id, data.target_latest_received_nonce))
-		}
-
-		async fn prove_messages_receiving(
-			&self,
-			id: TargetHeaderIdOf<TestMessageLane>,
-		) -> Result<(TargetHeaderIdOf<TestMessageLane>, TestMessagesReceivingProof), Self::Error> {
-			Ok((id, self.data.lock().target_latest_received_nonce))
-		}
-
-		async fn submit_messages_proof(
-			&self,
-			_generated_at_header: SourceHeaderIdOf<TestMessageLane>,
-			nonces: RangeInclusive<TestMessageNonce>,
-			proof: TestMessagesProof,
-		) -> Result<RangeInclusive<TestMessageNonce>, Self::Error> {
-			let mut data = self.data.lock();
-			(self.tick)(&mut *data);
-			if data.is_target_fails {
-				return Err(TestError::Connection);
-			}
-			data.target_state.best_self =
-				HeaderId(data.target_state.best_self.0 + 1, data.target_state.best_self.1 + 1);
-			data.target_latest_received_nonce = *proof.end();
-			data.submitted_messages_proofs.push(proof);
-			Ok(nonces)
-		}
-	}
-
-	fn run_loop_test(
-		data: TestClientData,
-		source_tick: Arc<dyn Fn(&mut TestClientData)>,
-		target_tick: Arc<dyn Fn(&mut TestClientData)>,
-		exit_signal: impl Future<Output = ()>,
-	) -> TestClientData {
-		async_std::task::block_on(async {
-			let data = Arc::new(Mutex::new(data));
-
-			let source_client = TestSourceClient {
-				data: data.clone(),
-				tick: source_tick,
-			};
-			let target_client = TestTargetClient {
-				data: data.clone(),
-				tick: target_tick,
-			};
-			run(
-				source_client,
-				Duration::from_millis(100),
-				target_client,
-				Duration::from_millis(100),
-				Duration::from_millis(0),
-				Duration::from_secs(60),
-				exit_signal,
-			);
-
-			let result = data.lock().clone();
-			result
-		})
-	}
-
-	#[test]
-	fn message_lane_loop_is_able_to_recover_from_connection_errors() {
-		// with this configuration, source client will return Err, making source client
-		// reconnect. Then the target client will fail with Err + reconnect. Then we finally
-		// able to deliver messages.
-		let (exit_sender, exit_receiver) = unbounded();
-		let result = run_loop_test(
-			TestClientData {
-				is_source_fails: true,
-				source_state: ClientState {
-					best_self: HeaderId(0, 0),
-					best_peer: HeaderId(0, 0),
-				},
-				source_latest_generated_nonce: 1,
-				target_state: ClientState {
-					best_self: HeaderId(0, 0),
-					best_peer: HeaderId(0, 0),
-				},
-				target_latest_received_nonce: 0,
-				..Default::default()
-			},
-			Arc::new(|data: &mut TestClientData| {
-				if data.is_source_reconnected {
-					data.is_source_fails = false;
-					data.is_target_fails = true;
-				}
-			}),
-			Arc::new(move |data: &mut TestClientData| {
-				if data.is_target_reconnected {
-					data.is_target_fails = false;
-				}
-				if data.target_state.best_peer.0 < 10 {
-					data.target_state.best_peer =
-						HeaderId(data.target_state.best_peer.0 + 1, data.target_state.best_peer.0 + 1);
-				}
-				if !data.submitted_messages_proofs.is_empty() {
-					exit_sender.unbounded_send(()).unwrap();
-				}
-			}),
-			exit_receiver.into_future().map(|(_, _)| ()),
-		);
-
-		assert_eq!(result.submitted_messages_proofs, vec![1..=1],);
-	}
-
-	#[test]
-	fn message_lane_loop_works() {
-		// with this configuration, target client must first sync headers [1; 10] and
-		// then submit proof-of-messages [0; 10] at once
-		let (exit_sender, exit_receiver) = unbounded();
-		let result = run_loop_test(
-			TestClientData {
-				source_state: ClientState {
-					best_self: HeaderId(10, 10),
-					best_peer: HeaderId(0, 0),
-				},
-				source_latest_generated_nonce: 10,
-				target_state: ClientState {
-					best_self: HeaderId(0, 0),
-					best_peer: HeaderId(0, 0),
-				},
-				target_latest_received_nonce: 0,
-				..Default::default()
-			},
-			Arc::new(|_: &mut TestClientData| {}),
-			Arc::new(move |data: &mut TestClientData| {
-				// syncing source headers -> target chain (by one)
-				if data.target_state.best_peer.0 < data.source_state.best_self.0 {
-					data.target_state.best_peer =
-						HeaderId(data.target_state.best_peer.0 + 1, data.target_state.best_peer.0 + 1);
-				}
-				// syncing source headers -> target chain (all at once)
-				if data.source_state.best_peer.0 < data.target_state.best_self.0 {
-					data.source_state.best_peer = data.target_state.best_self;
-				}
-				// if target has received all messages => increase target block so that confirmations may be sent
-				if data.target_latest_received_nonce == 10 {
-					data.target_state.best_self =
-						HeaderId(data.source_state.best_self.0 + 1, data.source_state.best_self.0 + 1);
-				}
-				// if source has received all messages receiving confirmations => increase source block so that confirmations may be sent
-				if data.source_latest_confirmed_received_nonce == 10 {
-					exit_sender.unbounded_send(()).unwrap();
-				}
-			}),
-			exit_receiver.into_future().map(|(_, _)| ()),
-		);
-
-		assert_eq!(result.submitted_messages_proofs, vec![1..=4, 5..=8, 9..=10],);
-		assert!(!result.submitted_messages_receiving_proofs.is_empty());
-	}
-}

bridges/relays/ethereum/src/message_race_delivery.rs

@@ -1,425 +0,0 @@
-// 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.
-
-//! Message delivery race delivers proof-of-messages from lane.source to lane.target.
-
-use crate::message_lane::{MessageLane, SourceHeaderIdOf, TargetHeaderIdOf};
-use crate::message_lane_loop::{
-	SourceClient as MessageLaneSourceClient, SourceClientState, TargetClient as MessageLaneTargetClient,
-	TargetClientState,
-};
-use crate::message_race_loop::{MessageRace, RaceState, RaceStrategy, SourceClient, TargetClient};
-use crate::utils::{FailedClient, HeaderId};
-
-use async_trait::async_trait;
-use futures::stream::FusedStream;
-use num_traits::{One, Zero};
-use std::{collections::VecDeque, marker::PhantomData, ops::RangeInclusive, time::Duration};
-
-/// Maximal number of messages to relay in single transaction.
-const MAX_MESSAGES_TO_RELAY_IN_SINGLE_TX: u32 = 4;
-
-/// Run message delivery race.
-pub async fn run<P: MessageLane>(
-	source_client: impl MessageLaneSourceClient<P>,
-	source_state_updates: impl FusedStream<Item = SourceClientState<P>>,
-	target_client: impl MessageLaneTargetClient<P>,
-	target_state_updates: impl FusedStream<Item = TargetClientState<P>>,
-	stall_timeout: Duration,
-) -> Result<(), FailedClient> {
-	crate::message_race_loop::run(
-		MessageDeliveryRaceSource {
-			client: source_client,
-			_phantom: Default::default(),
-		},
-		source_state_updates,
-		MessageDeliveryRaceTarget {
-			client: target_client,
-			_phantom: Default::default(),
-		},
-		target_state_updates,
-		stall_timeout,
-		MessageDeliveryStrategy::<P>::new(MAX_MESSAGES_TO_RELAY_IN_SINGLE_TX.into()),
-	)
-	.await
-}
-
-/// Message delivery race.
-struct MessageDeliveryRace<P>(std::marker::PhantomData<P>);
-
-impl<P: MessageLane> MessageRace for MessageDeliveryRace<P> {
-	type SourceHeaderId = SourceHeaderIdOf<P>;
-	type TargetHeaderId = TargetHeaderIdOf<P>;
-
-	type MessageNonce = P::MessageNonce;
-	type Proof = P::MessagesProof;
-
-	fn source_name() -> String {
-		format!("{}::MessagesDelivery", P::SOURCE_NAME)
-	}
-
-	fn target_name() -> String {
-		format!("{}::MessagesDelivery", P::TARGET_NAME)
-	}
-}
-
-/// Message delivery race source, which is a source of the lane.
-struct MessageDeliveryRaceSource<P: MessageLane, C> {
-	client: C,
-	_phantom: PhantomData<P>,
-}
-
-#[async_trait(?Send)]
-impl<P, C> SourceClient<MessageDeliveryRace<P>> for MessageDeliveryRaceSource<P, C>
-where
-	P: MessageLane,
-	C: MessageLaneSourceClient<P>,
-{
-	type Error = C::Error;
-
-	async fn latest_nonce(
-		&self,
-		at_block: SourceHeaderIdOf<P>,
-	) -> Result<(SourceHeaderIdOf<P>, P::MessageNonce), Self::Error> {
-		self.client.latest_generated_nonce(at_block).await
-	}
-
-	async fn generate_proof(
-		&self,
-		at_block: SourceHeaderIdOf<P>,
-		nonces: RangeInclusive<P::MessageNonce>,
-	) -> Result<(SourceHeaderIdOf<P>, RangeInclusive<P::MessageNonce>, P::MessagesProof), Self::Error> {
-		self.client.prove_messages(at_block, nonces).await
-	}
-}
-
-/// Message delivery race target, which is a target of the lane.
-struct MessageDeliveryRaceTarget<P: MessageLane, C> {
-	client: C,
-	_phantom: PhantomData<P>,
-}
-
-#[async_trait(?Send)]
-impl<P, C> TargetClient<MessageDeliveryRace<P>> for MessageDeliveryRaceTarget<P, C>
-where
-	P: MessageLane,
-	C: MessageLaneTargetClient<P>,
-{
-	type Error = C::Error;
-
-	async fn latest_nonce(
-		&self,
-		at_block: TargetHeaderIdOf<P>,
-	) -> Result<(TargetHeaderIdOf<P>, P::MessageNonce), Self::Error> {
-		self.client.latest_received_nonce(at_block).await
-	}
-
-	async fn submit_proof(
-		&self,
-		generated_at_block: SourceHeaderIdOf<P>,
-		nonces: RangeInclusive<P::MessageNonce>,
-		proof: P::MessagesProof,
-	) -> Result<RangeInclusive<P::MessageNonce>, Self::Error> {
-		self.client
-			.submit_messages_proof(generated_at_block, nonces, proof)
-			.await
-	}
-}
-
-/// Messages delivery strategy.
-type MessageDeliveryStrategy<P> = DeliveryStrategy<
-	<P as MessageLane>::SourceHeaderNumber,
-	<P as MessageLane>::SourceHeaderHash,
-	<P as MessageLane>::TargetHeaderNumber,
-	<P as MessageLane>::TargetHeaderHash,
-	<P as MessageLane>::MessageNonce,
-	<P as MessageLane>::MessagesProof,
->;
-
-/// Nonces delivery strategy.
-#[derive(Debug)]
-pub struct DeliveryStrategy<SourceHeaderNumber, SourceHeaderHash, TargetHeaderNumber, TargetHeaderHash, Nonce, Proof> {
-	/// All queued nonces.
-	source_queue: VecDeque<(HeaderId<SourceHeaderHash, SourceHeaderNumber>, Nonce)>,
-	/// Best nonce known to target node.
-	target_nonce: Nonce,
-	/// Max nonces to relay in single transaction.
-	max_nonces_to_relay_in_single_tx: Nonce,
-	/// Unused generic types dump.
-	_phantom: PhantomData<(TargetHeaderNumber, TargetHeaderHash, Proof)>,
-}
-
-impl<SourceHeaderNumber, SourceHeaderHash, TargetHeaderNumber, TargetHeaderHash, Nonce: Default, Proof>
-	DeliveryStrategy<SourceHeaderNumber, SourceHeaderHash, TargetHeaderNumber, TargetHeaderHash, Nonce, Proof>
-{
-	/// Create new delivery strategy.
-	pub fn new(max_nonces_to_relay_in_single_tx: Nonce) -> Self {
-		DeliveryStrategy {
-			source_queue: VecDeque::new(),
-			target_nonce: Default::default(),
-			max_nonces_to_relay_in_single_tx,
-			_phantom: Default::default(),
-		}
-	}
-}
-
-impl<SourceHeaderNumber, SourceHeaderHash, TargetHeaderNumber, TargetHeaderHash, Nonce, Proof>
-	RaceStrategy<
-		HeaderId<SourceHeaderHash, SourceHeaderNumber>,
-		HeaderId<TargetHeaderHash, TargetHeaderNumber>,
-		Nonce,
-		Proof,
-	> for DeliveryStrategy<SourceHeaderNumber, SourceHeaderHash, TargetHeaderNumber, TargetHeaderHash, Nonce, Proof>
-where
-	SourceHeaderHash: Clone,
-	SourceHeaderNumber: Clone + Ord,
-	Nonce: Clone + Copy + From<u32> + Ord + std::ops::Add<Output = Nonce> + One + Zero,
-{
-	fn is_empty(&self) -> bool {
-		self.source_queue.is_empty()
-	}
-
-	fn source_nonce_updated(&mut self, at_block: HeaderId<SourceHeaderHash, SourceHeaderNumber>, nonce: Nonce) {
-		if nonce <= self.target_nonce {
-			return;
-		}
-
-		match self.source_queue.back() {
-			Some((_, prev_nonce)) if *prev_nonce < nonce => (),
-			Some(_) => return,
-			None => (),
-		}
-
-		self.source_queue.push_back((at_block, nonce))
-	}
-
-	fn target_nonce_updated(
-		&mut self,
-		nonce: Nonce,
-		race_state: &mut RaceState<
-			HeaderId<SourceHeaderHash, SourceHeaderNumber>,
-			HeaderId<TargetHeaderHash, TargetHeaderNumber>,
-			Nonce,
-			Proof,
-		>,
-	) {
-		if nonce < self.target_nonce {
-			return;
-		}
-
-		while let Some(true) = self
-			.source_queue
-			.front()
-			.map(|(_, source_nonce)| *source_nonce <= nonce)
-		{
-			self.source_queue.pop_front();
-		}
-
-		let need_to_select_new_nonces = race_state
-			.nonces_to_submit
-			.as_ref()
-			.map(|(_, nonces, _)| *nonces.end() <= nonce)
-			.unwrap_or(false);
-		if need_to_select_new_nonces {
-			race_state.nonces_to_submit = None;
-		}
-
-		let need_new_nonces_to_submit = race_state
-			.nonces_submitted
-			.as_ref()
-			.map(|nonces| *nonces.end() <= nonce)
-			.unwrap_or(false);
-		if need_new_nonces_to_submit {
-			race_state.nonces_submitted = None;
-		}
-
-		self.target_nonce = nonce;
-	}
-
-	fn select_nonces_to_deliver(
-		&mut self,
-		race_state: &RaceState<
-			HeaderId<SourceHeaderHash, SourceHeaderNumber>,
-			HeaderId<TargetHeaderHash, TargetHeaderNumber>,
-			Nonce,
-			Proof,
-		>,
-	) -> Option<RangeInclusive<Nonce>> {
-		// if we have already selected nonces that we want to submit, do nothing
-		if race_state.nonces_to_submit.is_some() {
-			return None;
-		}
-
-		// if we already submitted some nonces, do nothing
-		if race_state.nonces_submitted.is_some() {
-			return None;
-		}
-
-		// 1) we want to deliver all nonces, starting from `target_nonce + 1`
-		// 2) we want to deliver at most `self.max_nonces_to_relay_in_single_tx` nonces in this batch
-		// 3) we can't deliver new nonce until header, that has emitted this nonce, is finalized
-		// by target client
-		let nonces_begin = self.target_nonce + 1.into();
-		let best_header_at_target = &race_state.target_state.as_ref()?.best_peer;
-		let mut nonces_end = None;
-		let mut i = Zero::zero();
-		while i < self.max_nonces_to_relay_in_single_tx {
-			let nonce = nonces_begin + i;
-
-			// if queue is empty, we don't need to prove anything
-			let (first_queued_at, first_queued_nonce) = match self.source_queue.front() {
-				Some((first_queued_at, first_queued_nonce)) => ((*first_queued_at).clone(), *first_queued_nonce),
-				None => break,
-			};
-
-			// if header that has queued the message is not yet finalized at bridged chain,
-			// we can't prove anything
-			if first_queued_at.0 > best_header_at_target.0 {
-				break;
-			}
-
-			// ok, we may deliver this nonce
-			nonces_end = Some(nonce);
-
-			// probably remove it from the queue?
-			if nonce == first_queued_nonce {
-				self.source_queue.pop_front();
-			}
-
-			i = i + One::one();
-		}
-
-		nonces_end.map(|nonces_end| RangeInclusive::new(nonces_begin, nonces_end))
-	}
-}
-
-#[cfg(test)]
-mod tests {
-	use super::*;
-	use crate::message_lane_loop::{
-		tests::{header_id, TestMessageLane, TestMessageNonce, TestMessagesProof},
-		ClientState,
-	};
-
-	#[test]
-	fn strategy_is_empty_works() {
-		let mut strategy = MessageDeliveryStrategy::<TestMessageLane>::new(4);
-		assert_eq!(strategy.is_empty(), true);
-		strategy.source_nonce_updated(header_id(1), 1);
-		assert_eq!(strategy.is_empty(), false);
-	}
-
-	#[test]
-	fn source_nonce_is_never_lower_than_known_target_nonce() {
-		let mut strategy = MessageDeliveryStrategy::<TestMessageLane>::new(4);
-		strategy.target_nonce_updated(10, &mut Default::default());
-		strategy.source_nonce_updated(header_id(1), 5);
-		assert_eq!(strategy.source_queue, vec![]);
-	}
-
-	#[test]
-	fn source_nonce_is_never_lower_than_latest_known_source_nonce() {
-		let mut strategy = MessageDeliveryStrategy::<TestMessageLane>::new(4);
-		strategy.source_nonce_updated(header_id(1), 5);
-		strategy.source_nonce_updated(header_id(2), 3);
-		strategy.source_nonce_updated(header_id(2), 5);
-		assert_eq!(strategy.source_queue, vec![(header_id(1), 5)]);
-	}
-
-	#[test]
-	fn target_nonce_is_never_lower_than_latest_known_target_nonce() {
-		let mut strategy = MessageDeliveryStrategy::<TestMessageLane>::new(4);
-		strategy.target_nonce_updated(10, &mut Default::default());
-		strategy.target_nonce_updated(5, &mut Default::default());
-		assert_eq!(strategy.target_nonce, 10);
-	}
-
-	#[test]
-	fn updated_target_nonce_removes_queued_entries() {
-		let mut strategy = MessageDeliveryStrategy::<TestMessageLane>::new(4);
-		strategy.source_nonce_updated(header_id(1), 5);
-		strategy.source_nonce_updated(header_id(2), 10);
-		strategy.source_nonce_updated(header_id(3), 15);
-		strategy.source_nonce_updated(header_id(4), 20);
-		strategy.target_nonce_updated(15, &mut Default::default());
-		assert_eq!(strategy.source_queue, vec![(header_id(4), 20)]);
-	}
-
-	#[test]
-	fn selected_nonces_are_dropped_on_target_nonce_update() {
-		let mut state = RaceState::default();
-		let mut strategy = MessageDeliveryStrategy::<TestMessageLane>::new(4);
-		state.nonces_to_submit = Some((header_id(1), 5..=10, 5..=10));
-		strategy.target_nonce_updated(7, &mut state);
-		assert!(state.nonces_to_submit.is_some());
-		strategy.target_nonce_updated(10, &mut state);
-		assert!(state.nonces_to_submit.is_none());
-	}
-
-	#[test]
-	fn submitted_nonces_are_dropped_on_target_nonce_update() {
-		let mut state = RaceState::default();
-		let mut strategy = MessageDeliveryStrategy::<TestMessageLane>::new(4);
-		state.nonces_submitted = Some(5..=10);
-		strategy.target_nonce_updated(7, &mut state);
-		assert!(state.nonces_submitted.is_some());
-		strategy.target_nonce_updated(10, &mut state);
-		assert!(state.nonces_submitted.is_none());
-	}
-
-	#[test]
-	fn nothing_is_selected_if_something_is_already_selected() {
-		let mut state = RaceState::default();
-		let mut strategy = MessageDeliveryStrategy::<TestMessageLane>::new(4);
-		state.nonces_to_submit = Some((header_id(1), 1..=10, 1..=10));
-		strategy.source_nonce_updated(header_id(1), 10);
-		assert_eq!(strategy.select_nonces_to_deliver(&state), None);
-	}
-
-	#[test]
-	fn nothing_is_selected_if_something_is_already_submitted() {
-		let mut state = RaceState::default();
-		let mut strategy = MessageDeliveryStrategy::<TestMessageLane>::new(4);
-		state.nonces_submitted = Some(1..=10);
-		strategy.source_nonce_updated(header_id(1), 10);
-		assert_eq!(strategy.select_nonces_to_deliver(&state), None);
-	}
-
-	#[test]
-	fn select_nonces_to_deliver_works() {
-		let mut state = RaceState::<_, _, TestMessageNonce, TestMessagesProof>::default();
-		let mut strategy = MessageDeliveryStrategy::<TestMessageLane>::new(4);
-		strategy.source_nonce_updated(header_id(1), 1);
-		strategy.source_nonce_updated(header_id(2), 2);
-		strategy.source_nonce_updated(header_id(3), 6);
-		strategy.source_nonce_updated(header_id(5), 8);
-
-		state.target_state = Some(ClientState {
-			best_self: header_id(0),
-			best_peer: header_id(4),
-		});
-		assert_eq!(strategy.select_nonces_to_deliver(&state), Some(1..=4));
-		strategy.target_nonce_updated(4, &mut state);
-		assert_eq!(strategy.select_nonces_to_deliver(&state), Some(5..=6));
-		strategy.target_nonce_updated(6, &mut state);
-		assert_eq!(strategy.select_nonces_to_deliver(&state), None);
-
-		state.target_state = Some(ClientState {
-			best_self: header_id(0),
-			best_peer: header_id(5),
-		});
-		assert_eq!(strategy.select_nonces_to_deliver(&state), Some(7..=8));
-		strategy.target_nonce_updated(8, &mut state);
-		assert_eq!(strategy.select_nonces_to_deliver(&state), None);
-	}
-}

bridges/relays/ethereum/src/message_race_loop.rs

@@ -1,359 +0,0 @@
-// 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.
-
-//! Loop that is serving single race within message lane. This could be
-//! message delivery race, receiving confirmations race or processing
-//! confirmations race.
-//!
-//! The idea of the race is simple - we have `nonce`-s on source and target
-//! nodes. We're trying to prove that the source node has this nonce (and
-//! associated data - like messages, lane state, etc) to the target node by
-//! generating and submitting proof.
-
-// Until there'll be actual message-lane in the runtime.
-#![allow(dead_code)]
-
-use crate::message_lane_loop::ClientState;
-use crate::utils::{process_future_result, retry_backoff, FailedClient, MaybeConnectionError};
-
-use async_trait::async_trait;
-use futures::{
-	future::FutureExt,
-	stream::{FusedStream, StreamExt},
-};
-use std::{
-	fmt::Debug,
-	ops::RangeInclusive,
-	time::{Duration, Instant},
-};
-
-/// One of races within lane.
-pub trait MessageRace {
-	/// Header id of the race source.
-	type SourceHeaderId: Debug + Clone + PartialEq;
-	/// Header id of the race source.
-	type TargetHeaderId: Debug + Clone + PartialEq;
-
-	/// Message nonce used in the race.
-	type MessageNonce: Debug + Clone;
-	/// Proof that is generated and delivered in this race.
-	type Proof: Clone;
-
-	/// Name of the race source.
-	fn source_name() -> String;
-	/// Name of the race target.
-	fn target_name() -> String;
-}
-
-/// State of race source client.
-type SourceClientState<P> = ClientState<<P as MessageRace>::SourceHeaderId, <P as MessageRace>::TargetHeaderId>;
-
-/// State of race target client.
-type TargetClientState<P> = ClientState<<P as MessageRace>::TargetHeaderId, <P as MessageRace>::SourceHeaderId>;
-
-/// One of message lane clients, which is source client for the race.
-#[async_trait(?Send)]
-pub trait SourceClient<P: MessageRace> {
-	/// Type of error this clients returns.
-	type Error: std::fmt::Debug + MaybeConnectionError;
-
-	/// Return latest nonce that is known to the source client.
-	async fn latest_nonce(
-		&self,
-		at_block: P::SourceHeaderId,
-	) -> Result<(P::SourceHeaderId, P::MessageNonce), Self::Error>;
-	/// Generate proof for delivering to the target client.
-	async fn generate_proof(
-		&self,
-		at_block: P::SourceHeaderId,
-		nonces: RangeInclusive<P::MessageNonce>,
-	) -> Result<(P::SourceHeaderId, RangeInclusive<P::MessageNonce>, P::Proof), Self::Error>;
-}
-
-/// One of message lane clients, which is target client for the race.
-#[async_trait(?Send)]
-pub trait TargetClient<P: MessageRace> {
-	/// Type of error this clients returns.
-	type Error: std::fmt::Debug + MaybeConnectionError;
-
-	/// Return latest nonce that is known to the target client.
-	async fn latest_nonce(
-		&self,
-		at_block: P::TargetHeaderId,
-	) -> Result<(P::TargetHeaderId, P::MessageNonce), Self::Error>;
-	/// Submit proof to the target client.
-	async fn submit_proof(
-		&self,
-		generated_at_block: P::SourceHeaderId,
-		nonces: RangeInclusive<P::MessageNonce>,
-		proof: P::Proof,
-	) -> Result<RangeInclusive<P::MessageNonce>, Self::Error>;
-}
-
-/// Race strategy.
-pub trait RaceStrategy<SourceHeaderId, TargetHeaderId, MessageNonce, Proof> {
-	/// Should return true if nothing has to be synced.
-	fn is_empty(&self) -> bool;
-	/// Called when latest nonce is updated at source node of the race.
-	fn source_nonce_updated(&mut self, at_block: SourceHeaderId, nonce: MessageNonce);
-	/// Called when latest nonce is updated at target node of the race.
-	fn target_nonce_updated(
-		&mut self,
-		nonce: MessageNonce,
-		race_state: &mut RaceState<SourceHeaderId, TargetHeaderId, MessageNonce, Proof>,
-	);
-	/// Should return `Some(nonces)` if we need to deliver proof of `nonces` (and associated
-	/// data) from source to target node.
-	fn select_nonces_to_deliver(
-		&mut self,
-		race_state: &RaceState<SourceHeaderId, TargetHeaderId, MessageNonce, Proof>,
-	) -> Option<RangeInclusive<MessageNonce>>;
-}
-
-/// State of the race.
-pub struct RaceState<SourceHeaderId, TargetHeaderId, MessageNonce, Proof> {
-	/// Source state, if known.
-	pub source_state: Option<ClientState<SourceHeaderId, TargetHeaderId>>,
-	/// Target state, if known.
-	pub target_state: Option<ClientState<TargetHeaderId, SourceHeaderId>>,
-	/// Range of nonces that we have selected to submit.
-	pub nonces_to_submit: Option<(SourceHeaderId, RangeInclusive<MessageNonce>, Proof)>,
-	/// Range of nonces that is currently submitted.
-	pub nonces_submitted: Option<RangeInclusive<MessageNonce>>,
-}
-
-/// Run race loop until connection with target or source node is lost.
-pub async fn run<P: MessageRace>(
-	race_source: impl SourceClient<P>,
-	race_source_updated: impl FusedStream<Item = SourceClientState<P>>,
-	race_target: impl TargetClient<P>,
-	race_target_updated: impl FusedStream<Item = TargetClientState<P>>,
-	stall_timeout: Duration,
-	mut strategy: impl RaceStrategy<P::SourceHeaderId, P::TargetHeaderId, P::MessageNonce, P::Proof>,
-) -> Result<(), FailedClient> {
-	let mut race_state = RaceState::default();
-	let mut stall_countdown = Instant::now();
-
-	let mut source_retry_backoff = retry_backoff();
-	let mut source_client_is_online = true;
-	let mut source_latest_nonce_required = false;
-	let source_latest_nonce = futures::future::Fuse::terminated();
-	let source_generate_proof = futures::future::Fuse::terminated();
-	let source_go_offline_future = futures::future::Fuse::terminated();
-
-	let mut target_retry_backoff = retry_backoff();
-	let mut target_client_is_online = true;
-	let mut target_latest_nonce_required = false;
-	let target_latest_nonce = futures::future::Fuse::terminated();
-	let target_submit_proof = futures::future::Fuse::terminated();
-	let target_go_offline_future = futures::future::Fuse::terminated();
-
-	futures::pin_mut!(
-		race_source_updated,
-		source_latest_nonce,
-		source_generate_proof,
-		source_go_offline_future,
-		race_target_updated,
-		target_latest_nonce,
-		target_submit_proof,
-		target_go_offline_future,
-	);
-
-	loop {
-		futures::select! {
-			// when headers ids are updated
-			source_state = race_source_updated.next() => {
-				if let Some(source_state) = source_state {
-					if race_state.source_state.as_ref() != Some(&source_state) {
-						source_latest_nonce_required = true;
-						race_state.source_state = Some(source_state);
-					}
-				}
-			},
-			target_state = race_target_updated.next() => {
-				if let Some(target_state) = target_state {
-					if race_state.target_state.as_ref() != Some(&target_state) {
-						target_latest_nonce_required = true;
-						race_state.target_state = Some(target_state);
-					}
-				}
-			},
-
-			// when nonces are updated
-			latest_nonce = source_latest_nonce => {
-				source_latest_nonce_required = false;
-
-				source_client_is_online = process_future_result(
-					latest_nonce,
-					&mut source_retry_backoff,
-					|(at_block, latest_nonce)| {
-						log::debug!(
-							target: "bridge",
-							"Received latest nonce from {}: {:?}",
-							P::source_name(),
-							latest_nonce,
-						);
-
-						strategy.source_nonce_updated(at_block, latest_nonce);
-					},
-					&mut source_go_offline_future,
-					|delay| async_std::task::sleep(delay),
-					|| format!("Error retrieving latest nonce from {}", P::source_name()),
-				).fail_if_connection_error(FailedClient::Source)?;
-			},
-			latest_nonce = target_latest_nonce => {
-				target_latest_nonce_required = false;
-
-				target_client_is_online = process_future_result(
-					latest_nonce,
-					&mut target_retry_backoff,
-					|(_, latest_nonce)| {
-						log::debug!(
-							target: "bridge",
-							"Received latest nonce from {}: {:?}",
-							P::target_name(),
-							latest_nonce,
-						);
-
-						strategy.target_nonce_updated(latest_nonce, &mut race_state);
-					},
-					&mut target_go_offline_future,
-					|delay| async_std::task::sleep(delay),
-					|| format!("Error retrieving latest nonce from {}", P::target_name()),
-				).fail_if_connection_error(FailedClient::Target)?;
-			},
-
-			// proof generation and submission
-			proof = source_generate_proof => {
-				source_client_is_online = process_future_result(
-					proof,
-					&mut source_retry_backoff,
-					|(at_block, nonces_range, proof)| {
-						log::debug!(
-							target: "bridge",
-							"Received proof for nonces in range {:?} from {}",
-							nonces_range,
-							P::source_name(),
-						);
-
-						race_state.nonces_to_submit = Some((at_block, nonces_range, proof));
-					},
-					&mut source_go_offline_future,
-					|delay| async_std::task::sleep(delay),
-					|| format!("Error generating proof at {}", P::source_name()),
-				).fail_if_connection_error(FailedClient::Source)?;
-			},
-			proof_submit_result = target_submit_proof => {
-				target_client_is_online = process_future_result(
-					proof_submit_result,
-					&mut target_retry_backoff,
-					|nonces_range| {
-						log::debug!(
-							target: "bridge",
-							"Successfully submitted proof of nonces {:?} to {}",
-							nonces_range,
-							P::target_name(),
-						);
-
-						race_state.nonces_to_submit = None;
-						race_state.nonces_submitted = Some(nonces_range);
-					},
-					&mut target_go_offline_future,
-					|delay| async_std::task::sleep(delay),
-					|| format!("Error submitting proof {}", P::target_name()),
-				).fail_if_connection_error(FailedClient::Target)?;
-			}
-		}
-
-		if stall_countdown.elapsed() > stall_timeout {
-			return Err(FailedClient::Both);
-		} else if race_state.nonces_to_submit.is_none() && race_state.nonces_submitted.is_none() && strategy.is_empty()
-		{
-			stall_countdown = Instant::now();
-		}
-
-		if source_client_is_online {
-			source_client_is_online = false;
-
-			let nonces_to_deliver = race_state.source_state.as_ref().and_then(|source_state| {
-				strategy
-					.select_nonces_to_deliver(&race_state)
-					.map(|nonces_range| (source_state.best_self.clone(), nonces_range))
-			});
-
-			if let Some((at_block, nonces_range)) = nonces_to_deliver {
-				log::debug!(
-					target: "bridge",
-					"Asking {} to prove nonces in range {:?}",
-					P::source_name(),
-					nonces_range,
-				);
-				source_generate_proof.set(race_source.generate_proof(at_block, nonces_range).fuse());
-			} else if source_latest_nonce_required {
-				log::debug!(target: "bridge", "Asking {} about latest generated message nonce", P::source_name());
-				let at_block = race_state
-					.source_state
-					.as_ref()
-					.expect("source_latest_nonce_required is only true when source_state is Some; qed")
-					.best_self
-					.clone();
-				source_latest_nonce.set(race_source.latest_nonce(at_block).fuse());
-			} else {
-				source_client_is_online = true;
-			}
-		}
-
-		if target_client_is_online {
-			target_client_is_online = false;
-
-			if let Some((at_block, nonces_range, proof)) = race_state.nonces_to_submit.as_ref() {
-				log::debug!(
-					target: "bridge",
-					"Going to submit proof of messages in range {:?} to {} node",
-					nonces_range,
-					P::target_name(),
-				);
-				target_submit_proof.set(
-					race_target
-						.submit_proof(at_block.clone(), nonces_range.clone(), proof.clone())
-						.fuse(),
-				);
-			}
-			if target_latest_nonce_required {
-				log::debug!(target: "bridge", "Asking {} about latest nonce", P::target_name());
-				let at_block = race_state
-					.target_state
-					.as_ref()
-					.expect("target_latest_nonce_required is only true when target_state is Some; qed")
-					.best_self
-					.clone();
-				target_latest_nonce.set(race_target.latest_nonce(at_block).fuse());
-			} else {
-				target_client_is_online = true;
-			}
-		}
-	}
-}
-
-impl<SourceHeaderId, TargetHeaderId, MessageNonce, Proof> Default
-	for RaceState<SourceHeaderId, TargetHeaderId, MessageNonce, Proof>
-{
-	fn default() -> Self {
-		RaceState {
-			source_state: None,
-			target_state: None,
-			nonces_to_submit: None,
-			nonces_submitted: None,
-		}
-	}
-}

bridges/relays/ethereum/src/message_race_receiving.rs

@@ -1,152 +0,0 @@
-// 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.
-
-use crate::message_lane::{MessageLane, SourceHeaderIdOf, TargetHeaderIdOf};
-use crate::message_lane_loop::{
-	SourceClient as MessageLaneSourceClient, SourceClientState, TargetClient as MessageLaneTargetClient,
-	TargetClientState,
-};
-use crate::message_race_delivery::DeliveryStrategy;
-use crate::message_race_loop::{MessageRace, SourceClient, TargetClient};
-use crate::utils::FailedClient;
-
-use async_trait::async_trait;
-use futures::stream::FusedStream;
-use std::{marker::PhantomData, ops::RangeInclusive, time::Duration};
-
-/// Message receiving confirmations delivery strategy.
-type ReceivingConfirmationsDeliveryStrategy<P> = DeliveryStrategy<
-	<P as MessageLane>::TargetHeaderNumber,
-	<P as MessageLane>::TargetHeaderHash,
-	<P as MessageLane>::SourceHeaderNumber,
-	<P as MessageLane>::SourceHeaderHash,
-	<P as MessageLane>::MessageNonce,
-	<P as MessageLane>::MessagesReceivingProof,
->;
-
-/// Run receiving confirmations race.
-pub async fn run<P: MessageLane>(
-	source_client: impl MessageLaneSourceClient<P>,
-	source_state_updates: impl FusedStream<Item = SourceClientState<P>>,
-	target_client: impl MessageLaneTargetClient<P>,
-	target_state_updates: impl FusedStream<Item = TargetClientState<P>>,
-	stall_timeout: Duration,
-) -> Result<(), FailedClient> {
-	crate::message_race_loop::run(
-		ReceivingConfirmationsRaceSource {
-			client: target_client,
-			_phantom: Default::default(),
-		},
-		target_state_updates,
-		ReceivingConfirmationsRaceTarget {
-			client: source_client,
-			_phantom: Default::default(),
-		},
-		source_state_updates,
-		stall_timeout,
-		ReceivingConfirmationsDeliveryStrategy::<P>::new(std::u32::MAX.into()),
-	)
-	.await
-}
-
-/// Messages receiving confirmations race.
-struct ReceivingConfirmationsRace<P>(std::marker::PhantomData<P>);
-
-impl<P: MessageLane> MessageRace for ReceivingConfirmationsRace<P> {
-	type SourceHeaderId = TargetHeaderIdOf<P>;
-	type TargetHeaderId = SourceHeaderIdOf<P>;
-
-	type MessageNonce = P::MessageNonce;
-	type Proof = P::MessagesReceivingProof;
-
-	fn source_name() -> String {
-		format!("{}::ReceivingConfirmationsDelivery", P::SOURCE_NAME)
-	}
-
-	fn target_name() -> String {
-		format!("{}::ReceivingConfirmationsDelivery", P::TARGET_NAME)
-	}
-}
-
-/// Message receiving confirmations race source, which is a target of the lane.
-struct ReceivingConfirmationsRaceSource<P: MessageLane, C> {
-	client: C,
-	_phantom: PhantomData<P>,
-}
-
-#[async_trait(?Send)]
-impl<P, C> SourceClient<ReceivingConfirmationsRace<P>> for ReceivingConfirmationsRaceSource<P, C>
-where
-	P: MessageLane,
-	C: MessageLaneTargetClient<P>,
-{
-	type Error = C::Error;
-
-	async fn latest_nonce(
-		&self,
-		at_block: TargetHeaderIdOf<P>,
-	) -> Result<(TargetHeaderIdOf<P>, P::MessageNonce), Self::Error> {
-		self.client.latest_received_nonce(at_block).await
-	}
-
-	async fn generate_proof(
-		&self,
-		at_block: TargetHeaderIdOf<P>,
-		nonces: RangeInclusive<P::MessageNonce>,
-	) -> Result<
-		(
-			TargetHeaderIdOf<P>,
-			RangeInclusive<P::MessageNonce>,
-			P::MessagesReceivingProof,
-		),
-		Self::Error,
-	> {
-		self.client
-			.prove_messages_receiving(at_block)
-			.await
-			.map(|(at_block, proof)| (at_block, nonces, proof))
-	}
-}
-
-/// Message receiving confirmations race target, which is a source of the lane.
-struct ReceivingConfirmationsRaceTarget<P: MessageLane, C> {
-	client: C,
-	_phantom: PhantomData<P>,
-}
-
-#[async_trait(?Send)]
-impl<P, C> TargetClient<ReceivingConfirmationsRace<P>> for ReceivingConfirmationsRaceTarget<P, C>
-where
-	P: MessageLane,
-	C: MessageLaneSourceClient<P>,
-{
-	type Error = C::Error;
-
-	async fn latest_nonce(
-		&self,
-		at_block: SourceHeaderIdOf<P>,
-	) -> Result<(SourceHeaderIdOf<P>, P::MessageNonce), Self::Error> {
-		self.client.latest_confirmed_received_nonce(at_block).await
-	}
-
-	async fn submit_proof(
-		&self,
-		generated_at_block: TargetHeaderIdOf<P>,
-		_nonces: RangeInclusive<P::MessageNonce>,
-		proof: P::MessagesReceivingProof,
-	) -> Result<RangeInclusive<P::MessageNonce>, Self::Error> {
-		self.client
-			.submit_messages_receiving_proof(generated_at_block, proof)
-			.await
-	}
-}

bridges/relays/ethereum/src/metrics.rs

@@ -1,165 +0,0 @@
-// 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/>.
-
-pub use substrate_prometheus_endpoint::{register, Counter, CounterVec, Gauge, GaugeVec, Opts, Registry, F64, U64};
-
-use std::net::SocketAddr;
-use substrate_prometheus_endpoint::init_prometheus;
-use sysinfo::{ProcessExt, RefreshKind, System, SystemExt};
-
-/// Prometheus endpoint MetricsParams.
-#[derive(Debug, Clone)]
-pub struct MetricsParams {
-	/// Serve HTTP requests at given host.
-	pub host: String,
-	/// Serve HTTP requests at given port.
-	pub port: u16,
-}
-
-/// Metrics API.
-pub trait Metrics {
-	/// Register metrics in the registry.
-	fn register(&self, registry: &Registry) -> Result<(), String>;
-}
-
-/// Global Prometheus metrics.
-#[derive(Debug)]
-pub struct GlobalMetrics {
-	system: System,
-	system_average_load: GaugeVec<F64>,
-	process_cpu_usage_percentage: Gauge<F64>,
-	process_memory_usage_bytes: Gauge<U64>,
-}
-
-/// Start Prometheus endpoint with given metrics registry.
-pub fn start(
-	prefix: String,
-	params: Option<MetricsParams>,
-	global_metrics: &GlobalMetrics,
-	extra_metrics: &impl Metrics,
-) {
-	let params = match params {
-		Some(params) => params,
-		None => return,
-	};
-
-	assert!(!prefix.is_empty(), "Metrics prefix can not be empty");
-
-	let do_start = move || {
-		let prometheus_socket_addr = SocketAddr::new(
-			params
-				.host
-				.parse()
-				.map_err(|err| format!("Invalid Prometheus host {}: {}", params.host, err))?,
-			params.port,
-		);
-		let metrics_registry =
-			Registry::new_custom(Some(prefix), None).expect("only fails if prefix is empty; prefix is not empty; qed");
-		global_metrics.register(&metrics_registry)?;
-		extra_metrics.register(&metrics_registry)?;
-		async_std::task::spawn(async move {
-			init_prometheus(prometheus_socket_addr, metrics_registry)
-				.await
-				.map_err(|err| format!("Error starting Prometheus endpoint: {}", err))
-		});
-
-		Ok(())
-	};
-
-	let result: Result<(), String> = do_start();
-	if let Err(err) = result {
-		log::warn!(
-			target: "bridge",
-			"Failed to expose metrics: {}",
-			err,
-		);
-	}
-}
-
-impl Default for MetricsParams {
-	fn default() -> Self {
-		MetricsParams {
-			host: "127.0.0.1".into(),
-			port: 9616,
-		}
-	}
-}
-
-impl Metrics for GlobalMetrics {
-	fn register(&self, registry: &Registry) -> Result<(), String> {
-		register(self.system_average_load.clone(), registry).map_err(|e| e.to_string())?;
-		register(self.process_cpu_usage_percentage.clone(), registry).map_err(|e| e.to_string())?;
-		register(self.process_memory_usage_bytes.clone(), registry).map_err(|e| e.to_string())?;
-		Ok(())
-	}
-}
-
-impl GlobalMetrics {
-	/// Creates global metrics.
-	pub fn new() -> Self {
-		GlobalMetrics {
-			system: System::new_with_specifics(RefreshKind::everything()),
-			system_average_load: GaugeVec::new(Opts::new("system_average_load", "System load average"), &["over"])
-				.expect("metric is static and thus valid; qed"),
-			process_cpu_usage_percentage: Gauge::new("process_cpu_usage_percentage", "Process CPU usage")
-				.expect("metric is static and thus valid; qed"),
-			process_memory_usage_bytes: Gauge::new(
-				"process_memory_usage_bytes",
-				"Process memory (resident set size) usage",
-			)
-			.expect("metric is static and thus valid; qed"),
-		}
-	}
-
-	/// Update metrics.
-	pub fn update(&mut self) {
-		// update system-wide metrics
-		let load = self.system.get_load_average();
-		self.system_average_load.with_label_values(&["1min"]).set(load.one);
-		self.system_average_load.with_label_values(&["5min"]).set(load.five);
-		self.system_average_load.with_label_values(&["15min"]).set(load.fifteen);
-
-		// update process-related metrics
-		let pid = sysinfo::get_current_pid().expect(
-			"only fails where pid is unavailable (os=unknown || arch=wasm32);\
-				relay is not supposed to run in such MetricsParamss;\
-				qed",
-		);
-		let is_process_refreshed = self.system.refresh_process(pid);
-		match (is_process_refreshed, self.system.get_process(pid)) {
-			(true, Some(process_info)) => {
-				let cpu_usage = process_info.cpu_usage() as f64;
-				let memory_usage = process_info.memory() * 1024;
-				log::trace!(
-					target: "bridge-metrics",
-					"Refreshed process metrics: CPU={}, memory={}",
-					cpu_usage,
-					memory_usage,
-				);
-
-				self.process_cpu_usage_percentage
-					.set(if cpu_usage.is_finite() { cpu_usage } else { 0f64 });
-				self.process_memory_usage_bytes.set(memory_usage);
-			}
-			_ => {
-				log::warn!(
-					target: "bridge",
-					"Failed to refresh process information. Metrics may show obsolete values",
-				);
-			}
-		}
-	}
-}

bridges/relays/ethereum/src/rpc_errors.rs

@@ -14,9 +14,8 @@
 // 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/>.
 
-use crate::utils::MaybeConnectionError;
-
 use jsonrpsee::client::RequestError;
+use relay_utils::MaybeConnectionError;
 
 /// Contains common errors that can occur when
 /// interacting with a Substrate or Ethereum node

bridges/relays/ethereum/src/substrate_client.rs

@@ -19,16 +19,16 @@ use crate::instances::BridgeInstance;
 use crate::rpc::{Substrate, SubstrateRpc};
 use crate::rpc_errors::RpcError;
 use crate::substrate_types::{Hash, Header as SubstrateHeader, Number, SignedBlock as SignedSubstrateBlock};
-use crate::sync_types::SubmittedHeaders;
-use crate::utils::HeaderId;
 
 use async_trait::async_trait;
 use bp_eth_poa::AuraHeader as SubstrateEthereumHeader;
 use codec::{Decode, Encode};
+use headers_relay::sync_types::SubmittedHeaders;
 use jsonrpsee::raw::RawClient;
 use jsonrpsee::transport::http::HttpTransportClient;
 use jsonrpsee::Client;
 use num_traits::Zero;
+use relay_utils::HeaderId;
 use sp_core::crypto::Pair;
 use sp_runtime::traits::IdentifyAccount;
 use std::collections::VecDeque;

bridges/relays/ethereum/src/substrate_sync_loop.rs

@@ -21,18 +21,21 @@ use crate::ethereum_client::{
 };
 use crate::ethereum_types::Address;
 use crate::instances::BridgeInstance;
-use crate::metrics::MetricsParams;
 use crate::rpc::SubstrateRpc;
 use crate::rpc_errors::RpcError;
 use crate::substrate_client::{SubstrateConnectionParams, SubstrateRpcClient};
 use crate::substrate_types::{
-	GrandpaJustification, Hash, Header, Number, QueuedSubstrateHeader, SubstrateHeaderId, SubstrateHeadersSyncPipeline,
+	GrandpaJustification, Hash, Number, QueuedSubstrateHeader, SubstrateHeaderId, SubstrateHeadersSyncPipeline,
+	SubstrateSyncHeader as Header,
 };
-use crate::sync::HeadersSyncParams;
-use crate::sync_loop::{SourceClient, TargetClient};
-use crate::sync_types::{SourceHeader, SubmittedHeaders};
 
 use async_trait::async_trait;
+use headers_relay::{
+	sync::HeadersSyncParams,
+	sync_loop::{SourceClient, TargetClient},
+	sync_types::{SourceHeader, SubmittedHeaders},
+};
+use relay_utils::metrics::MetricsParams;
 
 use std::fmt::Debug;
 use std::{collections::HashSet, time::Duration};
@@ -92,11 +95,11 @@ impl SourceClient<SubstrateHeadersSyncPipeline> for SubstrateHeadersSource {
 	}
 
 	async fn header_by_hash(&self, hash: Hash) -> Result<Header, Self::Error> {
-		self.client.header_by_hash(hash).await
+		self.client.header_by_hash(hash).await.map(Into::into)
 	}
 
 	async fn header_by_number(&self, number: Number) -> Result<Header, Self::Error> {
-		self.client.header_by_number(number).await
+		self.client.header_by_number(number).await.map(Into::into)
 	}
 
 	async fn header_completion(
@@ -197,7 +200,7 @@ pub fn run(params: SubstrateSyncParams) -> Result<(), RpcError> {
 	let target = EthereumHeadersTarget::new(eth_client, eth_contract_address, eth_sign);
 	let source = SubstrateHeadersSource::new(sub_client);
 
-	crate::sync_loop::run(
+	headers_relay::sync_loop::run(
 		source,
 		consts::SUBSTRATE_TICK_INTERVAL,
 		target,

bridges/relays/ethereum/src/substrate_types.rs

@@ -17,10 +17,10 @@
 use crate::ethereum_types::{
 	Header as EthereumHeader, Receipt as EthereumReceipt, HEADER_ID_PROOF as ETHEREUM_HEADER_ID_PROOF,
 };
-use crate::sync_types::{HeadersSyncPipeline, QueuedHeader, SourceHeader};
-use crate::utils::HeaderId;
 
 use codec::Encode;
+use headers_relay::sync_types::{HeadersSyncPipeline, QueuedHeader, SourceHeader};
+use relay_utils::HeaderId;
 
 pub use bp_eth_poa::{
 	Address, AuraHeader as SubstrateEthereumHeader, Bloom, Bytes, LogEntry as SubstrateEthereumLogEntry,
@@ -36,6 +36,17 @@ pub type Number = rialto_runtime::BlockNumber;
 /// Substrate header type.
 pub type Header = rialto_runtime::Header;
 
+/// Substrate header type used in headers sync.
+#[derive(Clone, Debug, PartialEq)]
+pub struct SubstrateSyncHeader(Header);
+
+impl std::ops::Deref for SubstrateSyncHeader {
+	type Target = Header;
+	fn deref(&self) -> &Self::Target {
+		&self.0
+	}
+}
+
 /// Substrate signed block type.
 pub type SignedBlock = rialto_runtime::SignedBlock;
 
@@ -59,7 +70,7 @@ impl HeadersSyncPipeline for SubstrateHeadersSyncPipeline {
 
 	type Hash = rialto_runtime::Hash;
 	type Number = rialto_runtime::BlockNumber;
-	type Header = Header;
+	type Header = SubstrateSyncHeader;
 	type Extra = ();
 	type Completion = GrandpaJustification;
 
@@ -68,7 +79,13 @@ impl HeadersSyncPipeline for SubstrateHeadersSyncPipeline {
 	}
 }
 
-impl SourceHeader<rialto_runtime::Hash, rialto_runtime::BlockNumber> for Header {
+impl From<Header> for SubstrateSyncHeader {
+	fn from(header: Header) -> Self {
+		Self(header)
+	}
+}
+
+impl SourceHeader<rialto_runtime::Hash, rialto_runtime::BlockNumber> for SubstrateSyncHeader {
 	fn id(&self) -> SubstrateHeaderId {
 		HeaderId(self.number, self.hash())
 	}

bridges/relays/ethereum/src/sync.rs

@@ -1,550 +0,0 @@
-// 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/>.
-
-use crate::headers::QueuedHeaders;
-use crate::sync_types::{HeaderIdOf, HeaderStatus, HeadersSyncPipeline, QueuedHeader};
-use num_traits::{One, Saturating, Zero};
-
-/// Common sync params.
-#[derive(Debug, Clone)]
-pub struct HeadersSyncParams {
-	/// Maximal number of ethereum headers to pre-download.
-	pub max_future_headers_to_download: usize,
-	/// Maximal number of active (we believe) submit header transactions.
-	pub max_headers_in_submitted_status: usize,
-	/// Maximal number of headers in single submit request.
-	pub max_headers_in_single_submit: usize,
-	/// Maximal total headers size in single submit request.
-	pub max_headers_size_in_single_submit: usize,
-	/// We only may store and accept (from Ethereum node) headers that have
-	/// number >= than best_substrate_header.number - prune_depth.
-	pub prune_depth: u32,
-	/// Target transactions mode.
-	pub target_tx_mode: TargetTransactionMode,
-}
-
-impl HeadersSyncParams {
-	/// Default parameters for syncing Ethereum headers.
-	pub fn ethereum_sync_default() -> Self {
-		use crate::ethereum_sync_loop::consts::*;
-
-		Self {
-			max_future_headers_to_download: MAX_FUTURE_HEADERS_TO_DOWNLOAD,
-			max_headers_in_submitted_status: MAX_SUBMITTED_HEADERS,
-			max_headers_in_single_submit: MAX_HEADERS_IN_SINGLE_SUBMIT,
-			max_headers_size_in_single_submit: MAX_HEADERS_SIZE_IN_SINGLE_SUBMIT,
-			prune_depth: PRUNE_DEPTH,
-			target_tx_mode: TargetTransactionMode::Signed,
-		}
-	}
-
-	/// Default parameters for syncing Substrate headers.
-	pub fn substrate_sync_default() -> Self {
-		use crate::substrate_sync_loop::consts::*;
-
-		Self {
-			max_future_headers_to_download: MAX_FUTURE_HEADERS_TO_DOWNLOAD,
-			max_headers_in_submitted_status: MAX_SUBMITTED_HEADERS,
-			// since we always have single Substrate header in separate Ethereum transaction,
-			// all max_**_in_single_submit aren't important here
-			max_headers_in_single_submit: 4,
-			max_headers_size_in_single_submit: std::usize::MAX,
-			prune_depth: PRUNE_DEPTH,
-			target_tx_mode: TargetTransactionMode::Signed,
-		}
-	}
-}
-
-/// Target transaction mode.
-#[derive(Debug, PartialEq, Clone)]
-pub enum TargetTransactionMode {
-	/// Submit new headers using signed transactions.
-	Signed,
-	/// Submit new headers using unsigned transactions.
-	Unsigned,
-	/// Submit new headers using signed transactions, but only when we
-	/// believe that sync has stalled.
-	Backup,
-}
-
-/// Headers synchronization context.
-#[derive(Debug)]
-pub struct HeadersSync<P: HeadersSyncPipeline> {
-	/// Synchronization parameters.
-	params: HeadersSyncParams,
-	/// Best header number known to source node.
-	source_best_number: Option<P::Number>,
-	/// Best header known to target node.
-	target_best_header: Option<HeaderIdOf<P>>,
-	/// Headers queue.
-	headers: QueuedHeaders<P>,
-	/// Pause headers submission.
-	pause_submit: bool,
-}
-
-impl<P: HeadersSyncPipeline> HeadersSync<P> {
-	/// Creates new headers synchronizer.
-	pub fn new(params: HeadersSyncParams) -> Self {
-		HeadersSync {
-			headers: QueuedHeaders::new(),
-			params,
-			source_best_number: None,
-			target_best_header: None,
-			pause_submit: false,
-		}
-	}
-
-	/// Return best header number known to source node.
-	pub fn source_best_number(&self) -> Option<P::Number> {
-		self.source_best_number
-	}
-
-	/// Best header known to target node.
-	pub fn target_best_header(&self) -> Option<HeaderIdOf<P>> {
-		self.target_best_header
-	}
-
-	/// Returns true if we have synced almost all known headers.
-	pub fn is_almost_synced(&self) -> bool {
-		match self.source_best_number {
-			Some(source_best_number) => self
-				.target_best_header
-				.map(|best| source_best_number.saturating_sub(best.0) < 4.into())
-				.unwrap_or(false),
-			None => true,
-		}
-	}
-
-	/// Returns synchronization status.
-	pub fn status(&self) -> (&Option<HeaderIdOf<P>>, &Option<P::Number>) {
-		(&self.target_best_header, &self.source_best_number)
-	}
-
-	/// Returns reference to the headers queue.
-	pub fn headers(&self) -> &QueuedHeaders<P> {
-		&self.headers
-	}
-
-	/// Returns mutable reference to the headers queue.
-	pub fn headers_mut(&mut self) -> &mut QueuedHeaders<P> {
-		&mut self.headers
-	}
-
-	/// Select header that needs to be downloaded from the source node.
-	pub fn select_new_header_to_download(&self) -> Option<P::Number> {
-		// if we haven't received best header from source node yet, there's nothing we can download
-		let source_best_number = self.source_best_number?;
-
-		// if we haven't received known best header from target node yet, there's nothing we can download
-		let target_best_header = self.target_best_header.as_ref()?;
-
-		// if there's too many headers in the queue, stop downloading
-		let in_memory_headers = self.headers.total_headers();
-		if in_memory_headers >= self.params.max_future_headers_to_download {
-			return None;
-		}
-
-		// if queue is empty and best header on target is > than best header on source,
-		// then we shoud reorg
-		let best_queued_number = self.headers.best_queued_number();
-		if best_queued_number.is_zero() && source_best_number < target_best_header.0 {
-			return Some(source_best_number);
-		}
-
-		// we assume that there were no reorgs if we have already downloaded best header
-		let best_downloaded_number = std::cmp::max(
-			std::cmp::max(best_queued_number, self.headers.best_synced_number()),
-			target_best_header.0,
-		);
-		if best_downloaded_number >= source_best_number {
-			return None;
-		}
-
-		// download new header
-		Some(best_downloaded_number + One::one())
-	}
-
-	/// Selech orphan header to downoload.
-	pub fn select_orphan_header_to_download(&self) -> Option<&QueuedHeader<P>> {
-		let orphan_header = self.headers.header(HeaderStatus::Orphan)?;
-
-		// we consider header orphan until we'll find it ancestor that is known to the target node
-		// => we may get orphan header while we ask target node whether it knows its parent
-		// => let's avoid fetching duplicate headers
-		let parent_id = orphan_header.parent_id();
-		if self.headers.status(&parent_id) != HeaderStatus::Unknown {
-			return None;
-		}
-
-		Some(orphan_header)
-	}
-
-	/// Select headers that need to be submitted to the target node.
-	pub fn select_headers_to_submit(&self, stalled: bool) -> Option<Vec<&QueuedHeader<P>>> {
-		// maybe we have paused new headers submit?
-		if self.pause_submit {
-			return None;
-		}
-
-		// if we operate in backup mode, we only submit headers when sync has stalled
-		if self.params.target_tx_mode == TargetTransactionMode::Backup && !stalled {
-			return None;
-		}
-
-		let headers_in_submit_status = self.headers.headers_in_status(HeaderStatus::Submitted);
-		let headers_to_submit_count = self
-			.params
-			.max_headers_in_submitted_status
-			.checked_sub(headers_in_submit_status)?;
-
-		let mut total_size = 0;
-		let mut total_headers = 0;
-		self.headers.headers(HeaderStatus::Ready, |header| {
-			if total_headers == headers_to_submit_count {
-				return false;
-			}
-			if total_headers == self.params.max_headers_in_single_submit {
-				return false;
-			}
-
-			let encoded_size = P::estimate_size(header);
-			if total_headers != 0 && total_size + encoded_size > self.params.max_headers_size_in_single_submit {
-				return false;
-			}
-
-			total_size += encoded_size;
-			total_headers += 1;
-
-			true
-		})
-	}
-
-	/// Receive new target header number from the source node.
-	pub fn source_best_header_number_response(&mut self, best_header_number: P::Number) {
-		log::debug!(
-			target: "bridge",
-			"Received best header number from {} node: {}",
-			P::SOURCE_NAME,
-			best_header_number,
-		);
-		self.source_best_number = Some(best_header_number);
-	}
-
-	/// Receive new best header from the target node.
-	/// Returns true if it is different from the previous block known to us.
-	pub fn target_best_header_response(&mut self, best_header: HeaderIdOf<P>) -> bool {
-		log::debug!(
-			target: "bridge",
-			"Received best known header from {}: {:?}",
-			P::TARGET_NAME,
-			best_header,
-		);
-
-		// early return if it is still the same
-		if self.target_best_header == Some(best_header) {
-			return false;
-		}
-
-		// remember that this header is now known to the Substrate runtime
-		self.headers.target_best_header_response(&best_header);
-
-		// prune ancient headers
-		self.headers
-			.prune(best_header.0.saturating_sub(self.params.prune_depth.into()));
-
-		// finally remember the best header itself
-		self.target_best_header = Some(best_header);
-
-		// we are ready to submit headers again
-		if self.pause_submit {
-			log::debug!(
-				target: "bridge",
-				"Ready to submit {} headers to {} node again!",
-				P::SOURCE_NAME,
-				P::TARGET_NAME,
-			);
-
-			self.pause_submit = false;
-		}
-
-		true
-	}
-
-	/// Pause headers submit until best header will be updated on target node.
-	pub fn pause_submit(&mut self) {
-		log::debug!(
-			target: "bridge",
-			"Stopping submitting {} headers to {} node. Waiting for {} submitted headers to be accepted",
-			P::SOURCE_NAME,
-			P::TARGET_NAME,
-			self.headers.headers_in_status(HeaderStatus::Submitted),
-		);
-
-		self.pause_submit = true;
-	}
-
-	/// Restart synchronization.
-	pub fn restart(&mut self) {
-		self.source_best_number = None;
-		self.target_best_header = None;
-		self.headers.clear();
-		self.pause_submit = false;
-	}
-}
-
-#[cfg(test)]
-pub mod tests {
-	use super::*;
-	use crate::ethereum_types::{EthereumHeadersSyncPipeline, H256};
-	use crate::headers::tests::{header, id};
-	use crate::sync_types::HeaderStatus;
-	use crate::utils::HeaderId;
-
-	fn side_hash(number: u64) -> H256 {
-		H256::from_low_u64_le(1000 + number)
-	}
-
-	pub fn default_sync_params() -> HeadersSyncParams {
-		HeadersSyncParams {
-			max_future_headers_to_download: 128,
-			max_headers_in_submitted_status: 128,
-			max_headers_in_single_submit: 32,
-			max_headers_size_in_single_submit: 131_072,
-			prune_depth: 4096,
-			target_tx_mode: TargetTransactionMode::Signed,
-		}
-	}
-
-	#[test]
-	fn select_new_header_to_download_works() {
-		let mut eth_sync = HeadersSync::<EthereumHeadersSyncPipeline>::new(default_sync_params());
-
-		// both best && target headers are unknown
-		assert_eq!(eth_sync.select_new_header_to_download(), None);
-
-		// best header is known, target header is unknown
-		eth_sync.target_best_header = Some(HeaderId(0, Default::default()));
-		assert_eq!(eth_sync.select_new_header_to_download(), None);
-
-		// target header is known, best header is unknown
-		eth_sync.target_best_header = None;
-		eth_sync.source_best_number = Some(100);
-		assert_eq!(eth_sync.select_new_header_to_download(), None);
-
-		// when our best block has the same number as the target
-		eth_sync.target_best_header = Some(HeaderId(100, Default::default()));
-		assert_eq!(eth_sync.select_new_header_to_download(), None);
-
-		// when we actually need a new header
-		eth_sync.source_best_number = Some(101);
-		assert_eq!(eth_sync.select_new_header_to_download(), Some(101));
-
-		// when we have to reorganize to longer fork
-		eth_sync.source_best_number = Some(100);
-		eth_sync.target_best_header = Some(HeaderId(200, Default::default()));
-		assert_eq!(eth_sync.select_new_header_to_download(), Some(100));
-
-		// when there are too many headers scheduled for submitting
-		for i in 1..1000 {
-			eth_sync.headers.header_response(header(i).header().clone());
-		}
-		assert_eq!(eth_sync.select_new_header_to_download(), None);
-	}
-
-	#[test]
-	fn select_new_header_to_download_works_with_empty_queue() {
-		let mut eth_sync = HeadersSync::<EthereumHeadersSyncPipeline>::new(default_sync_params());
-		eth_sync.source_best_header_number_response(100);
-
-		// when queue is not empty => everything goes as usually
-		eth_sync.target_best_header_response(header(10).id());
-		eth_sync.headers_mut().header_response(header(11).header().clone());
-		eth_sync.headers_mut().maybe_extra_response(&header(11).id(), false);
-		assert_eq!(eth_sync.select_new_header_to_download(), Some(12));
-
-		// but then queue is drained
-		eth_sync.headers_mut().target_best_header_response(&header(11).id());
-
-		// even though it's empty, we know that header#11 is synced
-		assert_eq!(eth_sync.headers().best_queued_number(), 0);
-		assert_eq!(eth_sync.headers().best_synced_number(), 11);
-		assert_eq!(eth_sync.select_new_header_to_download(), Some(12));
-	}
-
-	#[test]
-	fn sync_without_reorgs_works() {
-		let mut eth_sync = HeadersSync::new(default_sync_params());
-		eth_sync.params.max_headers_in_submitted_status = 1;
-
-		// ethereum reports best header #102
-		eth_sync.source_best_header_number_response(102);
-
-		// substrate reports that it is at block #100
-		eth_sync.target_best_header_response(id(100));
-
-		// block #101 is downloaded first
-		assert_eq!(eth_sync.select_new_header_to_download(), Some(101));
-		eth_sync.headers.header_response(header(101).header().clone());
-
-		// now header #101 is ready to be submitted
-		assert_eq!(eth_sync.headers.header(HeaderStatus::MaybeExtra), Some(&header(101)));
-		eth_sync.headers.maybe_extra_response(&id(101), false);
-		assert_eq!(eth_sync.headers.header(HeaderStatus::Ready), Some(&header(101)));
-		assert_eq!(eth_sync.select_headers_to_submit(false), Some(vec![&header(101)]));
-
-		// and header #102 is ready to be downloaded
-		assert_eq!(eth_sync.select_new_header_to_download(), Some(102));
-		eth_sync.headers.header_response(header(102).header().clone());
-
-		// receive submission confirmation
-		eth_sync.headers.headers_submitted(vec![id(101)]);
-
-		// we have nothing to submit because previous header hasn't been confirmed yet
-		// (and we allow max 1 submit transaction in the wild)
-		assert_eq!(eth_sync.headers.header(HeaderStatus::MaybeExtra), Some(&header(102)));
-		eth_sync.headers.maybe_extra_response(&id(102), false);
-		assert_eq!(eth_sync.headers.header(HeaderStatus::Ready), Some(&header(102)));
-		assert_eq!(eth_sync.select_headers_to_submit(false), None);
-
-		// substrate reports that it has imported block #101
-		eth_sync.target_best_header_response(id(101));
-
-		// and we are ready to submit #102
-		assert_eq!(eth_sync.select_headers_to_submit(false), Some(vec![&header(102)]));
-		eth_sync.headers.headers_submitted(vec![id(102)]);
-
-		// substrate reports that it has imported block #102
-		eth_sync.target_best_header_response(id(102));
-
-		// and we have nothing to download
-		assert_eq!(eth_sync.select_new_header_to_download(), None);
-	}
-
-	#[test]
-	fn sync_with_orphan_headers_work() {
-		let mut eth_sync = HeadersSync::new(default_sync_params());
-
-		// ethereum reports best header #102
-		eth_sync.source_best_header_number_response(102);
-
-		// substrate reports that it is at block #100, but it isn't part of best chain
-		eth_sync.target_best_header_response(HeaderId(100, side_hash(100)));
-
-		// block #101 is downloaded first
-		assert_eq!(eth_sync.select_new_header_to_download(), Some(101));
-		eth_sync.headers.header_response(header(101).header().clone());
-
-		// we can't submit header #101, because its parent status is unknown
-		assert_eq!(eth_sync.select_headers_to_submit(false), None);
-
-		// instead we are trying to determine status of its parent (#100)
-		assert_eq!(eth_sync.headers.header(HeaderStatus::MaybeOrphan), Some(&header(101)));
-
-		// and the status is still unknown
-		eth_sync.headers.maybe_orphan_response(&id(100), false);
-
-		// so we consider #101 orphaned now && will download its parent - #100
-		assert_eq!(eth_sync.headers.header(HeaderStatus::Orphan), Some(&header(101)));
-		eth_sync.headers.header_response(header(100).header().clone());
-
-		// #101 is now Orphan and #100 is MaybeOrphan => we do not want to retrieve
-		// header #100 again
-		assert_eq!(eth_sync.headers.header(HeaderStatus::Orphan), Some(&header(101)));
-		assert_eq!(eth_sync.select_orphan_header_to_download(), None);
-
-		// we can't submit header #100, because its parent status is unknown
-		assert_eq!(eth_sync.select_headers_to_submit(false), None);
-
-		// instead we are trying to determine status of its parent (#99)
-		assert_eq!(eth_sync.headers.header(HeaderStatus::MaybeOrphan), Some(&header(100)));
-
-		// and the status is known, so we move previously orphaned #100 and #101 to ready queue
-		eth_sync.headers.maybe_orphan_response(&id(99), true);
-
-		// and we are ready to submit #100
-		assert_eq!(eth_sync.headers.header(HeaderStatus::MaybeExtra), Some(&header(100)));
-		eth_sync.headers.maybe_extra_response(&id(100), false);
-		assert_eq!(eth_sync.select_headers_to_submit(false), Some(vec![&header(100)]));
-		eth_sync.headers.headers_submitted(vec![id(100)]);
-
-		// and we are ready to submit #101
-		assert_eq!(eth_sync.headers.header(HeaderStatus::MaybeExtra), Some(&header(101)));
-		eth_sync.headers.maybe_extra_response(&id(101), false);
-		assert_eq!(eth_sync.select_headers_to_submit(false), Some(vec![&header(101)]));
-		eth_sync.headers.headers_submitted(vec![id(101)]);
-	}
-
-	#[test]
-	fn pruning_happens_on_target_best_header_response() {
-		let mut eth_sync = HeadersSync::<EthereumHeadersSyncPipeline>::new(default_sync_params());
-		eth_sync.params.prune_depth = 50;
-		eth_sync.target_best_header_response(id(100));
-		assert_eq!(eth_sync.headers.prune_border(), 50);
-	}
-
-	#[test]
-	fn only_submitting_headers_in_backup_mode_when_stalled() {
-		let mut eth_sync = HeadersSync::new(default_sync_params());
-		eth_sync.params.target_tx_mode = TargetTransactionMode::Backup;
-
-		// ethereum reports best header #102
-		eth_sync.source_best_header_number_response(102);
-
-		// substrate reports that it is at block #100
-		eth_sync.target_best_header_response(id(100));
-
-		// block #101 is downloaded first
-		eth_sync.headers.header_response(header(101).header().clone());
-		eth_sync.headers.maybe_extra_response(&id(101), false);
-
-		// ensure that headers are not submitted when sync is not stalled
-		assert_eq!(eth_sync.select_headers_to_submit(false), None);
-
-		// ensure that headers are not submitted when sync is stalled
-		assert_eq!(eth_sync.select_headers_to_submit(true), Some(vec![&header(101)]));
-	}
-
-	#[test]
-	fn does_not_select_new_headers_to_submit_when_submit_is_paused() {
-		let mut eth_sync = HeadersSync::new(default_sync_params());
-		eth_sync.params.max_headers_in_submitted_status = 1;
-
-		// ethereum reports best header #102 and substrate is at #100
-		eth_sync.source_best_header_number_response(102);
-		eth_sync.target_best_header_response(id(100));
-
-		// let's prepare #101 and #102 for submitting
-		eth_sync.headers.header_response(header(101).header().clone());
-		eth_sync.headers.maybe_extra_response(&id(101), false);
-		eth_sync.headers.header_response(header(102).header().clone());
-		eth_sync.headers.maybe_extra_response(&id(102), false);
-
-		// when submit is not paused, we're ready to submit #101
-		assert_eq!(eth_sync.select_headers_to_submit(false), Some(vec![&header(101)]));
-
-		// when submit is paused, we're not ready to submit anything
-		eth_sync.pause_submit();
-		assert_eq!(eth_sync.select_headers_to_submit(false), None);
-
-		// if best header on substrate node isn't updated, we still not submitting anything
-		eth_sync.target_best_header_response(id(100));
-		assert_eq!(eth_sync.select_headers_to_submit(false), None);
-
-		// but after it is actually updated, we are ready to submit
-		eth_sync.target_best_header_response(id(101));
-		assert_eq!(eth_sync.select_headers_to_submit(false), Some(vec![&header(102)]));
-	}
-}

bridges/relays/ethereum/src/sync_loop.rs

@@ -1,585 +0,0 @@
-// 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/>.
-
-use crate::metrics::{start as metrics_start, GlobalMetrics, MetricsParams};
-use crate::sync::HeadersSyncParams;
-use crate::sync_loop_metrics::SyncLoopMetrics;
-use crate::sync_types::{HeaderIdOf, HeaderStatus, HeadersSyncPipeline, QueuedHeader, SubmittedHeaders};
-use crate::utils::{
-	format_ids, interval, process_future_result, retry_backoff, MaybeConnectionError, StringifiedMaybeConnectionError,
-};
-
-use async_trait::async_trait;
-use futures::{future::FutureExt, stream::StreamExt};
-use num_traits::{Saturating, Zero};
-use std::{
-	collections::HashSet,
-	future::Future,
-	time::{Duration, Instant},
-};
-
-/// When we submit headers to target node, but see no updates of best
-/// source block known to target node during STALL_SYNC_TIMEOUT seconds,
-/// we consider that our headers are rejected because there has been reorg in target chain.
-/// This reorg could invalidate our knowledge about sync process (i.e. we have asked if
-/// HeaderA is known to target, but then reorg happened and the answer is different
-/// now) => we need to reset sync.
-/// The other option is to receive **EVERY** best target header and check if it is
-/// direct child of previous best header. But: (1) subscription doesn't guarantee that
-/// the subscriber will receive every best header (2) reorg won't always lead to sync
-/// stall and restart is a heavy operation (we forget all in-memory headers).
-const STALL_SYNC_TIMEOUT: Duration = Duration::from_secs(5 * 60);
-/// Delay after we have seen update of best source header at target node,
-/// for us to treat sync stalled. ONLY when relay operates in backup mode.
-const BACKUP_STALL_SYNC_TIMEOUT: Duration = Duration::from_secs(10 * 60);
-
-/// Source client trait.
-#[async_trait]
-pub trait SourceClient<P: HeadersSyncPipeline>: Sized {
-	/// Type of error this clients returns.
-	type Error: std::fmt::Debug + MaybeConnectionError;
-
-	/// Get best block number.
-	async fn best_block_number(&self) -> Result<P::Number, Self::Error>;
-
-	/// Get header by hash.
-	async fn header_by_hash(&self, hash: P::Hash) -> Result<P::Header, Self::Error>;
-
-	/// Get canonical header by number.
-	async fn header_by_number(&self, number: P::Number) -> Result<P::Header, Self::Error>;
-
-	/// Get completion data by header hash.
-	async fn header_completion(&self, id: HeaderIdOf<P>)
-		-> Result<(HeaderIdOf<P>, Option<P::Completion>), Self::Error>;
-
-	/// Get extra data by header hash.
-	async fn header_extra(
-		&self,
-		id: HeaderIdOf<P>,
-		header: QueuedHeader<P>,
-	) -> Result<(HeaderIdOf<P>, P::Extra), Self::Error>;
-}
-
-/// Target client trait.
-#[async_trait]
-pub trait TargetClient<P: HeadersSyncPipeline>: Sized {
-	/// Type of error this clients returns.
-	type Error: std::fmt::Debug + MaybeConnectionError;
-
-	/// Returns ID of best header known to the target node.
-	async fn best_header_id(&self) -> Result<HeaderIdOf<P>, Self::Error>;
-
-	/// Returns true if header is known to the target node.
-	async fn is_known_header(&self, id: HeaderIdOf<P>) -> Result<(HeaderIdOf<P>, bool), Self::Error>;
-
-	/// Submit headers.
-	async fn submit_headers(&self, headers: Vec<QueuedHeader<P>>) -> SubmittedHeaders<HeaderIdOf<P>, Self::Error>;
-
-	/// Returns ID of headers that require to be 'completed' before children can be submitted.
-	async fn incomplete_headers_ids(&self) -> Result<HashSet<HeaderIdOf<P>>, Self::Error>;
-
-	/// Submit completion data for header.
-	async fn complete_header(&self, id: HeaderIdOf<P>, completion: P::Completion)
-		-> Result<HeaderIdOf<P>, Self::Error>;
-
-	/// Returns true if header requires extra data to be submitted.
-	async fn requires_extra(&self, header: QueuedHeader<P>) -> Result<(HeaderIdOf<P>, bool), Self::Error>;
-}
-
-/// Run headers synchronization.
-pub fn run<P: HeadersSyncPipeline, TC: TargetClient<P>>(
-	source_client: impl SourceClient<P>,
-	source_tick: Duration,
-	target_client: TC,
-	target_tick: Duration,
-	sync_params: HeadersSyncParams,
-	metrics_params: Option<MetricsParams>,
-	exit_signal: impl Future<Output = ()>,
-) {
-	let mut local_pool = futures::executor::LocalPool::new();
-	let mut progress_context = (Instant::now(), None, None);
-
-	local_pool.run_until(async move {
-		let mut sync = crate::sync::HeadersSync::<P>::new(sync_params);
-		let mut stall_countdown = None;
-		let mut last_update_time = Instant::now();
-
-		let mut metrics_global = GlobalMetrics::new();
-		let mut metrics_sync = SyncLoopMetrics::new();
-		let metrics_enabled = metrics_params.is_some();
-		metrics_start(
-			format!("{}_to_{}_Sync", P::SOURCE_NAME, P::TARGET_NAME),
-			metrics_params,
-			&metrics_global,
-			&metrics_sync,
-		);
-
-		let mut source_retry_backoff = retry_backoff();
-		let mut source_client_is_online = false;
-		let mut source_best_block_number_required = false;
-		let source_best_block_number_future = source_client.best_block_number().fuse();
-		let source_new_header_future = futures::future::Fuse::terminated();
-		let source_orphan_header_future = futures::future::Fuse::terminated();
-		let source_extra_future = futures::future::Fuse::terminated();
-		let source_completion_future = futures::future::Fuse::terminated();
-		let source_go_offline_future = futures::future::Fuse::terminated();
-		let source_tick_stream = interval(source_tick).fuse();
-
-		let mut target_retry_backoff = retry_backoff();
-		let mut target_client_is_online = false;
-		let mut target_best_block_required = false;
-		let mut target_incomplete_headers_required = true;
-		let target_best_block_future = target_client.best_header_id().fuse();
-		let target_incomplete_headers_future = futures::future::Fuse::terminated();
-		let target_extra_check_future = futures::future::Fuse::terminated();
-		let target_existence_status_future = futures::future::Fuse::terminated();
-		let target_submit_header_future = futures::future::Fuse::terminated();
-		let target_complete_header_future = futures::future::Fuse::terminated();
-		let target_go_offline_future = futures::future::Fuse::terminated();
-		let target_tick_stream = interval(target_tick).fuse();
-
-		let exit_signal = exit_signal.fuse();
-
-		futures::pin_mut!(
-			source_best_block_number_future,
-			source_new_header_future,
-			source_orphan_header_future,
-			source_extra_future,
-			source_completion_future,
-			source_go_offline_future,
-			source_tick_stream,
-			target_best_block_future,
-			target_incomplete_headers_future,
-			target_extra_check_future,
-			target_existence_status_future,
-			target_submit_header_future,
-			target_complete_header_future,
-			target_go_offline_future,
-			target_tick_stream,
-			exit_signal
-		);
-
-		loop {
-			futures::select! {
-				source_best_block_number = source_best_block_number_future => {
-					source_best_block_number_required = false;
-
-					source_client_is_online = process_future_result(
-						source_best_block_number,
-						&mut source_retry_backoff,
-						|source_best_block_number| sync.source_best_header_number_response(source_best_block_number),
-						&mut source_go_offline_future,
-						|delay| async_std::task::sleep(delay),
-						|| format!("Error retrieving best header number from {}", P::SOURCE_NAME),
-					).is_ok();
-				},
-				source_new_header = source_new_header_future => {
-					source_client_is_online = process_future_result(
-						source_new_header,
-						&mut source_retry_backoff,
-						|source_new_header| sync.headers_mut().header_response(source_new_header),
-						&mut source_go_offline_future,
-						|delay| async_std::task::sleep(delay),
-						|| format!("Error retrieving header from {} node", P::SOURCE_NAME),
-					).is_ok();
-				},
-				source_orphan_header = source_orphan_header_future => {
-					source_client_is_online = process_future_result(
-						source_orphan_header,
-						&mut source_retry_backoff,
-						|source_orphan_header| sync.headers_mut().header_response(source_orphan_header),
-						&mut source_go_offline_future,
-						|delay| async_std::task::sleep(delay),
-						|| format!("Error retrieving orphan header from {} node", P::SOURCE_NAME),
-					).is_ok();
-				},
-				source_extra = source_extra_future => {
-					source_client_is_online = process_future_result(
-						source_extra,
-						&mut source_retry_backoff,
-						|(header, extra)| sync.headers_mut().extra_response(&header, extra),
-						&mut source_go_offline_future,
-						|delay| async_std::task::sleep(delay),
-						|| format!("Error retrieving extra data from {} node", P::SOURCE_NAME),
-					).is_ok();
-				},
-				source_completion = source_completion_future => {
-					source_client_is_online = process_future_result(
-						source_completion,
-						&mut source_retry_backoff,
-						|(header, completion)| sync.headers_mut().completion_response(&header, completion),
-						&mut source_go_offline_future,
-						|delay| async_std::task::sleep(delay),
-						|| format!("Error retrieving completion data from {} node", P::SOURCE_NAME),
-					).is_ok();
-				},
-				source_client = source_go_offline_future => {
-					source_client_is_online = true;
-				},
-				_ = source_tick_stream.next() => {
-					if sync.is_almost_synced() {
-						source_best_block_number_required = true;
-					}
-				},
-				target_best_block = target_best_block_future => {
-					target_best_block_required = false;
-
-					target_client_is_online = process_future_result(
-						target_best_block,
-						&mut target_retry_backoff,
-						|target_best_block| {
-							let head_updated = sync.target_best_header_response(target_best_block);
-							if head_updated {
-								last_update_time = Instant::now();
-							}
-							match head_updated {
-								// IF head is updated AND there are still our transactions:
-								// => restart stall countdown timer
-								true if sync.headers().headers_in_status(HeaderStatus::Submitted) != 0 =>
-									stall_countdown = Some(Instant::now()),
-								// IF head is updated AND there are no our transactions:
-								// => stop stall countdown timer
-								true => stall_countdown = None,
-								// IF head is not updated AND stall countdown is not yet completed
-								// => do nothing
-								false if stall_countdown
-									.map(|stall_countdown| stall_countdown.elapsed() < STALL_SYNC_TIMEOUT)
-									.unwrap_or(true)
-									=> (),
-								// IF head is not updated AND stall countdown has completed
-								// => restart sync
-								false => {
-									log::info!(
-										target: "bridge",
-										"Sync has stalled. Restarting {} headers synchronization.",
-										P::SOURCE_NAME,
-									);
-									stall_countdown = None;
-									sync.restart();
-								},
-							}
-						},
-						&mut target_go_offline_future,
-						|delay| async_std::task::sleep(delay),
-						|| format!("Error retrieving best known header from {} node", P::TARGET_NAME),
-					).is_ok();
-				},
-				incomplete_headers_ids = target_incomplete_headers_future => {
-					target_incomplete_headers_required = false;
-
-					target_client_is_online = process_future_result(
-						incomplete_headers_ids,
-						&mut target_retry_backoff,
-						|incomplete_headers_ids| sync.headers_mut().incomplete_headers_response(incomplete_headers_ids),
-						&mut target_go_offline_future,
-						|delay| async_std::task::sleep(delay),
-						|| format!("Error retrieving incomplete headers from {} node", P::TARGET_NAME),
-					).is_ok();
-				},
-				target_existence_status = target_existence_status_future => {
-					target_client_is_online = process_future_result(
-						target_existence_status,
-						&mut target_retry_backoff,
-						|(target_header, target_existence_status)| sync
-							.headers_mut()
-							.maybe_orphan_response(&target_header, target_existence_status),
-						&mut target_go_offline_future,
-						|delay| async_std::task::sleep(delay),
-						|| format!("Error retrieving existence status from {} node", P::TARGET_NAME),
-					).is_ok();
-				},
-				submitted_headers = target_submit_header_future => {
-					// following line helps Rust understand the type of `submitted_headers` :/
-					let submitted_headers: SubmittedHeaders<HeaderIdOf<P>, TC::Error> = submitted_headers;
-					let submitted_headers_str = format!("{}", submitted_headers);
-					let all_headers_rejected = submitted_headers.submitted.is_empty()
-						&& submitted_headers.incomplete.is_empty();
-					let has_submitted_headers = sync.headers().headers_in_status(HeaderStatus::Submitted) != 0;
-
-					let maybe_fatal_error = match submitted_headers.fatal_error {
-						Some(fatal_error) => Err(StringifiedMaybeConnectionError::new(
-							fatal_error.is_connection_error(),
-							format!("{:?}", fatal_error),
-						)),
-						None if all_headers_rejected && !has_submitted_headers =>
-							Err(StringifiedMaybeConnectionError::new(false, "All headers were rejected".into())),
-						None => Ok(()),
-					};
-
-					let no_fatal_error = maybe_fatal_error.is_ok();
-					target_client_is_online = process_future_result(
-						maybe_fatal_error,
-						&mut target_retry_backoff,
-						|_| {},
-						&mut target_go_offline_future,
-						|delay| async_std::task::sleep(delay),
-						|| format!("Error submitting headers to {} node", P::TARGET_NAME),
-					).is_ok();
-
-					log::debug!(target: "bridge", "Header submit result: {}", submitted_headers_str);
-
-					sync.headers_mut().headers_submitted(submitted_headers.submitted);
-					sync.headers_mut().add_incomplete_headers(false, submitted_headers.incomplete);
-
-					// when there's no fatal error, but node has rejected all our headers we may
-					// want to pause until our submitted headers will be accepted
-					if no_fatal_error && all_headers_rejected && has_submitted_headers {
-						sync.pause_submit();
-					}
-				},
-				target_complete_header_result = target_complete_header_future => {
-					target_client_is_online = process_future_result(
-						target_complete_header_result,
-						&mut target_retry_backoff,
-						|completed_header| sync.headers_mut().header_completed(&completed_header),
-						&mut target_go_offline_future,
-						|delay| async_std::task::sleep(delay),
-						|| format!("Error completing headers at {}", P::TARGET_NAME),
-					).is_ok();
-				},
-				target_extra_check_result = target_extra_check_future => {
-					target_client_is_online = process_future_result(
-						target_extra_check_result,
-						&mut target_retry_backoff,
-						|(header, extra_check_result)| sync
-							.headers_mut()
-							.maybe_extra_response(&header, extra_check_result),
-						&mut target_go_offline_future,
-						|delay| async_std::task::sleep(delay),
-						|| format!("Error retrieving receipts requirement from {} node", P::TARGET_NAME),
-					).is_ok();
-				},
-				target_client = target_go_offline_future => {
-					target_client_is_online = true;
-				},
-				_ = target_tick_stream.next() => {
-					target_best_block_required = true;
-					target_incomplete_headers_required = true;
-				},
-
-				_ = exit_signal => {
-					return;
-				}
-			}
-
-			// update metrics
-			if metrics_enabled {
-				metrics_global.update();
-				metrics_sync.update(&sync);
-			}
-
-			// print progress
-			progress_context = print_sync_progress(progress_context, &sync);
-
-			// If the target client is accepting requests we update the requests that
-			// we want it to run
-			if target_client_is_online {
-				// NOTE: Is is important to reset this so that we only have one
-				// request being processed by the client at a time. This prevents
-				// race conditions like receiving two transactions with the same
-				// nonce from the client.
-				target_client_is_online = false;
-
-				// The following is how we prioritize requests:
-				//
-				// 1. Get best block
-				//     - Stops us from downloading or submitting new blocks
-				//     - Only called rarely
-				//
-				// 2. Get incomplete headers
-				//     - Stops us from submitting new blocks
-				//     - Only called rarely
-				//
-				// 3. Get complete headers
-				//     - Stops us from submitting new blocks
-				//
-				// 4. Check if we need extra data from source
-				//     - Stops us from downloading or submitting new blocks
-				//
-				// 5. Check existence of header
-				//     - Stops us from submitting new blocks
-				//
-				// 6. Submit header
-
-				if target_best_block_required {
-					log::debug!(target: "bridge", "Asking {} about best block", P::TARGET_NAME);
-					target_best_block_future.set(target_client.best_header_id().fuse());
-				} else if target_incomplete_headers_required {
-					log::debug!(target: "bridge", "Asking {} about incomplete headers", P::TARGET_NAME);
-					target_incomplete_headers_future.set(target_client.incomplete_headers_ids().fuse());
-				} else if let Some((id, completion)) = sync.headers_mut().header_to_complete() {
-					log::debug!(
-						target: "bridge",
-						"Going to complete header: {:?}",
-						id,
-					);
-
-					target_complete_header_future.set(target_client.complete_header(id, completion.clone()).fuse());
-				} else if let Some(header) = sync.headers().header(HeaderStatus::MaybeExtra) {
-					log::debug!(
-						target: "bridge",
-						"Checking if header submission requires extra: {:?}",
-						header.id(),
-					);
-
-					target_extra_check_future.set(target_client.requires_extra(header.clone()).fuse());
-				} else if let Some(header) = sync.headers().header(HeaderStatus::MaybeOrphan) {
-					// for MaybeOrphan we actually ask for parent' header existence
-					let parent_id = header.parent_id();
-
-					log::debug!(
-						target: "bridge",
-						"Asking {} node for existence of: {:?}",
-						P::TARGET_NAME,
-						parent_id,
-					);
-
-					target_existence_status_future.set(target_client.is_known_header(parent_id).fuse());
-				} else if let Some(headers) =
-					sync.select_headers_to_submit(last_update_time.elapsed() > BACKUP_STALL_SYNC_TIMEOUT)
-				{
-					log::debug!(
-						target: "bridge",
-						"Submitting {} header(s) to {} node: {:?}",
-						headers.len(),
-						P::TARGET_NAME,
-						format_ids(headers.iter().map(|header| header.id())),
-					);
-
-					let headers = headers.into_iter().cloned().collect();
-					target_submit_header_future.set(target_client.submit_headers(headers).fuse());
-
-					// remember that we have submitted some headers
-					if stall_countdown.is_none() {
-						stall_countdown = Some(Instant::now());
-					}
-				} else {
-					target_client_is_online = true;
-				}
-			}
-
-			// If the source client is accepting requests we update the requests that
-			// we want it to run
-			if source_client_is_online {
-				// NOTE: Is is important to reset this so that we only have one
-				// request being processed by the client at a time. This prevents
-				// race conditions like receiving two transactions with the same
-				// nonce from the client.
-				source_client_is_online = false;
-
-				// The following is how we prioritize requests:
-				//
-				// 1. Get best block
-				//     - Stops us from downloading or submitting new blocks
-				//     - Only called rarely
-				//
-				// 2. Download completion data
-				//     - Stops us from submitting new blocks
-				//
-				// 3. Download extra data
-				//     - Stops us from submitting new blocks
-				//
-				// 4. Download missing headers
-				//     - Stops us from downloading or submitting new blocks
-				//
-				// 5. Downloading new headers
-
-				if source_best_block_number_required {
-					log::debug!(target: "bridge", "Asking {} node about best block number", P::SOURCE_NAME);
-					source_best_block_number_future.set(source_client.best_block_number().fuse());
-				} else if let Some(id) = sync.headers_mut().incomplete_header() {
-					log::debug!(
-						target: "bridge",
-						"Retrieving completion data for header: {:?}",
-						id,
-					);
-					source_completion_future.set(source_client.header_completion(id).fuse());
-				} else if let Some(header) = sync.headers().header(HeaderStatus::Extra) {
-					let id = header.id();
-					log::debug!(
-						target: "bridge",
-						"Retrieving extra data for header: {:?}",
-						id,
-					);
-					source_extra_future.set(source_client.header_extra(id, header.clone()).fuse());
-				} else if let Some(header) = sync.select_orphan_header_to_download() {
-					// for Orphan we actually ask for parent' header
-					let parent_id = header.parent_id();
-
-					// if we have end up with orphan header#0, then we are misconfigured
-					if parent_id.0.is_zero() {
-						log::error!(
-							target: "bridge",
-							"Misconfiguration. Genesis {} header is considered orphan by {} node",
-							P::SOURCE_NAME,
-							P::TARGET_NAME,
-						);
-						return;
-					}
-
-					log::debug!(
-						target: "bridge",
-						"Going to download orphan header from {} node: {:?}",
-						P::SOURCE_NAME,
-						parent_id,
-					);
-
-					source_orphan_header_future.set(source_client.header_by_hash(parent_id.1).fuse());
-				} else if let Some(id) = sync.select_new_header_to_download() {
-					log::debug!(
-						target: "bridge",
-						"Going to download new header from {} node: {:?}",
-						P::SOURCE_NAME,
-						id,
-					);
-
-					source_new_header_future.set(source_client.header_by_number(id).fuse());
-				} else {
-					source_client_is_online = true;
-				}
-			}
-		}
-	});
-}
-
-/// Print synchronization progress.
-fn print_sync_progress<P: HeadersSyncPipeline>(
-	progress_context: (Instant, Option<P::Number>, Option<P::Number>),
-	eth_sync: &crate::sync::HeadersSync<P>,
-) -> (Instant, Option<P::Number>, Option<P::Number>) {
-	let (prev_time, prev_best_header, prev_target_header) = progress_context;
-	let now_time = Instant::now();
-	let (now_best_header, now_target_header) = eth_sync.status();
-
-	let need_update = now_time - prev_time > Duration::from_secs(10)
-		|| match (prev_best_header, now_best_header) {
-			(Some(prev_best_header), Some(now_best_header)) => {
-				now_best_header.0.saturating_sub(prev_best_header) > 10.into()
-			}
-			_ => false,
-		};
-	if !need_update {
-		return (prev_time, prev_best_header, prev_target_header);
-	}
-
-	log::info!(
-		target: "bridge",
-		"Synced {:?} of {:?} headers",
-		now_best_header.map(|id| id.0),
-		now_target_header,
-	);
-	(now_time, now_best_header.clone().map(|id| id.0), *now_target_header)
-}

bridges/relays/ethereum/src/sync_loop_metrics.rs

@@ -1,91 +0,0 @@
-// 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/>.
-
-use crate::metrics::{register, GaugeVec, Metrics, Opts, Registry, U64};
-use crate::sync::HeadersSync;
-use crate::sync_types::{HeaderStatus, HeadersSyncPipeline};
-
-use num_traits::Zero;
-
-/// Headers sync metrics.
-pub struct SyncLoopMetrics {
-	/// Best syncing headers at "source" and "target" nodes.
-	best_block_numbers: GaugeVec<U64>,
-	/// Number of headers in given states (see `HeaderStatus`).
-	blocks_in_state: GaugeVec<U64>,
-}
-
-impl Metrics for SyncLoopMetrics {
-	fn register(&self, registry: &Registry) -> Result<(), String> {
-		register(self.best_block_numbers.clone(), registry).map_err(|e| e.to_string())?;
-		register(self.blocks_in_state.clone(), registry).map_err(|e| e.to_string())?;
-		Ok(())
-	}
-}
-
-impl SyncLoopMetrics {
-	/// Creates sync loop metrics.
-	pub fn new() -> Self {
-		SyncLoopMetrics {
-			best_block_numbers: GaugeVec::new(
-				Opts::new("best_block_numbers", "Best block numbers on source and target nodes"),
-				&["node"],
-			)
-			.expect("metric is static and thus valid; qed"),
-			blocks_in_state: GaugeVec::new(
-				Opts::new("blocks_in_state", "Number of blocks in given state"),
-				&["state"],
-			)
-			.expect("metric is static and thus valid; qed"),
-		}
-	}
-
-	/// Update metrics.
-	pub fn update<P: HeadersSyncPipeline>(&mut self, sync: &HeadersSync<P>) {
-		let headers = sync.headers();
-		let source_best_number = sync.source_best_number().unwrap_or_else(Zero::zero);
-		let target_best_number = sync.target_best_header().map(|id| id.0).unwrap_or_else(Zero::zero);
-
-		self.best_block_numbers
-			.with_label_values(&["source"])
-			.set(source_best_number.into());
-		self.best_block_numbers
-			.with_label_values(&["target"])
-			.set(target_best_number.into());
-
-		self.blocks_in_state
-			.with_label_values(&["maybe_orphan"])
-			.set(headers.headers_in_status(HeaderStatus::MaybeOrphan) as _);
-		self.blocks_in_state
-			.with_label_values(&["orphan"])
-			.set(headers.headers_in_status(HeaderStatus::Orphan) as _);
-		self.blocks_in_state
-			.with_label_values(&["maybe_extra"])
-			.set(headers.headers_in_status(HeaderStatus::MaybeExtra) as _);
-		self.blocks_in_state
-			.with_label_values(&["extra"])
-			.set(headers.headers_in_status(HeaderStatus::Extra) as _);
-		self.blocks_in_state
-			.with_label_values(&["ready"])
-			.set(headers.headers_in_status(HeaderStatus::Ready) as _);
-		self.blocks_in_state
-			.with_label_values(&["incomplete"])
-			.set(headers.headers_in_status(HeaderStatus::Incomplete) as _);
-		self.blocks_in_state
-			.with_label_values(&["submitted"])
-			.set(headers.headers_in_status(HeaderStatus::Submitted) as _);
-	}
-}

bridges/relays/ethereum/src/sync_loop_tests.rs

@@ -1,573 +0,0 @@
-// 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/>.
-
-#![cfg(test)]
-
-use crate::sync_loop::{run, SourceClient, TargetClient};
-use crate::sync_types::{HeadersSyncPipeline, QueuedHeader, SourceHeader, SubmittedHeaders};
-use crate::utils::{process_future_result, retry_backoff, HeaderId, MaybeConnectionError};
-
-use async_trait::async_trait;
-use backoff::backoff::Backoff;
-use futures::{future::FutureExt, stream::StreamExt};
-use parking_lot::Mutex;
-use std::{
-	collections::{HashMap, HashSet},
-	sync::Arc,
-	time::Duration,
-};
-
-type TestNumber = u64;
-type TestHash = u64;
-type TestExtra = u64;
-type TestCompletion = u64;
-type TestHeaderId = HeaderId<TestHash, TestNumber>;
-type TestQueuedHeader = QueuedHeader<TestHeadersSyncPipeline>;
-
-#[derive(Debug, Clone, PartialEq)]
-struct TestHeader {
-	hash: TestHash,
-	number: TestNumber,
-	parent_hash: TestHash,
-}
-
-impl SourceHeader<TestHash, TestNumber> for TestHeader {
-	fn id(&self) -> TestHeaderId {
-		HeaderId(self.number, self.hash)
-	}
-
-	fn parent_id(&self) -> TestHeaderId {
-		HeaderId(self.number - 1, self.parent_hash)
-	}
-}
-
-#[derive(Debug, Clone)]
-struct TestError(bool);
-
-impl MaybeConnectionError for TestError {
-	fn is_connection_error(&self) -> bool {
-		self.0
-	}
-}
-
-#[derive(Debug, Clone, Copy)]
-struct TestHeadersSyncPipeline;
-
-impl HeadersSyncPipeline for TestHeadersSyncPipeline {
-	const SOURCE_NAME: &'static str = "Source";
-	const TARGET_NAME: &'static str = "Target";
-
-	type Hash = TestHash;
-	type Number = TestNumber;
-	type Header = TestHeader;
-	type Extra = TestExtra;
-	type Completion = TestCompletion;
-
-	fn estimate_size(_: &TestQueuedHeader) -> usize {
-		0
-	}
-}
-
-enum SourceMethod {
-	BestBlockNumber,
-	HeaderByHash(TestHash),
-	HeaderByNumber(TestNumber),
-	HeaderCompletion(TestHeaderId),
-	HeaderExtra(TestHeaderId, TestQueuedHeader),
-}
-
-struct Source {
-	data: Mutex<SourceData>,
-	on_method_call: Arc<dyn Fn(SourceMethod, &mut SourceData) + Send + Sync>,
-}
-
-struct SourceData {
-	best_block_number: Result<TestNumber, TestError>,
-	header_by_hash: HashMap<TestHash, TestHeader>,
-	header_by_number: HashMap<TestNumber, TestHeader>,
-	provides_completion: bool,
-	provides_extra: bool,
-}
-
-impl Source {
-	pub fn new(
-		best_block_id: TestHeaderId,
-		headers: Vec<(bool, TestHeader)>,
-		on_method_call: impl Fn(SourceMethod, &mut SourceData) + Send + Sync + 'static,
-	) -> Self {
-		Source {
-			data: Mutex::new(SourceData {
-				best_block_number: Ok(best_block_id.0),
-				header_by_hash: headers
-					.iter()
-					.map(|(_, header)| (header.hash, header.clone()))
-					.collect(),
-				header_by_number: headers
-					.iter()
-					.filter_map(|(is_canonical, header)| {
-						if *is_canonical {
-							Some((header.hash, header.clone()))
-						} else {
-							None
-						}
-					})
-					.collect(),
-				provides_completion: true,
-				provides_extra: true,
-			}),
-			on_method_call: Arc::new(on_method_call),
-		}
-	}
-}
-
-#[async_trait]
-impl SourceClient<TestHeadersSyncPipeline> for Source {
-	type Error = TestError;
-
-	async fn best_block_number(&self) -> Result<TestNumber, Self::Error> {
-		let mut data = self.data.lock();
-		(self.on_method_call)(SourceMethod::BestBlockNumber, &mut *data);
-		data.best_block_number.clone()
-	}
-
-	async fn header_by_hash(&self, hash: TestHash) -> Result<TestHeader, Self::Error> {
-		let mut data = self.data.lock();
-		(self.on_method_call)(SourceMethod::HeaderByHash(hash), &mut *data);
-		data.header_by_hash.get(&hash).cloned().ok_or(TestError(false))
-	}
-
-	async fn header_by_number(&self, number: TestNumber) -> Result<TestHeader, Self::Error> {
-		let mut data = self.data.lock();
-		(self.on_method_call)(SourceMethod::HeaderByNumber(number), &mut *data);
-		data.header_by_number.get(&number).cloned().ok_or(TestError(false))
-	}
-
-	async fn header_completion(&self, id: TestHeaderId) -> Result<(TestHeaderId, Option<TestCompletion>), Self::Error> {
-		let mut data = self.data.lock();
-		(self.on_method_call)(SourceMethod::HeaderCompletion(id), &mut *data);
-		if data.provides_completion {
-			Ok((id, Some(test_completion(id))))
-		} else {
-			Ok((id, None))
-		}
-	}
-
-	async fn header_extra(
-		&self,
-		id: TestHeaderId,
-		header: TestQueuedHeader,
-	) -> Result<(TestHeaderId, TestExtra), Self::Error> {
-		let mut data = self.data.lock();
-		(self.on_method_call)(SourceMethod::HeaderExtra(id, header), &mut *data);
-		if data.provides_extra {
-			Ok((id, test_extra(id)))
-		} else {
-			Err(TestError(false))
-		}
-	}
-}
-
-enum TargetMethod {
-	BestHeaderId,
-	IsKnownHeader(TestHeaderId),
-	SubmitHeaders(Vec<TestQueuedHeader>),
-	IncompleteHeadersIds,
-	CompleteHeader(TestHeaderId, TestCompletion),
-	RequiresExtra(TestQueuedHeader),
-}
-
-struct Target {
-	data: Mutex<TargetData>,
-	on_method_call: Arc<dyn Fn(TargetMethod, &mut TargetData) + Send + Sync>,
-}
-
-struct TargetData {
-	best_header_id: Result<TestHeaderId, TestError>,
-	is_known_header_by_hash: HashMap<TestHash, bool>,
-	submitted_headers: HashMap<TestHash, TestQueuedHeader>,
-	submit_headers_result: Option<SubmittedHeaders<TestHeaderId, TestError>>,
-	completed_headers: HashMap<TestHash, TestCompletion>,
-	requires_completion: bool,
-	requires_extra: bool,
-}
-
-impl Target {
-	pub fn new(
-		best_header_id: TestHeaderId,
-		headers: Vec<TestHeaderId>,
-		on_method_call: impl Fn(TargetMethod, &mut TargetData) + Send + Sync + 'static,
-	) -> Self {
-		Target {
-			data: Mutex::new(TargetData {
-				best_header_id: Ok(best_header_id),
-				is_known_header_by_hash: headers.iter().map(|header| (header.1, true)).collect(),
-				submitted_headers: HashMap::new(),
-				submit_headers_result: None,
-				completed_headers: HashMap::new(),
-				requires_completion: false,
-				requires_extra: false,
-			}),
-			on_method_call: Arc::new(on_method_call),
-		}
-	}
-}
-
-#[async_trait]
-impl TargetClient<TestHeadersSyncPipeline> for Target {
-	type Error = TestError;
-
-	async fn best_header_id(&self) -> Result<TestHeaderId, TestError> {
-		let mut data = self.data.lock();
-		(self.on_method_call)(TargetMethod::BestHeaderId, &mut *data);
-		data.best_header_id.clone()
-	}
-
-	async fn is_known_header(&self, id: TestHeaderId) -> Result<(TestHeaderId, bool), TestError> {
-		let mut data = self.data.lock();
-		(self.on_method_call)(TargetMethod::IsKnownHeader(id), &mut *data);
-		data.is_known_header_by_hash
-			.get(&id.1)
-			.cloned()
-			.map(|is_known_header| Ok((id, is_known_header)))
-			.unwrap_or(Ok((id, false)))
-	}
-
-	async fn submit_headers(&self, headers: Vec<TestQueuedHeader>) -> SubmittedHeaders<TestHeaderId, TestError> {
-		let mut data = self.data.lock();
-		(self.on_method_call)(TargetMethod::SubmitHeaders(headers.clone()), &mut *data);
-		data.submitted_headers
-			.extend(headers.iter().map(|header| (header.id().1, header.clone())));
-		data.submit_headers_result.take().expect("test must accept headers")
-	}
-
-	async fn incomplete_headers_ids(&self) -> Result<HashSet<TestHeaderId>, TestError> {
-		let mut data = self.data.lock();
-		(self.on_method_call)(TargetMethod::IncompleteHeadersIds, &mut *data);
-		if data.requires_completion {
-			Ok(data
-				.submitted_headers
-				.iter()
-				.filter(|(hash, _)| !data.completed_headers.contains_key(hash))
-				.map(|(_, header)| header.id())
-				.collect())
-		} else {
-			Ok(HashSet::new())
-		}
-	}
-
-	async fn complete_header(&self, id: TestHeaderId, completion: TestCompletion) -> Result<TestHeaderId, TestError> {
-		let mut data = self.data.lock();
-		(self.on_method_call)(TargetMethod::CompleteHeader(id, completion), &mut *data);
-		data.completed_headers.insert(id.1, completion);
-		Ok(id)
-	}
-
-	async fn requires_extra(&self, header: TestQueuedHeader) -> Result<(TestHeaderId, bool), TestError> {
-		let mut data = self.data.lock();
-		(self.on_method_call)(TargetMethod::RequiresExtra(header.clone()), &mut *data);
-		if data.requires_extra {
-			Ok((header.id(), true))
-		} else {
-			Ok((header.id(), false))
-		}
-	}
-}
-
-fn test_tick() -> Duration {
-	// in ideal world that should have been Duration::from_millis(0), because we do not want
-	// to sleep in tests at all, but that could lead to `select! {}` always waking on tick
-	// => not doing actual job
-	Duration::from_millis(10)
-}
-
-fn test_id(number: TestNumber) -> TestHeaderId {
-	HeaderId(number, number)
-}
-
-fn test_header(number: TestNumber) -> TestHeader {
-	let id = test_id(number);
-	TestHeader {
-		hash: id.1,
-		number: id.0,
-		parent_hash: if number == 0 {
-			TestHash::default()
-		} else {
-			test_id(number - 1).1
-		},
-	}
-}
-
-fn test_forked_id(number: TestNumber, forked_from: TestNumber) -> TestHeaderId {
-	const FORK_OFFSET: TestNumber = 1000;
-
-	if number == forked_from {
-		HeaderId(number, number)
-	} else {
-		HeaderId(number, FORK_OFFSET + number)
-	}
-}
-
-fn test_forked_header(number: TestNumber, forked_from: TestNumber) -> TestHeader {
-	let id = test_forked_id(number, forked_from);
-	TestHeader {
-		hash: id.1,
-		number: id.0,
-		parent_hash: if number == 0 {
-			TestHash::default()
-		} else {
-			test_forked_id(number - 1, forked_from).1
-		},
-	}
-}
-
-fn test_completion(id: TestHeaderId) -> TestCompletion {
-	id.0
-}
-
-fn test_extra(id: TestHeaderId) -> TestExtra {
-	id.0
-}
-
-fn source_reject_completion(method: &SourceMethod) {
-	if let SourceMethod::HeaderCompletion(_) = method {
-		unreachable!("HeaderCompletion request is not expected")
-	}
-}
-
-fn source_reject_extra(method: &SourceMethod) {
-	if let SourceMethod::HeaderExtra(_, _) = method {
-		unreachable!("HeaderExtra request is not expected")
-	}
-}
-
-fn target_accept_all_headers(method: &TargetMethod, data: &mut TargetData, requires_extra: bool) {
-	if let TargetMethod::SubmitHeaders(ref submitted) = method {
-		assert_eq!(submitted.iter().all(|header| header.extra().is_some()), requires_extra,);
-
-		let mut submitted_headers = SubmittedHeaders::default();
-		submitted_headers.submitted = submitted.iter().map(|header| header.id()).collect();
-		data.submit_headers_result = Some(submitted_headers);
-	}
-}
-
-fn target_signal_exit_when_header_submitted(
-	method: &TargetMethod,
-	header_id: TestHeaderId,
-	exit_signal: &futures::channel::mpsc::UnboundedSender<()>,
-) {
-	if let TargetMethod::SubmitHeaders(ref submitted) = method {
-		if submitted.iter().any(|header| header.id() == header_id) {
-			exit_signal.unbounded_send(()).unwrap();
-		}
-	}
-}
-
-fn target_signal_exit_when_header_completed(
-	method: &TargetMethod,
-	header_id: TestHeaderId,
-	exit_signal: &futures::channel::mpsc::UnboundedSender<()>,
-) {
-	if let TargetMethod::CompleteHeader(completed_id, _) = method {
-		if *completed_id == header_id {
-			exit_signal.unbounded_send(()).unwrap();
-		}
-	}
-}
-
-fn run_backoff_test(result: Result<(), TestError>) -> (Duration, Duration) {
-	let mut backoff = retry_backoff();
-
-	// no randomness in tests (otherwise intervals may overlap => asserts are failing)
-	backoff.randomization_factor = 0f64;
-
-	// increase backoff's current interval
-	let interval1 = backoff.next_backoff().unwrap();
-	let interval2 = backoff.next_backoff().unwrap();
-	assert!(interval2 > interval1);
-
-	// successful future result leads to backoff's reset
-	let go_offline_future = futures::future::Fuse::terminated();
-	futures::pin_mut!(go_offline_future);
-
-	process_future_result(
-		result,
-		&mut backoff,
-		|_| {},
-		&mut go_offline_future,
-		async_std::task::sleep,
-		|| "Test error".into(),
-	);
-
-	(interval2, backoff.next_backoff().unwrap())
-}
-
-#[test]
-fn process_future_result_resets_backoff_on_success() {
-	let (interval2, interval_after_reset) = run_backoff_test(Ok(()));
-	assert!(interval2 > interval_after_reset);
-}
-
-#[test]
-fn process_future_result_resets_backoff_on_connection_error() {
-	let (interval2, interval_after_reset) = run_backoff_test(Err(TestError(true)));
-	assert!(interval2 > interval_after_reset);
-}
-
-#[test]
-fn process_future_result_does_not_reset_backoff_on_non_connection_error() {
-	let (interval2, interval_after_reset) = run_backoff_test(Err(TestError(false)));
-	assert!(interval2 < interval_after_reset);
-}
-
-struct SyncLoopTestParams {
-	best_source_header: TestHeader,
-	headers_on_source: Vec<(bool, TestHeader)>,
-	best_target_header: TestHeader,
-	headers_on_target: Vec<TestHeader>,
-	target_requires_extra: bool,
-	target_requires_completion: bool,
-	stop_at: TestHeaderId,
-}
-
-fn run_sync_loop_test(params: SyncLoopTestParams) {
-	let (exit_sender, exit_receiver) = futures::channel::mpsc::unbounded();
-	let target_requires_extra = params.target_requires_extra;
-	let target_requires_completion = params.target_requires_completion;
-	let stop_at = params.stop_at;
-	let source = Source::new(
-		params.best_source_header.id(),
-		params.headers_on_source,
-		move |method, _| {
-			if !target_requires_extra {
-				source_reject_extra(&method);
-			}
-			if !target_requires_completion {
-				source_reject_completion(&method);
-			}
-		},
-	);
-	let target = Target::new(
-		params.best_target_header.id(),
-		params.headers_on_target.into_iter().map(|header| header.id()).collect(),
-		move |method, data| {
-			target_accept_all_headers(&method, data, target_requires_extra);
-			if target_requires_completion {
-				target_signal_exit_when_header_completed(&method, stop_at, &exit_sender);
-			} else {
-				target_signal_exit_when_header_submitted(&method, stop_at, &exit_sender);
-			}
-		},
-	);
-	target.data.lock().requires_extra = target_requires_extra;
-	target.data.lock().requires_completion = target_requires_completion;
-
-	run(
-		source,
-		test_tick(),
-		target,
-		test_tick(),
-		crate::sync::tests::default_sync_params(),
-		None,
-		exit_receiver.into_future().map(|(_, _)| ()),
-	);
-}
-
-#[test]
-fn sync_loop_is_able_to_synchronize_single_header() {
-	run_sync_loop_test(SyncLoopTestParams {
-		best_source_header: test_header(1),
-		headers_on_source: vec![(true, test_header(1))],
-		best_target_header: test_header(0),
-		headers_on_target: vec![test_header(0)],
-		target_requires_extra: false,
-		target_requires_completion: false,
-		stop_at: test_id(1),
-	});
-}
-
-#[test]
-fn sync_loop_is_able_to_synchronize_single_header_with_extra() {
-	run_sync_loop_test(SyncLoopTestParams {
-		best_source_header: test_header(1),
-		headers_on_source: vec![(true, test_header(1))],
-		best_target_header: test_header(0),
-		headers_on_target: vec![test_header(0)],
-		target_requires_extra: true,
-		target_requires_completion: false,
-		stop_at: test_id(1),
-	});
-}
-
-#[test]
-fn sync_loop_is_able_to_synchronize_single_header_with_completion() {
-	run_sync_loop_test(SyncLoopTestParams {
-		best_source_header: test_header(1),
-		headers_on_source: vec![(true, test_header(1))],
-		best_target_header: test_header(0),
-		headers_on_target: vec![test_header(0)],
-		target_requires_extra: false,
-		target_requires_completion: true,
-		stop_at: test_id(1),
-	});
-}
-
-#[test]
-fn sync_loop_is_able_to_reorganize_from_shorter_fork() {
-	run_sync_loop_test(SyncLoopTestParams {
-		best_source_header: test_header(3),
-		headers_on_source: vec![
-			(true, test_header(1)),
-			(true, test_header(2)),
-			(true, test_header(3)),
-			(false, test_forked_header(1, 0)),
-			(false, test_forked_header(2, 0)),
-		],
-		best_target_header: test_forked_header(2, 0),
-		headers_on_target: vec![test_header(0), test_forked_header(1, 0), test_forked_header(2, 0)],
-		target_requires_extra: false,
-		target_requires_completion: false,
-		stop_at: test_id(3),
-	});
-}
-
-#[test]
-fn sync_loop_is_able_to_reorganize_from_longer_fork() {
-	run_sync_loop_test(SyncLoopTestParams {
-		best_source_header: test_header(3),
-		headers_on_source: vec![
-			(true, test_header(1)),
-			(true, test_header(2)),
-			(true, test_header(3)),
-			(false, test_forked_header(1, 0)),
-			(false, test_forked_header(2, 0)),
-			(false, test_forked_header(3, 0)),
-			(false, test_forked_header(4, 0)),
-			(false, test_forked_header(5, 0)),
-		],
-		best_target_header: test_forked_header(5, 0),
-		headers_on_target: vec![
-			test_header(0),
-			test_forked_header(1, 0),
-			test_forked_header(2, 0),
-			test_forked_header(3, 0),
-			test_forked_header(4, 0),
-			test_forked_header(5, 0),
-		],
-		target_requires_extra: false,
-		target_requires_completion: false,
-		stop_at: test_id(3),
-	});
-}

bridges/relays/ethereum/src/sync_types.rs

@@ -1,200 +0,0 @@
-// 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/>.
-
-use crate::utils::{format_ids, HeaderId};
-
-use std::{ops::Deref, sync::Arc};
-
-/// Ethereum header synchronization status.
-#[derive(Debug, Clone, Copy, PartialEq)]
-pub enum HeaderStatus {
-	/// Header is unknown.
-	Unknown,
-	/// Header is in MaybeOrphan queue.
-	MaybeOrphan,
-	/// Header is in Orphan queue.
-	Orphan,
-	/// Header is in MaybeExtra queue.
-	MaybeExtra,
-	/// Header is in Extra queue.
-	Extra,
-	/// Header is in Ready queue.
-	Ready,
-	/// Header is in Incomplete queue.
-	Incomplete,
-	/// Header has been recently submitted to the target node.
-	Submitted,
-	/// Header is known to the target node.
-	Synced,
-}
-
-/// Headers synchronization pipeline.
-pub trait HeadersSyncPipeline: Clone + Copy {
-	/// Name of the headers source.
-	const SOURCE_NAME: &'static str;
-	/// Name of the headers target.
-	const TARGET_NAME: &'static str;
-
-	/// Headers we're syncing are identified by this hash.
-	type Hash: Eq + Clone + Copy + std::fmt::Debug + std::fmt::Display + std::hash::Hash;
-	/// Headers we're syncing are identified by this number.
-	type Number: From<u32>
-		+ Ord
-		+ Clone
-		+ Copy
-		+ std::fmt::Debug
-		+ std::fmt::Display
-		+ std::hash::Hash
-		+ std::ops::Add<Output = Self::Number>
-		+ std::ops::Sub<Output = Self::Number>
-		+ num_traits::Saturating
-		+ num_traits::Zero
-		+ num_traits::One
-		+ Into<u64>;
-	/// Type of header that we're syncing.
-	type Header: Clone + std::fmt::Debug + PartialEq + SourceHeader<Self::Hash, Self::Number>;
-	/// Type of extra data for the header that we're receiving from the source node:
-	/// 1) extra data is required for some headers;
-	/// 2) target node may answer if it'll require extra data before header is submitted;
-	/// 3) extra data available since the header creation time;
-	/// 4) header and extra data are submitted in single transaction.
-	///
-	/// Example: Ethereum transactions receipts.
-	type Extra: Clone + PartialEq + std::fmt::Debug;
-	/// Type of data required to 'complete' header that we're receiving from the source node:
-	/// 1) completion data is required for some headers;
-	/// 2) target node can't answer if it'll require completion data before header is accepted;
-	/// 3) completion data may be generated after header generation;
-	/// 4) header and completion data are submitted in separate transactions.
-	///
-	/// Example: Substrate GRANDPA justifications.
-	type Completion: Clone + std::fmt::Debug;
-
-	/// Function used to estimate size of target-encoded header.
-	fn estimate_size(source: &QueuedHeader<Self>) -> usize;
-}
-
-/// A HeaderId for `HeaderSyncPipeline`.
-pub type HeaderIdOf<P> = HeaderId<<P as HeadersSyncPipeline>::Hash, <P as HeadersSyncPipeline>::Number>;
-
-/// Header that we're receiving from source node.
-pub trait SourceHeader<Hash, Number> {
-	/// Returns ID of header.
-	fn id(&self) -> HeaderId<Hash, Number>;
-	/// Returns ID of parent header.
-	fn parent_id(&self) -> HeaderId<Hash, Number>;
-}
-
-/// Header how it's stored in the synchronization queue.
-#[derive(Clone, Debug)]
-#[cfg_attr(test, derive(PartialEq))]
-pub struct QueuedHeader<P: HeadersSyncPipeline>(Arc<QueuedHeaderData<P>>);
-
-impl<P: HeadersSyncPipeline> QueuedHeader<P> {
-	/// Creates new queued header.
-	pub fn new(header: P::Header) -> Self {
-		QueuedHeader(Arc::new(QueuedHeaderData { header, extra: None }))
-	}
-
-	/// Set associated extra data.
-	pub fn set_extra(self, extra: P::Extra) -> Self {
-		QueuedHeader(Arc::new(QueuedHeaderData {
-			header: Arc::try_unwrap(self.0)
-				.map(|data| data.header)
-				.unwrap_or_else(|data| data.header.clone()),
-			extra: Some(extra),
-		}))
-	}
-}
-
-impl<P: HeadersSyncPipeline> Deref for QueuedHeader<P> {
-	type Target = QueuedHeaderData<P>;
-
-	fn deref(&self) -> &Self::Target {
-		&self.0
-	}
-}
-
-/// Header how it's stored in the synchronization queue.
-#[derive(Clone, Debug, Default)]
-#[cfg_attr(test, derive(PartialEq))]
-pub struct QueuedHeaderData<P: HeadersSyncPipeline> {
-	header: P::Header,
-	extra: Option<P::Extra>,
-}
-
-impl<P: HeadersSyncPipeline> QueuedHeader<P> {
-	/// Returns ID of header.
-	pub fn id(&self) -> HeaderId<P::Hash, P::Number> {
-		self.header.id()
-	}
-
-	/// Returns ID of parent header.
-	pub fn parent_id(&self) -> HeaderId<P::Hash, P::Number> {
-		self.header.parent_id()
-	}
-
-	/// Returns reference to header.
-	pub fn header(&self) -> &P::Header {
-		&self.header
-	}
-
-	/// Returns reference to associated extra data.
-	pub fn extra(&self) -> &Option<P::Extra> {
-		&self.extra
-	}
-}
-
-/// Headers submission result.
-#[derive(Debug)]
-#[cfg_attr(test, derive(PartialEq))]
-pub struct SubmittedHeaders<Id, Error> {
-	/// IDs of headers that have been submitted to target node.
-	pub submitted: Vec<Id>,
-	/// IDs of incomplete headers. These headers were submitted (so this id is also in `submitted` vec),
-	/// but all descendants are not.
-	pub incomplete: Vec<Id>,
-	/// IDs of ignored headers that we have decided not to submit (they're either rejected by
-	/// target node immediately, or they're descendants of incomplete headers).
-	pub rejected: Vec<Id>,
-	/// Fatal target node error, if it has occured during submission.
-	pub fatal_error: Option<Error>,
-}
-
-impl<Id, Error> Default for SubmittedHeaders<Id, Error> {
-	fn default() -> Self {
-		SubmittedHeaders {
-			submitted: Vec::new(),
-			incomplete: Vec::new(),
-			rejected: Vec::new(),
-			fatal_error: None,
-		}
-	}
-}
-
-impl<Id: std::fmt::Debug, Error> std::fmt::Display for SubmittedHeaders<Id, Error> {
-	fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
-		let submitted = format_ids(self.submitted.iter());
-		let incomplete = format_ids(self.incomplete.iter());
-		let rejected = format_ids(self.rejected.iter());
-
-		write!(
-			f,
-			"Submitted: {}, Incomplete: {}, Rejected: {}",
-			submitted, incomplete, rejected
-		)
-	}
-}

bridges/relays/ethereum/src/utils.rs

@@ -1,223 +0,0 @@
-// 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/>.
-
-use backoff::{backoff::Backoff, ExponentialBackoff};
-use futures::future::FutureExt;
-use std::time::Duration;
-
-/// Max delay after connection-unrelated error happened before we'll try the
-/// same request again.
-const MAX_BACKOFF_INTERVAL: Duration = Duration::from_secs(60);
-/// Delay after connection-related error happened before we'll try
-/// reconnection again.
-const CONNECTION_ERROR_DELAY: Duration = Duration::from_secs(10);
-
-/// Macro that returns (client, Err(error)) tuple from function if result is Err(error).
-#[macro_export]
-macro_rules! bail_on_error {
-	($result: expr) => {
-		match $result {
-			(client, Ok(result)) => (client, result),
-			(client, Err(error)) => return (client, Err(error)),
-			}
-	};
-}
-
-/// Macro that returns (client, Err(error)) tuple from function if result is Err(error).
-#[macro_export]
-macro_rules! bail_on_arg_error {
-	($result: expr, $client: ident) => {
-		match $result {
-			Ok(result) => result,
-			Err(error) => return ($client, Err(error)),
-			}
-	};
-}
-
-/// Ethereum header Id.
-#[derive(Debug, Default, Clone, Copy, Eq, Hash, PartialEq)]
-pub struct HeaderId<Hash, Number>(pub Number, pub Hash);
-
-/// Error type that can signal connection errors.
-pub trait MaybeConnectionError {
-	/// Returns true if error (maybe) represents connection error.
-	fn is_connection_error(&self) -> bool;
-}
-
-/// Stringified error that may be either connection-related or not.
-#[derive(Debug)]
-pub enum StringifiedMaybeConnectionError {
-	/// The error is connection-related error.
-	Connection(String),
-	/// The error is connection-unrelated error.
-	NonConnection(String),
-}
-
-impl StringifiedMaybeConnectionError {
-	/// Create new stringified connection error.
-	pub fn new(is_connection_error: bool, error: String) -> Self {
-		if is_connection_error {
-			StringifiedMaybeConnectionError::Connection(error)
-		} else {
-			StringifiedMaybeConnectionError::NonConnection(error)
-		}
-	}
-}
-
-impl MaybeConnectionError for StringifiedMaybeConnectionError {
-	fn is_connection_error(&self) -> bool {
-		match *self {
-			StringifiedMaybeConnectionError::Connection(_) => true,
-			StringifiedMaybeConnectionError::NonConnection(_) => false,
-		}
-	}
-}
-
-impl ToString for StringifiedMaybeConnectionError {
-	fn to_string(&self) -> String {
-		match *self {
-			StringifiedMaybeConnectionError::Connection(ref err) => err.clone(),
-			StringifiedMaybeConnectionError::NonConnection(ref err) => err.clone(),
-		}
-	}
-}
-
-/// Exponential backoff for connection-unrelated errors retries.
-pub fn retry_backoff() -> ExponentialBackoff {
-	let mut backoff = ExponentialBackoff::default();
-	// we do not want relayer to stop
-	backoff.max_elapsed_time = None;
-	backoff.max_interval = MAX_BACKOFF_INTERVAL;
-	backoff
-}
-
-/// Compact format of IDs vector.
-pub fn format_ids<Id: std::fmt::Debug>(mut ids: impl ExactSizeIterator<Item = Id>) -> String {
-	const NTH_PROOF: &str = "we have checked len; qed";
-	match ids.len() {
-		0 => "<nothing>".into(),
-		1 => format!("{:?}", ids.next().expect(NTH_PROOF)),
-		2 => {
-			let id0 = ids.next().expect(NTH_PROOF);
-			let id1 = ids.next().expect(NTH_PROOF);
-			format!("[{:?}, {:?}]", id0, id1)
-		}
-		len => {
-			let id0 = ids.next().expect(NTH_PROOF);
-			let id_last = ids.last().expect(NTH_PROOF);
-			format!("{}:[{:?} ... {:?}]", len, id0, id_last)
-		}
-	}
-}
-
-/// Stream that emits item every `timeout_ms` milliseconds.
-pub fn interval(timeout: Duration) -> impl futures::Stream<Item = ()> {
-	futures::stream::unfold((), move |_| async move {
-		async_std::task::sleep(timeout).await;
-		Some(((), ()))
-	})
-}
-
-/// Which client has caused error.
-#[derive(Debug, Clone, Copy, PartialEq)]
-pub enum FailedClient {
-	/// It is the source client who has caused error.
-	Source,
-	/// It is the target client who has caused error.
-	Target,
-	/// Both clients are failing, or we just encountered some other error that
-	/// should be treated like that.
-	Both,
-}
-
-/// Future process result.
-#[derive(Debug, Clone, Copy)]
-pub enum ProcessFutureResult {
-	/// Future has been processed successfully.
-	Success,
-	/// Future has failed with non-connection error.
-	Failed,
-	/// Future has failed with connection error.
-	ConnectionFailed,
-}
-
-impl ProcessFutureResult {
-	/// Returns true if result is Success.
-	pub fn is_ok(self) -> bool {
-		match self {
-			ProcessFutureResult::Success => true,
-			ProcessFutureResult::Failed | ProcessFutureResult::ConnectionFailed => false,
-		}
-	}
-
-	/// Returns Ok(true) if future has succeeded.
-	/// Returns Ok(false) if future has failed with non-connection error.
-	/// Returns Err if future is `ConnectionFailed`.
-	pub fn fail_if_connection_error(self, failed_client: FailedClient) -> Result<bool, FailedClient> {
-		match self {
-			ProcessFutureResult::Success => Ok(true),
-			ProcessFutureResult::Failed => Ok(false),
-			ProcessFutureResult::ConnectionFailed => Err(failed_client),
-		}
-	}
-}
-
-/// Process result of the future from a client.
-pub(crate) fn process_future_result<TResult, TError, TGoOfflineFuture>(
-	result: Result<TResult, TError>,
-	retry_backoff: &mut ExponentialBackoff,
-	on_success: impl FnOnce(TResult),
-	go_offline_future: &mut std::pin::Pin<&mut futures::future::Fuse<TGoOfflineFuture>>,
-	go_offline: impl FnOnce(Duration) -> TGoOfflineFuture,
-	error_pattern: impl FnOnce() -> String,
-) -> ProcessFutureResult
-where
-	TError: std::fmt::Debug + MaybeConnectionError,
-	TGoOfflineFuture: FutureExt,
-{
-	match result {
-		Ok(result) => {
-			on_success(result);
-			retry_backoff.reset();
-			ProcessFutureResult::Success
-		}
-		Err(error) if error.is_connection_error() => {
-			log::error!(
-				target: "bridge",
-				"{}: {:?}. Going to restart",
-				error_pattern(),
-				error,
-			);
-
-			retry_backoff.reset();
-			go_offline_future.set(go_offline(CONNECTION_ERROR_DELAY).fuse());
-			ProcessFutureResult::ConnectionFailed
-		}
-		Err(error) => {
-			let retry_delay = retry_backoff.next_backoff().unwrap_or(CONNECTION_ERROR_DELAY);
-			log::error!(
-				target: "bridge",
-				"{}: {:?}. Retrying in {}",
-				error_pattern(),
-				error,
-				retry_delay.as_secs_f64(),
-			);
-
-			go_offline_future.set(go_offline(retry_delay).fuse());
-			ProcessFutureResult::Failed
-		}
-	}
-}