Removed dummy benchmarks from pallets. Updated afloat pallet mock clients to remove deprecated helper types from configs and add BenchmarkHelper types. Updated bitcoin_vaults pallet mock clients to remove deprecated helper types from configs and add BenchmarkHelper types. Updated fruniques pallet mock clients to remove deprecated helper types from configs and add BenchmarkHelper types. Updated fund admin pallet mock clients to remove deprecated helper types from configs and add BenchmarkHelper types. Updated gated marketplace pallet mock clients to remove deprecated helper types from configs and add BenchmarkHelper types. Updated mapped assets pallet mock clients to remove deprecated helper types from configs and add BenchmarkHelper types. Started developing confidential-docs benchmarking. Developed test_util module for confidential docs. Updated tests and benchmarking modules to use the new test_util module.

Author: sebastianmontero

.vscode/settings.json

@@ -13,4 +13,7 @@
     "editor.insertSpaces": true,
     "editor.tabSize": 4
   },
+  "rust-analyzer.linkedProjects": [
+    "./pallets/confidential-docs/Cargo.toml"
+  ],
 }

pallets/afloat/src/benchmarking.rs

@@ -147,8 +147,6 @@ impl pallet_uniques::Config for Test {
 	type KeyLimit = KeyLimit;
 	type ValueLimit = ValueLimit;
 	type WeightInfo = ();
-	#[cfg(feature = "runtime-benchmarks")]
-	type Helper = ();
 	type CreateOrigin = AsEnsureOriginWithArg<EnsureSigned<Self::AccountId>>;
 	type Locker = ();
 }
@@ -237,6 +235,8 @@ impl pallet_mapped_assets::Config for Test {
 	type Extra = ();
 	type RemoveItemsLimit = ConstU32<5>;
 	type Rbac = RBAC;
+	#[cfg(feature = "runtime-benchmarks")]
+	type BenchmarkHelper = ();
 }
 
 // Build genesis storage according to the mock runtime.

pallets/afloat/src/mock.rs

@@ -8,9 +8,6 @@ mod mock;
 #[cfg(test)]
 mod tests;
 
-#[cfg(feature = "runtime-benchmarks")]
-mod benchmarking;
-
 mod functions;
 pub mod types;
 

pallets/bitcoin-vaults/src/benchmarking.rs

@@ -3,48 +3,134 @@
 #![cfg(feature = "runtime-benchmarks")]
 
 use super::*;
-use crate::Pallet as ConfidentialDocs;
+use crate::{
+	test_util::*,
+	types::{Vault, *},
+	Pallet as ConfidentialDocs,
+};
 
 use frame_benchmarking::v2::*;
+use frame_support::{assert_ok, traits::Get};
 use frame_system::RawOrigin;
-use sp_runtime::traits::Bounded;
-use types::ExtraFlags;
 
 const SEED: u32 = 0;
 
