Run RustFmt as part of the CI (#37)

* Run RustFmt as part of the CI

* Format repo

* Run RustFmt before the default Travis build step

Apparently if you override `script` you also need to make
sure to `build` and `test` the code yourself.

* Format repo

bridges/relays/ethereum/src/ethereum_client.rs

@@ -30,18 +30,13 @@
 // You should have received a copy of the GNU General Public License
 // along with Parity-Bridge.  If not, see <http://www.gnu.org/licenses/>.
 
+use crate::ethereum_sync_loop::MaybeConnectionError;
+use crate::ethereum_types::{Header, HeaderId, Receipt, H256, U64};
 use jsonrpsee::common::Params;
-use jsonrpsee::raw::{
-	RawClient,
-	RawClientError,
-};
-use jsonrpsee::transport::http::{
-	HttpTransportClient, RequestError
-};
+use jsonrpsee::raw::{RawClient, RawClientError};
+use jsonrpsee::transport::http::{HttpTransportClient, RequestError};
 use serde::de::DeserializeOwned;
 use serde_json::{from_value, to_value};
-use crate::ethereum_sync_loop::MaybeConnectionError;
-use crate::ethereum_types::{H256, Header, HeaderId, Receipt, U64};
 
 /// Proof of hash serialization success.
 const HASH_SERIALIZATION_PROOF: &'static str = "hash serialization never fails; qed";
@@ -87,11 +82,7 @@ pub fn client(uri: &str) -> Client {
 
 /// Retrieve best known block number from Ethereum node.
 pub async fn best_block_number(client: Client) -> (Client, Result<u64, Error>) {
-	let (client, result) = call_rpc::<U64>(
-		client,
-		"eth_blockNumber",
-		Params::None,
-	).await;
+	let (client, result) = call_rpc::<U64>(client, "eth_blockNumber", Params::None).await;
 	(client, result.map(|x| x.as_u64()))
 }
 
@@ -104,11 +95,17 @@ pub async fn header_by_number(client: Client, number: u64) -> (Client, Result<He
 			to_value(U64::from(number)).expect(INT_SERIALIZATION_PROOF),
 			to_value(false).expect(BOOL_SERIALIZATION_PROOF),
 		]),
-	).await;
-	(client, header.and_then(|header: Header| match header.number.is_some() && header.hash.is_some() {
-		true => Ok(header),
-		false => Err(Error::IncompleteHeader),
-	}))
+	)
+	.await;
+	(
+		client,
+		header.and_then(
+			|header: Header| match header.number.is_some() && header.hash.is_some() {
+				true => Ok(header),
+				false => Err(Error::IncompleteHeader),
+			},
+		),
+	)
 }
 
 /// Retrieve block header by its hash from Ethereum node.
@@ -120,11 +117,17 @@ pub async fn header_by_hash(client: Client, hash: H256) -> (Client, Result<Heade
 			to_value(hash).expect(HASH_SERIALIZATION_PROOF),
 			to_value(false).expect(BOOL_SERIALIZATION_PROOF),
 		]),
-	).await;
-	(client, header.and_then(|header: Header| match header.number.is_none() && header.hash.is_none() {
-		true => Ok(header),
-		false => Err(Error::IncompleteHeader),
-	}))
+	)
+	.await;
+	(
+		client,
+		header.and_then(
+			|header: Header| match header.number.is_none() && header.hash.is_none() {
+				true => Ok(header),
+				false => Err(Error::IncompleteHeader),
+			},
+		),
+	)
 }
 
 /// Retrieve transactions receipts for given block.
@@ -151,16 +154,16 @@ async fn transaction_receipt(client: Client, hash: H256) -> (Client, Result<Rece
 	let (client, receipt) = call_rpc::<Receipt>(
 		client,
 		"eth_getTransactionReceipt",
-		Params::Array(vec![
-			to_value(hash).expect(HASH_SERIALIZATION_PROOF),
-		]),
-	).await;
-	(client, receipt.and_then(|receipt| {
-		match receipt.gas_used.is_some() {
+		Params::Array(vec![to_value(hash).expect(HASH_SERIALIZATION_PROOF)]),
+	)
+	.await;
+	(
+		client,
+		receipt.and_then(|receipt| match receipt.gas_used.is_some() {
 			true => Ok(receipt),
 			false => Err(Error::IncompleteReceipt),
-		}
-	}))
+		}),
+	)
 }
 
 /// Calls RPC on Ethereum node.

bridges/relays/ethereum/src/ethereum_headers.rs

@@ -30,12 +30,10 @@
 // You should have received a copy of the GNU General Public License
 // along with Parity-Bridge.  If not, see <http://www.gnu.org/licenses/>.
 
+use crate::ethereum_types::{Header, HeaderId, HeaderStatus, QueuedHeader, Receipt, H256};
 use std::collections::{
-	BTreeMap, HashMap, HashSet,
-	btree_map::Entry as BTreeMapEntry,
-	hash_map::Entry as HashMapEntry,
+	btree_map::Entry as BTreeMapEntry, hash_map::Entry as HashMapEntry, BTreeMap, HashMap, HashSet,
 };
-use crate::ethereum_types::{H256, Header, HeaderId, HeaderStatus, QueuedHeader, Receipt};
 
 type HeadersQueue = BTreeMap<u64, HashMap<H256, QueuedHeader>>;
 type KnownHeaders = BTreeMap<u64, HashMap<H256, HeaderStatus>>;
