harmonize tokens events with pallet_balances

Signed-off-by: Gregory Hill <[email protected]>

Author: gregdhill

tokens/src/lib.rs

@@ -206,12 +206,21 @@ pub mod module {
 	#[pallet::event]
 	#[pallet::generate_deposit(pub(crate) fn deposit_event)]
 	pub enum Event<T: Config> {
-		/// Token transfer success. \[currency_id, from, to, amount\]
-		Transferred(T::CurrencyId, T::AccountId, T::AccountId, T::Balance),
+		/// An account was created with some free balance. \[currency_id,
+		/// account, free_balance\]
+		Endowed(T::CurrencyId, T::AccountId, T::Balance),
 		/// An account was removed whose balance was non-zero but below
-		/// ExistentialDeposit, resulting in an outright loss. \[account,
-		/// currency_id, amount\]
-		DustLost(T::AccountId, T::CurrencyId, T::Balance),
+		/// ExistentialDeposit, resulting in an outright loss. \[currency_id,
+		/// account, balance\]
+		DustLost(T::CurrencyId, T::AccountId, T::Balance),
+		/// Transfer succeeded. \[currency_id, from, to, value\]
+		Transfer(T::CurrencyId, T::AccountId, T::AccountId, T::Balance),
+		/// Some balance was reserved (moved from free to reserved).
+		/// \[currency_id, who, value\]
+		Reserved(T::CurrencyId, T::AccountId, T::Balance),
+		/// Some balance was unreserved (moved from reserved to free).
+		/// \[currency_id, who, value\]
+		Unreserved(T::CurrencyId, T::AccountId, T::Balance),
 	}
 
 	/// The total issuance of a token type.
@@ -321,7 +330,7 @@ pub mod module {
 			let to = T::Lookup::lookup(dest)?;
 			<Self as MultiCurrency<_>>::transfer(currency_id, &from, &to, amount)?;
 
-			Self::deposit_event(Event::Transferred(currency_id, from, to, amount));
+			Self::deposit_event(Event::Transfer(currency_id, from, to, amount));
 			Ok(().into())
 		}
 
@@ -340,7 +349,7 @@ pub mod module {
 			let balance = <Self as MultiCurrency<T::AccountId>>::free_balance(currency_id, &from);
 			<Self as MultiCurrency<T::AccountId>>::transfer(currency_id, &from, &to, balance)?;
 
-			Self::deposit_event(Event::Transferred(currency_id, from, to, balance));
+			Self::deposit_event(Event::Transfer(currency_id, from, to, balance));
 			Ok(().into())
 		}
 	}
@@ -358,41 +367,47 @@ impl<T: Config> Pallet<T> {
 		f: impl FnOnce(&mut AccountData<T::Balance>, bool) -> sp_std::result::Result<R, E>,
 	) -> sp_std::result::Result<R, E> {
 		Accounts::<T>::try_mutate_exists(who, currency_id, |maybe_account| {
-			let existed = maybe_account.is_some();
+			let is_new = maybe_account.is_some();
 			let mut account = maybe_account.take().unwrap_or_default();
-			f(&mut account, existed).map(move |result| {
-				let mut handle_dust: Option<T::Balance> = None;
+			f(&mut account, is_new).map(move |result| {
+				let maybe_endowed = if is_new { Some(account.free) } else { None };
+
+				let mut maybe_dust: Option<T::Balance> = None;
 				let total = account.total();
 				*maybe_account = if total.is_zero() {
 					None
 				} else {
 					// if non_zero total is below existential deposit and the account is not a
 					// module account, should handle the dust.
 					if total < T::ExistentialDeposits::get(&currency_id) && !Self::is_module_account_id(who) {
-						handle_dust = Some(total);
+						maybe_dust = Some(total);
 					}
 					Some(account)
 				};
 
-				(existed, maybe_account.is_some(), handle_dust, result)
+				(maybe_endowed, maybe_account.is_some(), maybe_dust, result)
 			})
 		})
-		.map(|(existed, exists, handle_dust, result)| {
-			if existed && !exists {
+		.map(|(maybe_endowed, exists, maybe_dust, result)| {
+			if maybe_endowed.is_some() && !exists {
 				// If existed before, decrease account provider.
-				// Ignore the result, because if it failed means that these’s remain consumers,
-				// and the account storage in frame_system shouldn't be repeaded.
+				// Ignore the result, because if it failed then there are remaining consumers,
+				// and the account storage in frame_system shouldn't be reaped.
 				let _ = frame_system::Pallet::<T>::dec_providers(who);
-			} else if !existed && exists {
+			} else if maybe_endowed.is_none() && exists {
 				// if new, increase account provider
 				frame_system::Pallet::<T>::inc_providers(who);
 			}
 
-			if let Some(dust_amount) = handle_dust {
+			if let Some(endowed) = maybe_endowed {
+				Self::deposit_event(Event::Endowed(currency_id, who.clone(), endowed));
+			}
+
+			if let Some(dust_amount) = maybe_dust {
 				// `OnDust` maybe get/set storage `Accounts` of `who`, trigger handler here
 				// to avoid some unexpected errors.
 				T::OnDust::on_dust(who, currency_id, dust_amount);
-				Self::deposit_event(Event::DustLost(who.clone(), currency_id, dust_amount));
+				Self::deposit_event(Event::DustLost(currency_id, who.clone(), dust_amount));
 			}
 
 			result
@@ -757,6 +772,8 @@ impl<T: Config> MultiReservableCurrency<T::AccountId> for Pallet<T> {
 		// Cannot overflow becuase total issuance is using the same balance type and
 		// this doesn't increase total issuance
 		Self::set_reserved_balance(currency_id, who, account.reserved + value);
+
+		Self::deposit_event(Event::Reserved(currency_id, who.clone(), value));
 		Ok(())
 	}
 
@@ -774,6 +791,7 @@ impl<T: Config> MultiReservableCurrency<T::AccountId> for Pallet<T> {
 		Self::set_reserved_balance(currency_id, who, account.reserved - actual);
 		Self::set_free_balance(currency_id, who, account.free + actual);
 
+		Self::deposit_event(Event::Unreserved(currency_id, who.clone(), actual.clone()));
 		value - actual
 	}
 

tokens/src/tests.rs

@@ -62,7 +62,7 @@ fn remove_dust_work() {
 		assert_eq!(Tokens::free_balance(DOT, &DustAccount::get()), 1);
 		assert_eq!(System::providers(&DustAccount::get()), 1);
 
-		System::assert_last_event(Event::tokens(crate::Event::DustLost(ALICE, DOT, 1)));
+		System::assert_last_event(Event::tokens(crate::Event::DustLost(1, ALICE, DOT)));
 	});
 }
 
@@ -305,7 +305,7 @@ fn transfer_should_work() {
 			assert_eq!(Tokens::free_balance(DOT, &BOB), 150);
 			assert_eq!(Tokens::total_issuance(DOT), 200);
 
-			System::assert_last_event(Event::tokens(crate::Event::Transferred(DOT, ALICE, BOB, 50)));
+			System::assert_last_event(Event::tokens(crate::Event::Transfer(DOT, ALICE, BOB, 50)));
 
 			assert_noop!(
 				Tokens::transfer(Some(ALICE).into(), BOB, DOT, 60),