temporarily remove balance guard (#2121)

bridges/relays/client-substrate/src/guard.rs

@@ -20,10 +20,8 @@
 use crate::{error::Error, Chain, ChainWithBalances, Client};
 
 use async_trait::async_trait;
-use num_traits::CheckedSub;
 use sp_version::RuntimeVersion;
 use std::{
-	collections::VecDeque,
 	fmt::Display,
 	time::{Duration, Instant},
 };
@@ -36,11 +34,6 @@ pub trait Environment<C: ChainWithBalances>: Send + Sync + 'static {
 
 	/// Return current runtime version.
 	async fn runtime_version(&mut self) -> Result<RuntimeVersion, Self::Error>;
-	/// Return free native balance of the account on the chain.
-	async fn free_native_balance(
-		&mut self,
-		account: C::AccountId,
-	) -> Result<C::Balance, Self::Error>;
 
 	/// Return current time.
 	fn now(&self) -> Instant {
@@ -99,80 +92,6 @@ pub fn abort_on_spec_version_change<C: ChainWithBalances>(
 	});
 }
 
-/// Abort if, during 24 hours, free balance of given account is decreased at least by given value.
-/// Other components may increase (or decrease) balance of account and it WILL affect logic of the
-/// guard.
-pub fn abort_when_account_balance_decreased<C: ChainWithBalances>(
-	mut env: impl Environment<C>,
-	account_id: C::AccountId,
-	maximal_decrease: C::Balance,
-) {
-	const DAY: Duration = Duration::from_secs(60 * 60 * 24);
-
-	async_std::task::spawn(async move {
-		log::info!(
-			target: "bridge-guard",
-			"Starting balance guard for {}/{:?}. Maximal decrease: {:?}",
-			C::NAME,
-			account_id,
-			maximal_decrease,
-		);
-
-		let mut balances = VecDeque::new();
-
-		loop {
-			let current_time = env.now();
-
-			// remember balances that are beyound 24h border
-			if let Some(time_border) = current_time.checked_sub(DAY) {
-				while balances.front().map(|(time, _)| *time < time_border).unwrap_or(false) {
-					balances.pop_front();
-				}
-			}
-
-			// read balance of the account
-			let current_balance = env.free_native_balance(account_id.clone()).await;
-
-			// remember balance and check difference
-			match current_balance {
-				Ok(current_balance) => {
-					// remember balance
-					balances.push_back((current_time, current_balance));
-
-					// check if difference between current and oldest balance is too large
-					let (oldest_time, oldest_balance) =
-						balances.front().expect("pushed to queue couple of lines above; qed");
-					let balances_difference = oldest_balance.checked_sub(&current_balance);
-					if balances_difference > Some(maximal_decrease) {
-						log::error!(
-							target: "bridge-guard",
-							"Balance of {} account {:?} has decreased from {:?} to {:?} in {} minutes. Aborting relay",
-							C::NAME,
-							account_id,
-							oldest_balance,
-							current_balance,
-							current_time.duration_since(*oldest_time).as_secs() / 60,
-						);
-
-						env.abort().await;
-					}
-				},
-				Err(error) => {
-					log::warn!(
-						target: "bridge-guard",
-						"Failed to read {} account {:?} balance: {}. Relay may need to be stopped manually",
-						C::NAME,
-						account_id,
-						error,
-					);
-				},
-			};
-
-			env.sleep(conditions_check_delay::<C>()).await;
-		}
-	});
-}
-
 /// Delay between conditions check.
 fn conditions_check_delay<C: Chain>() -> Duration {
 	C::AVERAGE_BLOCK_INTERVAL * (10 + rand::random::<u32>() % 10)
@@ -185,13 +104,6 @@ impl<C: ChainWithBalances> Environment<C> for Client<C> {
 	async fn runtime_version(&mut self) -> Result<RuntimeVersion, Self::Error> {
 		Client::<C>::runtime_version(self).await
 	}
-
-	async fn free_native_balance(
-		&mut self,
-		account: C::AccountId,
-	) -> Result<C::Balance, Self::Error> {
-		Client::<C>::free_native_balance(self, account).await
-	}
 }
 
 #[cfg(test)]
@@ -207,7 +119,6 @@ mod tests {
 
 	struct TestEnvironment {
 		runtime_version_rx: UnboundedReceiver<RuntimeVersion>,
-		free_native_balance_rx: UnboundedReceiver<u32>,
 		slept_tx: UnboundedSender<()>,
 		aborted_tx: UnboundedSender<()>,
 	}
@@ -220,10 +131,6 @@ mod tests {
 			Ok(self.runtime_version_rx.next().await.unwrap_or_default())
 		}
 
-		async fn free_native_balance(&mut self, _account: u32) -> Result<u32, Self::Error> {
-			Ok(self.free_native_balance_rx.next().await.unwrap_or_default())
-		}
-
 		async fn sleep(&mut self, _duration: Duration) {
 			let _ = self.slept_tx.send(()).await;
 		}
@@ -240,17 +147,11 @@ mod tests {
 		async_std::task::block_on(async {
 			let (
 				(mut runtime_version_tx, runtime_version_rx),
-				(_free_native_balance_tx, free_native_balance_rx),
 				(slept_tx, mut slept_rx),
 				(aborted_tx, mut aborted_rx),
-			) = (unbounded(), unbounded(), unbounded(), unbounded());
+			) = (unbounded(), unbounded(), unbounded());
 			abort_on_spec_version_change(
-				TestEnvironment {
-					runtime_version_rx,
-					free_native_balance_rx,
-					slept_tx,
-					aborted_tx,
-				},
+				TestEnvironment { runtime_version_rx, slept_tx, aborted_tx },
 				0,
 			);
 
@@ -272,17 +173,11 @@ mod tests {
 		async_std::task::block_on(async {
 			let (
 				(mut runtime_version_tx, runtime_version_rx),
-				(_free_native_balance_tx, free_native_balance_rx),
 				(slept_tx, mut slept_rx),
 				(aborted_tx, mut aborted_rx),
-			) = (unbounded(), unbounded(), unbounded(), unbounded());
+			) = (unbounded(), unbounded(), unbounded());
 			abort_on_spec_version_change(
-				TestEnvironment {
-					runtime_version_rx,
-					free_native_balance_rx,
-					slept_tx,
-					aborted_tx,
-				},
+				TestEnvironment { runtime_version_rx, slept_tx, aborted_tx },
 				42,
 			);
 
@@ -298,76 +193,4 @@ mod tests {
 			assert!(aborted_rx.next().now_or_never().is_none());
 		});
 	}
-
-	#[test]
-	fn aborts_when_balance_is_too_low() {
-		async_std::task::block_on(async {
-			let (
-				(_runtime_version_tx, runtime_version_rx),
-				(mut free_native_balance_tx, free_native_balance_rx),
-				(slept_tx, mut slept_rx),
-				(aborted_tx, mut aborted_rx),
-			) = (unbounded(), unbounded(), unbounded(), unbounded());
-			abort_when_account_balance_decreased(
-				TestEnvironment {
-					runtime_version_rx,
-					free_native_balance_rx,
-					slept_tx,
-					aborted_tx,
-				},
-				0,
-				100,
-			);
-
-			// client responds with initial balance
-			free_native_balance_tx.send(1000).await.unwrap();
-
-			// then the guard sleeps
-			slept_rx.next().await;
-
-			// and then client responds with updated balance, which is too low
-			free_native_balance_tx.send(899).await.unwrap();
-
-			// then the `abort` function is called
-			aborted_rx.next().await;
-			// and we do not reach next `sleep` function call
-			assert!(slept_rx.next().now_or_never().is_none());
-		});
-	}
-
-	#[test]
-	fn does_not_aborts_when_balance_is_enough() {
-		async_std::task::block_on(async {
-			let (
-				(_runtime_version_tx, runtime_version_rx),
-				(mut free_native_balance_tx, free_native_balance_rx),
-				(slept_tx, mut slept_rx),
-				(aborted_tx, mut aborted_rx),
-			) = (unbounded(), unbounded(), unbounded(), unbounded());
-			abort_when_account_balance_decreased(
-				TestEnvironment {
-					runtime_version_rx,
-					free_native_balance_rx,
-					slept_tx,
-					aborted_tx,
-				},
-				0,
-				100,
-			);
-
-			// client responds with initial balance
-			free_native_balance_tx.send(1000).await.unwrap();
-
-			// then the guard sleeps
-			slept_rx.next().await;
-
-			// and then client responds with updated balance, which is enough
-			free_native_balance_tx.send(950).await.unwrap();
-
-			// then the `sleep` function is called
-			slept_rx.next().await;
-			// and `abort` is not called
-			assert!(aborted_rx.next().now_or_never().is_none());
-		});
-	}
 }