extend named reservable

Author: stanly-johnson

tokens/src/tests.rs

@@ -1773,6 +1773,94 @@ fn slashed_reserved_named_works() {
 		});
 }
 
+#[test]
+fn named_multi_reservable_ensure_named_reserved_works() {
+	ExtBuilder::default()
+		.balances(vec![(ALICE, DOT, 100)])
+		.build()
+		.execute_with(|| {
+			assert_ok!(Tokens::reserve_named(&RID_1, DOT, &ALICE, 50));
+			assert_eq!(Tokens::free_balance(DOT, &ALICE), 50);
+			assert_eq!(Tokens::reserved_balance_named(&RID_1, DOT, &ALICE), 50);
+			assert_eq!(Tokens::total_issuance(DOT), 100);
+
+			assert_ok!(Tokens::ensure_reserved_named(&RID_1, DOT, &ALICE, 20));
+			assert_ok!(Tokens::ensure_reserved_named(&RID_1, DOT, &ALICE, 70));
+
+			assert_eq!(Tokens::free_balance(DOT, &ALICE), 30);
+			assert_eq!(Tokens::reserved_balance_named(&RID_1, DOT, &ALICE), 70);
+		});
+}
+
+#[test]
+fn named_multi_reservable_unreserve_all_named() {
+	ExtBuilder::default()
+		.balances(vec![(ALICE, DOT, 100)])
+		.build()
+		.execute_with(|| {
+			assert_ok!(Tokens::reserve_named(&RID_1, DOT, &ALICE, 50));
+			assert_ok!(Tokens::reserve_named(&RID_1, DOT, &ALICE, 20));
+			assert_eq!(Tokens::free_balance(DOT, &ALICE), 30);
+			assert_eq!(Tokens::reserved_balance_named(&RID_1, DOT, &ALICE), 70);
+
+			let value = Tokens::unreserve_all_named(&RID_1, DOT, &ALICE);
+			assert!(value == 70);
+
+			assert_eq!(Tokens::free_balance(DOT, &ALICE), 100);
+			assert_eq!(Tokens::reserved_balance_named(&RID_1, DOT, &ALICE), 0);
+		});
+}
+
+#[test]
+fn named_multi_reservable_slash_all_reserved_named() {
+	ExtBuilder::default()
+		.balances(vec![(ALICE, DOT, 100)])
+		.build()
+		.execute_with(|| {
+			assert_ok!(Tokens::reserve_named(&RID_1, DOT, &ALICE, 50));
+			assert_eq!(Tokens::free_balance(DOT, &ALICE), 50);
+			assert_eq!(Tokens::reserved_balance_named(&RID_1, DOT, &ALICE), 50);
+
+			let value = Tokens::slash_all_reserved_named(&RID_1, DOT, &ALICE);
+			assert!(value == 0);
+
+			assert_eq!(Tokens::free_balance(DOT, &ALICE), 50);
+			assert_eq!(Tokens::reserved_balance_named(&RID_1, DOT, &ALICE), 0);
+		});
+}
+
+#[test]
+fn named_multi_reservable_repatriate_all_reserved_named_works() {
+	ExtBuilder::default()
+		.balances(vec![(ALICE, DOT, 100), (BOB, DOT, 100)])
+		.build()
+		.execute_with(|| {
+			assert_eq!(Tokens::free_balance(DOT, &ALICE), 100);
+			assert_eq!(Tokens::reserved_balance_named(&RID_1, DOT, &ALICE), 0);
+			assert_eq!(Tokens::reserved_balance_named(&RID_1, DOT, &BOB), 0);
+			assert_ok!(Tokens::reserve_named(&RID_1, DOT, &ALICE, 50));
+
+			assert_ok!(Tokens::repatriate_all_reserved_named(
+				&RID_1,
+				DOT,
+				&ALICE,
+				&BOB,
+				BalanceStatus::Reserved
+			));
+
+			assert_eq!(Tokens::free_balance(DOT, &BOB), 100);
+			assert_eq!(Tokens::reserved_balance_named(&RID_1, DOT, &BOB), 50);
+
+			System::assert_last_event(Event::Tokens(crate::Event::ReserveRepatriated {
+				currency_id: DOT,
+				from: ALICE,
+				to: BOB,
+				amount: 50,
+				status: BalanceStatus::Reserved,
+			}));
+		});
+}
+
 // *************************************************
 // tests for CurrencyAdapter
 // *************************************************

traits/src/currency.rs

@@ -288,6 +288,76 @@ pub trait NamedMultiReservableCurrency<AccountId>: MultiReservableCurrency<Accou
 		value: Self::Balance,
 		status: BalanceStatus,
 	) -> result::Result<Self::Balance, DispatchError>;
+
+	/// Ensure the reserved balance is equal to `value`.
+	///
+	/// This will reserve extra amount of current reserved balance is less than
+	/// `value`. And unreserve if current reserved balance is greater than
+	/// `value`.
+	fn ensure_reserved_named(
+		id: &Self::ReserveIdentifier,
+		currency_id: Self::CurrencyId,
+		who: &AccountId,
+		value: Self::Balance,
+	) -> DispatchResult {
+		let current = Self::reserved_balance_named(id, currency_id, who);
+		if current > value {
+			// we always have enough balance to unreserve here
+			Self::unreserve_named(id, currency_id, who, current - value);
+			Ok(())
+		} else if value > current {
+			// we checked value > current
+			Self::reserve_named(id, currency_id, who, value - current)
+		} else {
+			// current == value
+			Ok(())
+		}
+	}
+
+	/// Unreserve all the named reserved balances, returning unreserved amount.
+	///
+	/// Is a no-op if the value to be unreserved is zero.
+	fn unreserve_all_named(
+		id: &Self::ReserveIdentifier,
+		currency_id: Self::CurrencyId,
+		who: &AccountId,
+	) -> Self::Balance {
+		let value = Self::reserved_balance_named(id, currency_id, who);
+		Self::unreserve_named(id, currency_id, who, value);
+		value
+	}
+
+	/// Slash all the reserved balance, returning the negative imbalance
+	/// created.
+	///
+	/// Is a no-op if the value to be slashed is zero.
+	fn slash_all_reserved_named(
+		id: &Self::ReserveIdentifier,
+		currency_id: Self::CurrencyId,
+		who: &AccountId,
+	) -> Self::Balance {
+		let value = Self::reserved_balance_named(id, currency_id, who);
+		Self::slash_reserved_named(id, currency_id, who, value)
+	}
+
+	/// Move all the named reserved balance of one account into the balance of
+	/// another, according to `status`. If `status` is `Reserved`, the balance
+	/// will be reserved with given `id`.
+	///
+	/// Is a no-op if:
+	/// - the value to be moved is zero; or
+	/// - the `slashed` id equal to `beneficiary` and the `status` is
+	///   `Reserved`.
+	fn repatriate_all_reserved_named(
+		id: &Self::ReserveIdentifier,
+		currency_id: Self::CurrencyId,
+		slashed: &AccountId,
+		beneficiary: &AccountId,
+		status: BalanceStatus,
+	) -> DispatchResult {
+		let value = Self::reserved_balance_named(id, currency_id, slashed);
+		Self::repatriate_reserved_named(id, currency_id, slashed, beneficiary, value, status).map(|_| ())
+	}
 }
 
 /// Abstraction over a fungible (single) currency system.