Apply fmt

humanode-network · Feb 7, 2025 · dba0d19 · dba0d19
1 parent 918930e
commit dba0d19
Show file tree

Hide file tree

Showing 12 changed files with 2,927 additions and 2,958 deletions.
diff --git a/crates/pallet-evm-balances/src/account_data.rs b/crates/pallet-evm-balances/src/account_data.rs
@@ -5,62 +5,42 @@ use frame_support::traits::WithdrawReasons;
 use super::*;
 
 /// All balance information for an account.
-#[derive(
-	Encode,
-	Decode,
-	Clone,
-	PartialEq,
-	Eq,
-	Default,
-	RuntimeDebug,
-	MaxEncodedLen,
-	TypeInfo
-)]
+#[derive(Encode, Decode, Clone, PartialEq, Eq, Default, RuntimeDebug, MaxEncodedLen, TypeInfo)]
 pub struct AccountData<Balance> {
-	/// Non-reserved part of the balance. There may still be restrictions on this, but it is the
-	/// total pool what may in principle be transferred, reserved and used for tipping.
-	///
-	/// This is the only balance that matters in terms of most operations on tokens. It
-	/// alone is used to determine the balance when in the contract execution environment.
-	pub free: Balance,
+    /// Non-reserved part of the balance. There may still be restrictions on this, but it is the
+    /// total pool what may in principle be transferred, reserved and used for tipping.
+    ///
+    /// This is the only balance that matters in terms of most operations on tokens. It
+    /// alone is used to determine the balance when in the contract execution environment.
+    pub free: Balance,
 }
 
 impl<Balance: Copy> AccountData<Balance> {
-	/// The total balance in this account.
-	pub(crate) fn total(&self) -> Balance {
-		self.free
-	}
+    /// The total balance in this account.
+    pub(crate) fn total(&self) -> Balance {
+        self.free
+    }
 }
 
 /// Simplified reasons for withdrawing balance.
-#[derive(
-	Encode,
-	Decode,
-	Clone,
-	Copy,
-	PartialEq,
-	Eq,
-	RuntimeDebug,
-	MaxEncodedLen,
-	TypeInfo
-)]
+#[derive(Encode, Decode, Clone, Copy, PartialEq, Eq, RuntimeDebug, MaxEncodedLen, TypeInfo)]
 pub enum Reasons {
-	/// Paying system transaction fees.
-	Fee = 0,
-	/// Any reason other than paying system transaction fees.
-	Misc = 1,
-	/// Any reason at all.
-	All = 2,
+    /// Paying system transaction fees.
+    Fee = 0,
+    /// Any reason other than paying system transaction fees.
+    Misc = 1,
+    /// Any reason at all.
+    All = 2,
 }
 
 impl From<WithdrawReasons> for Reasons {
-	fn from(r: WithdrawReasons) -> Reasons {
-		if r == WithdrawReasons::TRANSACTION_PAYMENT {
-			Reasons::Fee
-		} else if r.contains(WithdrawReasons::TRANSACTION_PAYMENT) {
-			Reasons::All
-		} else {
-			Reasons::Misc
-		}
-	}
+    fn from(r: WithdrawReasons) -> Reasons {
+        if r == WithdrawReasons::TRANSACTION_PAYMENT {
+            Reasons::Fee
+        } else if r.contains(WithdrawReasons::TRANSACTION_PAYMENT) {
+            Reasons::All
+        } else {
+            Reasons::Misc
+        }
+    }
 }
diff --git a/crates/pallet-evm-balances/src/imbalances.rs b/crates/pallet-evm-balances/src/imbalances.rs
@@ -12,10 +12,10 @@ use super::*;
 pub struct PositiveImbalance<T: Config<I>, I: 'static = ()>(T::Balance);
 
 impl<T: Config<I>, I: 'static> PositiveImbalance<T, I> {
-	/// Create a new positive imbalance from a balance.
-	pub fn new(amount: T::Balance) -> Self {
-		PositiveImbalance(amount)
-	}
+    /// Create a new positive imbalance from a balance.
+    pub fn new(amount: T::Balance) -> Self {
+        PositiveImbalance(amount)
+    }
 }
 
 /// Opaque, move-only struct with private fields that serves as a token denoting that
