feat: benchmarks

crates/kilt-dip-support/Cargo.toml

@@ -24,8 +24,8 @@ pallet-relay-store.workspace = true
 pallet-web3-names.workspace = true
 
 # Parity dependencies
-parity-scale-codec = {workspace = true, features = ["derive"]}
-scale-info = {workspace = true, features = ["derive"]}
+parity-scale-codec = { workspace = true, features = ["derive"] }
+scale-info = { workspace = true, features = ["derive"] }
 
 # Substrate dependencies
 frame-system.workspace = true
@@ -81,5 +81,6 @@ std = [
 ]
 runtime-benchmarks = [
   "pallet-dip-consumer/runtime-benchmarks",
-  "rococo-runtime/runtime-benchmarks"
+  "rococo-runtime/runtime-benchmarks",
+  "pallet-dip-provider/runtime-benchmarks",
 ]

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;

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

@@ -133,6 +133,7 @@ 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 {
@@ -143,4 +144,5 @@ impl pallet_dip_provider::Config for Runtime {
 	type IdentityProvider = LinkedDidInfoProvider;
 	type ProviderHooks = deposit::DepositCollectorHooks;
 	type RuntimeEvent = RuntimeEvent;
+	type WeightInfo = ();
 }

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

@@ -13,19 +13,28 @@ description = "Stores all deposits under a single pallet, with suport for namesp
 [package.metadata.docs.rs]
 targets = ["x86_64-unknown-linux-gnu"]
 
+[dev-dependencies]
+sp-keystore = { workspace = true, features = ["std"] }
+
 [dependencies]
 # Substrate dependencies
 frame-support.workspace = true
 frame-system.workspace = true
 kilt-support.workspace = true
 pallet-dip-provider.workspace = true
-parity-scale-codec = {workspace = true, features = ["derive"]}
-scale-info = {workspace = true, features = ["derive"]}
+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
+pallet-balances = { workspace = true, optional = true }
+frame-benchmarking = { workspace = true, optional = true }
+sp-io = { workspace = true, optional = true }
+
+
 [features]
 default = ["std"]
 std = [
@@ -38,4 +47,9 @@ std = [
   "sp-runtime/std",
   "sp-std/std",
   "log/std",
+  "sp-keystore/std",
 ]
+
+runtime-benchmarks = ["frame-benchmarking", "pallet-balances"]
+
+try-runtime = ["kilt-support/try-runtime"]

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

@@ -0,0 +1,88 @@
+// 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 info@botlabs.org
+
+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());
+
+		#[extrinsic_call]
+		Pallet::<T>::reclaim_deposit(origin, namespace.clone(), key.clone());
+
+		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))
+	}
+}

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

@@ -19,16 +19,24 @@
 #![cfg_attr(not(feature = "std"), no_std)]
 #![recursion_limit = "256"]
 
+pub mod default_weights;
 mod deposit;
 pub mod traits;
 
+#[cfg(test)]
+mod mock;
+
+#[cfg(feature = "runtime-benchmarks")]
+mod benchmarking;
+
 pub use deposit::FixedDepositCollectorViaDepositsPallet;
 pub use pallet::*;
 pub use traits::NoopDepositStorageHooks;
 
 #[frame_support::pallet(dev_mode)]
 pub mod pallet {
 	use crate::{
+		default_weights::WeightInfo,
 		deposit::{free_deposit, reserve_deposit, DepositEntry},
 		traits::DepositStorageHooks,
 	};
@@ -67,6 +75,7 @@ pub mod pallet {
 		type Namespace: Parameter;
 		type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
 		type RuntimeHoldReason: From<HoldReason> + Clone + PartialEq + Debug + FullCodec + MaxEncodedLen + TypeInfo;
+		type WeightInfo: WeightInfo;
 	}
 
 	#[pallet::composite_enum]
@@ -110,8 +119,9 @@ pub mod pallet {
 	#[pallet::call]
 	impl<T: Config> Pallet<T> {
 		#[pallet::call_index(0)]
-		// TODO: Update weight
-		#[pallet::weight(0)]
+		#[pallet::weight({
+			<T as Config>::WeightInfo::reclaim_deposit()
+		})]
 		pub fn reclaim_deposit(origin: OriginFor<T>, namespace: T::Namespace, key: DepositKeyOf<T>) -> DispatchResult {
 			let dispatcher = T::CheckOrigin::ensure_origin(origin)?;