Updated afloat benchmarks to use worst-case scenarios of dependent extrinsics from: rbac, gated_marketplace and fruniques

Author: Dreyhh

.vscode/settings.json

@@ -1,6 +1,9 @@
 {
     "rust-analyzer.linkedProjects": [
-        "./pallets/afloat/Cargo.toml"
+        "./pallets/afloat/Cargo.toml",
+        "./pallets/rbac/Cargo.toml",
+        "./pallets/gated-marketplace/Cargo.toml",
+        "./pallets/fruniques/Cargo.toml",
     ],
     "rust-analyzer.showUnlinkedFileNotification": false
 }

pallets/afloat/src/benchmarking.rs

@@ -4,6 +4,7 @@ use super::*;
 use crate::{types::*, Pallet as Afloat};
 use frame_benchmarking::v2::*;
 use frame_support::{
+	assert_ok,
 	pallet_prelude::*,
 	traits::{Currency, Get},
 };
@@ -15,10 +16,134 @@ type DepositBalanceOf<T> = <<T as pallet_mapped_assets::Config>::Currency as Cur
 	<T as SystemConfig>::AccountId,
 >>::Balance;
 
+use pallet_rbac::types::{IdOrVec, RoleBasedAccessControl, RoleId};
+use sp_io::hashing::blake2_256;
+use std::cmp;
+
 const SEED: u32 = 0;
 const MAX_U32: u32 = u32::MAX;
 const MAX_U64: u64 = u64::MAX;
 const MAX_TAX_CREDIT_AMOUNT: u32 = 100;