@@ -79,9 +77,15 @@ impl QueuedHeaders {
 	pub fn headers_in_status(&self, status: HeaderStatus) -> usize {
 		match status {
 			HeaderStatus::Unknown | HeaderStatus::Synced => return 0,
-			HeaderStatus::MaybeOrphan => self.maybe_orphan.values().fold(0, |total, headers| total + headers.len()),
+			HeaderStatus::MaybeOrphan => self
+				.maybe_orphan
+				.values()
+				.fold(0, |total, headers| total + headers.len()),
 			HeaderStatus::Orphan => self.orphan.values().fold(0, |total, headers| total + headers.len()),
-			HeaderStatus::MaybeReceipts => self.maybe_receipts.values().fold(0, |total, headers| total + headers.len()),
+			HeaderStatus::MaybeReceipts => self
+				.maybe_receipts
+				.values()
+				.fold(0, |total, headers| total + headers.len()),
 			HeaderStatus::Receipts => self.receipts.values().fold(0, |total, headers| total + headers.len()),
 			HeaderStatus::Ready => self.ready.values().fold(0, |total, headers| total + headers.len()),
 			HeaderStatus::Submitted => self.submitted.values().fold(0, |total, headers| total + headers.len()),
@@ -90,9 +94,14 @@ impl QueuedHeaders {
 
 	/// Returns number of headers that are currently in the queue.
 	pub fn total_headers(&self) -> usize {
-		self.maybe_orphan.values().fold(0, |total, headers| total + headers.len())
+		self.maybe_orphan
+			.values()
+			.fold(0, |total, headers| total + headers.len())
 			+ self.orphan.values().fold(0, |total, headers| total + headers.len())
-			+ self.maybe_receipts.values().fold(0, |total, headers| total + headers.len())
+			+ self
+				.maybe_receipts
+				.values()
+				.fold(0, |total, headers| total + headers.len())
 			+ self.receipts.values().fold(0, |total, headers| total + headers.len())
 			+ self.ready.values().fold(0, |total, headers| total + headers.len())
 	}
@@ -171,16 +180,19 @@ impl QueuedHeaders {
 			HeaderStatus::Unknown | HeaderStatus::MaybeOrphan => {
 				insert_header(&mut self.maybe_orphan, id, header);
 				HeaderStatus::MaybeOrphan
-			},
+			}
 			HeaderStatus::Orphan => {
 				insert_header(&mut self.orphan, id, header);
 				HeaderStatus::Orphan
 			}
-			HeaderStatus::MaybeReceipts | HeaderStatus::Receipts | HeaderStatus::Ready
-				| HeaderStatus::Submitted | HeaderStatus::Synced => {
+			HeaderStatus::MaybeReceipts
+			| HeaderStatus::Receipts
+			| HeaderStatus::Ready
+			| HeaderStatus::Submitted
+			| HeaderStatus::Synced => {
 				insert_header(&mut self.maybe_receipts, id, header);
 				HeaderStatus::MaybeReceipts
-			},
+			}
 		};
 
 		self.known_headers.entry(id.0).or_default().insert(id.1, status);
@@ -202,10 +214,12 @@ impl QueuedHeaders {
 				HeaderStatus::Ready => remove_header(&mut self.ready, &current),
 				HeaderStatus::Submitted => remove_header(&mut self.submitted, &current),
 				HeaderStatus::Synced => break,
-			}.expect("header has a given status; given queue has the header; qed");
+			}
+			.expect("header has a given status; given queue has the header; qed");
 
 			log::debug!(target: "bridge", "Ethereum header {:?} is now {:?}", current, HeaderStatus::Synced);
-			*self.known_headers
+			*self
+				.known_headers
 				.entry(current.0)
 				.or_default()
 				.entry(current.1)
@@ -215,7 +229,8 @@ impl QueuedHeaders {
 
 		// remember that the header is synced
 		log::debug!(target: "bridge", "Ethereum header {:?} is now {:?}", id, HeaderStatus::Synced);
-		*self.known_headers
+		*self
+			.known_headers
 			.entry(id.0)
 			.or_default()
 			.entry(id.1)
@@ -303,7 +318,7 @@ impl QueuedHeaders {
 		if prune_border <= self.prune_border {
 			return;
 		}
-		
+
 		prune_queue(&mut self.maybe_orphan, prune_border);
 		prune_queue(&mut self.orphan, prune_border);
 		prune_queue(&mut self.maybe_receipts, prune_border);
@@ -402,7 +417,10 @@ fn move_header_descendants(
 				if current_parents.contains(&entry.get().header().parent_hash) {
 					let header_to_move = entry.remove();
 					let header_to_move_id = header_to_move.id();
-					known_headers.entry(header_to_move_id.0).or_default().insert(header_to_move_id.1, destination_status);
+					known_headers
+						.entry(header_to_move_id.0)
+						.or_default()
+						.insert(header_to_move_id.1, destination_status);
 					headers_to_move.push((header_to_move_id, header_to_move));
 
 					log::debug!(
@@ -438,7 +456,8 @@ fn oldest_header(queue: &HeadersQueue) -> Option<&QueuedHeader> {
 
 /// Return oldest headers from the queue until functor will return false.
 fn oldest_headers(queue: &HeadersQueue, mut f: impl FnMut(&QueuedHeader) -> bool) -> Option<Vec<&QueuedHeader>> {
-	let result = queue.values()
+	let result = queue
+		.values()
 		.flat_map(|h| h.values())
 		.take_while(|h| f(h))
 		.collect::<Vec<_>>();
@@ -490,11 +509,27 @@ pub(crate) mod tests {
 	fn total_headers_works() {
 		// total headers just sums up number of headers in every queue
 		let mut queue = QueuedHeaders::default();
-		queue.maybe_orphan.entry(1).or_default().insert(hash(1), Default::default());
-		queue.maybe_orphan.entry(1).or_default().insert(hash(2), Default::default());
-		queue.maybe_orphan.entry(2).or_default().insert(hash(3), Default::default());
+		queue
+			.maybe_orphan
+			.entry(1)
+			.or_default()
+			.insert(hash(1), Default::default());
+		queue
+			.maybe_orphan
+			.entry(1)
+			.or_default()
+			.insert(hash(2), Default::default());
+		queue
+			.maybe_orphan
+			.entry(2)
+			.or_default()
+			.insert(hash(3), Default::default());
 		queue.orphan.entry(3).or_default().insert(hash(4), Default::default());
-		queue.maybe_receipts.entry(4).or_default().insert(hash(5), Default::default());
+		queue
+			.maybe_receipts
+			.entry(4)
+			.or_default()
+			.insert(hash(5), Default::default());
 		queue.ready.entry(5).or_default().insert(hash(6), Default::default());
 		assert_eq!(queue.total_headers(), 6);
 	}
@@ -503,21 +538,41 @@ pub(crate) mod tests {
 	fn best_queued_number_works() {
 		// initially there are headers in MaybeOrphan queue only
 		let mut queue = QueuedHeaders::default();
-		queue.maybe_orphan.entry(1).or_default().insert(hash(1), Default::default());
-		queue.maybe_orphan.entry(1).or_default().insert(hash(2), Default::default());
-		queue.maybe_orphan.entry(3).or_default().insert(hash(3), Default::default());
+		queue
+			.maybe_orphan
+			.entry(1)
+			.or_default()
+			.insert(hash(1), Default::default());
+		queue
+			.maybe_orphan
+			.entry(1)
+			.or_default()
+			.insert(hash(2), Default::default());
+		queue
+			.maybe_orphan
+			.entry(3)
+			.or_default()
+			.insert(hash(3), Default::default());
 		assert_eq!(queue.best_queued_number(), 3);
 		// and then there's better header in Orphan
 		queue.orphan.entry(10).or_default().insert(hash(10), Default::default());
 		assert_eq!(queue.best_queued_number(), 10);
 		// and then there's better header in MaybeReceipts
-		queue.maybe_receipts.entry(20).or_default().insert(hash(20), Default::default());
+		queue
+			.maybe_receipts
+			.entry(20)
+			.or_default()
+			.insert(hash(20), Default::default());
 		assert_eq!(queue.best_queued_number(), 20);
 		// and then there's better header in Ready
 		queue.ready.entry(30).or_default().insert(hash(30), Default::default());
 		assert_eq!(queue.best_queued_number(), 30);
 		// and then there's better header in MaybeOrphan again
-		queue.maybe_orphan.entry(40).or_default().insert(hash(40), Default::default());
+		queue
+			.maybe_orphan
+			.entry(40)
+			.or_default()
+			.insert(hash(40), Default::default());
 		assert_eq!(queue.best_queued_number(), 40);
 	}
 
@@ -527,7 +582,11 @@ pub(crate) mod tests {
 		let mut queue = QueuedHeaders::default();
 		assert_eq!(queue.status(&id(10)), HeaderStatus::Unknown);
 		// and status is read from the KnownHeaders
-		queue.known_headers.entry(10).or_default().insert(hash(10), HeaderStatus::Ready);
+		queue
+			.known_headers
+			.entry(10)
+			.or_default()
+			.insert(hash(10), HeaderStatus::Ready);
 		assert_eq!(queue.status(&id(10)), HeaderStatus::Ready);
 	}
 
@@ -536,50 +595,83 @@ pub(crate) mod tests {
 		// initially we have oldest header #10
 		let mut queue = QueuedHeaders::default();
 		queue.maybe_orphan.entry(10).or_default().insert(hash(1), header(100));
-		assert_eq!(queue.header(HeaderStatus::MaybeOrphan).unwrap().header().hash.unwrap(), hash(100));
+		assert_eq!(
+			queue.header(HeaderStatus::MaybeOrphan).unwrap().header().hash.unwrap(),
+			hash(100)
+		);
 		// inserting #20 changes nothing
 		queue.maybe_orphan.entry(20).or_default().insert(hash(1), header(101));
-		assert_eq!(queue.header(HeaderStatus::MaybeOrphan).unwrap().header().hash.unwrap(), hash(100));
+		assert_eq!(
+			queue.header(HeaderStatus::MaybeOrphan).unwrap().header().hash.unwrap(),
+			hash(100)
+		);
 		// inserting #5 makes it oldest
 		queue.maybe_orphan.entry(5).or_default().insert(hash(1), header(102));
-		assert_eq!(queue.header(HeaderStatus::MaybeOrphan).unwrap().header().hash.unwrap(), hash(102));
+		assert_eq!(
+			queue.header(HeaderStatus::MaybeOrphan).unwrap().header().hash.unwrap(),
+			hash(102)
+		);
 	}
 
 	#[test]
 	fn header_response_works() {
 		// when parent is Synced, we insert to MaybeReceipts
 		let mut queue = QueuedHeaders::default();
-		queue.known_headers.entry(100).or_default().insert(hash(100), HeaderStatus::Synced);
+		queue
+			.known_headers
+			.entry(100)
+			.or_default()
+			.insert(hash(100), HeaderStatus::Synced);
 		queue.header_response(header(101).header().clone());
 		assert_eq!(queue.status(&id(101)), HeaderStatus::MaybeReceipts);
 
 		// when parent is Ready, we insert to MaybeReceipts
 		let mut queue = QueuedHeaders::default();
-		queue.known_headers.entry(100).or_default().insert(hash(100), HeaderStatus::Ready);
+		queue
+			.known_headers
+			.entry(100)
+			.or_default()
+			.insert(hash(100), HeaderStatus::Ready);
 		queue.header_response(header(101).header().clone());
 		assert_eq!(queue.status(&id(101)), HeaderStatus::MaybeReceipts);
 
 		// when parent is Receipts, we insert to MaybeReceipts
 		let mut queue = QueuedHeaders::default();
-		queue.known_headers.entry(100).or_default().insert(hash(100), HeaderStatus::Receipts);
+		queue
+			.known_headers
+			.entry(100)
+			.or_default()
+			.insert(hash(100), HeaderStatus::Receipts);
 		queue.header_response(header(101).header().clone());
 		assert_eq!(queue.status(&id(101)), HeaderStatus::MaybeReceipts);
 
 		// when parent is MaybeReceipts, we insert to MaybeReceipts
 		let mut queue = QueuedHeaders::default();
-		queue.known_headers.entry(100).or_default().insert(hash(100), HeaderStatus::MaybeReceipts);
+		queue
+			.known_headers
+			.entry(100)
+			.or_default()
+			.insert(hash(100), HeaderStatus::MaybeReceipts);
 		queue.header_response(header(101).header().clone());
 		assert_eq!(queue.status(&id(101)), HeaderStatus::MaybeReceipts);
 
 		// when parent is Orphan, we insert to Orphan
 		let mut queue = QueuedHeaders::default();
-		queue.known_headers.entry(100).or_default().insert(hash(100), HeaderStatus::Orphan);
+		queue
+			.known_headers
+			.entry(100)
+			.or_default()
+			.insert(hash(100), HeaderStatus::Orphan);
 		queue.header_response(header(101).header().clone());
 		assert_eq!(queue.status(&id(101)), HeaderStatus::Orphan);
 
 		// when parent is MaybeOrphan, we insert to MaybeOrphan
 		let mut queue = QueuedHeaders::default();
-		queue.known_headers.entry(100).or_default().insert(hash(100), HeaderStatus::MaybeOrphan);
+		queue
+			.known_headers
+			.entry(100)
+			.or_default()
+			.insert(hash(100), HeaderStatus::MaybeOrphan);
 		queue.header_response(header(101).header().clone());
 		assert_eq!(queue.status(&id(101)), HeaderStatus::MaybeOrphan);
 
@@ -599,15 +691,39 @@ pub(crate) mod tests {
 		// #97 in Receipts
 		// #96 in Ready
 		let mut queue = QueuedHeaders::default();
-		queue.known_headers.entry(100).or_default().insert(hash(100), HeaderStatus::MaybeOrphan);
-		queue.maybe_orphan.entry(100).or_default().insert(hash(100), header(100));
-		queue.known_headers.entry(99).or_default().insert(hash(99), HeaderStatus::Orphan);
+		queue
+			.known_headers
+			.entry(100)
+			.or_default()
+			.insert(hash(100), HeaderStatus::MaybeOrphan);
+		queue
+			.maybe_orphan
+			.entry(100)
+			.or_default()
+			.insert(hash(100), header(100));
+		queue
+			.known_headers
+			.entry(99)
+			.or_default()
+			.insert(hash(99), HeaderStatus::Orphan);
 		queue.orphan.entry(99).or_default().insert(hash(99), header(99));
-		queue.known_headers.entry(98).or_default().insert(hash(98), HeaderStatus::MaybeReceipts);
+		queue
+			.known_headers
+			.entry(98)
+			.or_default()
+			.insert(hash(98), HeaderStatus::MaybeReceipts);
 		queue.maybe_receipts.entry(98).or_default().insert(hash(98), header(98));
-		queue.known_headers.entry(97).or_default().insert(hash(97), HeaderStatus::Receipts);
+		queue
+			.known_headers
+			.entry(97)
+			.or_default()
+			.insert(hash(97), HeaderStatus::Receipts);
 		queue.receipts.entry(97).or_default().insert(hash(97), header(97));
-		queue.known_headers.entry(96).or_default().insert(hash(96), HeaderStatus::Ready);
+		queue
+			.known_headers
+			.entry(96)
+			.or_default()
+			.insert(hash(96), HeaderStatus::Ready);
 		queue.ready.entry(96).or_default().insert(hash(96), header(96));
 		queue.substrate_best_header_response(&id(100));
 
@@ -618,7 +734,10 @@ pub(crate) mod tests {
 		assert!(queue.receipts.is_empty());
 		assert!(queue.ready.is_empty());
 		assert_eq!(queue.known_headers.len(), 5);
-		assert!(queue.known_headers.values().all(|s| s.values().all(|s| *s == HeaderStatus::Synced)));
+		assert!(queue
+			.known_headers
+			.values()
+			.all(|s| s.values().all(|s| *s == HeaderStatus::Synced)));
 	}
 
 	#[test]
@@ -629,11 +748,27 @@ pub(crate) mod tests {
 		// #102 in MaybeOrphan
 		// #103 in Orphan
 		let mut queue = QueuedHeaders::default();
-		queue.known_headers.entry(101).or_default().insert(hash(101), HeaderStatus::Orphan);
+		queue
+			.known_headers
+			.entry(101)
+			.or_default()
+			.insert(hash(101), HeaderStatus::Orphan);
 		queue.orphan.entry(101).or_default().insert(hash(101), header(101));
-		queue.known_headers.entry(102).or_default().insert(hash(102), HeaderStatus::MaybeOrphan);
-		queue.maybe_orphan.entry(102).or_default().insert(hash(102), header(102));
-		queue.known_headers.entry(103).or_default().insert(hash(103), HeaderStatus::Orphan);
+		queue
+			.known_headers
+			.entry(102)
+			.or_default()
+			.insert(hash(102), HeaderStatus::MaybeOrphan);
+		queue
+			.maybe_orphan
+			.entry(102)
+			.or_default()
+			.insert(hash(102), header(102));
+		queue
+			.known_headers
+			.entry(103)
+			.or_default()
+			.insert(hash(103), HeaderStatus::Orphan);
 		queue.orphan.entry(103).or_default().insert(hash(103), header(103));
 		queue.substrate_best_header_response(&id(100));
 
@@ -655,12 +790,32 @@ pub(crate) mod tests {
 		// and we have asked for MaybeOrphan status of #100.parent (i.e. #99)
 		// and the response is: YES, #99 is known to the Substrate runtime
 		let mut queue = QueuedHeaders::default();
-		queue.known_headers.entry(100).or_default().insert(hash(100), HeaderStatus::MaybeOrphan);
-		queue.maybe_orphan.entry(100).or_default().insert(hash(100), header(100));
-		queue.known_headers.entry(101).or_default().insert(hash(101), HeaderStatus::Orphan);
+		queue
+			.known_headers
+			.entry(100)
+			.or_default()
+			.insert(hash(100), HeaderStatus::MaybeOrphan);
+		queue
+			.maybe_orphan
+			.entry(100)
+			.or_default()
+			.insert(hash(100), header(100));
+		queue
+			.known_headers
+			.entry(101)
+			.or_default()
+			.insert(hash(101), HeaderStatus::Orphan);
 		queue.orphan.entry(101).or_default().insert(hash(101), header(101));
-		queue.known_headers.entry(102).or_default().insert(hash(102), HeaderStatus::MaybeOrphan);
-		queue.maybe_orphan.entry(102).or_default().insert(hash(102), header(102));
+		queue
+			.known_headers
+			.entry(102)
+			.or_default()
+			.insert(hash(102), HeaderStatus::MaybeOrphan);
+		queue
+			.maybe_orphan
+			.entry(102)
+			.or_default()
+			.insert(hash(102), header(102));
 		queue.maybe_orphan_response(&id(99), true);
 
 		// then all headers (#100..#103) are moved to the MaybeReceipts queue
@@ -680,10 +835,26 @@ pub(crate) mod tests {
 		// and we have asked for MaybeOrphan status of #100.parent (i.e. #99)
 		// and the response is: NO, #99 is NOT known to the Substrate runtime
 		let mut queue = QueuedHeaders::default();
-		queue.known_headers.entry(100).or_default().insert(hash(100), HeaderStatus::MaybeOrphan);
-		queue.maybe_orphan.entry(100).or_default().insert(hash(100), header(100));
-		queue.known_headers.entry(101).or_default().insert(hash(101), HeaderStatus::MaybeOrphan);
-		queue.maybe_orphan.entry(101).or_default().insert(hash(101), header(101));
+		queue
+			.known_headers
+			.entry(100)
+			.or_default()
+			.insert(hash(100), HeaderStatus::MaybeOrphan);
+		queue
+			.maybe_orphan
+			.entry(100)
+			.or_default()
+			.insert(hash(100), header(100));
+		queue
+			.known_headers
+			.entry(101)
+			.or_default()
+			.insert(hash(101), HeaderStatus::MaybeOrphan);
+		queue
+			.maybe_orphan
+			.entry(101)
+			.or_default()
+			.insert(hash(101), header(101));
 		queue.maybe_orphan_response(&id(99), false);
 
 		// then all headers (#100..#101) are moved to the Orphan queue
@@ -696,8 +867,16 @@ pub(crate) mod tests {
 	#[test]
 	fn positive_maybe_receipts_response_works() {
 		let mut queue = QueuedHeaders::default();
-		queue.known_headers.entry(100).or_default().insert(hash(100), HeaderStatus::MaybeReceipts);
-		queue.maybe_receipts.entry(100).or_default().insert(hash(100), header(100));
+		queue
+			.known_headers
+			.entry(100)
+			.or_default()
+			.insert(hash(100), HeaderStatus::MaybeReceipts);
+		queue
+			.maybe_receipts
+			.entry(100)
+			.or_default()
+			.insert(hash(100), header(100));
 		queue.maybe_receipts_response(&id(100), true);
 		assert!(queue.maybe_receipts.is_empty());
 		assert_eq!(queue.receipts.len(), 1);
@@ -707,8 +886,16 @@ pub(crate) mod tests {
 	#[test]
 	fn negative_maybe_receipts_response_works() {
 		let mut queue = QueuedHeaders::default();
-		queue.known_headers.entry(100).or_default().insert(hash(100), HeaderStatus::MaybeReceipts);
-		queue.maybe_receipts.entry(100).or_default().insert(hash(100), header(100));
+		queue
+			.known_headers
+			.entry(100)
+			.or_default()
+			.insert(hash(100), HeaderStatus::MaybeReceipts);
+		queue
+			.maybe_receipts
+			.entry(100)
+			.or_default()
+			.insert(hash(100), header(100));
 		queue.maybe_receipts_response(&id(100), false);
 		assert!(queue.maybe_receipts.is_empty());
 		assert_eq!(queue.ready.len(), 1);
@@ -718,7 +905,11 @@ pub(crate) mod tests {
 	#[test]
 	fn receipts_response_works() {
 		let mut queue = QueuedHeaders::default();
-		queue.known_headers.entry(100).or_default().insert(hash(100), HeaderStatus::Receipts);
+		queue
+			.known_headers
+			.entry(100)
+			.or_default()
+			.insert(hash(100), HeaderStatus::Receipts);
 		queue.receipts.entry(100).or_default().insert(hash(100), header(100));
 		queue.receipts_response(&id(100), Vec::new());
 		assert!(queue.receipts.is_empty());
@@ -729,7 +920,11 @@ pub(crate) mod tests {
 	#[test]
 	fn header_submitted_works() {
 		let mut queue = QueuedHeaders::default();
-		queue.known_headers.entry(100).or_default().insert(hash(100), HeaderStatus::Ready);
+		queue
+			.known_headers
+			.entry(100)
+			.or_default()
+			.insert(hash(100), HeaderStatus::Ready);
 		queue.ready.entry(100).or_default().insert(hash(100), header(100));
 		queue.headers_submitted(vec![id(100)]);
 		assert!(queue.ready.is_empty());
@@ -739,15 +934,43 @@ pub(crate) mod tests {
 	#[test]
 	fn prune_works() {
 		let mut queue = QueuedHeaders::default();
-		queue.known_headers.entry(104).or_default().insert(hash(104), HeaderStatus::MaybeOrphan);
-		queue.maybe_orphan.entry(104).or_default().insert(hash(104), header(104));
-		queue.known_headers.entry(103).or_default().insert(hash(103), HeaderStatus::Orphan);
+		queue
+			.known_headers
+			.entry(104)
+			.or_default()
+			.insert(hash(104), HeaderStatus::MaybeOrphan);
+		queue
+			.maybe_orphan
+			.entry(104)
+			.or_default()
+			.insert(hash(104), header(104));
+		queue
+			.known_headers
+			.entry(103)
+			.or_default()
+			.insert(hash(103), HeaderStatus::Orphan);
 		queue.orphan.entry(103).or_default().insert(hash(103), header(103));
-		queue.known_headers.entry(102).or_default().insert(hash(102), HeaderStatus::MaybeReceipts);
-		queue.maybe_receipts.entry(102).or_default().insert(hash(102), header(102));
-		queue.known_headers.entry(101).or_default().insert(hash(101), HeaderStatus::Receipts);
+		queue
+			.known_headers
+			.entry(102)
+			.or_default()
+			.insert(hash(102), HeaderStatus::MaybeReceipts);
+		queue
+			.maybe_receipts
+			.entry(102)
+			.or_default()
+			.insert(hash(102), header(102));
+		queue
+			.known_headers
+			.entry(101)
+			.or_default()
+			.insert(hash(101), HeaderStatus::Receipts);
 		queue.receipts.entry(101).or_default().insert(hash(101), header(101));
-		queue.known_headers.entry(100).or_default().insert(hash(100), HeaderStatus::Ready);
+		queue
+			.known_headers
+			.entry(100)
+			.or_default()
+			.insert(hash(100), HeaderStatus::Ready);
 		queue.ready.entry(100).or_default().insert(hash(100), header(100));
 
 		queue.prune(102);

bridges/relays/ethereum/src/ethereum_sync.rs

@@ -30,11 +30,11 @@
 // You should have received a copy of the GNU General Public License
 // along with Parity-Bridge.  If not, see <http://www.gnu.org/licenses/>.
 
-use codec::Encode;
 use crate::ethereum_headers::QueuedHeaders;
-use crate::ethereum_types::{HeaderId, HeaderStatus, QueuedHeader};
 use crate::ethereum_sync_loop::EthereumSyncParams;
+use crate::ethereum_types::{HeaderId, HeaderStatus, QueuedHeader};
 use crate::substrate_types::{into_substrate_ethereum_header, into_substrate_ethereum_receipts};
+use codec::Encode;
 
 /// Ethereum headers synchronization context.
 #[derive(Debug)]
@@ -63,7 +63,8 @@ impl HeadersSync {
 	/// Returns true if we have synced almost all known headers.
 	pub fn is_almost_synced(&self) -> bool {
 		match self.target_header_number {
-			Some(target_header_number) => self.best_header
+			Some(target_header_number) => self
+				.best_header
 				.map(|best| target_header_number.saturating_sub(best.0) < 4)
 				.unwrap_or(false),
 			None => true,
@@ -100,10 +101,7 @@ impl HeadersSync {
 		}
 
 		// we assume that there were no reorgs if we have already downloaded best header
-		let best_downloaded_number = std::cmp::max(
-			self.headers.best_queued_number(),
-			best_header.0,
-		);
+		let best_downloaded_number = std::cmp::max(self.headers.best_queued_number(), best_header.0);
 		if best_downloaded_number == target_header_number {
 			return None;
 		}
@@ -115,7 +113,9 @@ impl HeadersSync {
 	/// Select headers that need to be submitted to the Substrate node.
 	pub fn select_headers_to_submit(&self) -> Option<Vec<&QueuedHeader>> {
 		let headers_in_submit_status = self.headers.headers_in_status(HeaderStatus::Submitted);
-		let headers_to_submit_count = self.params.max_headers_in_submitted_status
+		let headers_to_submit_count = self
+			.params
+			.max_headers_in_submitted_status
 			.checked_sub(headers_in_submit_status)?;
 
 		let mut total_size = 0;
@@ -129,7 +129,8 @@ impl HeadersSync {
 			}
 
 			let encoded_size = into_substrate_ethereum_header(header.header()).encode().len()
-				+ into_substrate_ethereum_receipts(header.receipts()).map(|receipts| receipts.encode().len())
+				+ into_substrate_ethereum_receipts(header.receipts())
+					.map(|receipts| receipts.encode().len())
 					.unwrap_or(0);
 			if total_headers != 0 && total_size + encoded_size > self.params.max_headers_size_in_single_submit {
 				return false;
@@ -162,7 +163,8 @@ impl HeadersSync {
 		self.headers.substrate_best_header_response(&best_header);
 
 		// prune ancient headers
-		self.headers.prune(best_header.0.saturating_sub(self.params.prune_depth));
+		self.headers
+			.prune(best_header.0.saturating_sub(self.params.prune_depth));
 
 		// finally remember the best header itself
 		self.best_header = Some(best_header);
@@ -180,9 +182,9 @@ impl HeadersSync {
 
 #[cfg(test)]
 mod tests {
-	use crate::ethereum_headers::tests::{header, id};
-	use crate::ethereum_types::{H256, HeaderStatus};
 	use super::*;
+	use crate::ethereum_headers::tests::{header, id};
+	use crate::ethereum_types::{HeaderStatus, H256};
 
 	fn side_hash(number: u64) -> H256 {
 		H256::from_low_u64_le(1000 + number)

bridges/relays/ethereum/src/ethereum_sync_loop.rs

@@ -30,10 +30,10 @@
 // You should have received a copy of the GNU General Public License
 // along with Parity-Bridge.  If not, see <http://www.gnu.org/licenses/>.
 
-use futures::{future::FutureExt, stream::StreamExt};
 use crate::ethereum_client;
 use crate::ethereum_types::HeaderStatus as EthereumHeaderStatus;
 use crate::substrate_client;
+use futures::{future::FutureExt, stream::StreamExt};
 
 // TODO: when SharedClient will be available, switch to Substrate headers subscription
 // (because we do not need old Substrate headers)
@@ -98,7 +98,10 @@ impl std::fmt::Debug for EthereumSyncParams {
 			.field("max_future_headers_to_download", &self.max_future_headers_to_download)
 			.field("max_headers_in_submitted_status", &self.max_headers_in_submitted_status)
 			.field("max_headers_in_single_submit", &self.max_headers_in_single_submit)
-			.field("max_headers_size_in_single_submit", &self.max_headers_size_in_single_submit)
+			.field(
+				"max_headers_size_in_single_submit",
+				&self.max_headers_size_in_single_submit,
+			)
 			.field("prune_depth", &self.prune_depth)
 			.finish()
 	}
@@ -136,9 +139,7 @@ pub fn run(params: EthereumSyncParams) {
 
 		let mut eth_maybe_client = None;
 		let mut eth_best_block_number_required = false;
-		let eth_best_block_number_future = ethereum_client::best_block_number(
-			ethereum_client::client(&eth_uri)
-		).fuse();
+		let eth_best_block_number_future = ethereum_client::best_block_number(ethereum_client::client(&eth_uri)).fuse();
 		let eth_new_header_future = futures::future::Fuse::terminated();
 		let eth_orphan_header_future = futures::future::Fuse::terminated();
 		let eth_receipts_future = futures::future::Fuse::terminated();
@@ -147,9 +148,8 @@ pub fn run(params: EthereumSyncParams) {
 
 		let mut sub_maybe_client = None;
 		let mut sub_best_block_required = false;
-		let sub_best_block_future = substrate_client::best_ethereum_block(
-			substrate_client::client(&sub_uri, sub_signer),
-		).fuse();
+		let sub_best_block_future =
+			substrate_client::best_ethereum_block(substrate_client::client(&sub_uri, sub_signer)).fuse();
 		let sub_receipts_check_future = futures::future::Fuse::terminated();
 		let sub_existence_status_future = futures::future::Fuse::terminated();
 		let sub_submit_header_future = futures::future::Fuse::terminated();
@@ -326,7 +326,7 @@ pub fn run(params: EthereumSyncParams) {
 				// 2) check transactions receipts - it stops us from downloading/submitting new blocks;
 				// 3) check existence - it stops us from submitting new blocks;
 				// 4) submit header
-				
+
 				if sub_best_block_required {
 					log::debug!(target: "bridge", "Asking Substrate about best block");
 					sub_best_block_future.set(substrate_client::best_ethereum_block(sub_client).fuse());
@@ -338,9 +338,8 @@ pub fn run(params: EthereumSyncParams) {
 					);
 
 					let header = header.clone();
-					sub_receipts_check_future.set(
-						substrate_client::ethereum_receipts_required(sub_client, header).fuse()
-					);
+					sub_receipts_check_future
+						.set(substrate_client::ethereum_receipts_required(sub_client, header).fuse());
 				} else if let Some(header) = eth_sync.headers().header(EthereumHeaderStatus::MaybeOrphan) {
 					// for MaybeOrphan we actually ask for parent' header existence
 					let parent_id = header.parent_id();
@@ -351,9 +350,8 @@ pub fn run(params: EthereumSyncParams) {
 						parent_id,
 					);
 
-					sub_existence_status_future.set(
-						substrate_client::ethereum_header_known(sub_client, parent_id).fuse(),
-					);
+					sub_existence_status_future
+						.set(substrate_client::ethereum_header_known(sub_client, parent_id).fuse());
 				} else if let Some(headers) = eth_sync.select_headers_to_submit() {
 					let ids = match headers.len() {
 						1 => format!("{:?}", headers[0].id()),
@@ -368,9 +366,7 @@ pub fn run(params: EthereumSyncParams) {
 					);
 
 					let headers = headers.into_iter().cloned().collect();
-					sub_submit_header_future.set(
-						substrate_client::submit_ethereum_headers(sub_client, headers).fuse(),
-					);
+					sub_submit_header_future.set(substrate_client::submit_ethereum_headers(sub_client, headers).fuse());
 
 					// remember that we have submitted some headers
 					if stall_countdown.is_none() {
@@ -400,11 +396,8 @@ pub fn run(params: EthereumSyncParams) {
 						id,
 					);
 					eth_receipts_future.set(
-						ethereum_client::transactions_receipts(
-							eth_client,
-							id,
-							header.header().transactions.clone(),
-						).fuse()
+						ethereum_client::transactions_receipts(eth_client, id, header.header().transactions.clone())
+							.fuse(),
 					);
 				} else if let Some(header) = eth_sync.headers().header(EthereumHeaderStatus::Orphan) {
 					// for Orphan we actually ask for parent' header
@@ -416,9 +409,7 @@ pub fn run(params: EthereumSyncParams) {
 						parent_id,
 					);
 
-					eth_orphan_header_future.set(
-						ethereum_client::header_by_hash(eth_client, parent_id.1).fuse(),
-					);
+					eth_orphan_header_future.set(ethereum_client::header_by_hash(eth_client, parent_id.1).fuse());
 				} else if let Some(id) = eth_sync.select_new_header_to_download() {
 					log::debug!(
 						target: "bridge",
@@ -426,9 +417,7 @@ pub fn run(params: EthereumSyncParams) {
 						id,
 					);
 
-					eth_new_header_future.set(
-						ethereum_client::header_by_number(eth_client, id).fuse(),
-					);
+					eth_new_header_future.set(ethereum_client::header_by_number(eth_client, id).fuse());
 				} else {
 					eth_maybe_client = Some(eth_client);
 				}
@@ -469,7 +458,10 @@ async fn delay<T>(timeout_ms: u64, retval: T) -> T {
 }
 
 fn interval(timeout_ms: u64) -> impl futures::Stream<Item = ()> {
-	futures::stream::unfold((), move |_| async move { delay(timeout_ms, ()).await; Some(((), ())) })
+	futures::stream::unfold((), move |_| async move {
+		delay(timeout_ms, ()).await;
+		Some(((), ()))
+	})
 }
 
 fn process_future_result<TClient, TResult, TError, TGoOfflineFuture>(
@@ -488,7 +480,7 @@ fn process_future_result<TClient, TResult, TError, TGoOfflineFuture>(
 		Ok(result) => {
 			*maybe_client = Some(client);
 			on_success(result);
-		},
+		}
 		Err(error) => {
 			if error.is_connection_error() {
 				go_offline_future.set(go_offline(client).fuse());
@@ -497,6 +489,6 @@ fn process_future_result<TClient, TResult, TError, TGoOfflineFuture>(
 			}
 
 			log::error!(target: "bridge", "{}: {:?}", error_pattern, error);
-		},
+		}
 	}
 }

bridges/relays/ethereum/src/ethereum_types.rs

@@ -52,7 +52,10 @@ pub struct HeaderId(pub u64, pub H256);
 
 impl From<&Header> for HeaderId {
 	fn from(header: &Header) -> HeaderId {
-		HeaderId(header.number.expect(HEADER_ID_PROOF).as_u64(), header.hash.expect(HEADER_ID_PROOF))
+		HeaderId(
+			header.number.expect(HEADER_ID_PROOF).as_u64(),
+			header.hash.expect(HEADER_ID_PROOF),
+		)
 	}
 }
 

bridges/relays/ethereum/src/main.rs

@@ -30,7 +30,7 @@
 // You should have received a copy of the GNU General Public License
 // along with Parity-Bridge.  If not, see <http://www.gnu.org/licenses/>.
 
-#![recursion_limit="1024"]
+#![recursion_limit = "1024"]
 
 mod ethereum_client;
 mod ethereum_headers;
@@ -40,8 +40,8 @@ mod ethereum_types;
 mod substrate_client;
 mod substrate_types;
 
-use std::io::Write;
 use sp_core::crypto::Pair;
+use std::io::Write;
 
 fn main() {
 	initialize();
@@ -51,7 +51,7 @@ fn main() {
 		Err(err) => {
 			log::error!(target: "bridge", "Error parsing parameters: {}", err);
 			return;
-		},
+		}
 	});
 }
 
@@ -66,8 +66,8 @@ fn initialize() {
 	builder.parse_filters(&filters);
 	builder.format(move |buf, record| {
 		writeln!(buf, "{}", {
-			let timestamp = time::strftime("%Y-%m-%d %H:%M:%S %Z", &time::now())
-				.expect("Time is incorrectly formatted");
+			let timestamp =
+				time::strftime("%Y-%m-%d %H:%M:%S %Z", &time::now()).expect("Time is incorrectly formatted");
 			if cfg!(windows) {
 				format!("{} {} {} {}", timestamp, record.level(), record.target(), record.args())
 			} else {
@@ -79,11 +79,13 @@ fn initialize() {
 					log::Level::Debug => Color::Fixed(14).paint(record.level().to_string()),
 					log::Level::Trace => Color::Fixed(12).paint(record.level().to_string()),
 				};
-				format!("{} {} {} {}"
-					, Color::Fixed(8).bold().paint(timestamp)
-					, log_level
-					, Color::Fixed(8).paint(record.target())
-					, record.args())
+				format!(
+					"{} {} {} {}",
+					Color::Fixed(8).bold().paint(timestamp),
+					log_level,
+					Color::Fixed(8).paint(record.target()),
+					record.args()
+				)
 			}
 		})
 	});
@@ -110,8 +112,8 @@ fn ethereum_sync_params() -> Result<ethereum_sync_loop::EthereumSyncParams, Stri
 	}
 	if let Some(sub_signer) = matches.value_of("sub-signer") {
 		let sub_signer_password = matches.value_of("sub-signer-password");
-		eth_sync_params.sub_signer = sp_core::sr25519::Pair::from_string(sub_signer, sub_signer_password)
-			.map_err(|e| format!("{:?}", e))?;
+		eth_sync_params.sub_signer =
+			sp_core::sr25519::Pair::from_string(sub_signer, sub_signer_password).map_err(|e| format!("{:?}", e))?;
 	}
 
 	Ok(eth_sync_params)

bridges/relays/ethereum/src/substrate_client.rs

@@ -30,29 +30,16 @@
 // You should have received a copy of the GNU General Public License
 // along with Parity-Bridge.  If not, see <http://www.gnu.org/licenses/>.
 
-use codec::{Encode, Decode};
+use crate::ethereum_sync_loop::MaybeConnectionError;
+use crate::ethereum_types::{Bytes, HeaderId as EthereumHeaderId, QueuedHeader as QueuedEthereumHeader, H256};
+use crate::substrate_types::{into_substrate_ethereum_header, into_substrate_ethereum_receipts, TransactionHash};
+use codec::{Decode, Encode};
 use jsonrpsee::common::Params;
-use jsonrpsee::raw::{
-	RawClient, RawClientError
-};
-use jsonrpsee::transport::http::{
-	HttpTransportClient, RequestError
-};
+use jsonrpsee::raw::{RawClient, RawClientError};
+use jsonrpsee::transport::http::{HttpTransportClient, RequestError};
 use serde_json::{from_value, to_value};
 use sp_core::crypto::Pair;
 use sp_runtime::traits::IdentifyAccount;
-use crate::ethereum_sync_loop::MaybeConnectionError;
-use crate::ethereum_types::{
-	Bytes,
-	H256,
-	HeaderId as EthereumHeaderId,
-	QueuedHeader as QueuedEthereumHeader,
-};
-use crate::substrate_types::{
-	TransactionHash,
-	into_substrate_ethereum_header,
-	into_substrate_ethereum_receipts,
-};
 
 /// Substrate client type.
 pub struct Client {
@@ -105,7 +92,8 @@ pub async fn best_ethereum_block(client: Client) -> (Client, Result<EthereumHead
 			to_value("EthereumHeadersApi_best_block").unwrap(),
 			to_value("0x").unwrap(),
 		]),
-	).await;
+	)
+	.await;
 	(client, result.map(|(num, hash)| EthereumHeaderId(num, hash)))
 }
 
@@ -124,8 +112,12 @@ pub async fn ethereum_receipts_required(
 			to_value("EthereumHeadersApi_is_import_requires_receipts").unwrap(),
 			to_value(Bytes(encoded_header)).unwrap(),
 		]),
-	).await;
-	(client, receipts_required.map(|receipts_required| (id, receipts_required)))
+	)
+	.await;
+	(
+		client,
+		receipts_required.map(|receipts_required| (id, receipts_required)),
+	)
 }
 
 /// Returns true if Ethereum header is known to Substrate runtime.
@@ -147,7 +139,8 @@ pub async fn ethereum_header_known(
 			to_value("EthereumHeadersApi_is_known_block").unwrap(),
 			to_value(Bytes(encoded_id)).unwrap(),
 		]),
-	).await;
+	)
+	.await;
 	(client, is_known_block.map(|is_known_block| (id, is_known_block)))
 }
 
@@ -167,7 +160,7 @@ pub async fn submit_ethereum_headers(
 			};
 			client.genesis_hash = Some(genesis_hash);
 			(client, genesis_hash)
-		},
+		}
 	};
 	let account_id = client.signer.public().as_array_ref().clone().into();
 	let (client, nonce) = next_account_index(client, account_id).await;
@@ -175,20 +168,14 @@ pub async fn submit_ethereum_headers(
 		Ok(nonce) => nonce,
 		Err(err) => return (client, Err(err)),
 	};
-	let transaction = create_submit_transaction(
-		headers,
-		&client.signer,
-		nonce,
-		genesis_hash,
-	);
+	let transaction = create_submit_transaction(headers, &client.signer, nonce, genesis_hash);
 	let encoded_transaction = transaction.encode();
 	let (client, transaction_hash) = call_rpc(
 		client,
 		"author_submitExtrinsic",
-		Params::Array(vec![
-			to_value(Bytes(encoded_transaction)).unwrap(),
-		]),
-	).await;
+		Params::Array(vec![to_value(Bytes(encoded_transaction)).unwrap()]),
+	)
+	.await;
 	(client, transaction_hash.map(|transaction_hash| (transaction_hash, ids)))
 }
 
@@ -197,10 +184,9 @@ async fn block_hash_by_number(client: Client, number: u64) -> (Client, Result<H2
 	call_rpc(
 		client,
 		"chain_getBlockHash",
-		Params::Array(vec![
-			to_value(number).unwrap(),
-		]),
-	).await
+		Params::Array(vec![to_value(number).unwrap()]),
+	)
+	.await
 }
 
 /// Get substrate account nonce.
@@ -213,24 +199,15 @@ async fn next_account_index(
 	let (client, index) = call_rpc_u64(
 		client,
 		"system_accountNextIndex",
-		Params::Array(vec![
-			to_value(account.to_ss58check()).unwrap(),
-		]),
-	).await;
+		Params::Array(vec![to_value(account.to_ss58check()).unwrap()]),
+	)
+	.await;
 	(client, index.map(|index| index as _))
 }
 
 /// Calls RPC on Substrate node that returns Bytes.
-async fn call_rpc<T: Decode>(
-	mut client: Client,
-	method: &'static str,
-	params: Params,
-) -> (Client, Result<T, Error>) {
-	async fn do_call_rpc<T: Decode>(
-		client: &mut Client,
-		method: &'static str,
-		params: Params,
-	) -> Result<T, Error> {
+async fn call_rpc<T: Decode>(mut client: Client, method: &'static str, params: Params) -> (Client, Result<T, Error>) {
+	async fn do_call_rpc<T: Decode>(client: &mut Client, method: &'static str, params: Params) -> Result<T, Error> {
 		let request_id = client
 			.rpc_client
 			.start_request(method, params)
@@ -253,16 +230,8 @@ async fn call_rpc<T: Decode>(
 }
 
 /// Calls RPC on Substrate node that returns u64.
-async fn call_rpc_u64(
-	mut client: Client,
-	method: &'static str,
-	params: Params,
-) -> (Client, Result<u64, Error>) {
-	async fn do_call_rpc(
-		client: &mut Client,
-		method: &'static str,
-		params: Params,
-	) -> Result<u64, Error> {
+async fn call_rpc_u64(mut client: Client, method: &'static str, params: Params) -> (Client, Result<u64, Error>) {
+	async fn do_call_rpc(client: &mut Client, method: &'static str, params: Params) -> Result<u64, Error> {
 		let request_id = client
 			.rpc_client
 			.start_request(method, params)
@@ -290,20 +259,18 @@ fn create_submit_transaction(
 	index: node_primitives::Index,
 	genesis_hash: H256,
 ) -> bridge_node_runtime::UncheckedExtrinsic {
-	let function = bridge_node_runtime::Call::BridgeEthPoA(
-		bridge_node_runtime::BridgeEthPoACall::import_headers(
-			headers
-				.into_iter()
-				.map(|header| {
-					let (header, receipts) = header.extract();
-					(
-						into_substrate_ethereum_header(&header),
-						into_substrate_ethereum_receipts(&receipts),
-					)
-				})
-				.collect(),
-		),
-	);
+	let function = bridge_node_runtime::Call::BridgeEthPoA(bridge_node_runtime::BridgeEthPoACall::import_headers(
+		headers
+			.into_iter()
+			.map(|header| {
+				let (header, receipts) = header.extract();
+				(
+					into_substrate_ethereum_header(&header),
+					into_substrate_ethereum_receipts(&receipts),
+				)
+			})
+			.collect(),
+	));
 
 	let extra = |i: node_primitives::Index, f: node_primitives::Balance| {
 		(
@@ -331,10 +298,5 @@ fn create_submit_transaction(
 	let signer: sp_runtime::MultiSigner = signer.public().into();
 	let (function, extra, _) = raw_payload.deconstruct();
 
-	bridge_node_runtime::UncheckedExtrinsic::new_signed(
-		function,
-		signer.into_account().into(),
-		signature.into(),
-		extra,
-	)
+	bridge_node_runtime::UncheckedExtrinsic::new_signed(function, signer.into_account().into(), signature.into(), extra)
 }

bridges/relays/ethereum/src/substrate_types.rs

@@ -30,17 +30,14 @@
 // You should have received a copy of the GNU General Public License
 // along with Parity-Bridge.  If not, see <http://www.gnu.org/licenses/>.
 
-pub use sp_bridge_eth_poa::{
-	Address, Bloom, Bytes, H256, Header as SubstrateEthereumHeader,
-	LogEntry as SubstrateEthereumLogEntry, Receipt as SubstrateEthereumReceipt,
-	TransactionOutcome as SubstrateEthereumTransactionOutcome, U256,
-};
 pub use crate::ethereum_types::H256 as TransactionHash;
 use crate::ethereum_types::{
-	HEADER_ID_PROOF as ETHEREUM_HEADER_ID_PROOF,
+	Header as EthereumHeader, Receipt as EthereumReceipt, HEADER_ID_PROOF as ETHEREUM_HEADER_ID_PROOF,
 	RECEIPT_GAS_USED_PROOF as ETHEREUM_RECEIPT_GAS_USED_PROOF,
-	Header as EthereumHeader,
-	Receipt as EthereumReceipt,
+};
+pub use sp_bridge_eth_poa::{
+	Address, Bloom, Bytes, Header as SubstrateEthereumHeader, LogEntry as SubstrateEthereumLogEntry,
+	Receipt as SubstrateEthereumReceipt, TransactionOutcome as SubstrateEthereumTransactionOutcome, H256, U256,
 };
 
 /// Convert Ethereum header into Ethereum header for Substrate.
@@ -67,18 +64,27 @@ pub fn into_substrate_ethereum_header(header: &EthereumHeader) -> SubstrateEther
 pub fn into_substrate_ethereum_receipts(
 	receipts: &Option<Vec<EthereumReceipt>>,
 ) -> Option<Vec<SubstrateEthereumReceipt>> {
-	receipts.as_ref().map(|receipts| receipts.iter().map(|receipt| SubstrateEthereumReceipt {
-		gas_used: receipt.gas_used.expect(ETHEREUM_RECEIPT_GAS_USED_PROOF),
-		log_bloom: receipt.logs_bloom.data().into(),
-		logs: receipt.logs.iter().map(|log_entry| SubstrateEthereumLogEntry {
-			address: log_entry.address,
-			topics: log_entry.topics.clone(),
-			data: log_entry.data.0.clone(),
-		}).collect(),
-		outcome: match (receipt.status, receipt.root) {
-			(Some(status), None) => SubstrateEthereumTransactionOutcome::StatusCode(status.as_u64() as u8),
-			(None, Some(root)) => SubstrateEthereumTransactionOutcome::StateRoot(root),
-			_ => SubstrateEthereumTransactionOutcome::Unknown,
-		},
-	}).collect())
+	receipts.as_ref().map(|receipts| {
+		receipts
+			.iter()
+			.map(|receipt| SubstrateEthereumReceipt {
+				gas_used: receipt.gas_used.expect(ETHEREUM_RECEIPT_GAS_USED_PROOF),
+				log_bloom: receipt.logs_bloom.data().into(),
+				logs: receipt
+					.logs
+					.iter()
+					.map(|log_entry| SubstrateEthereumLogEntry {
+						address: log_entry.address,
+						topics: log_entry.topics.clone(),
+						data: log_entry.data.0.clone(),
+					})
+					.collect(),
+				outcome: match (receipt.status, receipt.root) {
+					(Some(status), None) => SubstrateEthereumTransactionOutcome::StatusCode(status.as_u64() as u8),
+					(None, Some(root)) => SubstrateEthereumTransactionOutcome::StateRoot(root),
+					_ => SubstrateEthereumTransactionOutcome::Unknown,
+				},
+			})
+			.collect()
+	})
 }