@@ -25,148 +25,148 @@ impl<T: Config<I>, I: 'static> PositiveImbalance<T, I> {
 pub struct NegativeImbalance<T: Config<I>, I: 'static = ()>(T::Balance);
 
 impl<T: Config<I>, I: 'static> NegativeImbalance<T, I> {
-	/// Create a new negative imbalance from a balance.
-	pub fn new(amount: T::Balance) -> Self {
-		NegativeImbalance(amount)
-	}
+    /// Create a new negative imbalance from a balance.
+    pub fn new(amount: T::Balance) -> Self {
+        NegativeImbalance(amount)
+    }
 }
 
 impl<T: Config<I>, I: 'static> TryDrop for PositiveImbalance<T, I> {
-	fn try_drop(self) -> result::Result<(), Self> {
-		self.drop_zero()
-	}
+    fn try_drop(self) -> result::Result<(), Self> {
+        self.drop_zero()
+    }
 }
 
 impl<T: Config<I>, I: 'static> Default for PositiveImbalance<T, I> {
-	fn default() -> Self {
-		Self::zero()
-	}
+    fn default() -> Self {
+        Self::zero()
+    }
 }
 
 impl<T: Config<I>, I: 'static> Imbalance<T::Balance> for PositiveImbalance<T, I> {
-	type Opposite = NegativeImbalance<T, I>;
-
-	fn zero() -> Self {
-		Self(Zero::zero())
-	}
-
-	fn drop_zero(self) -> result::Result<(), Self> {
-		if self.0.is_zero() {
-			Ok(())
-		} else {
-			Err(self)
-		}
-	}
-
-	fn split(self, amount: T::Balance) -> (Self, Self) {
-		let first = self.0.min(amount);
-		let second = self.0 - first;
-
-		mem::forget(self);
-		(Self(first), Self(second))
-	}
-
-	fn merge(mut self, other: Self) -> Self {
-		self.0 = self.0.saturating_add(other.0);
-		mem::forget(other);
-
-		self
-	}
-
-	fn subsume(&mut self, other: Self) {
-		self.0 = self.0.saturating_add(other.0);
-		mem::forget(other);
-	}
-
-	fn offset(self, other: Self::Opposite) -> SameOrOther<Self, Self::Opposite> {
-		let (a, b) = (self.0, other.0);
-		mem::forget((self, other));
-
-		match a.cmp(&b) {
-			Ordering::Greater => SameOrOther::Same(Self(a - b)),
-			Ordering::Less => SameOrOther::Other(NegativeImbalance::new(b - a)),
-			Ordering::Equal => SameOrOther::None,
-		}
-	}
-
-	fn peek(&self) -> T::Balance {
-		self.0
-	}
+    type Opposite = NegativeImbalance<T, I>;
+
+    fn zero() -> Self {
+        Self(Zero::zero())
+    }
+
+    fn drop_zero(self) -> result::Result<(), Self> {
+        if self.0.is_zero() {
+            Ok(())
+        } else {
+            Err(self)
+        }
+    }
+
+    fn split(self, amount: T::Balance) -> (Self, Self) {
+        let first = self.0.min(amount);
+        let second = self.0 - first;
+
+        mem::forget(self);
+        (Self(first), Self(second))
+    }
+
+    fn merge(mut self, other: Self) -> Self {
+        self.0 = self.0.saturating_add(other.0);
+        mem::forget(other);
+
+        self
+    }
+
+    fn subsume(&mut self, other: Self) {
+        self.0 = self.0.saturating_add(other.0);
+        mem::forget(other);
+    }
+
+    fn offset(self, other: Self::Opposite) -> SameOrOther<Self, Self::Opposite> {
+        let (a, b) = (self.0, other.0);
+        mem::forget((self, other));
+
+        match a.cmp(&b) {
+            Ordering::Greater => SameOrOther::Same(Self(a - b)),
+            Ordering::Less => SameOrOther::Other(NegativeImbalance::new(b - a)),
+            Ordering::Equal => SameOrOther::None,
+        }
+    }
+
+    fn peek(&self) -> T::Balance {
+        self.0
+    }
 }
 
 impl<T: Config<I>, I: 'static> TryDrop for NegativeImbalance<T, I> {
