Merge commit '392447f5c8f986ded2559a78457f4cd87942f393' into update-bridges-subtree-r/w

polkadot/bridges/relays/bin-ethereum/Cargo.toml

@@ -6,24 +6,22 @@ edition = "2018"
 license = "GPL-3.0-or-later WITH Classpath-exception-2.0"
 
 [dependencies]
-ansi_term = "0.12"
+anyhow = "1.0"
 async-std = "1.9.0"
 async-trait = "0.1.42"
 clap = { version = "2.33.3", features = ["yaml"] }
-codec = { package = "parity-scale-codec", version = "2.0.0" }
-env_logger = "0.8.3"
-ethabi = { git = "https://github.com/paritytech/ethabi", branch = "td-eth-types-11" }
-ethabi-contract = { git = "https://github.com/paritytech/ethabi", branch = "td-eth-types-11" }
-ethabi-derive = { git = "https://github.com/paritytech/ethabi", branch = "td-eth-types-11" }
+codec = { package = "parity-scale-codec", version = "2.2.0" }
+ethabi = { git = "https://github.com/svyatonik/ethabi.git", branch = "bump-deps" }
+ethabi-contract = { git = "https://github.com/svyatonik/ethabi.git", branch = "bump-deps" }
+ethabi-derive = { git = "https://github.com/svyatonik/ethabi.git", branch = "bump-deps" }
 futures = "0.3.12"
 hex = "0.4"
 hex-literal = "0.3"
-libsecp256k1 = { version = "0.3.4", default-features = false, features = ["hmac"] }
+libsecp256k1 = { version = "0.7", default-features = false, features = ["hmac"] }
 log = "0.4.14"
 num-traits = "0.2"
-serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0.64"
-time = "0.2"
+thiserror = "1.0.26"
 
 # Bridge dependencies
 
@@ -31,7 +29,6 @@ bp-currency-exchange = { path = "../../primitives/currency-exchange" }
 bp-eth-poa = { path = "../../primitives/ethereum-poa" }
 exchange-relay = { path = "../exchange" }
 headers-relay = { path = "../headers" }
-messages-relay = { path = "../messages" }
 relay-ethereum-client = { path = "../client-ethereum" }
 relay-rialto-client = { path = "../client-rialto" }
 relay-substrate-client = { path = "../client-substrate" }
@@ -40,9 +37,6 @@ rialto-runtime = { path = "../../bin/rialto/runtime" }
 
 # Substrate Dependencies
 
-frame-system = { git = "https://github.com/paritytech/substrate", branch = "master" }
-pallet-transaction-payment = { git = "https://github.com/paritytech/substrate", branch = "master" }
 sp-core = { git = "https://github.com/paritytech/substrate", branch = "master" }
 sp-keyring = { git = "https://github.com/paritytech/substrate", branch = "master" }
 sp-runtime = { git = "https://github.com/paritytech/substrate", branch = "master" }
-substrate-prometheus-endpoint = { git = "https://github.com/paritytech/substrate", branch = "master" }

polkadot/bridges/relays/bin-ethereum/src/error.rs

