Add improved homa lite redeem match

modules/homa-lite/src/lib.rs

@@ -236,7 +236,7 @@ pub mod module {
 	pub type XcmDestWeight<T: Config> = StorageValue<_, Weight, ValueQuery>;
 
 	/// Requests to redeem staked currencies.
-	/// RedeemRequests: Map: AccountId => Option<(liquid_amount: Balance, addtional_fee: Permill)>
+	/// RedeemRequests: Map: AccountId => Option<(liquid_amount: Balance, additional_fee: Permill)>
 	#[pallet::storage]
 	#[pallet::getter(fn redeem_requests)]
 	pub type RedeemRequests<T: Config> = StorageMap<_, Twox64Concat, T::AccountId, (Balance, Permill), OptionQuery>;
@@ -260,6 +260,12 @@ pub mod module {
 	#[pallet::getter(fn staking_interest_rate_per_update)]
 	pub type StakingInterestRatePerUpdate<T: Config> = StorageValue<_, Permill, ValueQuery>;
 
+	/// Next redeem request to iterate from when matching redeem requests.
+	/// NextRedeemRequestToMatch: Value: T::AccountId
+	#[pallet::storage]
+	#[pallet::getter(fn next_redeem_request_to_match)]
+	pub type NextRedeemRequestToMatch<T: Config> = StorageValue<_, T::AccountId, ValueQuery>;
+
 	#[pallet::pallet]
 	pub struct Pallet<T>(_);
 
@@ -306,7 +312,7 @@ pub mod module {
 		}
 
 		fn on_initialize(n: T::BlockNumber) -> Weight {
-			// Update the total amount of Staking balance by acrueing the interest periodically.
+			// Update the total amount of Staking balance by accruing the interest periodically.
 			let interest_rate = Self::staking_interest_rate_per_update();
 			if !interest_rate.is_zero()
 				&& n.checked_rem(&T::StakingUpdateFrequency::get())
@@ -333,7 +339,7 @@ pub mod module {
 		/// liquid currency.
 		///
 		/// If any amount is minted through XCM, a portion of that amount (T::MintFee and
-		/// T::MaxRewardPerEra) is reducted as fee.
+		/// T::MaxRewardPerEra) is deducted as fee.
 		///
 		/// Parameters:
 		/// - `amount`: The amount of Staking currency to be exchanged.
@@ -565,7 +571,7 @@ pub mod module {
 		/// Requires `T::GovernanceOrigin`
 		///
 		/// Parameters:
-		/// - `new_unbonds`: The new ScheduledUnbond storage to replace the currrent storage.
+		/// - `new_unbonds`: The new ScheduledUnbond storage to replace the current storage.
 		#[pallet::weight(< T as Config >::WeightInfo::replace_schedule_unbond())]
 		#[transactional]
 		pub fn replace_schedule_unbond(
@@ -634,7 +640,7 @@ pub mod module {
 		}
 
 		/// Set the interest rate for TotalStakingCurrency.
-		/// TotakStakingCurrency is incremented every `T::StakingUpdateFrequency` blocks
+		/// TotalStakingCurrency is incremented every `T::StakingUpdateFrequency` blocks
 		///
 		/// Requires `T::GovernanceOrigin`
 		///
@@ -768,10 +774,10 @@ pub mod module {
 			// Attempt to match redeem requests if there are any.
 			let total_liquid_to_mint = Self::convert_staking_to_liquid(amount)?;
 
-			// The amount of liquid currency to be redeemed for the mint reuqest.
+			// The amount of liquid currency to be redeemed for the mint request.
 			let mut liquid_remaining = total_liquid_to_mint;
 
-			// New balances after redeem requests are fullfilled.
+			// New balances after redeem requests are fulfilled.
 			let mut new_balances: Vec<(T::AccountId, Balance, Permill)> = vec![];
 
 			// Iterate through the prioritized requests first
@@ -801,21 +807,34 @@ pub mod module {
 			new_balances.clear();
 
 			let mut redeem_requests_limit_remaining = T::MaximumRedeemRequestMatchesForMint::get();
-			// Iterate all remaining redeem requests now.
-			for (redeemer, (request_amount, extra_fee)) in RedeemRequests::<T>::iter() {
-				// If all the currencies are minted, return.
-				if liquid_remaining.is_zero() || redeem_requests_limit_remaining.is_zero() {
-					break;
-				}
-				Self::match_mint_with_redeem_request(
-					minter,
-					&redeemer,
-					request_amount,
-					extra_fee,
-					&mut liquid_remaining,
-					&mut new_balances,
-				)?;
-				redeem_requests_limit_remaining -= 1;
+			if !liquid_remaining.is_zero() && !redeem_requests_limit_remaining.is_zero() {
+				// Define the function to be executed for each of the redeem request:
+				// Redeem the given requests with the current minting request.
+				//
+				// Params: redeemer: T::AccountId, request_amount: Balance, extra_fee: Permill
+				// Returns: Result<should_break, Error>
+				//
+				// Capturing: &mut liquid_remaining
+				//            &mut redeem_requests_limit_remaining
+				//            &mut new_balances
+				// If all the currencies are minted, return `should_break` as true.
+				let mut f = |redeemer, request_amount, extra_fee| -> Result<bool, DispatchError> {
+					Self::match_mint_with_redeem_request(
+						minter,
+						&redeemer,
+						request_amount,
+						extra_fee,
+						&mut liquid_remaining,
+						&mut new_balances,
+					)?;
+					redeem_requests_limit_remaining -= 1;
+
+					// Should break when all currencies are minted
+					Ok(liquid_remaining.is_zero() || redeem_requests_limit_remaining.is_zero())
+				};
+
+				// Call the function on redeem requests - iterating from the `NextRedeemRequestToMatch`
+				Self::iterate_from_next_redeem_request(&mut f)?;
 			}
 
 			// Update storage to the new balances. Remove Redeem requests that have been filled.
@@ -895,7 +914,7 @@ pub mod module {
 		/// 	- `max_num_matches`: Maximum number of redeem requests to be matched.
 		///
 		/// return:
-		/// 	Result<u32, DispatchError>: The number of redeem reqeusts actually matched.
+		/// 	Result<u32, DispatchError>: The number of redeem requests actually matched.
 		#[transactional]
 		pub fn process_redeem_requests_with_available_staking_balance(
 			max_num_matches: u32,
@@ -910,45 +929,59 @@ pub mod module {
 
 			let mut new_balances: Vec<(T::AccountId, Balance, Permill)> = vec![];
 			let mut num_matched = 0u32;
-			for (redeemer, (request_amount, extra_fee)) in RedeemRequests::<T>::iter() {
-				let actual_liquid_amount = min(
-					request_amount,
-					Self::convert_staking_to_liquid(available_staking_balance)?,
-				);
 
-				// Ensure the redeemer have enough liquid currency in their account.
-				if T::Currency::reserved_balance(T::LiquidCurrencyId::get(), &redeemer) >= actual_liquid_amount {
-					let actual_staking_amount = Self::convert_liquid_to_staking(actual_liquid_amount)?;
-
-					Self::update_total_staking_currency_storage(|total| {
-						Ok(total.saturating_sub(actual_staking_amount))
-					})?;
-
-					//Actual deposit amount has `T::XcmUnbondFee` deducted.
-					let actual_staking_amount_deposited = actual_staking_amount.saturating_sub(T::XcmUnbondFee::get());
-					T::Currency::deposit(T::StakingCurrencyId::get(), &redeemer, actual_staking_amount_deposited)?;
-
-					// Burn the corresponding amount of Liquid currency from the user.
-					// The redeemer is guaranteed to have enough fund
-					T::Currency::unreserve(T::LiquidCurrencyId::get(), &redeemer, actual_liquid_amount);
-					T::Currency::slash(T::LiquidCurrencyId::get(), &redeemer, actual_liquid_amount);
-
-					available_staking_balance = available_staking_balance.saturating_sub(actual_staking_amount);
-					let request_amount_remaining = request_amount.saturating_sub(actual_liquid_amount);
-					new_balances.push((redeemer.clone(), request_amount_remaining, extra_fee));
-
-					Self::deposit_event(Event::<T>::Redeemed(
-						redeemer,
-						actual_staking_amount_deposited,
-						actual_liquid_amount,
-					));
-					num_matched += 1u32;
-				}
+			{
+				// Define the function to be executed for each of the redeem request:
+				// Redeem the given requests using available_staking_balance.
+				//
+				// Params: redeemer: T::AccountId, request_amount: Balance, extra_fee: Permill
+				// Returns: Result< should_break, Error>
+				//
+				// Capturing: &mut available_staking_balance
+				//            &mut num_matched
+				//            &mut new_balances
+				let mut f = |redeemer, request_amount, extra_fee| -> Result<bool, DispatchError> {
+					let actual_liquid_amount = min(
+						request_amount,
+						Self::convert_staking_to_liquid(available_staking_balance)?,
+					);
 
-				// If all the currencies are minted, return.
-				if available_staking_balance < T::MinimumMintThreshold::get() || num_matched >= max_num_matches {
-					break;
-				}
+					// Ensure the redeemer have enough liquid currency in their account.
+					if T::Currency::reserved_balance(T::LiquidCurrencyId::get(), &redeemer) >= actual_liquid_amount {
+						let actual_staking_amount = Self::convert_liquid_to_staking(actual_liquid_amount)?;
+
+						Self::update_total_staking_currency_storage(|total| {
+							Ok(total.saturating_sub(actual_staking_amount))
+						})?;
+
+						//Actual deposit amount has `T::XcmUnbondFee` deducted.
+						let actual_staking_amount_deposited =
+							actual_staking_amount.saturating_sub(T::XcmUnbondFee::get());
+						T::Currency::deposit(T::StakingCurrencyId::get(), &redeemer, actual_staking_amount_deposited)?;
+
+						// Burn the corresponding amount of Liquid currency from the user.
+						// The redeemer is guaranteed to have enough fund
+						T::Currency::unreserve(T::LiquidCurrencyId::get(), &redeemer, actual_liquid_amount);
+						T::Currency::slash(T::LiquidCurrencyId::get(), &redeemer, actual_liquid_amount);
+
+						available_staking_balance = available_staking_balance.saturating_sub(actual_staking_amount);
+						let request_amount_remaining = request_amount.saturating_sub(actual_liquid_amount);
+						new_balances.push((redeemer.clone(), request_amount_remaining, extra_fee));
+
+						Self::deposit_event(Event::<T>::Redeemed(
+							redeemer,
+							actual_staking_amount_deposited,
+							actual_liquid_amount,
+						));
+						num_matched += 1u32;
+					}
+
+					// If all the currencies are minted, return `should_break` as true
+					Ok(available_staking_balance <= T::MinimumMintThreshold::get() || num_matched >= max_num_matches)
+				};
+
+				// Redeem requests from `NextRedeemRequestToMatch` using available_staking_balance.
+				Self::iterate_from_next_redeem_request(&mut f)?;
 			}
 
 			// Update storage to the new balances. Remove Redeem requests that have been filled.
@@ -976,12 +1009,22 @@ pub mod module {
 			}
 		}
 
+		// Helper function that checks if the `liquid_amount` is above the minimum redeem threshold, and
+		// is enough to pay for the XCM unbond fee.
 		fn liquid_amount_is_above_minimum_threshold(liquid_amount: Balance) -> bool {
 			liquid_amount > T::MinimumRedeemThreshold::get()
 				&& Self::convert_liquid_to_staking(liquid_amount).unwrap_or_default() > T::XcmUnbondFee::get()
 		}
 
-		/// Construct a XCM message
+		/// Helper function that construct an XCM message that:
+		/// 1. `withdraw_unbonded` from HomaLite sub-account.
+		/// 2. Transfer the withdrew fund into Sovereign account.
+		///
+		/// Param:
+		/// 	- `parachain_account` : sovereign account's AccountId
+		/// 	- `amount` : amount to withdraw from unbonded.
+		/// Return:
+		/// 	Xcm<()>: the Xcm message constructed.
 		pub fn construct_xcm_unreserve_message(parachain_account: T::AccountId, amount: Balance) -> Xcm<()> {
 			let xcm_message = T::RelayChainCallBuilder::utility_as_derivative_call(
 				T::RelayChainCallBuilder::utility_batch_call(vec![
@@ -997,7 +1040,8 @@ pub mod module {
 			)
 		}
 
-		/// Helper function that update the storage of total_staking_currency and emit event.
+		/// Helper function that update the storage of total_staking_currency.
+		/// Ensures that the total staking amount would not become zero, and emit an event.
 		fn update_total_staking_currency_storage(
 			f: impl FnOnce(Balance) -> Result<Balance, DispatchError>,
 		) -> DispatchResult {
@@ -1008,6 +1052,72 @@ pub mod module {
 				Ok(())
 			})
 		}
+
+		/// Helper function that iterates `RedeemRequests` storage from `NextRedeemRequestToMatch`,
+		/// and call the MutFn f() on that request.
+		///
+		/// If `NextRedeemRequestToMatch` is not found in storage, iterate from the start.
+		///
+		/// Param for FnMut f:
+		/// 	- `redeemer`: AccountId of the redeemer
+		/// 	- `amount`: The amount to be redeemed
+		/// 	- `extra_fee`: The extra fee to be paid to the minter from the redeemer
+		/// Return for FnMut f:
+		/// 	Result<should_break, error>: If Ok, return if the iteration should end. Otherwise return
+		/// the Error
+		pub fn iterate_from_next_redeem_request(
+			f: &mut impl FnMut(T::AccountId, Balance, Permill) -> Result<bool, DispatchError>,
+		) -> DispatchResult {
+			let first_element = match RedeemRequests::<T>::iter().next() {
+				// Current storage is empty. Do nothing and return
+				None => return Ok(()),
+				Some(element) => element,
+			};
+
+			// If "next" exists in storage, use it as the "starting_item". Otherwise use the first item.
+			let starting_redeemer = Self::next_redeem_request_to_match();
+			let starting_element = match Self::redeem_requests(starting_redeemer.clone()) {
+				Some(request) => (starting_redeemer, request),
+				None => first_element,
+			};
+			let starting_key = RedeemRequests::<T>::hashed_key_for(starting_element.0.clone());
+			let mut iterator = RedeemRequests::<T>::iter_from(starting_key);
+
+			// Call the function for the first item
+			let (redeemer, (request_amount, extra_fee)) = starting_element.clone();
+			if f(redeemer, request_amount, extra_fee)? {
+				// Store the `next` element as `NextRedeemRequestToMatch`
+				NextRedeemRequestToMatch::<T>::put(iterator.next().unwrap_or_default().0);
+				return Ok(());
+			}
+
+			// Iterate until the end of the storage, calling f() for each element
+			#[allow(clippy::while_let_on_iterator)]
+			while let Some((redeemer, (request_amount, extra_fee))) = iterator.next() {
+				if f(redeemer, request_amount, extra_fee)? {
+					// Store the `next` element as `NextRedeemRequestToMatch`
+					NextRedeemRequestToMatch::<T>::put(iterator.next().unwrap_or_default().0);
+					return Ok(());
+				}
+			}
+
+			// Reset the iterator and start from the beginning of the storage until `starting_redeemer`, calling
+			// f() for each element.
+			iterator = RedeemRequests::<T>::iter();
+
+			#[allow(clippy::while_let_on_iterator)]
+			while let Some((redeemer, (request_amount, extra_fee))) = iterator.next() {
+				if redeemer == starting_element.0 {
+					// We have wrapped to the beginning. Return.
+					return Ok(());
+				}
+				if f(redeemer, request_amount, extra_fee)? {
+					NextRedeemRequestToMatch::<T>::put(iterator.next().unwrap_or_default().0);
+					return Ok(());
+				}
+			}
+			Ok(())
+		}
 	}
 
 	impl<T: Config> ExchangeRateProvider for Pallet<T> {

modules/homa-lite/src/mock.rs

@@ -59,7 +59,7 @@ pub const MOCK_XCM_DESTINATION: MultiLocation = X1(Junction::AccountId32 {
 	id: [1u8; 32],
 })
 .into();
-pub const MOCK_XCM_ACCOUNTID: AccountId = AccountId32::new([255u8; 32]);
+pub const MOCK_XCM_ACCOUNT_ID: AccountId = AccountId32::new([255u8; 32]);
 pub const PARACHAIN_ID: u32 = 2000;
 
 /// For testing only. Does not check for overflow.
@@ -258,7 +258,7 @@ parameter_types! {
 	pub MinimumMintThreshold: Balance = millicent(1000);
 	pub MinimumRedeemThreshold: Balance = millicent(1000);
 	pub const MockXcmDestination: MultiLocation = MOCK_XCM_DESTINATION;
-	pub const MockXcmAccountId: AccountId = MOCK_XCM_ACCOUNTID;
+	pub const MockXcmAccountId: AccountId = MOCK_XCM_ACCOUNT_ID;
 	pub DefaultExchangeRate: ExchangeRate = ExchangeRate::saturating_from_rational(1, 10);
 	pub const MaxRewardPerEra: Permill = Permill::from_percent(1);
 	pub MintFee: Balance = millicent(1000);

modules/homa-lite/src/mock_no_fees.rs

@@ -207,7 +207,7 @@ parameter_types! {
 	pub MinimumMintThreshold: Balance = 0;
 	pub MinimumRedeemThreshold: Balance = 0;
 	pub const MockXcmDestination: MultiLocation = MOCK_XCM_DESTINATION;
-	pub const MockXcmAccountId: AccountId = MOCK_XCM_ACCOUNTID;
+	pub const MockXcmAccountId: AccountId = MOCK_XCM_ACCOUNT_ID;
 	pub DefaultExchangeRate: ExchangeRate = ExchangeRate::saturating_from_rational(1, 10);
 	pub const MaxRewardPerEra: Permill = Permill::zero();
 	pub MintFee: Balance = 0;