+const NUM_AFLOAT_ROLES: u32 = 4;
+
+pub fn generate_pallet_id_sized(id: u8, size: u32) -> IdOrVec {
+	IdOrVec::Vec(generate_vector(0, id, size))
+}
+
+pub fn generate_role_sized(id: u8, size: u32) -> Vec<u8> {
+	generate_vector(1, id, size)
+}
+
+pub fn generate_scope_sized(id: u32, size: u32) -> Vec<u8> {
+	generate_vector((id / u8::MAX as u32) as u8, (id % u8::MAX as u32) as u8, size)
+}
+
+pub fn generate_roles_sized(id: u8, num_roles: u32, size: u32) -> Vec<Vec<u8>> {
+	let mut roles = Vec::new();
+	for r in 0..num_roles {
+		roles.push(generate_role_sized(r as u8 + id, size));
+	}
+	roles
+}
+
+pub fn generate_id(item: Vec<u8>) -> [u8; 32] {
+	item.using_encoded(blake2_256)
+}
+
+fn set_rbac_assign_role_to_user_worst_case<T: Config>(
+	user: <T as frame_system::Config>::AccountId,
+	num_roles_available_user: u32,
+	inital_setup: bool,
+) -> Result<(), sp_runtime::DispatchError> {
+	// Leave only one Scope available for the pallet
+	let max_scopes =
+		<<T as pallet::Config>::Rbac as RoleBasedAccessControl<T::AccountId>>::MaxScopesPerPallet::get(
+		) - 1;
+	let mut scope_ids = Vec::new();
+	let pallet_id = Afloat::<T>::pallet_id();
+	for s in 0..max_scopes {
+		let scope = generate_scope_sized(s, 10);
+		let mut scope_id = generate_id(scope);
+		assert_ok!(
+			<<T as pallet::Config>::Rbac as RoleBasedAccessControl<T::AccountId>>::create_scope(
+				pallet_id.clone(),
+				scope_id
+			)
+		);
+		scope_ids.push(scope_id);
+	}
+	// Leave n roles available for the pallet
+	let num_roles = <<T as pallet::Config>::Rbac as RoleBasedAccessControl<T::AccountId>>::MaxRolesPerPallet::get() - NUM_AFLOAT_ROLES;
+	let size =
+		<<T as pallet::Config>::Rbac as RoleBasedAccessControl<T::AccountId>>::RoleMaxLen::get();
+
+	let roles = generate_roles_sized(1, num_roles, size);
+	assert_ok!(
+		<<T as pallet::Config>::Rbac as RoleBasedAccessControl<T::AccountId>>::create_and_set_roles(
+			pallet_id.clone(),
+			roles.clone()
+		)
+	);
+
+	if !inital_setup {
+		let role_ids: Vec<RoleId> = roles.into_iter().map(|role| generate_id(role)).collect();
+		let l = role_ids.len();
+		let r = l - num_roles_available_user as usize;
+		let n = cmp::min(l, r);
+		let role_ids = &role_ids[0..n];
+		let scope_id = Afloat::<T>::scope_id();
+		for role_id in role_ids {
+			assert_ok!(<<T as pallet::Config>::Rbac as RoleBasedAccessControl<T::AccountId>>::assign_role_to_user(
+			user.clone(),
+			pallet_id.clone(),
+			&scope_id,
+			role_id.clone()
+		));
+		}
+	}
+
+	Ok(())
+}
+
+fn set_start_take_sell_offer_worst_case<T: Config>(
+	user: <T as frame_system::Config>::AccountId,
+	offer_id: [u8; 32],
+) -> Result<(), sp_runtime::DispatchError>
+where
+	<T as pallet_uniques::Config>::ItemId: From<u32>,
+	<T as pallet_uniques::Config>::CollectionId: From<u32>,
+{
+	let max_trxs = TransactionBoundedVec::bound();
+	let num_trxs = max_trxs - 1;
+
+	for _ in 0..num_trxs {
+		Afloat::<T>::start_take_sell_order(
+			RawOrigin::Signed(user.clone()).into(),
+			offer_id,
+			T::AfloatBenchHelper::balance(99),
+		)?;
+	}
+	let offer = AfloatOffers::<T>::get(offer_id).unwrap();
+	let offer_trxs = offer.transactions.clone();
+	assert_eq!(offer.status, OfferStatus::CREATED);
+	assert_eq!(offer_trxs.len(), num_trxs);
+	Ok(())
+}
+
+fn set_gm_do_enlist_sell_offer_worst_case<T: Config>(
+	user: T::AccountId,
+	offer_id: [u8; 32],
+) -> Result<(), sp_runtime::DispatchError>
+where
+	<T as pallet_uniques::Config>::ItemId: From<u32>,
+	<T as pallet_uniques::Config>::CollectionId: From<u32>,
+{
+	let max_offers_by_item = <T as pallet_gated_marketplace::Config>::MaxOffersPerMarket::get() - 1;
+	for _ in 0..max_offers_by_item {
+		add_start_take_sell_order::<T>(user.clone(), offer_id.clone()).unwrap();
+	}
+	Ok(())
+}
 
 fn set_max_balance<T: Config>(account: T::AccountId) -> Result<(), sp_runtime::DispatchError> {
 	let max_balance = DepositBalanceOf::<T>::max_value();
@@ -106,6 +231,43 @@ where
 	Afloat::<T>::create_tax_credit(RawOrigin::Signed(user).into(), description, None, None)
 }
 
+fn set_up_fruniques_do_spawn_worst_case<T: Config>(
+	user: <T as frame_system::Config>::AccountId,
+) -> Result<(), sp_runtime::DispatchError>
+where
+	<T as pallet_uniques::Config>::ItemId: From<u32>,
+	<T as pallet_uniques::Config>::CollectionId: From<u32>,
+{
+	let max_children = <T as pallet_fruniques::Config>::ChildMaxLen::get() - 1; // since we still want to pass parent info when creating the actual tax credit
+	let max_attributes = <T as pallet_fruniques::Config>::MaxAttributes::get();
+	for c in 0..max_children {
+		let attributes = create_sized_attributes::<T>(
+			max_attributes,
+			<T as pallet_uniques::Config>::KeyLimit::get(),
+			<T as pallet_uniques::Config>::ValueLimit::get(),
+		);
+		let description =
+			create_sized_description::<T>(<T as pallet_uniques::Config>::StringLimit::get());
+		if c == 0 {
+			assert_ok!(Afloat::<T>::do_create_tax_credit(
+				user.clone(),
+				description,
+				Some(attributes),
+				None,
+			));
+		} else {
+			let parent_info = create_sized_parent_info::<T>(0, 0, MAX_U32, true);
+			assert_ok!(Afloat::<T>::do_create_tax_credit(
+				user.clone(),
+				description,
+				Some(attributes),
+				Some(parent_info),
+			));
+		}
+	}
+	Ok(())
+}
+
 fn add_sell_order<T: Config>(
 	user: <T as frame_system::Config>::AccountId,
 ) -> Result<[u8; 32], sp_runtime::DispatchError>
