Add pools to centrifuge runtime

flake.nix

@@ -93,7 +93,7 @@
             };
 
             # This is a hash of all the Cargo dependencies, for reproducibility.
-            cargoSha256 = "sha256-BBuNvCWqMQDNDeDNCr/C4CvJay/2sPGAZQefaKg0EFg=";
+            cargoSha256 = "sha256-B44+vaseMmcmEAn0qhGime0a1geVofH0Qtbd9Epo5KI=";
 
             nativeBuildInputs = with pkgs; [ clang git-mock pkg-config ];
             buildInputs = with pkgs; [ openssl ] ++ (

pallets/collator-allowlist/src/lib.rs

@@ -171,6 +171,24 @@ impl<T: Config> ValidatorRegistration<T::ValidatorId> for Pallet<T> {
 	/// True iff
 	///   - the validator id is present in the allowlist and
 	///   - the validator id is registered in the underlying validator registration center
+	#[cfg(not(test))]
+	fn is_registered(id: &T::ValidatorId) -> bool {
+		let contains_key = if cfg!(feature = "runtime-benchmarks") {
+			// NOTE: We want to return true but count the storage hit
+			//       during benchmarks here.
+			let _ = <Allowlist<T>>::contains_key(id);
+			true
+		} else {
+			<Allowlist<T>>::contains_key(id)
+		};
+
+		contains_key && T::ValidatorRegistration::is_registered(id)
+	}
+
+	// NOTE: Running test with `feature = "runtime-benchmarks"` breaks the test
+	//       with the above solution for fixing `pallet-collator-selection` benchmarks
+	//       hence, we have a "non-benchmarking implementation" here
+	#[cfg(test)]
 	fn is_registered(id: &T::ValidatorId) -> bool {
 		<Allowlist<T>>::contains_key(id) && T::ValidatorRegistration::is_registered(id)
 	}

pallets/interest-accrual/src/lib.rs

@@ -188,7 +188,7 @@ pub enum Release {
 
 impl Default for Release {
 	fn default() -> Self {
-		Self::V0
+		Self::V2
 	}
 }
 

pallets/interest-accrual/src/migrations.rs

@@ -115,6 +115,23 @@ pub mod v2 {
 	}
 }
 
+pub mod centrifuge {
+	use super::*;
+
+	pub struct SetStorageVersionToV2<T>(sp_std::marker::PhantomData<T>);
+
+	impl<T: Config> OnRuntimeUpgrade for SetStorageVersionToV2<T> {
+		fn on_runtime_upgrade() -> Weight {
+			if StorageVersion::<T>::get() != Release::V2 {
+				StorageVersion::<T>::set(Release::V2);
+				T::DbWeight::get().reads_writes(1, 1)
+			} else {
+				T::DbWeight::get().reads(1)
+			}
+		}
+	}
+}
+
 #[cfg(test)]
 mod test {
 	use super::*;

pallets/investments/src/lib.rs

@@ -459,7 +459,7 @@ pub mod pallet {
 		/// amount is less than the current order, the balance
 		/// will be transferred from the pool to the calling
 		/// account.
-		#[pallet::weight(80_000_000)]
+		#[pallet::weight(5_000_000_000)]
 		pub fn update_invest_order(
 			origin: OriginFor<T>,
 			investment_id: T::InvestmentId,
@@ -478,7 +478,7 @@ pub mod pallet {
 		/// amount is less than the current order, the balance
 		/// will be transferred from the pool to the calling
 		/// account.
-		#[pallet::weight(80_000_000)]
+		#[pallet::weight(5_000_000_000)]
 		pub fn update_redeem_order(
 			origin: OriginFor<T>,
 			investment_id: T::InvestmentId,
@@ -492,7 +492,7 @@ pub mod pallet {
 		/// Collect the results of a users invest orders for the given investment.
 		/// If any amounts are not fulfilled they are directly appended to the next active
 		/// order for this investment.
-		#[pallet::weight(80_000_000)]
+		#[pallet::weight(5_000_000_000)]
 		pub fn collect_investments(
 			origin: OriginFor<T>,
 			investment_id: T::InvestmentId,
@@ -505,7 +505,7 @@ pub mod pallet {
 		/// Collect the results of a users redeem orders for the given investment.
 		/// If any amounts are not fulfilled they are directly appended to the next active
 		/// order for this investment.
-		#[pallet::weight(80_000_000)]
+		#[pallet::weight(5_000_000_000)]
 		pub fn collect_redemptions(
 			origin: OriginFor<T>,
 			investment_id: T::InvestmentId,
@@ -518,7 +518,7 @@ pub mod pallet {
 		/// Collect the results of another users invest orders for the given investment.
 		/// If any amounts are not fulfilled they are directly appended to the next active
 		/// order for this investment.
-		#[pallet::weight(80_000_000)]
+		#[pallet::weight(5_000_000_000)]
 		pub fn collect_investments_for(
 			origin: OriginFor<T>,
 			who: T::AccountId,
@@ -532,7 +532,7 @@ pub mod pallet {
 		/// Collect the results of another users redeem orders for the given investment.
 		/// If any amounts are not fulfilled they are directly appended to the next active
 		/// order for this investment.
-		#[pallet::weight(80_000_000)]
+		#[pallet::weight(5_000_000_000)]
 		pub fn collect_redemptions_for(
 			origin: OriginFor<T>,
 			who: T::AccountId,

pallets/loans/src/mock.rs

@@ -352,7 +352,6 @@ impl pallet_permissions::Config for Runtime {
 	type AdminOrigin = EnsureSignedBy<One, u64>;
 	type Editors = Everything;
 	type MaxRolesPerScope = MaxRoles;
-	type MaxTranches = MaxTranches;
 	type Role = Role;
 	type RuntimeEvent = RuntimeEvent;
 	type Scope = PermissionScope<u64, CurrencyId>;

pallets/loans/src/test_utils.rs

@@ -31,10 +31,7 @@ use frame_support::{
 use frame_system::RawOrigin;
 #[cfg(feature = "runtime-benchmarks")]
 use pallet_pool_system::tranches::TrancheLoc;
-use pallet_pool_system::{
-	tranches::{TrancheInput, TrancheMetadata, TrancheType},
-	Pallet as PoolPallet, Pool as PoolStorage,
-};
+use pallet_pool_system::tranches::{TrancheInput, TrancheMetadata, TrancheType};
 use sp_runtime::{
 	traits::{AccountIdConversion, Zero},
 	Perquintill,

pallets/permissions/src/lib.rs

@@ -66,10 +66,6 @@ pub mod pallet {
 		#[pallet::constant]
 		type MaxRolesPerScope: Get<u32>;
 
-		/// The maximum number of tranches.
-		#[pallet::constant]
-		type MaxTranches: Get<u32>;
-
 		type WeightInfo: WeightInfo;
 	}
 

pallets/permissions/src/mock.rs

@@ -294,7 +294,6 @@ impl pallet_permissions::Config for Runtime {
 	type AdminOrigin = AdminOrigin;
 	type Editors = Editors;
 	type MaxRolesPerScope = MaxRoles;
-	type MaxTranches = MaxTranches;
 	type Role = Role;
 	type RuntimeEvent = RuntimeEvent;
 	type Scope = Scope;

pallets/pool-registry/Cargo.toml

@@ -28,6 +28,7 @@ pallet-pool-system = { path = "../pool-system", default-features = false }
 # Benchmarking dependencies - optional
 frame-benchmarking = { git = "https://github.com/paritytech/substrate", default-features = false, optional = true, branch = "polkadot-v0.9.32" }
 pallet-investments = { path = "../investments", default-features = false, optional = true }
+pallet-timestamp = { git = "https://github.com/paritytech/substrate", default-features = false, optional = true, branch = "polkadot-v0.9.32" }
 
 cfg-primitives = { path = "../../libs/primitives", default-features = false }
 cfg-traits = { path = "../../libs/traits", default-features = false }
@@ -58,6 +59,7 @@ runtime-benchmarks = [
   "frame-system/runtime-benchmarks",
   "orml-asset-registry/runtime-benchmarks",
   "sp-runtime/runtime-benchmarks",
+  "pallet-timestamp/runtime-benchmarks",
 ]
 std = [
   "codec/std",

pallets/pool-registry/src/benchmarking.rs

@@ -12,7 +12,7 @@
 // GNU General Public License for more details.
 
 //! Module provides benchmarking for Loan Pallet
-use cfg_primitives::PoolEpochId;
+use cfg_primitives::{Moment, PoolEpochId};
 use cfg_traits::{InvestmentAccountant, InvestmentProperties, TrancheCurrency as _};
 use cfg_types::tokens::{CurrencyId, TrancheCurrency};
 use frame_benchmarking::benchmarks;
@@ -45,7 +45,6 @@ const SECS_PER_DAY: u64 = 24 * SECS_PER_HOUR;
 const SECS_PER_YEAR: u64 = 365 * SECS_PER_DAY;
 
 const TRANCHE: TrancheIndex = 0;
-
 const POOL: u64 = 0;
 
 benchmarks! {
@@ -64,6 +63,7 @@ benchmarks! {
 			  MaxTokenNameLength = <T as Config>::MaxTokenNameLength,
 			  MaxTokenSymbolLength = <T as Config>::MaxTokenSymbolLength,
 			  MaxTranches = <T as Config>::MaxTranches>,
+		T: pallet_timestamp::Config<Moment = Moment>,
 		<T as pallet_investments::Config>::Tokens: Inspect<T::AccountId, AssetId = CurrencyId, Balance = u128>,
 		<<T as pallet_investments::Config>::Accountant as InvestmentAccountant<T::AccountId>>::InvestmentInfo:
 			InvestmentProperties<T::AccountId, Currency = CurrencyId>,
@@ -88,7 +88,11 @@ benchmarks! {
 		let n in 1..<T as pallet_pool_system::Config>::MaxTranches::get();
 		let caller: <T as frame_system::Config>::AccountId = create_admin::<T>(0);
 		let tranches = build_bench_input_tranches::<T>(n);
-		let origin = RawOrigin::Signed(caller.clone());
+		let origin = if let Ok(_) = <T as Config>::PoolCreateOrigin::try_origin(RawOrigin::Signed(caller.clone()).into()) {
+			RawOrigin::Signed(caller.clone())
+		} else {
+			RawOrigin::Root
+		};
 		prepare_asset_registry::<T>();
 	}: register(origin, caller, POOL, tranches.clone(), CurrencyId::AUSD, MAX_RESERVE, None)
 	verify {
@@ -102,36 +106,34 @@ benchmarks! {
 	}
 
 	update_no_execution {
+		// Execution of updates is blocked as no epoch has passed
+		// since we submitted the update
 		let admin: <T as frame_system::Config>::AccountId = create_admin::<T>(0);
 		let n in 1..<T as pallet_pool_system::Config>::MaxTranches::get();
 		let tranches = build_update_tranches::<T>(n);
 		prepare_asset_registry::<T>();
 		create_pool::<T>(n, admin.clone())?;
 
-		let pool = get_pool::<T>();
-		let default_min_epoch_time = pool.parameters.min_epoch_time;
-		let default_max_nav_age = pool.parameters.max_nav_age;
 
 		// Submit redemption order so the update isn't executed
 		let amount = MAX_RESERVE / 2;
-		let investor = create_investor::<T>(0, TRANCHE)?;
+		let investor = create_investor::<T>(0, TRANCHE, Some(amount))?;
 		let locator = get_tranche_id::<T>(TRANCHE);
 		pallet_investments::Pallet::<T>::update_redeem_order(RawOrigin::Signed(investor.clone()).into(), TrancheCurrency::generate(POOL, locator), amount)?;
 
+
 		let changes = PoolChanges {
 			tranches: Change::NoChange,
 			min_epoch_time: Change::NewValue(SECS_PER_DAY),
 			max_nav_age: Change::NewValue(SECS_PER_HOUR),
 			tranche_metadata: Change::NoChange,
 		};
-
-		update_pool::<T>(changes.clone())?;
 	}: update(RawOrigin::Signed(admin), POOL, changes.clone())
 	verify {
 		// Should be the old values
 		let pool = get_pool::<T>();
-		assert_eq!(pool.parameters.min_epoch_time, default_min_epoch_time);
-		assert_eq!(pool.parameters.max_nav_age, default_max_nav_age);
+		assert_eq!(pool.parameters.min_epoch_time, T::DefaultMinEpochTime::get());
+		assert_eq!(pool.parameters.max_nav_age, T::DefaultMaxNAVAge::get());
 
 		let actual_update = get_scheduled_update::<T>();
 		assert_eq!(actual_update.changes, changes);
@@ -145,12 +147,11 @@ benchmarks! {
 		create_pool::<T>(n, admin.clone())?;
 
 		let changes = PoolChanges {
-			tranches: Change::NewValue(build_update_tranches::<T>(n)),
+			tranches: Change::NewValue(tranches.clone()),
 			min_epoch_time: Change::NewValue(SECS_PER_DAY),
 			max_nav_age: Change::NewValue(SECS_PER_HOUR),
 			tranche_metadata: Change::NewValue(build_update_tranche_metadata::<T>()),
 		};
-		update_pool::<T>(changes.clone())?;
 	}: update(RawOrigin::Signed(admin), POOL, changes)
 	verify {
 		// No redemption order was submitted and the MinUpdateDelay is 0 for benchmarks,
@@ -179,7 +180,7 @@ benchmarks! {
 		};
 
 		// Invest so we can redeem later
-		let investor = create_investor::<T>(0, TRANCHE)?;
+		let investor = create_investor::<T>(0, TRANCHE, Some(1))?;
 		let locator = get_tranche_id::<T>(TRANCHE);
 		// Submit redemption order so the update isn't immediately executed
 		pallet_investments::Pallet::<T>::update_redeem_order(RawOrigin::Signed(investor.clone()).into(), TrancheCurrency::generate(POOL, locator), 1)?;
@@ -225,39 +226,16 @@ fn build_update_tranche_metadata<T: Config>(
 
 fn build_update_tranches<T: Config>(
 	num_tranches: u32,
-) -> BoundedVec<TrancheUpdate<T::InterestRate>, T::MaxTranches> {
-	let mut tranches = build_bench_update_tranches::<T>(num_tranches);
-
-	for tranche in &mut tranches {
-		tranche.tranche_type = match tranche.tranche_type {
-			TrancheType::Residual => TrancheType::Residual,
-			TrancheType::NonResidual {
-				interest_rate_per_sec,
-				min_risk_buffer,
-			} => {
-				let min_risk_buffer = Perquintill::from_parts(min_risk_buffer.deconstruct() * 2);
-				TrancheType::NonResidual {
-					interest_rate_per_sec,
-					min_risk_buffer,
-				}
-			}
-		}
-	}
-	tranches
-}
-
-fn build_bench_update_tranches<T: Config>(
-	num_tranches: u32,
 ) -> BoundedVec<TrancheUpdate<T::InterestRate>, T::MaxTranches> {
 	let senior_interest_rate = T::InterestRate::saturating_from_rational(5, 100)
 		/ T::InterestRate::saturating_from_integer(SECS_PER_YEAR);
 	let mut tranches: Vec<_> = (1..num_tranches)
 		.map(|tranche_id| TrancheUpdate {
 			tranche_type: TrancheType::NonResidual {
 				interest_rate_per_sec: senior_interest_rate
-					/ T::InterestRate::saturating_from_integer(tranche_id)
+					/ T::InterestRate::saturating_from_integer(tranche_id * 2)
 					+ One::one(),
-				min_risk_buffer: Perquintill::from_percent(tranche_id.into()),
+				min_risk_buffer: Perquintill::from_percent((tranche_id * 2).into()),
 			},
 			seniority: None,
 		})

pallets/pool-registry/src/mock.rs

@@ -361,10 +361,6 @@ impl PoolUpdateGuard for UpdateGuard {
 		update: &Self::ScheduledUpdateDetails,
 		now: Self::Moment,
 	) -> bool {
-		if now < update.scheduled_time {
-			return false;
-		}
-
 		// The epoch in which the redemptions were fulfilled,
 		// should have closed after the scheduled time already,
 		// to ensure that investors had the `MinUpdateDelay`