Named reserve

bin/node-template/runtime/src/lib.rs

@@ -232,6 +232,7 @@ parameter_types! {
 
 impl pallet_balances::Config for Runtime {
 	type MaxLocks = MaxLocks;
+	type MaxReserves = ();
 	/// The type for recording an account's balance.
 	type Balance = Balance;
 	/// The ubiquitous event type.

bin/node/runtime/src/lib.rs

@@ -361,10 +361,12 @@ parameter_types! {
 	// For weight estimation, we assume that the most locks on an individual account will be 50.
 	// This number may need to be adjusted in the future if this assumption no longer holds true.
 	pub const MaxLocks: u32 = 50;
+	pub const MaxReserves: u32 = 50;
 }
 
 impl pallet_balances::Config for Runtime {
 	type MaxLocks = MaxLocks;
+	type MaxReserves = MaxReserves;
 	type Balance = Balance;
 	type DustRemoval = ();
 	type Event = Event;

frame/assets/src/lib.rs

@@ -961,6 +961,7 @@ mod tests {
 
 	impl pallet_balances::Config for Test {
 		type MaxLocks = ();
+		type MaxReserves = ();
 		type Balance = u64;
 		type DustRemoval = ();
 		type Event = Event;

frame/atomic-swap/src/tests.rs

@@ -49,6 +49,7 @@ parameter_types! {
 }
 impl pallet_balances::Config for Test {
 	type MaxLocks = ();
+	type MaxReserves = ();
 	type Balance = u64;
 	type DustRemoval = ();
 	type Event = ();

frame/babe/src/mock.rs

@@ -149,6 +149,7 @@ parameter_types! {
 
 impl pallet_balances::Config for Test {
 	type MaxLocks = ();
+	type MaxReserves = ();
 	type Balance = u128;
 	type DustRemoval = ();
 	type Event = ();

frame/balances/src/lib.rs

@@ -166,6 +166,7 @@ use frame_support::{
 		WithdrawReasons, LockIdentifier, LockableCurrency, ExistenceRequirement,
 		Imbalance, SignedImbalance, ReservableCurrency, Get, ExistenceRequirement::KeepAlive,
 		ExistenceRequirement::AllowDeath, IsDeadAccount, BalanceStatus as Status,
+		ReserveIdentifier, NamedReservableCurrency,
 	}
 };
 use sp_runtime::{
@@ -196,6 +197,9 @@ pub trait Subtrait<I: Instance = DefaultInstance>: frame_system::Config {
 	/// The maximum number of locks that should exist on an account.
 	/// Not strictly enforced, but used for weight estimation.
 	type MaxLocks: Get<u32>;
+
+	/// The maximum number of named reserves that can exist on an account.
+	type MaxReserves: Get<u32>;
 }
 
 pub trait Config<I: Instance = DefaultInstance>: frame_system::Config {
@@ -221,6 +225,9 @@ pub trait Config<I: Instance = DefaultInstance>: frame_system::Config {
 	/// The maximum number of locks that should exist on an account.
 	/// Not strictly enforced, but used for weight estimation.
 	type MaxLocks: Get<u32>;
+
+	/// The maximum number of named reserves that can exist on an account.
+	type MaxReserves: Get<u32>;
 }
 
 impl<T: Config<I>, I: Instance> Subtrait<I> for T {
@@ -229,6 +236,7 @@ impl<T: Config<I>, I: Instance> Subtrait<I> for T {
 	type AccountStore = T::AccountStore;
 	type WeightInfo = <T as Config<I>>::WeightInfo;
 	type MaxLocks = T::MaxLocks;
+	type MaxReserves = T::MaxReserves;
 }
 
 decl_event!(
@@ -276,6 +284,8 @@ decl_error! {
 		ExistingVestingSchedule,
 		/// Beneficiary account must pre-exist
 		DeadAccount,
+		/// Number of named reserves exceed MaxReserves
+		TooManyReserves,
 	}
 }
 
@@ -322,6 +332,12 @@ pub struct BalanceLock<Balance> {
 	pub reasons: Reasons,
 }
 
+#[derive(Encode, Decode, Clone, PartialEq, Eq, RuntimeDebug)]
+pub struct ReserveData<Balance> {
+	pub id: ReserveIdentifier,
+	pub amount: Balance,
+}
+
 /// All balance information for an account.
 #[derive(Encode, Decode, Clone, PartialEq, Eq, Default, RuntimeDebug)]
 pub struct AccountData<Balance> {
@@ -397,6 +413,8 @@ decl_storage! {
 		/// NOTE: Should only be accessed when setting, changing and freeing a lock.
 		pub Locks get(fn locks): map hasher(blake2_128_concat) T::AccountId => Vec<BalanceLock<T::Balance>>;
 
+		pub Reserves get(fn reserves): map hasher(blake2_128_concat) T::AccountId => Vec<ReserveData<T::Balance>>;
+
 		/// Storage version of the pallet.
 		///
 		/// This is set to v2.0.0 for new networks.
@@ -1222,6 +1240,193 @@ impl<T: Config<I>, I: Instance> ReservableCurrency<T::AccountId> for Module<T, I
 	}
 }
 
+impl<T: Config<I>, I: Instance> NamedReservableCurrency<T::AccountId> for Module<T, I>  where
+	T::Balance: MaybeSerializeDeserialize + Debug
+{
+	fn reserved_balance_named(id: &ReserveIdentifier, who: &T::AccountId) -> Self::Balance {
+		let reserves = Self::reserves(who);
+		reserves
+			.binary_search_by_key(id, |data| data.id)
+			.map(|idx| reserves[idx].amount)
+			.unwrap_or_default()
+	}
+
+	/// Move `value` from the free balance from `who` to their reserved balance.
+	///
+	/// Is a no-op if value to be reserved is zero.
+	fn reserve_named(id: &ReserveIdentifier, who: &T::AccountId, value: Self::Balance) -> DispatchResult {
+		<Self as ReservableCurrency<_>>::reserve(who, value)?;
+		Reserves::<T, I>::try_mutate(who, |reserves| -> DispatchResult {
+			match reserves.binary_search_by_key(id, |data| data.id) {
+				Ok(idx) => {
+					// this add can't overflow but just to be defensive.
+					reserves[idx].amount = reserves[idx].amount.saturating_add(value);
+				},
+				Err(idx) => {
+					ensure!((reserves.len() as u32) < T::MaxReserves::get(), Error::<T, I>::TooManyReserves);
+					reserves.insert(idx, ReserveData {
+						id: id.clone(),
+						amount: value
+					});
+				},
+			};
+			Ok(())
+		})
+	}
+
+	/// Unreserve some funds, returning any amount that was unable to be unreserved.
+	///
+	/// Is a no-op if the value to be unreserved is zero.
+	fn unreserve_named(id: &ReserveIdentifier, who: &T::AccountId, value: Self::Balance) -> Self::Balance {
+		if value.is_zero() { return Zero::zero() }
+
+		Reserves::<T, I>::mutate_exists(who, |maybe_reserves| -> Self::Balance {
+			if let Some(reserves) = maybe_reserves.as_mut() {
+				match reserves.binary_search_by_key(id, |data| data.id) {
+					Ok(idx) => {
+						let to_change = cmp::min(reserves[idx].amount, value);
+
+						let remain = <Self as ReservableCurrency<_>>::unreserve(who, to_change);
+
+						// remain should always be zero but just to be defensive here
+						let actual = to_change.saturating_sub(remain);
+
+						// `actual <= to_change` and `to_change <= amount`; qed;
+						reserves[idx].amount -= actual;
+
+						if reserves[idx].amount.is_zero() {
+							if reserves.len() == 1 {
+								// no more named reserves
+								*maybe_reserves = None;
+							} else {
+								// remove this named reserve
+								reserves.remove(idx);
+							}
+						}
+
+						value - actual
+					},
+					Err(_) => {
+						value
+					},
+				}
+			} else {
+				value
+			}
+		})
+	}
+
+	/// Slash from reserved balance, returning the negative imbalance created,
+	/// and any amount that was unable to be slashed.
+	///
+	/// Is a no-op if the value to be slashed is zero.
+	fn slash_reserved_named(
+		id: &ReserveIdentifier,
+		who: &T::AccountId,
+		value: Self::Balance
+	) -> (Self::NegativeImbalance, Self::Balance) {
+		if value.is_zero() { return (NegativeImbalance::zero(), Zero::zero()) }
+
+		Reserves::<T, I>::mutate(who, |reserves| -> (Self::NegativeImbalance, Self::Balance) {
+			match reserves.binary_search_by_key(id, |data| data.id) {
+				Ok(idx) => {
+					let to_change = cmp::min(reserves[idx].amount, value);
+
+					let (imb, remain) = <Self as ReservableCurrency<_>>::slash_reserved(who, to_change);
+
+					// remain should always be zero but just to be defensive here
+					let actual = to_change.saturating_sub(remain);
+
+					// `actual <= to_change` and `to_change <= amount`; qed;
+					reserves[idx].amount -= actual;
+
+					(imb, value - actual)
+				},
+				Err(_) => {
+					(NegativeImbalance::zero(), value)
+				},
+			}
+		})
+	}
+
+	/// Move the reserved balance of one account into the balance of another, according to `status`.
+	///
+	/// 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_reserved_named(
+		id: &ReserveIdentifier,
+		slashed: &T::AccountId,
+		beneficiary: &T::AccountId,
+		value: Self::Balance,
+		status: Status,
+	) -> Result<Self::Balance, DispatchError> {
+		if value.is_zero() { return Ok(Zero::zero()) }
+
+		if slashed == beneficiary {
+			return match status {
+				Status::Free => Ok(Self::unreserve_named(id, slashed, value)),
+				Status::Reserved => Ok(value.saturating_sub(Self::reserved_balance_named(id, slashed))),
+			};
+		}
+
+		Reserves::<T, I>::try_mutate(slashed, |reserves| -> Result<Self::Balance, DispatchError> {
+			match reserves.binary_search_by_key(id, |data| data.id) {
+				Ok(idx) => {
+					let to_change = cmp::min(reserves[idx].amount, value);
+
+					let actual = if status == Status::Reserved {
+						// make it the reserved under same identifier
+						Reserves::<T, I>::try_mutate(beneficiary, |reserves| -> Result<T::Balance, DispatchError> {
+							match reserves.binary_search_by_key(id, |data| data.id) {
+								Ok(idx) => {
+									let remain = <Self as ReservableCurrency<_>>::repatriate_reserved(slashed, beneficiary, to_change, status)?;
+
+									// remain should always be zero but just to be defensive here
+									let actual = to_change.saturating_sub(remain);
+
+									// this add can't overflow but just to be defensive.
+									reserves[idx].amount = reserves[idx].amount.saturating_add(actual);
+
+									Ok(actual)
+								},
+								Err(idx) => {
+									ensure!((reserves.len() as u32) < T::MaxReserves::get(), Error::<T, I>::TooManyReserves);
+
+									let remain = <Self as ReservableCurrency<_>>::repatriate_reserved(slashed, beneficiary, to_change, status)?;
+
+									// remain should always be zero but just to be defensive here
+									let actual = to_change.saturating_sub(remain);
+
+									reserves.insert(idx, ReserveData {
+										id: id.clone(),
+										amount: actual
+									});
+
+									Ok(actual)
+								},
+							}
+						})?
+					} else {
+						let remain = <Self as ReservableCurrency<_>>::repatriate_reserved(slashed, beneficiary, to_change, status)?;
+
+						// remain should always be zero but just to be defensive here
+						to_change.saturating_sub(remain)
+					};
+
+					// `actual <= to_change` and `to_change <= amount`; qed;
+					reserves[idx].amount -= actual;
+
+					Ok(value - actual)
+				},
+				Err(_) => {
+					Ok(value)
+				},
+			}
+		})
+	}
+}
+
 /// Implement `OnKilledAccount` to remove the local account, if using local account storage.
 ///
 /// NOTE: You probably won't need to use this! This only needs to be "wired in" to System module

frame/balances/src/tests_composite.rs

@@ -96,6 +96,7 @@ impl Config for Test {
 	type ExistentialDeposit = ExistentialDeposit;
 	type AccountStore = system::Module<Test>;
 	type MaxLocks = ();
+	type MaxReserves = ();
 	type WeightInfo = ();
 }
 

frame/balances/src/tests_local.rs

@@ -104,6 +104,7 @@ impl Config for Test {
 		u64, super::AccountData<u64>
 	>;
 	type MaxLocks = MaxLocks;
+	type MaxReserves = ();
 	type WeightInfo = ();
 }
 

frame/bounties/src/tests.rs

@@ -89,6 +89,7 @@ parameter_types! {
 }
 impl pallet_balances::Config for Test {
 	type MaxLocks = ();
+	type MaxReserves = ();
 	type Balance = u64;
 	type Event = Event;
 	type DustRemoval = ();

frame/contracts/src/tests.rs

@@ -220,6 +220,7 @@ impl frame_system::Config for Test {
 }
 impl pallet_balances::Config for Test {
 	type MaxLocks = ();
+	type MaxReserves = ();
 	type Balance = u64;
 	type Event = MetaEvent;
 	type DustRemoval = ();

frame/democracy/src/tests.rs

@@ -133,6 +133,7 @@ parameter_types! {
 }
 impl pallet_balances::Config for Test {
 	type MaxLocks = ();
+	type MaxReserves = ();
 	type Balance = u64;
 	type Event = Event;
 	type DustRemoval = ();

frame/elections-phragmen/src/lib.rs

@@ -1113,6 +1113,7 @@ mod tests {
 		type ExistentialDeposit = ExistentialDeposit;
 		type AccountStore = frame_system::Module<Test>;
 		type MaxLocks = ();
+		type MaxReserves = ();
 		type WeightInfo = ();
 	}
 

frame/elections/src/mock.rs

@@ -65,6 +65,7 @@ parameter_types! {
 }
 impl pallet_balances::Config for Test {
 	type MaxLocks = ();
+	type MaxReserves = ();
 	type Balance = u64;
 	type DustRemoval = ();
 	type Event = Event;

frame/example/src/lib.rs

@@ -766,6 +766,7 @@ mod tests {
 	}
 	impl pallet_balances::Config for Test {
 		type MaxLocks = ();
+		type MaxReserves = ();
 		type Balance = u64;
 		type DustRemoval = ();
 		type Event = ();

frame/executive/src/lib.rs

@@ -632,6 +632,7 @@ mod tests {
 		type ExistentialDeposit = ExistentialDeposit;
 		type AccountStore = System;
 		type MaxLocks = ();
+		type MaxReserves = ();
 		type WeightInfo = ();
 	}
 

frame/grandpa/src/mock.rs

@@ -153,6 +153,7 @@ parameter_types! {
 
 impl pallet_balances::Config for Test {
 	type MaxLocks = ();
+	type MaxReserves = ();
 	type Balance = u128;
 	type DustRemoval = ();
 	type Event = TestEvent;

frame/identity/src/tests.rs

@@ -75,6 +75,7 @@ impl pallet_balances::Config for Test {
 	type ExistentialDeposit = ExistentialDeposit;
 	type AccountStore = System;
 	type MaxLocks = ();
+	type MaxReserves = ();
 	type WeightInfo = ();
 }
 parameter_types! {