@@ -136,17 +298,19 @@ where
 	<T as pallet_uniques::Config>::CollectionId: From<u32>,
 {
 	let offer = AfloatOffers::<T>::get(offer_id).unwrap();
-	let offer_trxs = offer.transactions.clone();
 	assert_eq!(offer.status, OfferStatus::CREATED);
-	assert!(offer_trxs.is_empty());
 	let admin: T::AccountId = account("admin", 0, SEED);
 	Afloat::<T>::set_afloat_balance(
 		RawOrigin::Signed(admin).into(),
 		user.clone(),
 		T::Balance::max_value().into(),
 	)?;
 
-	Afloat::<T>::start_take_sell_order(RawOrigin::Signed(user).into(), offer_id, 99)?;
+	Afloat::<T>::start_take_sell_order(
+		RawOrigin::Signed(user).into(),
+		offer_id,
+		T::AfloatBenchHelper::balance(99),
+	)?;
 	let offer = AfloatOffers::<T>::get(offer_id).unwrap();
 	let offer_trxs = offer.transactions.clone();
 	let trx_id = offer_trxs.last().unwrap();
@@ -186,6 +350,7 @@ mod benchmarks {
 		let creator: T::AccountId = account("creator", 0, SEED);
 		set_max_balance::<T>(admin.clone()).unwrap();
 		set_max_balance::<T>(creator.clone()).unwrap();
+		set_rbac_assign_role_to_user_worst_case::<T>(admin.clone(), 0, true).unwrap();
 		let asset_id: T::AssetId = T::AfloatBenchHelper::asset(0);
 		let min_balance: T::Balance = T::AfloatBenchHelper::balance(1);
 		let asset: CreateAsset<T> = CreateAsset::New { asset_id, min_balance };
@@ -244,17 +409,15 @@ mod benchmarks {
 			ShortString::try_from(generate_vector(0, 1, LSS)).unwrap();
 		let new_group: ShortString = ShortString::try_from(generate_vector(0, 1, LSS)).unwrap();
 
-		let update_user_info_args = UpdateUserArgs::AdminEdit {
-			cid: new_cid.clone(),
-			cid_creator: new_cid_creator,
-			group: new_group,
-		};
+		let update_user_info_args = UpdateUserArgs::Delete;
+
+		set_rbac_assign_role_to_user_worst_case::<T>(user.clone(), 1, false).unwrap();
 
 		let admin: T::AccountId = account("admin", 0, SEED);
 		#[extrinsic_call]
 		_(RawOrigin::Signed(admin.clone()), user.clone(), update_user_info_args);
 
-		assert_eq!(Afloat::<T>::user_info(&user).unwrap().cid, new_cid);
+		assert!(Afloat::<T>::user_info(&user).is_none());
 	}
 
 	#[benchmark]
@@ -271,13 +434,8 @@ mod benchmarks {
 		let description =
 			create_sized_description::<T>(<T as pallet_uniques::Config>::StringLimit::get());
 		let parent_info = create_sized_parent_info::<T>(0, 0, MAX_U32, true);
-		let _ = Afloat::<T>::create_tax_credit(
-			RawOrigin::Signed(user.clone()).into(),
-			description.clone(),
-			None,
-			None,
-		);
 		assert_eq!(attributes.len() as u32, a);
+		set_up_fruniques_do_spawn_worst_case::<T>(user.clone()).unwrap();
 		#[extrinsic_call]
 		_(RawOrigin::Signed(user.clone()), description, Some(attributes), Some(parent_info));
 	}
@@ -321,13 +479,15 @@ mod benchmarks {
 			T::Balance::max_value().into(),
 		);
 
+		set_start_take_sell_offer_worst_case::<T>(other_user.clone(), offer_id.clone()).unwrap();
+
 		#[extrinsic_call]
 		_(RawOrigin::Signed(other_user), offer_id, MAX_U32.into());
 
 		let offer = AfloatOffers::<T>::get(offer_id).unwrap();
 		let offer_trxs = offer.transactions.clone();
 		assert_eq!(offer.status, OfferStatus::CREATED);
-		assert_eq!(offer_trxs.len() as u32, 1);
+		assert_eq!(offer_trxs.len() as u32, 100);
 	}
 
 	#[benchmark]
@@ -346,6 +506,8 @@ mod benchmarks {
 		let transaction = AfloatTransactions::<T>::get(transaction_id).unwrap();
 		assert_eq!(transaction.confirmed, false);
 
+		set_gm_do_enlist_sell_offer_worst_case::<T>(other_user.clone(), offer_id).unwrap();
+
 		#[extrinsic_call]
 		_(RawOrigin::Signed(user.clone()), transaction_id);
 
@@ -414,6 +576,7 @@ mod benchmarks {
 		let admin: T::AccountId = account("admin", 0, SEED);
 		init::<T>().unwrap();
 		register_user::<T>(user.clone(), "user").unwrap();
+		set_rbac_assign_role_to_user_worst_case::<T>(user.clone(), 2, false).unwrap();
 		assert!(!Afloat::<T>::is_admin(user.clone()).unwrap());
 		#[extrinsic_call]
 		_(RawOrigin::Signed(admin.clone()), user.clone());
@@ -426,6 +589,7 @@ mod benchmarks {
 		let admin: T::AccountId = account("admin", 0, SEED);
 		init::<T>().unwrap();
 		register_user::<T>(user.clone(), "user").unwrap();
+		set_rbac_assign_role_to_user_worst_case::<T>(user.clone(), 2, false).unwrap();
 		let role: AfloatRole = AfloatRole::CPA;
 		assert!(!Afloat::<T>::is_cpa(user.clone()).unwrap());
 		#[extrinsic_call]

pallets/afloat/src/functions.rs

@@ -891,11 +891,11 @@ impl<T: Config> Pallet<T> {
 		Ok(())
 	}
 
-	fn scope_id() -> [u8; 32] {
+	pub fn scope_id() -> [u8; 32] {
 		"AfloatScope".as_bytes().using_encoded(blake2_256)
 	}
 
-	fn pallet_id() -> IdOrVec {
+	pub fn pallet_id() -> IdOrVec {
 		IdOrVec::Vec("AfloatPallet".as_bytes().to_vec())
 	}
 

pallets/afloat/src/lib.rs

@@ -386,10 +386,10 @@ pub mod pallet {
 		pub fn start_take_sell_order(
 			origin: OriginFor<T>,
 			offer_id: [u8; 32],
-			tax_credit_amount: u32,
+			tax_credit_amount: T::Balance,
 		) -> DispatchResult {
 			ensure_signed(origin.clone())?;
-			Self::do_start_take_sell_order(origin, offer_id, tax_credit_amount.into())
+			Self::do_start_take_sell_order(origin, offer_id, tax_credit_amount)
 		}
 
 		#[pallet::call_index(6)]

pallets/afloat/src/mock.rs

@@ -177,7 +177,7 @@ parameter_types! {
   pub const RoleMaxLen: u32 = 255;
   pub const PermissionMaxLen: u32 = 255;
   pub const MaxPermissionsPerRole: u32 = 30;
-  pub const MaxRolesPerUser: u32 = 10;
+  pub const MaxRolesPerUser: u32 = 6;
   pub const MaxUsersPerRole: u32 = 10;
 }
 impl pallet_rbac::Config for Test {

pallets/rbac/src/functions.rs

@@ -606,6 +606,8 @@ impl<T: Config> RoleBasedAccessControl<T::AccountId> for Pallet<T> {
 	type PermissionMaxLen = T::PermissionMaxLen;
 
 	type RoleMaxLen = T::RoleMaxLen;
+
+	type MaxScopesPerPallet = T::MaxScopesPerPallet;
 }
 
 impl<T: Config> Pallet<T> {

pallets/rbac/src/types.rs

@@ -42,6 +42,7 @@ pub trait RoleBasedAccessControl<AccountId> {
 	type MaxPermissionsPerRole: Get<u32>;
 	type RoleMaxLen: Get<u32>;
 	type PermissionMaxLen: Get<u32>;
+	type MaxScopesPerPallet: Get<u32>;
 	// scopes
 	fn create_scope(pallet: IdOrVec, scope_id: ScopeId) -> DispatchResult;
 	// scope removal