@@ -0,0 +1,38 @@
+// Copyright 2021 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::rpc_errors::RpcError;
+use thiserror::Error;
+
+/// Result type used by PoA relay.
+pub type Result<T> = std::result::Result<T, Error>;
+
+/// Ethereum PoA relay errors.
+#[derive(Error, Debug)]
+pub enum Error {
+	/// Failed to decode initial header.
+	#[error("Error decoding initial header: {0}")]
+	DecodeInitialHeader(codec::Error),
+	/// RPC error.
+	#[error("{0}")]
+	Rpc(#[from] RpcError),
+	/// Failed to read genesis header.
+	#[error("Error reading Substrate genesis header: {0:?}")]
+	ReadGenesisHeader(relay_substrate_client::Error),
+	/// Failed to read initial GRANDPA authorities.
+	#[error("Error reading GRANDPA authorities set: {0:?}")]
+	ReadAuthorities(relay_substrate_client::Error),
+	/// Failed to deploy bridge contract to Ethereum chain.
+	#[error("Error deploying contract: {0:?}")]
+	DeployContract(RpcError),
+}

polkadot/bridges/relays/bin-ethereum/src/ethereum_client.rs

@@ -14,8 +14,7 @@
 // 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::rpc_errors::RpcError;
-use crate::substrate_sync_loop::QueuedRialtoHeader;
+use crate::{rpc_errors::RpcError, substrate_sync_loop::QueuedRialtoHeader};
 
 use async_trait::async_trait;
 use bp_eth_poa::signatures::secret_to_address;
@@ -41,7 +40,7 @@ type RpcResult<T> = std::result::Result<T, RpcError>;
 /// interactions involving, for example, an Ethereum contract.
 #[async_trait]
 pub trait EthereumHighLevelRpc {
-	/// Returns best Substrate block that PoA chain knows of.
+	/// Returns the best Substrate block that PoA chain knows of.
 	async fn best_substrate_block(&self, contract_address: Address) -> RpcResult<RialtoHeaderId>;
 
 	/// Returns true if Substrate header is known to Ethereum node.
@@ -60,7 +59,10 @@ pub trait EthereumHighLevelRpc {
 	) -> SubmittedHeaders<RialtoHeaderId, RpcError>;
 
 	/// Returns ids of incomplete Substrate headers.
-	async fn incomplete_substrate_headers(&self, contract_address: Address) -> RpcResult<HashSet<RialtoHeaderId>>;
+	async fn incomplete_substrate_headers(
+		&self,
+		contract_address: Address,
+	) -> RpcResult<HashSet<RialtoHeaderId>>;
 
 	/// Complete Substrate header.
 	async fn complete_substrate_header(
@@ -104,7 +106,7 @@ impl EthereumHighLevelRpc for EthereumClient {
 		let hash = rialto_runtime::Hash::decode(&mut &raw_hash[..])?;
 
 		if number != number.low_u32().into() {
-			return Err(RpcError::Ethereum(EthereumNodeError::InvalidSubstrateBlockNumber));
+			return Err(RpcError::Ethereum(EthereumNodeError::InvalidSubstrateBlockNumber))
 		}
 
 		Ok(HeaderId(number.low_u32(), hash))
@@ -138,31 +140,28 @@ impl EthereumHighLevelRpc for EthereumClient {
 		let address: Address = secret_to_address(&params.signer);
 		let nonce = match self.account_nonce(address).await {
 			Ok(nonce) => nonce,
-			Err(error) => {
+			Err(error) =>
 				return SubmittedHeaders {
 					submitted: Vec::new(),
 					incomplete: Vec::new(),
 					rejected: headers.iter().rev().map(|header| header.id()).collect(),
 					fatal_error: Some(error.into()),
-				}
-			}
+				},
 		};
 
 		// submit headers. Note that we're cloning self here. It is ok, because
 		// cloning `jsonrpsee::Client` only clones reference to background threads
 		submit_substrate_headers(
-			EthereumHeadersSubmitter {
-				client: self.clone(),
-				params,
-				contract_address,
-				nonce,
-			},
+			EthereumHeadersSubmitter { client: self.clone(), params, contract_address, nonce },
 			headers,
 		)
 		.await
 	}
 
-	async fn incomplete_substrate_headers(&self, contract_address: Address) -> RpcResult<HashSet<RialtoHeaderId>> {
+	async fn incomplete_substrate_headers(
+		&self,
+		contract_address: Address,
+	) -> RpcResult<HashSet<RialtoHeaderId>> {
 		let (encoded_call, call_decoder) = bridge_contract::functions::incomplete_headers::call();
 		let call_request = CallRequest {
 			to: Some(contract_address),
@@ -173,13 +172,14 @@ impl EthereumHighLevelRpc for EthereumClient {
 		let call_result = self.eth_call(call_request).await?;
 
 		// Q: Is is correct to call these "incomplete_ids"?
-		let (incomplete_headers_numbers, incomplete_headers_hashes) = call_decoder.decode(&call_result.0)?;
+		let (incomplete_headers_numbers, incomplete_headers_hashes) =
+			call_decoder.decode(&call_result.0)?;
 		let incomplete_ids = incomplete_headers_numbers
 			.into_iter()
 			.zip(incomplete_headers_hashes)
 			.filter_map(|(number, hash)| {
 				if number != number.low_u32().into() {
-					return None;
+					return None
 				}
 
 				Some(HeaderId(number.low_u32(), hash))
@@ -202,7 +202,11 @@ impl EthereumHighLevelRpc for EthereumClient {
 				Some(contract_address),
 				None,
 				false,
-				bridge_contract::functions::import_finality_proof::encode_input(id.0, id.1, justification),
+				bridge_contract::functions::import_finality_proof::encode_input(
+					id.0,
+					id.1,
+					justification,
+				),
 			)
 			.await?;
 
@@ -263,7 +267,7 @@ impl HeadersBatch {
 	) -> Result<(Self, Vec<RialtoHeaderId>), ()> {
 		if headers.len() != ids.len() {
 			log::error!(target: "bridge", "Collection size mismatch ({} vs {})", headers.len(), ids.len());
-			return Err(());
+			return Err(())
 		}
 
 		let header1 = headers.pop().ok_or(())?;
@@ -276,27 +280,14 @@ impl HeadersBatch {
 			submitting_ids.extend(ids.pop().iter());
 		}
 
-		Ok((
-			Self {
-				header1,
-				header2,
-				header3,
-				header4,
-			},
-			submitting_ids,
-		))
+		Ok((Self { header1, header2, header3, header4 }, submitting_ids))
 	}
 
 	/// Returns unified array of headers.
 	///
 	/// The first element is always `Some`.
 	fn headers(&self) -> [Option<&QueuedRialtoHeader>; HEADERS_BATCH] {
-		[
-			Some(&self.header1),
-			self.header2.as_ref(),
-			self.header3.as_ref(),
-			self.header4.as_ref(),
-		]
+		[Some(&self.header1), self.header2.as_ref(), self.header3.as_ref(), self.header4.as_ref()]
 	}
 
 	/// Encodes all headers. If header is not present an empty vector will be returned.
@@ -323,9 +314,10 @@ impl HeadersBatch {
 	/// or when `idx > HEADERS_BATCH`.
 	pub fn split_off(&mut self, idx: usize) -> Result<(), ()> {
 		if idx == 0 || idx > HEADERS_BATCH {
-			return Err(());
+			return Err(())
 		}
-		let mut vals: [_; HEADERS_BATCH] = [&mut None, &mut self.header2, &mut self.header3, &mut self.header4];
+		let mut vals: [_; HEADERS_BATCH] =
+			[&mut None, &mut self.header2, &mut self.header3, &mut self.header4];
 		for val in vals.iter_mut().skip(idx) {
 			**val = None;
 		}
@@ -359,7 +351,8 @@ struct EthereumHeadersSubmitter {
 impl HeadersSubmitter for EthereumHeadersSubmitter {
 	async fn is_headers_incomplete(&self, headers: &HeadersBatch) -> RpcResult<usize> {
 		let [h1, h2, h3, h4] = headers.encode();
-		let (encoded_call, call_decoder) = bridge_contract::functions::is_incomplete_headers::call(h1, h2, h3, h4);
+		let (encoded_call, call_decoder) =
+			bridge_contract::functions::is_incomplete_headers::call(h1, h2, h3, h4);
 		let call_request = CallRequest {
 			to: Some(self.contract_address),
 			data: Some(encoded_call.into()),
@@ -369,7 +362,7 @@ impl HeadersSubmitter for EthereumHeadersSubmitter {
 		let call_result = self.client.eth_call(call_request).await?;
 		let incomplete_index: U256 = call_decoder.decode(&call_result.0)?;
 		if incomplete_index > HEADERS_BATCH.into() {
-			return Err(RpcError::Ethereum(EthereumNodeError::InvalidIncompleteIndex));
+			return Err(RpcError::Ethereum(EthereumNodeError::InvalidIncompleteIndex))
 		}
 
 		Ok(incomplete_index.low_u32() as _)
@@ -407,17 +400,21 @@ async fn submit_substrate_headers(
 	headers.reverse();
 
 	while !headers.is_empty() {
-		let (headers, submitting_ids) =
-			HeadersBatch::pop_from(&mut headers, &mut ids).expect("Headers and ids are not empty; qed");
+		let (headers, submitting_ids) = HeadersBatch::pop_from(&mut headers, &mut ids)
+			.expect("Headers and ids are not empty; qed");
 
-		submitted_headers.fatal_error =
-			submit_substrate_headers_batch(&mut header_submitter, &mut submitted_headers, submitting_ids, headers)
-				.await;
+		submitted_headers.fatal_error = submit_substrate_headers_batch(
+			&mut header_submitter,
+			&mut submitted_headers,
+			submitting_ids,
+			headers,
+		)
+		.await;
 
 		if submitted_headers.fatal_error.is_some() {
 			ids.reverse();
 			submitted_headers.rejected.extend(ids);
-			break;
+			break
 		}
 	}
 
@@ -436,9 +433,11 @@ async fn submit_substrate_headers_batch(
 	// if parent of first header is either incomplete, or rejected, we assume that contract
 	// will reject this header as well
 	let parent_id = headers.header1.parent_id();
-	if submitted_headers.rejected.contains(&parent_id) || submitted_headers.incomplete.contains(&parent_id) {
+	if submitted_headers.rejected.contains(&parent_id) ||
+		submitted_headers.incomplete.contains(&parent_id)
+	{
 		submitted_headers.rejected.extend(ids);
-		return None;
+		return None
 	}
 
 	// check if headers are incomplete
@@ -450,11 +449,11 @@ async fn submit_substrate_headers_batch(
 			// contract has rejected all headers => we do not want to submit it
 			submitted_headers.rejected.extend(ids);
 			if error.is_connection_error() {
-				return Some(error);
+				return Some(error)
 			} else {
-				return None;
+				return None
 			}
-		}
+		},
 	};
 
 	// Modify `ids` and `headers` to only contain values that are going to be accepted.
@@ -477,12 +476,12 @@ async fn submit_substrate_headers_batch(
 			submitted_headers.submitted.extend(submitted);
 			submitted_headers.rejected.extend(rejected);
 			None
-		}
+		},
 		Err(error) => {
 			submitted_headers.rejected.extend(submitted);
 			submitted_headers.rejected.extend(rejected);
 			Some(error)
-		}
+		},
 	}
 }
 
@@ -521,11 +520,7 @@ mod tests {
 				number,
 				Default::default(),
 				Default::default(),
-				if number == 0 {
-					Default::default()
-				} else {
-					header(number - 1).id().1
-				},
+				if number == 0 { Default::default() } else { header(number - 1).id().1 },
 				Default::default(),
 			)
 			.into(),
@@ -535,10 +530,7 @@ mod tests {
 	#[test]
 	fn descendants_of_incomplete_headers_are_not_submitted() {
 		let submitted_headers = async_std::task::block_on(submit_substrate_headers(
-			TestHeadersSubmitter {
-				incomplete: vec![header(5).id()],
-				failed: vec![],
-			},
+			TestHeadersSubmitter { incomplete: vec![header(5).id()], failed: vec![] },
 			vec![header(5), header(6)],
 		));
 		assert_eq!(submitted_headers.submitted, vec![header(5).id()]);
@@ -550,19 +542,8 @@ mod tests {
 	#[test]
 	fn headers_after_fatal_error_are_not_submitted() {
 		let submitted_headers = async_std::task::block_on(submit_substrate_headers(
-			TestHeadersSubmitter {
-				incomplete: vec![],
-				failed: vec![header(9).id()],
-			},
-			vec![
-				header(5),
-				header(6),
-				header(7),
-				header(8),
-				header(9),
-				header(10),
-				header(11),
-			],
+			TestHeadersSubmitter { incomplete: vec![], failed: vec![header(9).id()] },
+			vec![header(5), header(6), header(7), header(8), header(9), header(10), header(11)],
 		));
 		assert_eq!(
 			submitted_headers.submitted,
@@ -583,10 +564,7 @@ mod tests {
 		let (headers, ids) = HeadersBatch::pop_from(&mut init_headers, &mut init_ids).unwrap();
 		assert_eq!(init_headers, vec![header(5)]);
 		assert_eq!(init_ids, vec![header(5).id()]);
-		assert_eq!(
-			ids,
-			vec![header(1).id(), header(2).id(), header(3).id(), header(4).id()]
-		);
+		assert_eq!(ids, vec![header(1).id(), header(2).id(), header(3).id(), header(4).id()]);
 		headers
 	}
 

polkadot/bridges/relays/bin-ethereum/src/ethereum_deploy_contract.rs

@@ -14,17 +14,22 @@
 // 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::ethereum_client::{bridge_contract, EthereumHighLevelRpc};
-use crate::rpc_errors::RpcError;
+use crate::{
+	error::{Error, Result},
+	ethereum_client::{bridge_contract, EthereumHighLevelRpc},
+	rpc_errors::RpcError,
+};
 
 use codec::{Decode, Encode};
 use num_traits::Zero;
 use relay_ethereum_client::{
-	Client as EthereumClient, ConnectionParams as EthereumConnectionParams, SigningParams as EthereumSigningParams,
+	Client as EthereumClient, ConnectionParams as EthereumConnectionParams,
+	SigningParams as EthereumSigningParams,
 };
 use relay_rialto_client::{HeaderId as RialtoHeaderId, Rialto};
 use relay_substrate_client::{
-	Client as SubstrateClient, ConnectionParams as SubstrateConnectionParams, OpaqueGrandpaAuthoritiesSet,
+	Client as SubstrateClient, ConnectionParams as SubstrateConnectionParams,
+	OpaqueGrandpaAuthoritiesSet,
 };
 use relay_utils::HeaderId;
 
@@ -100,21 +105,21 @@ pub async fn run(params: EthereumDeployContractParams) {
 async fn prepare_initial_header(
 	sub_client: &SubstrateClient<Rialto>,
 	sub_initial_header: Option<Vec<u8>>,
-) -> Result<(RialtoHeaderId, Vec<u8>), String> {
+) -> Result<(RialtoHeaderId, Vec<u8>)> {
 	match sub_initial_header {
-		Some(raw_initial_header) => match rialto_runtime::Header::decode(&mut &raw_initial_header[..]) {
-			Ok(initial_header) => Ok((
-				HeaderId(initial_header.number, initial_header.hash()),
-				raw_initial_header,
-			)),
-			Err(error) => Err(format!("Error decoding initial header: {}", error)),
+		Some(raw_initial_header) => {
+			match rialto_runtime::Header::decode(&mut &raw_initial_header[..]) {
+				Ok(initial_header) =>
+					Ok((HeaderId(initial_header.number, initial_header.hash()), raw_initial_header)),
+				Err(error) => Err(Error::DecodeInitialHeader(error)),
+			}
 		},
 		None => {
 			let initial_header = sub_client.header_by_number(Zero::zero()).await;
 			initial_header
 				.map(|header| (HeaderId(Zero::zero(), header.hash()), header.encode()))
-				.map_err(|error| format!("Error reading Substrate genesis header: {:?}", error))
-		}
+				.map_err(Error::ReadGenesisHeader)
+		},
 	}
 }
 
@@ -123,13 +128,13 @@ async fn prepare_initial_authorities_set(
 	sub_client: &SubstrateClient<Rialto>,
 	sub_initial_header_hash: rialto_runtime::Hash,
 	sub_initial_authorities_set: Option<Vec<u8>>,
-) -> Result<OpaqueGrandpaAuthoritiesSet, String> {
+) -> Result<OpaqueGrandpaAuthoritiesSet> {
 	let initial_authorities_set = match sub_initial_authorities_set {
 		Some(initial_authorities_set) => Ok(initial_authorities_set),
 		None => sub_client.grandpa_authorities_set(sub_initial_header_hash).await,
 	};
 
-	initial_authorities_set.map_err(|error| format!("Error reading GRANDPA authorities set: {:?}", error))
+	initial_authorities_set.map_err(Error::ReadAuthorities)
 }
 
 /// Deploy bridge contract to Ethereum chain.
@@ -140,15 +145,20 @@ async fn deploy_bridge_contract(
 	initial_header: Vec<u8>,
 	initial_set_id: u64,
 	initial_authorities: Vec<u8>,
-) -> Result<(), String> {
+) -> Result<()> {
 	eth_client
 		.submit_ethereum_transaction(
 			params,
 			None,
 			None,
 			false,
-			bridge_contract::constructor(contract_code, initial_header, initial_set_id, initial_authorities),
+			bridge_contract::constructor(
+				contract_code,
+				initial_header,
+				initial_set_id,
+				initial_authorities,
+			),
 		)
 		.await
-		.map_err(|error| format!("Error deploying contract: {:?}", error))
+		.map_err(Error::DeployContract)
 }

polkadot/bridges/relays/bin-ethereum/src/ethereum_exchange.rs

@@ -16,28 +16,34 @@
 
 //! Relaying proofs of PoA -> Substrate exchange transactions.
 
-use crate::instances::BridgeInstance;
-use crate::rialto_client::{SubmitEthereumExchangeTransactionProof, SubstrateHighLevelRpc};
-use crate::rpc_errors::RpcError;
-use crate::substrate_types::into_substrate_ethereum_receipt;
+use crate::{
+	instances::BridgeInstance,
+	rialto_client::{SubmitEthereumExchangeTransactionProof, SubstrateHighLevelRpc},
+	rpc_errors::RpcError,
+	substrate_types::into_substrate_ethereum_receipt,
+};
 
 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::{
+		relay_single_transaction_proof, SourceBlock, SourceClient, SourceTransaction, TargetClient,
+		TransactionProofPipeline,
+	},
+	exchange_loop::{run as run_loop, InMemoryStorage},
 };
-use exchange_relay::exchange_loop::{run as run_loop, InMemoryStorage};
 use relay_ethereum_client::{
 	types::{
 		HeaderId as EthereumHeaderId, HeaderWithTransactions as EthereumHeaderWithTransactions,
-		Transaction as EthereumTransaction, TransactionHash as EthereumTransactionHash, H256, HEADER_ID_PROOF,
+		Transaction as EthereumTransaction, TransactionHash as EthereumTransactionHash, H256,
+		HEADER_ID_PROOF,
 	},
 	Client as EthereumClient, ConnectionParams as EthereumConnectionParams,
 };
 use relay_rialto_client::{Rialto, SigningParams as RialtoSigningParams};
 use relay_substrate_client::{
-	Chain as SubstrateChain, Client as SubstrateClient, ConnectionParams as SubstrateConnectionParams,
+	Chain as SubstrateChain, Client as SubstrateClient,
+	ConnectionParams as SubstrateConnectionParams,
 };
 use relay_utils::{metrics::MetricsParams, relay_loop::Client as RelayClient, HeaderId};
 use rialto_runtime::exchange::EthereumTransactionInclusionProof;
@@ -111,12 +117,7 @@ impl SourceBlock for EthereumSourceBlock {
 	}
 
 	fn transactions(&self) -> Vec<Self::Transaction> {
-		self.0
-			.transactions
-			.iter()
-			.cloned()
-			.map(EthereumSourceTransaction)
-			.collect()
+		self.0.transactions.iter().cloned().map(EthereumSourceTransaction).collect()
 	}
 }
 
@@ -178,13 +179,12 @@ impl SourceClient<EthereumToSubstrateExchange> for EthereumTransactionsSource {
 		};
 
 		// we need transaction to be mined => check if it is included in the block
-		let (eth_header_id, eth_tx_index) = match (eth_tx.block_number, eth_tx.block_hash, eth_tx.transaction_index) {
-			(Some(block_number), Some(block_hash), Some(transaction_index)) => (
-				HeaderId(block_number.as_u64(), block_hash),
-				transaction_index.as_u64() as _,
-			),
-			_ => return Ok(None),
-		};
+		let (eth_header_id, eth_tx_index) =
+			match (eth_tx.block_number, eth_tx.block_hash, eth_tx.transaction_index) {
+				(Some(block_number), Some(block_hash), Some(transaction_index)) =>
+					(HeaderId(block_number.as_u64(), block_hash), transaction_index.as_u64() as _),
+				_ => return Ok(None),
+			};
 
 		Ok(Some((eth_header_id, eth_tx_index)))
 	}
@@ -194,9 +194,11 @@ impl SourceClient<EthereumToSubstrateExchange> for EthereumTransactionsSource {
 		block: &EthereumSourceBlock,
 		tx_index: usize,
 	) -> Result<EthereumTransactionInclusionProof, RpcError> {
-		const TRANSACTION_HAS_RAW_FIELD_PROOF: &str = "RPC level checks that transactions from Ethereum\
+		const TRANSACTION_HAS_RAW_FIELD_PROOF: &str =
+			"RPC level checks that transactions from Ethereum\
 			node are having `raw` field; qed";
-		const BLOCK_HAS_HASH_FIELD_PROOF: &str = "RPC level checks that block has `hash` field; qed";
+		const BLOCK_HAS_HASH_FIELD_PROOF: &str =
+			"RPC level checks that block has `hash` field; qed";
 
 		let mut transaction_proof = Vec::with_capacity(block.0.transactions.len());
 		for tx in &block.0.transactions {
@@ -266,12 +268,15 @@ impl TargetClient<EthereumToSubstrateExchange> for SubstrateTransactionsTarget {
 		self.client.best_ethereum_finalized_block().await
 	}
 
-	async fn filter_transaction_proof(&self, proof: &EthereumTransactionInclusionProof) -> Result<bool, RpcError> {
+	async fn filter_transaction_proof(
+		&self,
+		proof: &EthereumTransactionInclusionProof,
+	) -> Result<bool, RpcError> {
 		// let's try to parse transaction locally
 		let (raw_tx, raw_tx_receipt) = &proof.proof[proof.index as usize];
 		let parse_result = rialto_runtime::exchange::EthTransaction::parse(raw_tx);
 		if parse_result.is_err() {
-			return Ok(false);
+			return Ok(false)
 		}
 
 		// now let's check if transaction is successful
@@ -285,8 +290,12 @@ impl TargetClient<EthereumToSubstrateExchange> for SubstrateTransactionsTarget {
 		self.client.verify_exchange_transaction_proof(proof.clone()).await
 	}
 
-	async fn submit_transaction_proof(&self, proof: EthereumTransactionInclusionProof) -> Result<(), RpcError> {
-		let (sign_params, bridge_instance) = (self.sign_params.clone(), self.bridge_instance.clone());
+	async fn submit_transaction_proof(
+		&self,
+		proof: EthereumTransactionInclusionProof,
+	) -> Result<(), RpcError> {
+		let (sign_params, bridge_instance) =
+			(self.sign_params.clone(), self.bridge_instance.clone());
 		self.client
 			.submit_exchange_transaction_proof(sign_params, bridge_instance, proof)
 			.await
@@ -311,9 +320,10 @@ pub async fn run(params: EthereumExchangeParams) {
 					err,
 				),
 			}
-		}
+		},
 		ExchangeRelayMode::Auto(eth_start_with_block_number) => {
-			let result = run_auto_transactions_relay_loop(params, eth_start_with_block_number).await;
+			let result =
+				run_auto_transactions_relay_loop(params, eth_start_with_block_number).await;
 			if let Err(err) = result {
 				log::error!(
 					target: "bridge",
@@ -321,23 +331,18 @@ pub async fn run(params: EthereumExchangeParams) {
 					err,
 				);
 			}
-		}
+		},
 	}
 }
 
 /// Run single transaction proof relay and stop.
-async fn run_single_transaction_relay(params: EthereumExchangeParams, eth_tx_hash: H256) -> Result<(), String> {
-	let EthereumExchangeParams {
-		eth_params,
-		sub_params,
-		sub_sign,
-		instance,
-		..
-	} = params;
+async fn run_single_transaction_relay(
+	params: EthereumExchangeParams,
+	eth_tx_hash: H256,
+) -> anyhow::Result<()> {
+	let EthereumExchangeParams { eth_params, sub_params, sub_sign, instance, .. } = params;
 
-	let eth_client = EthereumClient::try_connect(eth_params)
-		.await
-		.map_err(RpcError::Ethereum)?;
+	let eth_client = EthereumClient::try_connect(eth_params).await.map_err(RpcError::Ethereum)?;
 	let sub_client = SubstrateClient::<Rialto>::try_connect(sub_params)
 		.await
 		.map_err(RpcError::Substrate)?;
@@ -349,20 +354,17 @@ async fn run_single_transaction_relay(params: EthereumExchangeParams, eth_tx_has
 		bridge_instance: instance,
 	};
 
-	relay_single_transaction_proof(&source, &target, eth_tx_hash).await
+	relay_single_transaction_proof(&source, &target, eth_tx_hash)
+		.await
+		.map_err(Into::into)
 }
 
 async fn run_auto_transactions_relay_loop(
 	params: EthereumExchangeParams,
 	eth_start_with_block_number: Option<u64>,
-) -> Result<(), String> {
+) -> anyhow::Result<()> {
 	let EthereumExchangeParams {
-		eth_params,
-		sub_params,
-		sub_sign,
-		metrics_params,
-		instance,
-		..
+		eth_params, sub_params, sub_sign, metrics_params, instance, ..
 	} = params;
 
 	let eth_client = EthereumClient::new(eth_params).await;
@@ -370,18 +372,17 @@ async fn run_auto_transactions_relay_loop(
 
 	let eth_start_with_block_number = match eth_start_with_block_number {
 		Some(eth_start_with_block_number) => eth_start_with_block_number,
-		None => {
+		None =>
 			sub_client
 				.best_ethereum_finalized_block()
 				.await
 				.map_err(|err| {
-					format!(
+					anyhow::format_err!(
 						"Error retrieving best finalized Ethereum block from Substrate node: {:?}",
 						err
 					)
 				})?
-				.0
-		}
+				.0,
 	};
 
 	run_loop(

polkadot/bridges/relays/bin-ethereum/src/ethereum_exchange_submit.rs

@@ -16,13 +16,15 @@
 
 //! Submitting Ethereum -> Substrate exchange transactions.
 
+use anyhow::anyhow;
 use bp_eth_poa::{
 	signatures::{secret_to_address, SignTransaction},
 	UnsignedTransaction,
 };
 use relay_ethereum_client::{
 	types::{CallRequest, U256},
-	Client as EthereumClient, ConnectionParams as EthereumConnectionParams, SigningParams as EthereumSigningParams,
+	Client as EthereumClient, ConnectionParams as EthereumConnectionParams,
+	SigningParams as EthereumSigningParams,
 };
 use rialto_runtime::exchange::LOCK_FUNDS_ADDRESS;
 
@@ -43,18 +45,13 @@ pub struct EthereumExchangeSubmitParams {
 
 /// Submit single Ethereum -> Substrate exchange transaction.
 pub async fn run(params: EthereumExchangeSubmitParams) {
-	let EthereumExchangeSubmitParams {
-		eth_params,
-		eth_sign,
-		eth_nonce,
-		eth_amount,
-		sub_recipient,
-	} = params;
+	let EthereumExchangeSubmitParams { eth_params, eth_sign, eth_nonce, eth_amount, sub_recipient } =
+		params;
 
-	let result: Result<_, String> = async move {
+	let result: anyhow::Result<_> = async move {
 		let eth_client = EthereumClient::try_connect(eth_params)
 			.await
-			.map_err(|err| format!("error connecting to Ethereum node: {:?}", err))?;
+			.map_err(|err| anyhow!("error connecting to Ethereum node: {:?}", err))?;
 
 		let eth_signer_address = secret_to_address(&eth_sign.signer);
 		let sub_recipient_encoded = sub_recipient;
@@ -63,7 +60,7 @@ pub async fn run(params: EthereumExchangeSubmitParams) {
 			None => eth_client
 				.account_nonce(eth_signer_address)
 				.await
-				.map_err(|err| format!("error fetching acount nonce: {:?}", err))?,
+				.map_err(|err| anyhow!("error fetching acount nonce: {:?}", err))?,
 		};
 		let gas = eth_client
 			.estimate_gas(CallRequest {
@@ -74,7 +71,7 @@ pub async fn run(params: EthereumExchangeSubmitParams) {
 				..Default::default()
 			})
 			.await
-			.map_err(|err| format!("error estimating gas requirements: {:?}", err))?;
+			.map_err(|err| anyhow!("error estimating gas requirements: {:?}", err))?;
 		let eth_tx_unsigned = UnsignedTransaction {
 			nonce,
 			gas_price: eth_sign.gas_price,
@@ -83,13 +80,12 @@ pub async fn run(params: EthereumExchangeSubmitParams) {
 			value: eth_amount,
 			payload: sub_recipient_encoded.to_vec(),
 		};
-		let eth_tx_signed = eth_tx_unsigned
-			.clone()
-			.sign_by(&eth_sign.signer, Some(eth_sign.chain_id));
+		let eth_tx_signed =
+			eth_tx_unsigned.clone().sign_by(&eth_sign.signer, Some(eth_sign.chain_id));
 		eth_client
 			.submit_transaction(eth_tx_signed)
 			.await
-			.map_err(|err| format!("error submitting transaction: {:?}", err))?;
+			.map_err(|err| anyhow!("error submitting transaction: {:?}", err))?;
 
 		Ok(eth_tx_unsigned)
 	}
@@ -102,13 +98,13 @@ pub async fn run(params: EthereumExchangeSubmitParams) {
 				"Exchange transaction has been submitted to Ethereum node: {:?}",
 				eth_tx_unsigned,
 			);
-		}
+		},
 		Err(err) => {
 			log::error!(
 				target: "bridge",
 				"Error submitting exchange transaction to Ethereum node: {}",
 				err,
 			);
-		}
+		},
 	}
 }

polkadot/bridges/relays/bin-ethereum/src/ethereum_sync_loop.rs

@@ -16,11 +16,13 @@
 
 //! Ethereum PoA -> Rialto-Substrate synchronization.
 
-use crate::ethereum_client::EthereumHighLevelRpc;
-use crate::instances::BridgeInstance;
-use crate::rialto_client::{SubmitEthereumHeaders, SubstrateHighLevelRpc};
-use crate::rpc_errors::RpcError;
-use crate::substrate_types::{into_substrate_ethereum_header, into_substrate_ethereum_receipts};
+use crate::{
+	ethereum_client::EthereumHighLevelRpc,
+	instances::BridgeInstance,
+	rialto_client::{SubmitEthereumHeaders, SubstrateHighLevelRpc},
+	rpc_errors::RpcError,
+	substrate_types::{into_substrate_ethereum_header, into_substrate_ethereum_receipts},
+};
 
 use async_trait::async_trait;
 use codec::Encode;
@@ -35,12 +37,12 @@ use relay_ethereum_client::{
 };
 use relay_rialto_client::{Rialto, SigningParams as RialtoSigningParams};
 use relay_substrate_client::{
-	Chain as SubstrateChain, Client as SubstrateClient, ConnectionParams as SubstrateConnectionParams,
+	Chain as SubstrateChain, Client as SubstrateClient,
+	ConnectionParams as SubstrateConnectionParams,
 };
 use relay_utils::{metrics::MetricsParams, relay_loop::Client as RelayClient};
 
-use std::fmt::Debug;
-use std::{collections::HashSet, sync::Arc, time::Duration};
+use std::{collections::HashSet, fmt::Debug, sync::Arc, time::Duration};
 
 pub mod consts {
 	use super::*;
@@ -57,7 +59,8 @@ pub mod consts {
 	pub const MAX_FUTURE_HEADERS_TO_DOWNLOAD: usize = 128;
 	/// Max Ethereum headers count we want to have in 'submitted' state.
 	pub const MAX_SUBMITTED_HEADERS: usize = 128;
-	/// Max depth of in-memory headers in all states. Past this depth they will be forgotten (pruned).
+	/// Max depth of in-memory headers in all states. Past this depth they will be forgotten
+	/// (pruned).
 	pub const PRUNE_DEPTH: u32 = 4096;
 }
 
@@ -106,8 +109,8 @@ impl HeadersSyncPipeline for EthereumHeadersSyncPipeline {
 	type Completion = ();
 
 	fn estimate_size(source: &QueuedHeader<Self>) -> usize {
-		into_substrate_ethereum_header(source.header()).encode().len()
-			+ into_substrate_ethereum_receipts(source.extra())
+		into_substrate_ethereum_header(source.header()).encode().len() +
+			into_substrate_ethereum_receipts(source.extra())
 				.map(|extra| extra.encode().len())
 				.unwrap_or(0)
 	}
@@ -148,22 +151,17 @@ impl SourceClient<EthereumHeadersSyncPipeline> for EthereumHeadersSource {
 	}
 
 	async fn header_by_hash(&self, hash: HeaderHash) -> Result<Header, RpcError> {
-		self.client
-			.header_by_hash(hash)
-			.await
-			.map(Into::into)
-			.map_err(Into::into)
+		self.client.header_by_hash(hash).await.map(Into::into).map_err(Into::into)
 	}
 
 	async fn header_by_number(&self, number: u64) -> Result<Header, RpcError> {
-		self.client
-			.header_by_number(number)
-			.await
-			.map(Into::into)
-			.map_err(Into::into)
+		self.client.header_by_number(number).await.map(Into::into).map_err(Into::into)
 	}
 
-	async fn header_completion(&self, id: EthereumHeaderId) -> Result<(EthereumHeaderId, Option<()>), RpcError> {
+	async fn header_completion(
+		&self,
+		id: EthereumHeaderId,
+	) -> Result<(EthereumHeaderId, Option<()>), RpcError> {
 		Ok((id, None))
 	}
 
@@ -172,9 +170,7 @@ impl SourceClient<EthereumHeadersSyncPipeline> for EthereumHeadersSource {
 		id: EthereumHeaderId,
 		header: QueuedEthereumHeader,
 	) -> Result<(EthereumHeaderId, Vec<Receipt>), RpcError> {
-		self.client
-			.transaction_receipts(id, header.header().transactions.clone())
-			.await
+		self.client.transaction_receipts(id, header.header().transactions.clone()).await
 	}
 }
 
@@ -197,12 +193,7 @@ impl SubstrateHeadersTarget {
 		sign_params: RialtoSigningParams,
 		bridge_instance: Arc<dyn BridgeInstance>,
 	) -> Self {
-		Self {
-			client,
-			sign_transactions,
-			sign_params,
-			bridge_instance,
-		}
+		Self { client, sign_transactions, sign_params, bridge_instance }
 	}
 }
 
@@ -225,16 +216,19 @@ impl TargetClient<EthereumHeadersSyncPipeline> for SubstrateHeadersTarget {
 		self.client.best_ethereum_block().await
 	}
 
-	async fn is_known_header(&self, id: EthereumHeaderId) -> Result<(EthereumHeaderId, bool), RpcError> {
+	async fn is_known_header(
+		&self,
+		id: EthereumHeaderId,
+	) -> Result<(EthereumHeaderId, bool), RpcError> {
 		Ok((id, self.client.ethereum_header_known(id).await?))
 	}
 
-	async fn submit_headers(&self, headers: Vec<QueuedEthereumHeader>) -> SubmittedHeaders<EthereumHeaderId, RpcError> {
-		let (sign_params, bridge_instance, sign_transactions) = (
-			self.sign_params.clone(),
-			self.bridge_instance.clone(),
-			self.sign_transactions,
-		);
+	async fn submit_headers(
+		&self,
+		headers: Vec<QueuedEthereumHeader>,
+	) -> SubmittedHeaders<EthereumHeaderId, RpcError> {
+		let (sign_params, bridge_instance, sign_transactions) =
+			(self.sign_params.clone(), self.bridge_instance.clone(), self.sign_transactions);
 		self.client
 			.submit_ethereum_headers(sign_params, bridge_instance, headers, sign_transactions)
 			.await
@@ -245,11 +239,18 @@ impl TargetClient<EthereumHeadersSyncPipeline> for SubstrateHeadersTarget {
 	}
 
 	#[allow(clippy::unit_arg)]
-	async fn complete_header(&self, id: EthereumHeaderId, _completion: ()) -> Result<EthereumHeaderId, RpcError> {
+	async fn complete_header(
+		&self,
+		id: EthereumHeaderId,
+		_completion: (),
+	) -> Result<EthereumHeaderId, RpcError> {
 		Ok(id)
 	}
 
-	async fn requires_extra(&self, header: QueuedEthereumHeader) -> Result<(EthereumHeaderId, bool), RpcError> {
+	async fn requires_extra(
+		&self,
+		header: QueuedEthereumHeader,
+	) -> Result<(EthereumHeaderId, bool), RpcError> {
 		// we can minimize number of receipts_check calls by checking header
 		// logs bloom here, but it may give us false positives (when authorities
 		// source is contract, we never need any logs)
@@ -292,7 +293,7 @@ pub async fn run(params: EthereumSyncParams) -> Result<(), RpcError> {
 		futures::future::pending(),
 	)
 	.await
-	.map_err(RpcError::SyncLoop)?;
+	.map_err(|e| RpcError::SyncLoop(e.to_string()))?;
 
 	Ok(())
 }

polkadot/bridges/relays/bin-ethereum/src/instances.rs

@@ -18,16 +18,18 @@
 //! synchronizing a Substrate chain which can include multiple instances of the bridge pallet we
 //! must somehow decide which of the instances to sync.
 //!
-//! Note that each instance of the bridge pallet is coupled with an instance of the currency exchange
-//! pallet. We must also have a way to create `Call`s for the correct currency exchange instance.
+//! Note that each instance of the bridge pallet is coupled with an instance of the currency
+//! exchange pallet. We must also have a way to create `Call`s for the correct currency exchange
+//! instance.
 //!
 //! This module helps by preparing the correct `Call`s for each of the different pallet instances.
 
-use crate::ethereum_sync_loop::QueuedEthereumHeader;
-use crate::substrate_types::{into_substrate_ethereum_header, into_substrate_ethereum_receipts};
+use crate::{
+	ethereum_sync_loop::QueuedEthereumHeader,
+	substrate_types::{into_substrate_ethereum_header, into_substrate_ethereum_receipts},
+};
 
-use rialto_runtime::exchange::EthereumTransactionInclusionProof as Proof;
-use rialto_runtime::Call;
+use rialto_runtime::{exchange::EthereumTransactionInclusionProof as Proof, Call};
 
 /// Interface for `Calls` which are needed to correctly sync the bridge.
 ///
@@ -48,8 +50,8 @@ pub struct RialtoPoA;
 
 impl BridgeInstance for RialtoPoA {
 	fn build_signed_header_call(&self, headers: Vec<QueuedEthereumHeader>) -> Call {
-		let pallet_call = rialto_runtime::BridgeEthPoACall::import_signed_headers(
-			headers
+		let pallet_call = rialto_runtime::BridgeEthPoACall::import_signed_headers {
+			headers_with_receipts: headers
 				.into_iter()
 				.map(|header| {
 					(
@@ -58,22 +60,23 @@ impl BridgeInstance for RialtoPoA {
 					)
 				})
 				.collect(),
-		);
+		};
 
 		rialto_runtime::Call::BridgeRialtoPoa(pallet_call)
 	}
 
 	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_receipts(header.extra()),
-		);
+		let pallet_call = rialto_runtime::BridgeEthPoACall::import_unsigned_header {
+			header: Box::new(into_substrate_ethereum_header(header.header())),
+			receipts: into_substrate_ethereum_receipts(header.extra()),
+		};
 
 		rialto_runtime::Call::BridgeRialtoPoa(pallet_call)
 	}
 
 	fn build_currency_exchange_call(&self, proof: Proof) -> Call {
-		let pallet_call = rialto_runtime::BridgeCurrencyExchangeCall::import_peer_transaction(proof);
+		let pallet_call =
+			rialto_runtime::BridgeCurrencyExchangeCall::import_peer_transaction { proof };
 		rialto_runtime::Call::BridgeRialtoCurrencyExchange(pallet_call)
 	}
 }
@@ -84,8 +87,8 @@ pub struct Kovan;
 
 impl BridgeInstance for Kovan {
 	fn build_signed_header_call(&self, headers: Vec<QueuedEthereumHeader>) -> Call {
-		let pallet_call = rialto_runtime::BridgeEthPoACall::import_signed_headers(
-			headers
+		let pallet_call = rialto_runtime::BridgeEthPoACall::import_signed_headers {
+			headers_with_receipts: headers
 				.into_iter()
 				.map(|header| {
 					(
@@ -94,22 +97,23 @@ impl BridgeInstance for Kovan {
 					)
 				})
 				.collect(),
-		);
+		};
 
 		rialto_runtime::Call::BridgeKovan(pallet_call)
 	}
 
 	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_receipts(header.extra()),
-		);
+		let pallet_call = rialto_runtime::BridgeEthPoACall::import_unsigned_header {
+			header: Box::new(into_substrate_ethereum_header(header.header())),
+			receipts: into_substrate_ethereum_receipts(header.extra()),
+		};
 
 		rialto_runtime::Call::BridgeKovan(pallet_call)
 	}
 
 	fn build_currency_exchange_call(&self, proof: Proof) -> Call {
-		let pallet_call = rialto_runtime::BridgeCurrencyExchangeCall::import_peer_transaction(proof);
+		let pallet_call =
+			rialto_runtime::BridgeCurrencyExchangeCall::import_peer_transaction { proof };
 		rialto_runtime::Call::BridgeKovanCurrencyExchange(pallet_call)
 	}
 }

polkadot/bridges/relays/bin-ethereum/src/main.rs

@@ -16,6 +16,7 @@
 
 #![recursion_limit = "1024"]
 
+mod error;
 mod ethereum_client;
 mod ethereum_deploy_contract;
 mod ethereum_exchange;
@@ -27,6 +28,7 @@ mod rpc_errors;
 mod substrate_sync_loop;
 mod substrate_types;
 
+use anyhow::anyhow;
 use ethereum_deploy_contract::EthereumDeployContractParams;
 use ethereum_exchange::EthereumExchangeParams;
 use ethereum_exchange_submit::EthereumExchangeSubmitParams;
@@ -34,16 +36,18 @@ use ethereum_sync_loop::EthereumSyncParams;
 use headers_relay::sync::TargetTransactionMode;
 use hex_literal::hex;
 use instances::{BridgeInstance, Kovan, RialtoPoA};
+use libsecp256k1::SecretKey;
 use relay_utils::{
 	initialize::initialize_relay,
 	metrics::{MetricsAddress, MetricsParams},
 };
-use secp256k1::SecretKey;
 use sp_core::crypto::Pair;
 use substrate_sync_loop::SubstrateSyncParams;
 
 use headers_relay::sync::HeadersSyncParams;
-use relay_ethereum_client::{ConnectionParams as EthereumConnectionParams, SigningParams as EthereumSigningParams};
+use relay_ethereum_client::{
+	ConnectionParams as EthereumConnectionParams, SigningParams as EthereumSigningParams,
+};
 use relay_rialto_client::SigningParams as RialtoSigningParams;
 use relay_substrate_client::ConnectionParams as SubstrateConnectionParams;
 use std::sync::Arc;
@@ -64,123 +68,128 @@ async fn run_command(matches: &clap::ArgMatches<'_>) {
 				Ok(ethereum_sync_params) => ethereum_sync_params,
 				Err(err) => {
 					log::error!(target: "bridge", "Error parsing parameters: {}", err);
-					return;
-				}
+					return
+				},
 			})
 			.await
 			.is_err()
 			{
 				log::error!(target: "bridge", "Unable to get Substrate genesis block for Ethereum sync.");
 			};
-		}
+		},
 		("sub-to-eth", Some(sub_to_eth_matches)) => {
 			log::info!(target: "bridge", "Starting SUB ➡ ETH relay.");
 			if substrate_sync_loop::run(match substrate_sync_params(sub_to_eth_matches) {
 				Ok(substrate_sync_params) => substrate_sync_params,
 				Err(err) => {
 					log::error!(target: "bridge", "Error parsing parameters: {}", err);
-					return;
-				}
+					return
+				},
 			})
 			.await
 			.is_err()
 			{
 				log::error!(target: "bridge", "Unable to get Substrate genesis block for Substrate sync.");
 			};
-		}
+		},
 		("eth-deploy-contract", Some(eth_deploy_matches)) => {
 			log::info!(target: "bridge", "Deploying ETH contracts.");
-			ethereum_deploy_contract::run(match ethereum_deploy_contract_params(eth_deploy_matches) {
-				Ok(ethereum_deploy_params) => ethereum_deploy_params,
-				Err(err) => {
-					log::error!(target: "bridge", "Error during contract deployment: {}", err);
-					return;
-				}
-			})
+			ethereum_deploy_contract::run(
+				match ethereum_deploy_contract_params(eth_deploy_matches) {
+					Ok(ethereum_deploy_params) => ethereum_deploy_params,
+					Err(err) => {
+						log::error!(target: "bridge", "Error during contract deployment: {}", err);
+						return
+					},
+				},
+			)
 			.await;
-		}
+		},
 		("eth-submit-exchange-tx", Some(eth_exchange_submit_matches)) => {
 			log::info!(target: "bridge", "Submitting ETH ➡ SUB exchange transaction.");
-			ethereum_exchange_submit::run(match ethereum_exchange_submit_params(eth_exchange_submit_matches) {
-				Ok(eth_exchange_submit_params) => eth_exchange_submit_params,
-				Err(err) => {
-					log::error!(target: "bridge", "Error submitting Eethereum exchange transaction: {}", err);
-					return;
-				}
-			})
+			ethereum_exchange_submit::run(
+				match ethereum_exchange_submit_params(eth_exchange_submit_matches) {
+					Ok(eth_exchange_submit_params) => eth_exchange_submit_params,
+					Err(err) => {
+						log::error!(target: "bridge", "Error submitting Eethereum exchange transaction: {}", err);
+						return
+					},
+				},
+			)
 			.await;
-		}
+		},
 		("eth-exchange-sub", Some(eth_exchange_matches)) => {
 			log::info!(target: "bridge", "Starting ETH ➡ SUB exchange transactions relay.");
 			ethereum_exchange::run(match ethereum_exchange_params(eth_exchange_matches) {
 				Ok(eth_exchange_params) => eth_exchange_params,
 				Err(err) => {
 					log::error!(target: "bridge", "Error relaying Ethereum transactions proofs: {}", err);
-					return;
-				}
+					return
+				},
 			})
 			.await;
-		}
+		},
 		("", _) => {
 			log::error!(target: "bridge", "No subcommand specified");
-		}
+		},
 		_ => unreachable!("all possible subcommands are checked above; qed"),
 	}
 }
 
-fn ethereum_connection_params(matches: &clap::ArgMatches) -> Result<EthereumConnectionParams, String> {
+fn ethereum_connection_params(
+	matches: &clap::ArgMatches,
+) -> anyhow::Result<EthereumConnectionParams> {
 	let mut params = EthereumConnectionParams::default();
 	if let Some(eth_host) = matches.value_of("eth-host") {
 		params.host = eth_host.into();
 	}
 	if let Some(eth_port) = matches.value_of("eth-port") {
-		params.port = eth_port
-			.parse()
-			.map_err(|e| format!("Failed to parse eth-port: {}", e))?;
+		params.port = eth_port.parse().map_err(|e| anyhow!("Failed to parse eth-port: {}", e))?;
 	}
 	Ok(params)
 }
 
-fn ethereum_signing_params(matches: &clap::ArgMatches) -> Result<EthereumSigningParams, String> {
+fn ethereum_signing_params(matches: &clap::ArgMatches) -> anyhow::Result<EthereumSigningParams> {
 	let mut params = EthereumSigningParams::default();
 	if let Some(eth_signer) = matches.value_of("eth-signer") {
-		params.signer =
-			SecretKey::parse_slice(&hex::decode(eth_signer).map_err(|e| format!("Failed to parse eth-signer: {}", e))?)
-				.map_err(|e| format!("Invalid eth-signer: {}", e))?;
+		params.signer = SecretKey::parse_slice(
+			&hex::decode(eth_signer).map_err(|e| anyhow!("Failed to parse eth-signer: {}", e))?,
+		)
+		.map_err(|e| anyhow!("Invalid eth-signer: {}", e))?;
 	}
 	if let Some(eth_chain_id) = matches.value_of("eth-chain-id") {
 		params.chain_id = eth_chain_id
 			.parse::<u64>()
-			.map_err(|e| format!("Failed to parse eth-chain-id: {}", e))?;
+			.map_err(|e| anyhow!("Failed to parse eth-chain-id: {}", e))?;
 	}
 	Ok(params)
 }
 
-fn substrate_connection_params(matches: &clap::ArgMatches) -> Result<SubstrateConnectionParams, String> {
+fn substrate_connection_params(
+	matches: &clap::ArgMatches,
+) -> anyhow::Result<SubstrateConnectionParams> {
 	let mut params = SubstrateConnectionParams::default();
 	if let Some(sub_host) = matches.value_of("sub-host") {
 		params.host = sub_host.into();
 	}
 	if let Some(sub_port) = matches.value_of("sub-port") {
-		params.port = sub_port
-			.parse()
-			.map_err(|e| format!("Failed to parse sub-port: {}", e))?;
+		params.port = sub_port.parse().map_err(|e| anyhow!("Failed to parse sub-port: {}", e))?;
 	}
 	Ok(params)
 }
 
-fn rialto_signing_params(matches: &clap::ArgMatches) -> Result<RialtoSigningParams, String> {
+fn rialto_signing_params(matches: &clap::ArgMatches) -> anyhow::Result<RialtoSigningParams> {
 	let mut params = sp_keyring::AccountKeyring::Alice.pair();
 
 	if let Some(sub_signer) = matches.value_of("sub-signer") {
 		let sub_signer_password = matches.value_of("sub-signer-password");
 		params = sp_core::sr25519::Pair::from_string(sub_signer, sub_signer_password)
-			.map_err(|e| format!("Failed to parse sub-signer: {:?}", e))?;
+			.map_err(|e| anyhow!("Failed to parse sub-signer: {:?}", e))?;
 	}
 	Ok(params)
 }
 
-fn ethereum_sync_params(matches: &clap::ArgMatches) -> Result<EthereumSyncParams, String> {
+fn ethereum_sync_params(matches: &clap::ArgMatches) -> anyhow::Result<EthereumSyncParams> {
 	use crate::ethereum_sync_loop::consts::*;
 
 	let mut sync_params = HeadersSyncParams {
@@ -199,9 +208,9 @@ fn ethereum_sync_params(matches: &clap::ArgMatches) -> Result<EthereumSyncParams
 
 			// tx pool won't accept too much unsigned transactions
 			sync_params.max_headers_in_submitted_status = 10;
-		}
+		},
 		Some("backup") => sync_params.target_tx_mode = TargetTransactionMode::Backup,
-		Some(mode) => return Err(format!("Invalid sub-tx-mode: {}", mode)),
+		Some(mode) => return Err(anyhow!("Invalid sub-tx-mode: {}", mode)),
 		None => sync_params.target_tx_mode = TargetTransactionMode::Signed,
 	}
 
@@ -219,12 +228,12 @@ fn ethereum_sync_params(matches: &clap::ArgMatches) -> Result<EthereumSyncParams
 	Ok(params)
 }
 
-fn substrate_sync_params(matches: &clap::ArgMatches) -> Result<SubstrateSyncParams, String> {
+fn substrate_sync_params(matches: &clap::ArgMatches) -> anyhow::Result<SubstrateSyncParams> {
 	use crate::substrate_sync_loop::consts::*;
 
 	let eth_contract_address: relay_ethereum_client::types::Address =
 		if let Some(eth_contract) = matches.value_of("eth-contract") {
-			eth_contract.parse().map_err(|e| format!("{}", e))?
+			eth_contract.parse()?
 		} else {
 			"731a10897d267e19b34503ad902d0a29173ba4b1"
 				.parse()
@@ -252,15 +261,19 @@ fn substrate_sync_params(matches: &clap::ArgMatches) -> Result<SubstrateSyncPara
 	Ok(params)
 }
 
-fn ethereum_deploy_contract_params(matches: &clap::ArgMatches) -> Result<EthereumDeployContractParams, String> {
-	let eth_contract_code = parse_hex_argument(matches, "eth-contract-code")?.unwrap_or_else(|| {
-		hex::decode(include_str!("../res/substrate-bridge-bytecode.hex")).expect("code is hardcoded, thus valid; qed")
-	});
+fn ethereum_deploy_contract_params(
+	matches: &clap::ArgMatches,
+) -> anyhow::Result<EthereumDeployContractParams> {
+	let eth_contract_code =
+		parse_hex_argument(matches, "eth-contract-code")?.unwrap_or_else(|| {
+			hex::decode(include_str!("../res/substrate-bridge-bytecode.hex"))
+				.expect("code is hardcoded, thus valid; qed")
+		});
 	let sub_initial_authorities_set_id = matches
 		.value_of("sub-authorities-set-id")
 		.map(|set| {
 			set.parse()
-				.map_err(|e| format!("Failed to parse sub-authorities-set-id: {}", e))
+				.map_err(|e| anyhow!("Failed to parse sub-authorities-set-id: {}", e))
 		})
 		.transpose()?;
 	let sub_initial_authorities_set = parse_hex_argument(matches, "sub-authorities-set")?;
@@ -281,21 +294,21 @@ fn ethereum_deploy_contract_params(matches: &clap::ArgMatches) -> Result<Ethereu
 	Ok(params)
 }
 
-fn ethereum_exchange_submit_params(matches: &clap::ArgMatches) -> Result<EthereumExchangeSubmitParams, String> {
+fn ethereum_exchange_submit_params(
+	matches: &clap::ArgMatches,
+) -> anyhow::Result<EthereumExchangeSubmitParams> {
 	let eth_nonce = matches
 		.value_of("eth-nonce")
 		.map(|eth_nonce| {
 			relay_ethereum_client::types::U256::from_dec_str(eth_nonce)
-				.map_err(|e| format!("Failed to parse eth-nonce: {}", e))
+				.map_err(|e| anyhow!("Failed to parse eth-nonce: {}", e))
 		})
 		.transpose()?;
 
 	let eth_amount = matches
 		.value_of("eth-amount")
 		.map(|eth_amount| {
-			eth_amount
-				.parse()
-				.map_err(|e| format!("Failed to parse eth-amount: {}", e))
+			eth_amount.parse().map_err(|e| anyhow!("Failed to parse eth-amount: {}", e))
 		})
 		.transpose()?
 		.unwrap_or_else(|| {
@@ -304,7 +317,8 @@ fn ethereum_exchange_submit_params(matches: &clap::ArgMatches) -> Result<Ethereu
 		});
 
 	// This is the well-known Substrate account of Ferdie
-	let default_recepient = hex!("1cbd2d43530a44705ad088af313e18f80b53ef16b36177cd4b77b846f2a5f07c");
+	let default_recepient =
+		hex!("1cbd2d43530a44705ad088af313e18f80b53ef16b36177cd4b77b846f2a5f07c");
 
 	let sub_recipient = if let Some(sub_recipient) = matches.value_of("sub-recipient") {
 		hex::decode(&sub_recipient)
@@ -319,7 +333,7 @@ fn ethereum_exchange_submit_params(matches: &clap::ArgMatches) -> Result<Ethereu
 					Ok(sub_recipient)
 				}
 			})
-			.map_err(|e| format!("Failed to parse sub-recipient: {}", e))?
+			.map_err(|e| anyhow!("Failed to parse sub-recipient: {}", e))?
 	} else {
 		default_recepient
 	};
@@ -337,12 +351,10 @@ fn ethereum_exchange_submit_params(matches: &clap::ArgMatches) -> Result<Ethereu
 	Ok(params)
 }
 
-fn ethereum_exchange_params(matches: &clap::ArgMatches) -> Result<EthereumExchangeParams, String> {
+fn ethereum_exchange_params(matches: &clap::ArgMatches) -> anyhow::Result<EthereumExchangeParams> {
 	let mode = match matches.value_of("eth-tx-hash") {
 		Some(eth_tx_hash) => ethereum_exchange::ExchangeRelayMode::Single(
-			eth_tx_hash
-				.parse()
-				.map_err(|e| format!("Failed to parse eth-tx-hash: {}", e))?,
+			eth_tx_hash.parse().map_err(|e| anyhow!("Failed to parse eth-tx-hash: {}", e))?,
 		),
 		None => ethereum_exchange::ExchangeRelayMode::Auto(
 			matches
@@ -350,7 +362,7 @@ fn ethereum_exchange_params(matches: &clap::ArgMatches) -> Result<EthereumExchan
 				.map(|eth_start_with_block| {
 					eth_start_with_block
 						.parse()
-						.map_err(|e| format!("Failed to parse eth-start-with-block: {}", e))
+						.map_err(|e| anyhow!("Failed to parse eth-start-with-block: {}", e))
 				})
 				.transpose()?,
 		),
@@ -370,9 +382,9 @@ fn ethereum_exchange_params(matches: &clap::ArgMatches) -> Result<EthereumExchan
 	Ok(params)
 }
 
-fn metrics_params(matches: &clap::ArgMatches) -> Result<MetricsParams, String> {
+fn metrics_params(matches: &clap::ArgMatches) -> anyhow::Result<MetricsParams> {
 	if matches.is_present("no-prometheus") {
-		return Ok(None.into());
+		return Ok(None.into())
 	}
 
 	let mut metrics_params = MetricsAddress::default();
@@ -383,18 +395,18 @@ fn metrics_params(matches: &clap::ArgMatches) -> Result<MetricsParams, String> {
 	if let Some(prometheus_port) = matches.value_of("prometheus-port") {
 		metrics_params.port = prometheus_port
 			.parse()
-			.map_err(|e| format!("Failed to parse prometheus-port: {}", e))?;
+			.map_err(|e| anyhow!("Failed to parse prometheus-port: {}", e))?;
 	}
 
 	Ok(Some(metrics_params).into())
 }
 
-fn instance_params(matches: &clap::ArgMatches) -> Result<Arc<dyn BridgeInstance>, String> {
+fn instance_params(matches: &clap::ArgMatches) -> anyhow::Result<Arc<dyn BridgeInstance>> {
 	let instance = if let Some(instance) = matches.value_of("sub-pallet-instance") {
 		match instance.to_lowercase().as_str() {
 			"rialto" => Arc::new(RialtoPoA) as Arc<dyn BridgeInstance>,
 			"kovan" => Arc::new(Kovan),
-			_ => return Err("Unsupported bridge pallet instance".to_string()),
+			_ => return Err(anyhow!("Unsupported bridge pallet instance")),
 		}
 	} else {
 		unreachable!("CLI config enforces a default instance, can never be None")
@@ -403,11 +415,10 @@ fn instance_params(matches: &clap::ArgMatches) -> Result<Arc<dyn BridgeInstance>
 	Ok(instance)
 }
 
-fn parse_hex_argument(matches: &clap::ArgMatches, arg: &str) -> Result<Option<Vec<u8>>, String> {
+fn parse_hex_argument(matches: &clap::ArgMatches, arg: &str) -> anyhow::Result<Option<Vec<u8>>> {
 	match matches.value_of(arg) {
-		Some(value) => Ok(Some(
-			hex::decode(value).map_err(|e| format!("Failed to parse {}: {}", arg, e))?,
-		)),
+		Some(value) =>
+			Ok(Some(hex::decode(value).map_err(|e| anyhow!("Failed to parse {}: {}", arg, e))?)),
 		None => Ok(None),
 	}
 }

polkadot/bridges/relays/bin-ethereum/src/rialto_client.rs

@@ -14,9 +14,9 @@
 // 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::ethereum_sync_loop::QueuedEthereumHeader;
-use crate::instances::BridgeInstance;
-use crate::rpc_errors::RpcError;
+use crate::{
+	ethereum_sync_loop::QueuedEthereumHeader, instances::BridgeInstance, rpc_errors::RpcError,
+};
 
 use async_trait::async_trait;
 use bp_eth_poa::AuraHeader as SubstrateEthereumHeader;
@@ -24,7 +24,9 @@ use codec::{Decode, Encode};
 use headers_relay::sync_types::SubmittedHeaders;
 use relay_ethereum_client::types::HeaderId as EthereumHeaderId;
 use relay_rialto_client::{Rialto, SigningParams as RialtoSigningParams};
-use relay_substrate_client::{Client as SubstrateClient, TransactionSignScheme};
+use relay_substrate_client::{
+	Client as SubstrateClient, TransactionSignScheme, UnsignedTransaction,
+};
 use relay_utils::HeaderId;
 use sp_core::{crypto::Pair, Bytes};
 use std::{collections::VecDeque, sync::Arc};
@@ -33,7 +35,8 @@ const ETH_API_IMPORT_REQUIRES_RECEIPTS: &str = "RialtoPoAHeaderApi_is_import_req
 const ETH_API_IS_KNOWN_BLOCK: &str = "RialtoPoAHeaderApi_is_known_block";
 const ETH_API_BEST_BLOCK: &str = "RialtoPoAHeaderApi_best_block";
 const ETH_API_BEST_FINALIZED_BLOCK: &str = "RialtoPoAHeaderApi_finalized_block";
-const EXCH_API_FILTER_TRANSACTION_PROOF: &str = "RialtoCurrencyExchangeApi_filter_transaction_proof";
+const EXCH_API_FILTER_TRANSACTION_PROOF: &str =
+	"RialtoCurrencyExchangeApi_filter_transaction_proof";
 
 type RpcResult<T> = std::result::Result<T, RpcError>;
 
@@ -41,13 +44,13 @@ type RpcResult<T> = std::result::Result<T, RpcError>;
 /// interactions involving, for example, an Ethereum bridge module.
 #[async_trait]
 pub trait SubstrateHighLevelRpc {
-	/// Returns best Ethereum block that Substrate runtime knows of.
+	/// Returns the best Ethereum block that Substrate runtime knows of.
 	async fn best_ethereum_block(&self) -> RpcResult<EthereumHeaderId>;
 	/// Returns best finalized Ethereum block that Substrate runtime knows of.
 	async fn best_ethereum_finalized_block(&self) -> RpcResult<EthereumHeaderId>;
-	/// Returns whether or not transactions receipts are required for Ethereum header submission.
+	/// Returns whether transactions receipts are required for Ethereum header submission.
 	async fn ethereum_receipts_required(&self, header: SubstrateEthereumHeader) -> RpcResult<bool>;
-	/// Returns whether or not the given Ethereum header is known to the Substrate runtime.
+	/// Returns whether the given Ethereum header is known to the Substrate runtime.
 	async fn ethereum_header_known(&self, header_id: EthereumHeaderId) -> RpcResult<bool>;
 }
 
@@ -58,7 +61,8 @@ impl SubstrateHighLevelRpc for SubstrateClient<Rialto> {
 		let data = Bytes(Vec::new());
 
 		let encoded_response = self.state_call(call, data, None).await?;
-		let decoded_response: (u64, bp_eth_poa::H256) = Decode::decode(&mut &encoded_response.0[..])?;
+		let decoded_response: (u64, bp_eth_poa::H256) =
+			Decode::decode(&mut &encoded_response.0[..])?;
 
 		let best_header_id = HeaderId(decoded_response.0, decoded_response.1);
 		Ok(best_header_id)
@@ -69,7 +73,8 @@ impl SubstrateHighLevelRpc for SubstrateClient<Rialto> {
 		let data = Bytes(Vec::new());
 
 		let encoded_response = self.state_call(call, data, None).await?;
-		let decoded_response: (u64, bp_eth_poa::H256) = Decode::decode(&mut &encoded_response.0[..])?;
+		let decoded_response: (u64, bp_eth_poa::H256) =
+			Decode::decode(&mut &encoded_response.0[..])?;
 
 		let best_header_id = HeaderId(decoded_response.0, decoded_response.1);
 		Ok(best_header_id)
@@ -155,18 +160,25 @@ impl SubmitEthereumHeaders for SubstrateClient<Rialto> {
 		headers: Vec<QueuedEthereumHeader>,
 	) -> SubmittedHeaders<EthereumHeaderId, RpcError> {
 		let ids = headers.iter().map(|header| header.id()).collect();
+		let genesis_hash = *self.genesis_hash();
 		let submission_result = async {
-			self.submit_signed_extrinsic((*params.public().as_array_ref()).into(), |transaction_nonce| {
-				Bytes(
-					Rialto::sign_transaction(
-						*self.genesis_hash(),
-						&params,
-						transaction_nonce,
-						instance.build_signed_header_call(headers),
+			self.submit_signed_extrinsic(
+				(*params.public().as_array_ref()).into(),
+				move |_, transaction_nonce| {
+					Bytes(
+						Rialto::sign_transaction(
+							genesis_hash,
+							&params,
+							relay_substrate_client::TransactionEra::immortal(),
+							UnsignedTransaction::new(
+								instance.build_signed_header_call(headers),
+								transaction_nonce,
+							),
+						)
+						.encode(),
 					)
-					.encode(),
-				)
-			})
+				},
+			)
 			.await?;
 			Ok(())
 		}
@@ -208,8 +220,8 @@ impl SubmitEthereumHeaders for SubstrateClient<Rialto> {
 					submitted_headers.rejected.push(id);
 					submitted_headers.rejected.extend(ids);
 					submitted_headers.fatal_error = Some(error.into());
-					break;
-				}
+					break
+				},
 			}
 		}
 
@@ -257,23 +269,32 @@ impl SubmitEthereumExchangeTransactionProof for SubstrateClient<Rialto> {
 		instance: Arc<dyn BridgeInstance>,
 		proof: rialto_runtime::exchange::EthereumTransactionInclusionProof,
 	) -> RpcResult<()> {
-		self.submit_signed_extrinsic((*params.public().as_array_ref()).into(), |transaction_nonce| {
-			Bytes(
-				Rialto::sign_transaction(
-					*self.genesis_hash(),
-					&params,
-					transaction_nonce,
-					instance.build_currency_exchange_call(proof),
+		let genesis_hash = *self.genesis_hash();
+		self.submit_signed_extrinsic(
+			(*params.public().as_array_ref()).into(),
+			move |_, transaction_nonce| {
+				Bytes(
+					Rialto::sign_transaction(
+						genesis_hash,
+						&params,
+						relay_substrate_client::TransactionEra::immortal(),
+						UnsignedTransaction::new(
+							instance.build_currency_exchange_call(proof),
+							transaction_nonce,
+						),
+					)
+					.encode(),
 				)
-				.encode(),
-			)
-		})
+			},
+		)
 		.await?;
 		Ok(())
 	}
 }
 
 /// Create unsigned Substrate transaction for submitting Ethereum header.
-fn create_unsigned_submit_transaction(call: rialto_runtime::Call) -> rialto_runtime::UncheckedExtrinsic {
+fn create_unsigned_submit_transaction(
+	call: rialto_runtime::Call,
+) -> rialto_runtime::UncheckedExtrinsic {
 	rialto_runtime::UncheckedExtrinsic::new_unsigned(call)
 }

polkadot/bridges/relays/bin-ethereum/src/rpc_errors.rs

@@ -17,48 +17,30 @@
 use relay_ethereum_client::Error as EthereumNodeError;
 use relay_substrate_client::Error as SubstrateNodeError;
 use relay_utils::MaybeConnectionError;
+use thiserror::Error;
 
 /// Contains common errors that can occur when
 /// interacting with a Substrate or Ethereum node
 /// through RPC.
-#[derive(Debug)]
+#[derive(Debug, Error)]
 pub enum RpcError {
 	/// The arguments to the RPC method failed to serialize.
-	Serialization(serde_json::Error),
-	/// An error occured when interacting with an Ethereum node.
-	Ethereum(EthereumNodeError),
-	/// An error occured when interacting with a Substrate node.
-	Substrate(SubstrateNodeError),
+	#[error("RPC arguments serialization failed: {0}")]
+	Serialization(#[from] serde_json::Error),
+	/// An error occurred when interacting with an Ethereum node.
+	#[error("Ethereum node error: {0}")]
+	Ethereum(#[from] EthereumNodeError),
+	/// An error occurred when interacting with a Substrate node.
+	#[error("Substrate node error: {0}")]
+	Substrate(#[from] SubstrateNodeError),
 	/// Error running relay loop.
+	#[error("{0}")]
 	SyncLoop(String),
 }
 
 impl From<RpcError> for String {
 	fn from(err: RpcError) -> Self {
-		match err {
-			RpcError::Serialization(e) => e.to_string(),
-			RpcError::Ethereum(e) => e.to_string(),
-			RpcError::Substrate(e) => e.to_string(),
-			RpcError::SyncLoop(e) => e,
-		}
-	}
-}
-
-impl From<serde_json::Error> for RpcError {
-	fn from(err: serde_json::Error) -> Self {
-		Self::Serialization(err)
-	}
-}
-
-impl From<EthereumNodeError> for RpcError {
-	fn from(err: EthereumNodeError) -> Self {
-		Self::Ethereum(err)
-	}
-}
-
-impl From<SubstrateNodeError> for RpcError {
-	fn from(err: SubstrateNodeError) -> Self {
-		Self::Substrate(err)
+		format!("{}", err)
 	}
 }
 

polkadot/bridges/relays/bin-ethereum/src/substrate_sync_loop.rs

@@ -16,8 +16,7 @@
 
 //! Rialto-Substrate -> Ethereum PoA synchronization.
 
-use crate::ethereum_client::EthereumHighLevelRpc;
-use crate::rpc_errors::RpcError;
+use crate::{ethereum_client::EthereumHighLevelRpc, rpc_errors::RpcError};
 
 use async_trait::async_trait;
 use codec::Encode;
@@ -38,8 +37,7 @@ use relay_substrate_client::{
 use relay_utils::{metrics::MetricsParams, relay_loop::Client as RelayClient};
 use sp_runtime::EncodedJustification;
 
-use std::fmt::Debug;
-use std::{collections::HashSet, time::Duration};
+use std::{collections::HashSet, fmt::Debug, time::Duration};
 
 pub mod consts {
 	use super::*;
@@ -50,7 +48,8 @@ pub mod consts {
 	pub const MAX_FUTURE_HEADERS_TO_DOWNLOAD: usize = 8;
 	/// Max Ethereum headers count we want to have in 'submitted' state.
 	pub const MAX_SUBMITTED_HEADERS: usize = 4;
-	/// Max depth of in-memory headers in all states. Past this depth they will be forgotten (pruned).
+	/// Max depth of in-memory headers in all states. Past this depth they will be forgotten
+	/// (pruned).
 	pub const PRUNE_DEPTH: u32 = 256;
 }
 
@@ -110,11 +109,7 @@ struct EthereumHeadersTarget {
 
 impl EthereumHeadersTarget {
 	fn new(client: EthereumClient, contract: Address, sign_params: EthereumSigningParams) -> Self {
-		Self {
-			client,
-			contract,
-			sign_params,
-		}
+		Self { client, contract, sign_params }
 	}
 }
 
@@ -137,11 +132,17 @@ impl TargetClient<SubstrateHeadersSyncPipeline> for EthereumHeadersTarget {
 		self.client.best_substrate_block(self.contract).await
 	}
 
-	async fn is_known_header(&self, id: RialtoHeaderId) -> Result<(RialtoHeaderId, bool), RpcError> {
+	async fn is_known_header(
+		&self,
+		id: RialtoHeaderId,
+	) -> Result<(RialtoHeaderId, bool), RpcError> {
 		self.client.substrate_header_known(self.contract, id).await
 	}
 
-	async fn submit_headers(&self, headers: Vec<QueuedRialtoHeader>) -> SubmittedHeaders<RialtoHeaderId, RpcError> {
+	async fn submit_headers(
+		&self,
+		headers: Vec<QueuedRialtoHeader>,
+	) -> SubmittedHeaders<RialtoHeaderId, RpcError> {
 		self.client
 			.submit_substrate_headers(self.sign_params.clone(), self.contract, headers)
 			.await
@@ -161,7 +162,10 @@ impl TargetClient<SubstrateHeadersSyncPipeline> for EthereumHeadersTarget {
 			.await
 	}
 
-	async fn requires_extra(&self, header: QueuedRialtoHeader) -> Result<(RialtoHeaderId, bool), RpcError> {
+	async fn requires_extra(
+		&self,
+		header: QueuedRialtoHeader,
+	) -> Result<(RialtoHeaderId, bool), RpcError> {
 		Ok((header.header().id(), false))
 	}
 }
@@ -194,7 +198,7 @@ pub async fn run(params: SubstrateSyncParams) -> Result<(), RpcError> {
 		futures::future::pending(),
 	)
 	.await
-	.map_err(RpcError::SyncLoop)?;
+	.map_err(|e| RpcError::SyncLoop(e.to_string()))?;
 
 	Ok(())
 }

polkadot/bridges/relays/bin-ethereum/src/substrate_types.rs

@@ -17,11 +17,12 @@
 //! Converting between Ethereum headers and bridge module types.
 
 use bp_eth_poa::{
-	AuraHeader as SubstrateEthereumHeader, LogEntry as SubstrateEthereumLogEntry, Receipt as SubstrateEthereumReceipt,
-	TransactionOutcome as SubstrateEthereumTransactionOutcome,
+	AuraHeader as SubstrateEthereumHeader, LogEntry as SubstrateEthereumLogEntry,
+	Receipt as SubstrateEthereumReceipt, TransactionOutcome as SubstrateEthereumTransactionOutcome,
 };
 use relay_ethereum_client::types::{
-	Header as EthereumHeader, Receipt as EthereumReceipt, HEADER_ID_PROOF as ETHEREUM_HEADER_ID_PROOF,
+	Header as EthereumHeader, Receipt as EthereumReceipt,
+	HEADER_ID_PROOF as ETHEREUM_HEADER_ID_PROOF,
 };
 
 /// Convert Ethereum header into Ethereum header for Substrate.
@@ -68,7 +69,8 @@ pub fn into_substrate_ethereum_receipt(receipt: &EthereumReceipt) -> SubstrateEt
 			})
 			.collect(),
 		outcome: match (receipt.status, receipt.root) {
-			(Some(status), None) => SubstrateEthereumTransactionOutcome::StatusCode(status.as_u64() as u8),
+			(Some(status), None) =>
+				SubstrateEthereumTransactionOutcome::StatusCode(status.as_u64() as u8),
 			(None, Some(root)) => SubstrateEthereumTransactionOutcome::StateRoot(root),
 			_ => SubstrateEthereumTransactionOutcome::Unknown,
 		},