-#[instance_benchmarks]
+#[benchmarks(where T: Config)]
 mod benchmarks {
 	use super::*;
 
-	// Benchmark `transfer` extrinsic with the worst possible conditions:
-	// * Transfer will kill the sender account.
-	// * Transfer will create the recipient account.
 	#[benchmark]
-	fn set_vault() {
-		let existential_deposit = T::ExistentialDeposit::get();
-		let caller = whitelisted_caller();
+	fn set_vault(c: Linear<2, { CIDSize::get() }>) {
+		let owner: T::AccountId = account("owner", 0, SEED);
+		let (user_id, public_key, cid) = generate_vault_sized(1, c);
+		let vault = Vault::<T> { cid: cid.clone(), owner: owner.clone() };
 
-		// Give some multiple of the existential deposit
-		let balance = existential_deposit.saturating_mul(ED_MULTIPLIER.into());
-		let _ = <Balances<T, I> as Currency<_>>::make_free_balance_be(&caller, balance);
+		#[extrinsic_call]
+		_(RawOrigin::Signed(owner), user_id, public_key, cid.clone());
+		assert_eq!(ConfidentialDocs::vaults(user_id), Some(vault.clone()));
+	}
 
-		// Transfer `e - 1` existential deposits + 1 unit, which guarantees to create one account,
-		// and reap this user.
-		let recipient: T::AccountId = account("recipient", 0, SEED);
-		let recipient_lookup = T::Lookup::unlookup(recipient.clone());
-		let transfer_amount =
-			existential_deposit.saturating_mul((ED_MULTIPLIER - 1).into()) + 1u32.into();
+	#[benchmark]
+	fn set_owned_document(
+		c: Linear<2, { CIDSize::get() }>,
+		n: Linear<{ T::DocNameMinLen::get() }, { T::DocNameMaxLen::get() }>,
+		d: Linear<{ T::DocDescMinLen::get() }, { T::DocDescMaxLen::get() }>,
+		o: Linear<1, { T::MaxOwnedDocs::get() - 1 }>,
+	) {
+		let owner: T::AccountId = account("owner", 0, SEED);
+		let (user_id, public_key, cid) = generate_vault_sized(1, 5);
+		assert_ok!(ConfidentialDocs::<T>::set_vault(
+			RawOrigin::Signed(owner.clone()).into(),
+			user_id,
+			public_key,
+			cid.clone(),
+		));
+		// Add "o" docs to owned docs
+		for i in 1..=o {
+			let doc = generate_owned_doc_sized(i as u8, owner.clone(), c, n, d);
+			assert_ok!(ConfidentialDocs::<T>::set_owned_document(
+				RawOrigin::Signed(owner.clone()).into(),
+				doc.clone()
+			));
+		}
+		let doc = generate_owned_doc_sized((o + 1) as u8, owner.clone(), c, n, d);
+		#[extrinsic_call]
+		_(RawOrigin::Signed(owner), doc.clone());
+		assert_eq!(ConfidentialDocs::owned_docs(&doc.cid), Some(doc.clone()));
+	}
 
+	#[benchmark]
+	fn remove_owned_document(
+		c: Linear<2, { CIDSize::get() }>,
+		n: Linear<{ T::DocNameMinLen::get() }, { T::DocNameMaxLen::get() }>,
+		d: Linear<{ T::DocDescMinLen::get() }, { T::DocDescMaxLen::get() }>,
+		o: Linear<1, { T::MaxOwnedDocs::get() }>,
+	) {
+		let owner: T::AccountId = account("owner", 0, SEED);
+		let (user_id, public_key, cid) = generate_vault_sized(1, 5);
+		assert_ok!(ConfidentialDocs::<T>::set_vault(
+			RawOrigin::Signed(owner.clone()).into(),
+			user_id,
+			public_key,
+			cid.clone(),
+		));
+		// Add "o" docs to owned docs
+		for i in 1..=o {
+			let doc = generate_owned_doc_sized(i as u8, owner.clone(), c, n, d);
+			assert_ok!(ConfidentialDocs::<T>::set_owned_document(
+				RawOrigin::Signed(owner.clone()).into(),
+				doc.clone()
+			));
+		}
+		let cid = generate_cid_sized(o as u8, c);
 		#[extrinsic_call]
-		_(RawOrigin::Signed(caller.clone()), recipient_lookup, transfer_amount);
+		_(RawOrigin::Signed(owner), cid.clone());
+		assert_eq!(ConfidentialDocs::<T>::owned_docs(cid), None);
+	}
 
-		assert_eq!(Balances::<T, I>::free_balance(&caller), Zero::zero());
-		assert_eq!(Balances::<T, I>::free_balance(&recipient), transfer_amount);
+	#[benchmark]
+	fn share_document(
+		c: Linear<2, { CIDSize::get() }>, /* starts in to so that document type id and doc id
+		                                   * fit in the vector */
+		n: Linear<{ T::DocNameMinLen::get() }, { T::DocNameMaxLen::get() }>,
+		d: Linear<{ T::DocDescMinLen::get() }, { T::DocDescMaxLen::get() }>,
+		s: Linear<1, { T::MaxSharedFromDocs::get() - 1 }>,
+	) {
+		let from: T::AccountId = account("from", 0, SEED);
+		let to: T::AccountId = account("to", 0, SEED);
+		// Setup from vault
+		let (user_id, public_key, cid) = generate_vault_sized(1, 5);
+		assert_ok!(ConfidentialDocs::<T>::set_vault(
+			RawOrigin::Signed(from.clone()).into(),
+			user_id,
+			public_key,
+			cid.clone(),
+		));
+		// Setup to vault
+		let (user_id, public_key, cid) = generate_vault_sized(2, 5);
+		assert_ok!(ConfidentialDocs::<T>::set_vault(
+			RawOrigin::Signed(to.clone()).into(),
+			user_id,
+			public_key,
+			cid.clone(),
+		));
+		// Add "s" docs to shared docs
+		for i in 1..=s {
+			let doc = generate_shared_doc_sized(i as u8, from.clone(), to.clone(), c, n, d);
+			assert_ok!(ConfidentialDocs::<T>::share_document(
+				RawOrigin::Signed(from.clone()).into(),
+				doc.clone()
+			));
+		}
+		let doc = generate_shared_doc_sized((s + 1) as u8, from.clone(), to.clone(), c, n, d);
+		#[extrinsic_call]
+		_(RawOrigin::Signed(from), doc.clone());
+		assert_eq!(ConfidentialDocs::shared_docs(&doc.cid), Some(doc.clone()));
 	}
 
 	impl_benchmark_test_suite! {
-		Balances,
-		crate::tests::ExtBuilder::default().build(),
-		crate::tests::Test,
+		ConfidentialDocs,
+		crate::mock::new_test_ext(),
+		crate::mock::Test,
 	}
 }

pallets/bitcoin-vaults/src/lib.rs

@@ -5,14 +5,15 @@
 
 pub use pallet::*;
 
+// #[cfg(feature = "runtime-benchmarks")]
+mod benchmarking;
 #[cfg(test)]
 mod mock;
 
 #[cfg(test)]
 mod tests;
 
-// #[cfg(feature = "runtime-benchmarks")]
-mod benchmarking;
+mod test_util;
 
 mod functions;
 pub mod types;

pallets/confidential-docs/src/benchmarking.rs

@@ -0,0 +1,110 @@
+use crate::{types::*, Config, Error, Event};
+use codec::Encode;
+use sp_io::hashing::blake2_256;
+
+pub fn generate_user_id(id: u8) -> UserId {
+	format!("user id: {}", id).using_encoded(blake2_256)
+}
+
+pub fn generate_public_key(id: u8) -> PublicKey {
+	format!("public key: {}", id).using_encoded(blake2_256)
+}
+
+pub fn generate_cid(id: u8) -> CID {
+	generate_cid_sized(id, 3)
+}
+
+pub fn generate_cid_sized(id: u8, size: u32) -> CID {
+	generate_vector(1, id, size).try_into().unwrap()
+}
+
+pub fn generate_doc_name<T: Config>(id: u8) -> DocName<T> {
+	generate_doc_name_sized::<T>(id, 4)
+}
+
+pub fn generate_doc_name_sized<T: Config>(id: u8, size: u32) -> DocName<T> {
+	generate_vector(2, id, size).try_into().unwrap()
+}
+
+pub fn generate_doc_desc<T: Config>(id: u8) -> DocDesc<T> {
+	generate_doc_desc_sized::<T>(id, 5)
+}
+
+pub fn generate_doc_desc_sized<T: Config>(id: u8, size: u32) -> DocDesc<T> {
+	generate_vector(3, id, size).try_into().unwrap()
+}
+
+pub fn generate_group_name<T: Config>(id: u8) -> GroupName<T> {
+	generate_group_name_sized::<T>(id, 3)
+}
+
+pub fn generate_group_name_sized<T: Config>(id: u8, size: u32) -> GroupName<T> {
+	generate_vector(4, id, size).try_into().unwrap()
+}
+
+pub fn generate_vector(prefix: u8, id: u8, size: u32) -> Vec<u8> {
+	assert!(size > 0, "vector size must be greater than 0");
+	let mut v = vec![id; size as usize];
+	v[0] = prefix;
+	v
+}
+
+// fn generate_doc_name(id: &str) -> DocName<T> {
+// 	format!("doc name:{}", id).encode().try_into().unwrap()
+// }
+
+// fn generate_doc_desc(id: &str) -> DocDesc<T> {
+// 	format!("doc desc:{}", id).encode().try_into().unwrap()
+// }
+
+// fn generate_group_name(id: &str) -> GroupName<T> {
+// 	format!("group name:{}", id).encode().try_into().unwrap()
+// }
+
+pub fn generate_vault_sized(id: u8, size: u32) -> (UserId, PublicKey, CID) {
+	(generate_user_id(id), generate_public_key(id), generate_cid_sized(id, size))
+}
+
+pub fn generate_owned_doc<T: Config>(id: u8, owner: T::AccountId) -> OwnedDoc<T> {
+	generate_owned_doc_sized(id, owner, 5, 5, 5)
+}
+
+pub fn generate_owned_doc_sized<T: Config>(
+	id: u8,
+	owner: T::AccountId,
+	cid_size: u32,
+	name_size: u32,
+	desc_size: u32,
+) -> OwnedDoc<T> {
+	OwnedDoc {
+		cid: generate_cid_sized(id, cid_size),
+		name: generate_doc_name_sized::<T>(id, name_size),
+		description: generate_doc_desc_sized::<T>(id, desc_size),
+		owner,
+	}
+}
+
+pub fn generate_shared_doc<T: Config>(
+	id: u8,
+	from: T::AccountId,
+	to: T::AccountId,
+) -> SharedDoc<T> {
+	generate_shared_doc_sized(id, from, to, 5, 5, 5)
+}
+
+pub fn generate_shared_doc_sized<T: Config>(
+	id: u8,
+	from: T::AccountId,
+	to: T::AccountId,
+	cid_size: u32,
+	name_size: u32,
+	desc_size: u32,
+) -> SharedDoc<T> {
+	SharedDoc {
+		cid: generate_cid_sized(id, cid_size),
+		name: generate_doc_name_sized::<T>(id, name_size),
+		description: generate_doc_desc_sized::<T>(id, desc_size),
+		from,
+		to,
+	}
+}