-	fn try_drop(self) -> result::Result<(), Self> {
-		self.drop_zero()
-	}
+    fn try_drop(self) -> result::Result<(), Self> {
+        self.drop_zero()
+    }
 }
 
 impl<T: Config<I>, I: 'static> Default for NegativeImbalance<T, I> {
-	fn default() -> Self {
-		Self::zero()
-	}
+    fn default() -> Self {
+        Self::zero()
+    }
 }
 
 impl<T: Config<I>, I: 'static> Imbalance<T::Balance> for NegativeImbalance<T, I> {
-	type Opposite = PositiveImbalance<T, I>;
-
-	fn zero() -> Self {
-		Self(Zero::zero())
-	}
-
-	fn drop_zero(self) -> result::Result<(), Self> {
-		if self.0.is_zero() {
-			Ok(())
-		} else {
-			Err(self)
-		}
-	}
-
-	fn split(self, amount: T::Balance) -> (Self, Self) {
-		let first = self.0.min(amount);
-		let second = self.0 - first;
-
-		mem::forget(self);
-		(Self(first), Self(second))
-	}
-
-	fn merge(mut self, other: Self) -> Self {
-		self.0 = self.0.saturating_add(other.0);
-		mem::forget(other);
-
-		self
-	}
-
-	fn subsume(&mut self, other: Self) {
-		self.0 = self.0.saturating_add(other.0);
-		mem::forget(other);
-	}
-
-	fn offset(self, other: Self::Opposite) -> SameOrOther<Self, Self::Opposite> {
-		let (a, b) = (self.0, other.0);
-		mem::forget((self, other));
-
-		match a.cmp(&b) {
-			Ordering::Greater => SameOrOther::Same(Self(a - b)),
-			Ordering::Less => SameOrOther::Other(PositiveImbalance::new(b - a)),
-			Ordering::Equal => SameOrOther::None,
-		}
-	}
-
-	fn peek(&self) -> T::Balance {
-		self.0
-	}
+    type Opposite = PositiveImbalance<T, I>;
+
+    fn zero() -> Self {
+        Self(Zero::zero())
+    }
+
+    fn drop_zero(self) -> result::Result<(), Self> {
+        if self.0.is_zero() {
+            Ok(())
+        } else {
+            Err(self)
+        }
+    }
+
+    fn split(self, amount: T::Balance) -> (Self, Self) {
+        let first = self.0.min(amount);
+        let second = self.0 - first;
+
+        mem::forget(self);
+        (Self(first), Self(second))
+    }
+
+    fn merge(mut self, other: Self) -> Self {
+        self.0 = self.0.saturating_add(other.0);
+        mem::forget(other);
+
+        self
+    }
+
+    fn subsume(&mut self, other: Self) {
+        self.0 = self.0.saturating_add(other.0);
+        mem::forget(other);
+    }
+
+    fn offset(self, other: Self::Opposite) -> SameOrOther<Self, Self::Opposite> {
+        let (a, b) = (self.0, other.0);
+        mem::forget((self, other));
+
+        match a.cmp(&b) {
+            Ordering::Greater => SameOrOther::Same(Self(a - b)),
+            Ordering::Less => SameOrOther::Other(PositiveImbalance::new(b - a)),
+            Ordering::Equal => SameOrOther::None,
+        }
+    }
+
+    fn peek(&self) -> T::Balance {
+        self.0
+    }
 }
 
 impl<T: Config<I>, I: 'static> Drop for PositiveImbalance<T, I> {
-	/// Basic drop handler will just square up the total issuance.
-	fn drop(&mut self) {
-		TotalIssuance::<T, I>::mutate(|v| *v = v.saturating_add(self.0));
-	}
+    /// Basic drop handler will just square up the total issuance.
+    fn drop(&mut self) {
+        TotalIssuance::<T, I>::mutate(|v| *v = v.saturating_add(self.0));
+    }
 }
 
 impl<T: Config<I>, I: 'static> Drop for NegativeImbalance<T, I> {
-	/// Basic drop handler will just square up the total issuance.
-	fn drop(&mut self) {
-		TotalIssuance::<T, I>::mutate(|v| *v = v.saturating_sub(self.0));
-	}
+    /// Basic drop handler will just square up the total issuance.
+    fn drop(&mut self) {
+        TotalIssuance::<T, I>::mutate(|v| *v = v.saturating_sub(self.0));
+    }
 }