feat: benchmarks

crates/kilt-dip-support/Cargo.toml

@@ -81,5 +81,6 @@ std = [
 ]
 runtime-benchmarks = [
   "pallet-dip-consumer/runtime-benchmarks",
+  "pallet-dip-provider/runtime-benchmarks",
   "rococo-runtime/runtime-benchmarks"
 ]

crates/kilt-dip-support/src/export/child.rs

@@ -629,7 +629,6 @@ mod v0 {
 			// 1.2 If so, extract the state root from the header
 			let state_root_at_height = proof.relay_header.state_root;
 
-			// FIXME: Compilation error
 			// 2. Verify relay chain proof
 			let provider_parachain_header =
 				ParachainHeadProofVerifier::<RelayChainInfo>::verify_proof_for_parachain_with_root(

dip-template/runtimes/dip-consumer/src/dip.rs

@@ -49,6 +49,7 @@ impl pallet_dip_consumer::Config for Runtime {
 	type ProofVerifier = ProofVerifier;
 	type RuntimeCall = RuntimeCall;
 	type RuntimeOrigin = RuntimeOrigin;
+	type WeightInfo = ();
 }
 
 pub struct PreliminaryDipOriginFilter;
@@ -123,4 +124,5 @@ impl DipCallOriginFilter<RuntimeCall> for DipCallFilter {
 
 impl pallet_relay_store::Config for Runtime {
 	type MaxRelayBlocksStored = ConstU32<100>;
+	type WeightInfo = ();
 }

dip-template/runtimes/dip-consumer/src/origin_adapter.rs

@@ -35,8 +35,7 @@ impl EnsureOrigin<RuntimeOrigin> for EnsureDipOriginAdapter {
 
 	#[cfg(feature = "runtime-benchmarks")]
 	fn try_successful_origin() -> Result<RuntimeOrigin, ()> {
-		// TODO: Replace with actual DIP origin upon benchmarking
-		Ok(RuntimeOrigin::root())
+		EnsureDipOrigin::<DidIdentifier, AccountId, MerkleProofVerifierOutput>::try_successful_origin()
 	}
 }
 

dip-template/runtimes/dip-provider/Cargo.toml

@@ -66,6 +66,9 @@ cumulus-primitives-utility.workspace = true
 pallet-collator-selection.workspace = true
 parachain-info.workspace = true
 
+# Benchmarks
+frame-benchmarking = {workspace = true, optional = true}
+
 [features]
 default = [
 	"std",
@@ -115,7 +118,8 @@ std = [
 	"cumulus-primitives-timestamp/std",
 	"cumulus-primitives-utility/std",
   "pallet-collator-selection/std",
-  "parachain-info/std"
+  "parachain-info/std",
+  "frame-benchmarking?/std",
 ]
 runtime-benchmarks = [
   "did/runtime-benchmarks",
@@ -126,5 +130,6 @@ runtime-benchmarks = [
   "runtime-common/runtime-benchmarks",
   "frame-system/runtime-benchmarks",
   "frame-support/runtime-benchmarks",
-  "pallet-utility/runtime-benchmarks"
+  "pallet-utility/runtime-benchmarks",
+  "frame-benchmarking/runtime-benchmarks",
 ]

dip-template/runtimes/dip-provider/src/dip.rs

@@ -34,6 +34,8 @@ use crate::{
 	AccountId, Balances, DidIdentifier, Runtime, RuntimeEvent, RuntimeHoldReason,
 };
 
+const MAX_LINKED_ACCOUNTS: u32 = 20;
+
 pub mod runtime_api {
 	use super::*;
 
@@ -133,14 +135,16 @@ impl pallet_deposit_storage::Config for Runtime {
 	type Namespace = DepositNamespaces;
 	type RuntimeEvent = RuntimeEvent;
 	type RuntimeHoldReason = RuntimeHoldReason;
+	type WeightInfo = ();
 }
 
 impl pallet_dip_provider::Config for Runtime {
 	type CommitOriginCheck = EnsureDidOrigin<DidIdentifier, AccountId>;
 	type CommitOrigin = DidRawOrigin<DidIdentifier, AccountId>;
 	type Identifier = DidIdentifier;
 	type IdentityCommitmentGenerator = DidMerkleRootGenerator<Runtime>;
-	type IdentityProvider = LinkedDidInfoProvider;
+	type IdentityProvider = LinkedDidInfoProvider<MAX_LINKED_ACCOUNTS>;
 	type ProviderHooks = deposit::DepositCollectorHooks;
 	type RuntimeEvent = RuntimeEvent;
+	type WeightInfo = ();
 }

dip-template/runtimes/dip-provider/src/lib.rs

@@ -434,6 +434,30 @@ impl pallet_web3_names::Config for Runtime {
 	type WeightInfo = ();
 }
 
+#[cfg(feature = "runtime-benchmarks")]
+mod benches {
+	frame_benchmarking::define_benchmarks!(
+		[frame_system, SystemBench::<Runtime>]
+		[cumulus_pallet_parachain_system, ParachainSystem]
+		[pallet_timestamp, Timestamp]
+		[pallet_sudo, Sudo]
+		[pallet_utility, Utility]
+		[pallet_balances, Balances]
+		[pallet_transaction_payment, TransactionPayment]
+		[pallet_authorship, Authorship]
+		[pallet_collator_selection, CollatorSelection]
+		[pallet_session, Session]
+		[pallet_aura, Aura]
+		[cumulus_pallet_aura_ext, AuraExt]
+		[did, Did]
+		[pallet_did_lookup, DidLookup]
+		[pallet_web3_names, Web3Names]
+		[pallet_deposit_storage, DepositStorage]
+		[pallet_dip_provider, DipProvider]
+		[frame_benchmarking::baseline, Baseline::<Runtime>]
+	);
+}
+
 impl_runtime_apis! {
 	impl sp_consensus_aura::AuraApi<Block, AuraId> for Runtime {
 		fn slot_duration() -> SlotDuration {

pallets/ctype/src/lib.rs

@@ -94,7 +94,7 @@ pub mod pallet {
 
 	#[pallet::config]
 	pub trait Config: frame_system::Config {
-		type EnsureOrigin: EnsureOrigin<<Self as frame_system::Config>::RuntimeOrigin, Success = Self::OriginSuccess>;
+		type EnsureOrigin: EnsureOrigin<Self::RuntimeOrigin, Success = Self::OriginSuccess>;
 		type OverarchingOrigin: EnsureOrigin<<Self as frame_system::Config>::RuntimeOrigin>;
 		type OriginSuccess: CallSources<AccountIdOf<Self>, CtypeCreatorOf<Self>>;
 		type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;

pallets/pallet-deposit-storage/Cargo.toml

@@ -1,41 +1,63 @@
 [package]
 authors.workspace = true
+description = "Stores all deposits under a single pallet, with suport for namespacing different deposit contexts."
 documentation.workspace = true
 edition.workspace = true
 homepage.workspace = true
 license-file.workspace = true
+name = "pallet-deposit-storage"
 readme.workspace = true
 repository.workspace = true
 version.workspace = true
-name = "pallet-deposit-storage"
-description = "Stores all deposits under a single pallet, with suport for namespacing different deposit contexts."
 
 [package.metadata.docs.rs]
 targets = ["x86_64-unknown-linux-gnu"]
 
+[dev-dependencies]
+pallet-balances = {workspace = true, features = ["std"]}
+sp-io = {workspace = true, features = ["std"]}
+sp-keystore = {workspace = true, features = ["std"]}
+
 [dependencies]
 # Substrate dependencies
 frame-support.workspace = true
 frame-system.workspace = true
 kilt-support.workspace = true
+log.workspace = true
 pallet-dip-provider.workspace = true
 parity-scale-codec = {workspace = true, features = ["derive"]}
 scale-info = {workspace = true, features = ["derive"]}
 sp-runtime.workspace = true
 sp-std.workspace = true
 
-log.workspace = true
+# Benchmarking
+frame-benchmarking = {workspace = true, optional = true}
+pallet-balances = {workspace = true, optional = true}
 
 [features]
 default = ["std"]
 std = [
   "frame-support/std",
   "frame-system/std",
   "kilt-support/std",
+  "log/std",
   "pallet-dip-provider/std",
   "parity-scale-codec/std",
   "scale-info/std",
   "sp-runtime/std",
   "sp-std/std",
-  "log/std",
+  "frame-benchmarking?/std",
+  "pallet-balances?/std",
 ]
+
+runtime-benchmarks = [
+  "frame-support/runtime-benchmarks",
+  "frame-system/runtime-benchmarks",
+  "kilt-support/runtime-benchmarks",
+  "pallet-dip-provider/runtime-benchmarks",
+  "sp-runtime/runtime-benchmarks",
+  "frame-benchmarking/runtime-benchmarks",
+  "pallet-balances/runtime-benchmarks",
+]
+
+try-runtime = [ "kilt-support/try-runtime" ]

pallets/pallet-deposit-storage/src/benchmarking.rs

@@ -0,0 +1,91 @@
+// KILT Blockchain – https://botlabs.org
+// Copyright (C) 2019-2023 BOTLabs GmbH
+
+// The KILT Blockchain is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// The KILT Blockchain is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+// If you feel like getting in touch with us, you can do so at [email protected]
+
+use crate::{Call, Config, DepositEntryOf, DepositKeyOf, Deposits, HoldReason, Pallet};
+use frame_benchmarking::v2::*;
+use frame_support::traits::fungible::Mutate;
+use frame_system::RawOrigin;
+use kilt_support::{traits::Instanciate, Deposit};
+use sp_runtime::SaturatedConversion;
+
+#[benchmarks(
+	where
+		T::AccountId: Instanciate,
+        T: Config + pallet_balances::Config,
+        T::Namespace: Default
+)]
+mod benchmarks {
+
+	use sp_runtime::BoundedVec;
+
+	use super::*;
+
+	const KILT: u128 = 10u128.pow(15);
+
+	#[benchmark]
+	fn reclaim_deposit() {
+		let submitter = T::AccountId::new(1);
+
+		let origin = RawOrigin::Signed(submitter.clone());
+
+		let namespace: <T as Config>::Namespace = Default::default();
+
+		let key: DepositKeyOf<T> = BoundedVec::try_from(vec![1]).expect("Creation of key should not fail.");
+
+		assert!(Deposits::<T>::get(&namespace, &key).is_none());
+
+		let entry = DepositEntryOf::<T> {
+			deposit: Deposit {
+				amount: KILT.saturated_into(),
+				owner: submitter.clone(),
+			},
+			reason: <T as Config>::RuntimeHoldReason::from(HoldReason::Deposit),
+		};
+
+		let amount = KILT * 100;
+
+		<pallet_balances::Pallet<T> as Mutate<<T as frame_system::Config>::AccountId>>::set_balance(
+			&submitter,
+			amount.saturated_into(),
+		);
+
+		Pallet::<T>::add_deposit(namespace.clone(), key.clone(), entry).expect("Creating Deposit should not fail.");
+
+		assert!(Deposits::<T>::get(&namespace, &key).is_some());
+
+		let cloned_namespace = namespace.clone();
+		let cloned_key = key.clone();
+
+		#[extrinsic_call]
+		Pallet::<T>::reclaim_deposit(origin, cloned_namespace, cloned_key);
+
+		assert!(Deposits::<T>::get(&namespace, &key).is_none());
+	}
+
+	#[cfg(test)]
+	mod benchmarks_tests {
+		use crate::Pallet;
+		use frame_benchmarking::impl_benchmark_test_suite;
+
+		impl_benchmark_test_suite!(
+			Pallet,
+			crate::mock::ExtBuilder::default().build_with_keystore(),
+			crate::mock::TestRuntime,
+		);
+	}
+}

pallets/pallet-deposit-storage/src/default_weights.rs

@@ -0,0 +1,73 @@
+
+//! Autogenerated weights for pallet_deposit_storage
+//!
+//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
+//! DATE: 2023-11-24
+//! STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! WORST CASE MAP SIZE: `1000000`
+//! HOSTNAME: `rust-2`, CPU: `12th Gen Intel(R) Core(TM) i9-12900K`
+//! EXECUTION: , WASM-EXECUTION: Compiled, CHAIN: None, DB CACHE: 1024
+
+// Executed Command:
+// ./target/debug/kilt-parachain
+// benchmark
+// pallet
+// --pallet
+// pallet-deposit-storage
+// --extrinsic
+// *
+// --template
+// ./.maintain/weight-template.hbs
+// --output
+// ./pallets/pallet-deposit-storage/src/defaul_weights.rs
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use sp_std::marker::PhantomData;
+
+/// Weight functions needed for pallet_deposit_storage.
+pub trait WeightInfo {
+	fn reclaim_deposit() -> Weight;
+}
+
+/// Weights for pallet_deposit_storage using the Substrate node and recommended hardware.
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	/// Storage: `StorageDeposit::Deposits` (r:1 w:1)
+	/// Proof: `StorageDeposit::Deposits` (`max_values`: None, `max_size`: None, mode: `Measured`)
+	/// Storage: `System::Account` (r:1 w:1)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(132), added: 2607, mode: `MaxEncodedLen`)
+	/// Storage: `Balances::Holds` (r:1 w:1)
+	/// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(949), added: 3424, mode: `MaxEncodedLen`)
+	fn reclaim_deposit() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `907`
+		//  Estimated: `4414`
+		// Minimum execution time: 704_964 nanoseconds.
+		Weight::from_parts(1_003_107_000, 4414)
+			.saturating_add(T::DbWeight::get().reads(3_u64))
+			.saturating_add(T::DbWeight::get().writes(3_u64))
+	}
+}
+
+// For backwards compatibility and tests
+impl WeightInfo for () {
+	/// Storage: `StorageDeposit::Deposits` (r:1 w:1)
+	/// Proof: `StorageDeposit::Deposits` (`max_values`: None, `max_size`: None, mode: `Measured`)
+	/// Storage: `System::Account` (r:1 w:1)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(132), added: 2607, mode: `MaxEncodedLen`)
+	/// Storage: `Balances::Holds` (r:1 w:1)
+	/// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(949), added: 3424, mode: `MaxEncodedLen`)
+	fn reclaim_deposit() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `907`
+		//  Estimated: `4414`
+		// Minimum execution time: 704_964 nanoseconds.
+		Weight::from_parts(1_003_107_000, 4414)
+			.saturating_add(RocksDbWeight::get().reads(3_u64))
+			.saturating_add(RocksDbWeight::get().writes(3_u64))
+	}
+}