init passkey pallet (#2033)

# Goal
The goal of this PR is create an empty pallet for passkey

Closes #2026 

# Checklist
- [x] Chain spec updated
- [x] Tests added
- [x] Benchmarks added
- [x] Weights updated

Author: aramikm

Cargo.lock

@@ -123,8 +123,9 @@ benchmarks-frequency-tx-payment \
 benchmarks-overhead \
 benchmarks-schemas \
 benchmarks-stateful-storage \
-benchmarks-handles\
-benchmarks-time-release\
+benchmarks-handles \
+benchmarks-time-release \
+benchmarks-passkey \
 benchmarks-pallet_balances \
 benchmarks-pallet_collator_selection \
 benchmarks-pallet_democracy \
@@ -145,6 +146,7 @@ benchmarks-schemas-local \
 benchmarks-frequency-tx-payment-local \
 benchmarks-stateful-storage-local \
 benchmarks-handles-local \
+benchmarks-passkey-local \
 benchmarks-time-release-local \
 benchmarks-pallet_balances-local \
 benchmarks-pallet_collator_selection-local \

Makefile

@@ -0,0 +1,46 @@
+[package]
+name = "pallet-passkey"
+description = "Provides a way to execute transactions using passkey signatures."
+authors = ["Frequency"]
+edition = "2021"
+homepage = "https://frequency.xyz"
+license = "Apache-2.0"
+repository = "https://github.com/frequency-chain/frequency/"
+publish = false
+version = "0.0.0"
+
+[dependencies]
+parity-scale-codec = { workspace = true, features = ["max-encoded-len"] }
+scale-info = { workspace = true, features = ["derive"] }
+
+frame-support = { workspace = true }
+frame-system = { workspace = true }
+sp-io = { workspace = true }
+sp-runtime = { workspace = true }
+sp-std = { workspace = true }
+frame-benchmarking = { workspace = true, optional = true }
+sp-core = { workspace = true }
+log = { workspace = true, default-features = false }
+
+[dev-dependencies]
+common-runtime = { path = "../../runtime/common", default-features = false }
+
+[features]
+default = ["std"]
+std = [
+  "parity-scale-codec/std",
+  "frame-support/std",
+  "frame-system/std",
+  "scale-info/std",
+  "sp-io/std",
+  "sp-runtime/std",
+  "sp-std/std",
+  "frame-benchmarking/std",
+]
+runtime-benchmarks = [
+  "frame-support/runtime-benchmarks",
+  "frame-system/runtime-benchmarks",
+  "sp-runtime/runtime-benchmarks",
+  "frame-benchmarking/runtime-benchmarks"
+]
+try-runtime = ["frame-support/try-runtime", "frame-system/try-runtime"]

pallets/passkey/Cargo.toml

@@ -0,0 +1,3 @@
+# Passkey Pallet
+
+Provides a way to execute transactions using passkey signatures.

pallets/passkey/README.md

@@ -0,0 +1,22 @@
+#![allow(clippy::unwrap_used)]
+use super::*;
+
+#[allow(unused)]
+use crate::Pallet as Passkey;
+use frame_benchmarking::{benchmarks, whitelisted_caller};
+use frame_system::RawOrigin;
+use sp_std::prelude::*;
+
+benchmarks! {
+	proxy {
+		let caller: T::AccountId = whitelisted_caller();
+	}: _(RawOrigin::Signed(caller))
+	verify {
+	}
+
+	impl_benchmark_test_suite!(
+		Passkey,
+		crate::mock::new_test_ext(),
+		crate::mock::Test
+	);
+}

pallets/passkey/src/benchmarking.rs

@@ -0,0 +1,94 @@
+//! Using Passkeys to execute transactions
+//!
+//! ## Quick Links
+//! - [Configuration: `Config`](Config)
+//! - [Extrinsics: `Call`](Call)
+//! - [Event Enum: `Event`](Event)
+//! - [Error Enum: `Error`](Error)
+#![doc = include_str!("../README.md")]
+// Substrate macros are tripping the clippy::expect_used lint.
+#![allow(clippy::expect_used)]
+#![cfg_attr(not(feature = "std"), no_std)]
+// Strong Documentation Lints
+#![deny(
+	rustdoc::broken_intra_doc_links,
+	rustdoc::missing_crate_level_docs,
+	rustdoc::invalid_codeblock_attributes,
+	missing_docs
+)]
+
+use frame_support::{
+	dispatch::{DispatchResult, GetDispatchInfo, PostDispatchInfo},
+	pallet_prelude::*,
+	traits::IsSubType,
+};
+use frame_system::pallet_prelude::*;
+use sp_runtime::traits::Dispatchable;
+
+#[cfg(test)]
+mod mock;
+#[cfg(test)]
+mod tests;
+
+pub mod weights;
+pub use weights::*;
+
+#[cfg(feature = "runtime-benchmarks")]
+mod benchmarking;
+
+pub use module::*;
+
+#[frame_support::pallet]
+pub mod module {
+	use super::*;
+
+	/// the storage version for this pallet
+	pub const STORAGE_VERSION: StorageVersion = StorageVersion::new(0);
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+		/// The overarching event type.
+		type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+
+		/// The overarching call type.
+		type RuntimeCall: Parameter
+			+ Dispatchable<RuntimeOrigin = Self::RuntimeOrigin, PostInfo = PostDispatchInfo>
+			+ GetDispatchInfo
+			+ From<frame_system::Call<Self>>
+			+ IsSubType<Call<Self>>
+			+ IsType<<Self as frame_system::Config>::RuntimeCall>;
+
+		/// Weight information for extrinsics in this pallet.
+		type WeightInfo: WeightInfo;
+	}
+
+	#[pallet::error]
+	pub enum Error<T> {
+		/// PlaceHolder error
+		PlaceHolderError,
+	}
+
+	#[pallet::event]
+	#[pallet::generate_deposit(fn deposit_event)]
+	pub enum Event<T: Config> {
+		/// PlaceHolder event
+		PlaceHolderEvent,
+	}
+
+	#[pallet::pallet]
+	#[pallet::storage_version(STORAGE_VERSION)]
+	pub struct Pallet<T>(_);
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		/// proxy call
+		#[pallet::call_index(0)]
+		#[pallet::weight(T::WeightInfo::proxy())]
+		pub fn proxy(_origin: OriginFor<T>) -> DispatchResult {
+			Self::deposit_event(Event::PlaceHolderEvent);
+			Ok(())
+		}
+	}
+}
+
+impl<T: Config> Pallet<T> {}

pallets/passkey/src/lib.rs

@@ -0,0 +1,61 @@
+//! Mocks for the Time-release module.
+
+use super::*;
+use frame_support::{
+	construct_runtime,
+	traits::{ConstU32, Everything},
+};
+use sp_core::H256;
+use sp_runtime::{traits::IdentityLookup, BuildStorage};
+
+use crate as pallet_passkey;
+
+pub type AccountId = u128;
+impl frame_system::Config for Test {
+	type RuntimeOrigin = RuntimeOrigin;
+	type RuntimeCall = RuntimeCall;
+	type Nonce = u64;
+	type Hash = H256;
+	type Hashing = ::sp_runtime::traits::BlakeTwo256;
+	type AccountId = AccountId;
+	type Lookup = IdentityLookup<Self::AccountId>;
+	type RuntimeEvent = RuntimeEvent;
+	type Block = Block;
+	type BlockHashCount = ConstU32<250>;
+	type BlockWeights = ();
+	type BlockLength = ();
+	type Version = ();
+	type PalletInfo = PalletInfo;
+	type AccountData = ();
+	type OnNewAccount = ();
+	type OnKilledAccount = ();
+	type DbWeight = ();
+	type BaseCallFilter = Everything;
+	type SystemWeightInfo = ();
+	type SS58Prefix = ();
+	type OnSetCode = ();
+	type MaxConsumers = ConstU32<16>;
+}
+
+impl Config for Test {
+	type RuntimeEvent = RuntimeEvent;
+	type WeightInfo = ();
+	type RuntimeCall = RuntimeCall;
+}
+
+type Block = frame_system::mocking::MockBlockU32<Test>;
+
+construct_runtime!(
+	pub enum Test
+	{
+		System: frame_system::{Pallet, Call, Storage, Config<T>, Event<T>},
+		Passkey: pallet_passkey::{Pallet, Storage, Call, Event<T>},
+	}
+);
+
+pub fn new_test_ext() -> sp_io::TestExternalities {
+	let mut ext: sp_io::TestExternalities =
+		frame_system::GenesisConfig::<Test>::default().build_storage().unwrap().into();
+	ext.execute_with(|| System::set_block_number(1));
+	ext
+}

pallets/passkey/src/mock.rs

@@ -0,0 +1,12 @@
+//! Unit tests for the passkey module.
+use super::*;
+use frame_support::assert_ok;
+use mock::*;
+
+#[test]
+fn test_works() {
+	new_test_ext().execute_with(|| {
+		let caller_1 = 5;
+		assert_ok!(Passkey::proxy(RuntimeOrigin::signed(caller_1),));
+	});
+}

pallets/passkey/src/tests.rs

@@ -0,0 +1,84 @@
+
+//! Autogenerated weights for `pallet_passkey`
+//!
+//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
+//! DATE: 2024-06-14, STEPS: `20`, REPEAT: `10`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! WORST CASE MAP SIZE: `1000000`
+//! HOSTNAME: `ip-10-99-10-9.us-east-2.compute.internal`, CPU: `<UNKNOWN>`
+//! WASM-EXECUTION: `Compiled`, CHAIN: `Some("frequency-bench")`, DB CACHE: `1024`
+
+// Executed Command:
+// ./scripts/../target/bench-dev/frequency
+// benchmark
+// pallet
+// --pallet=pallet_passkey
+// --extrinsic
+// *
+// --chain=frequency-bench
+// --heap-pages=4096
+// --wasm-execution=compiled
+// --additional-trie-layers=5
+// --steps=20
+// --repeat=10
+// --output=./scripts/../pallets/passkey/src/weights.rs
+// --template=./scripts/../.maintain/frame-weight-template.hbs
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+#![allow(missing_docs)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use core::marker::PhantomData;
+
+/// Weight functions needed for `pallet_passkey`.
+pub trait WeightInfo {
+	fn proxy() -> Weight;
+}
+
+/// Weights for `pallet_passkey` using the Substrate node and recommended hardware.
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	fn proxy() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 3_000_000 picoseconds.
+		Weight::from_parts(4_000_000, 0)
+	}
+}
+
+// For backwards compatibility and tests.
+impl WeightInfo for () {
+	fn proxy() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 3_000_000 picoseconds.
+		Weight::from_parts(4_000_000, 0)
+	}
+}
+
+
+#[cfg(test)]
+mod tests {
+  use frame_support::{traits::Get, weights::Weight, dispatch::DispatchClass};
+  use common_runtime::constants::{MAXIMUM_BLOCK_WEIGHT, NORMAL_DISPATCH_RATIO};
+  use common_runtime::weights::extrinsic_weights::ExtrinsicBaseWeight;
+
+  struct BlockWeights;
+  impl Get<frame_system::limits::BlockWeights> for BlockWeights {
+  	fn get() -> frame_system::limits::BlockWeights {
+  		frame_system::limits::BlockWeights::builder()
+  			.base_block(Weight::zero())
+  			.for_class(DispatchClass::all(), |weights| {
+  				weights.base_extrinsic = ExtrinsicBaseWeight::get().into();
+  			})
+  			.for_class(DispatchClass::non_mandatory(), |weights| {
+  				weights.max_total = Some(NORMAL_DISPATCH_RATIO * MAXIMUM_BLOCK_WEIGHT);
+  			})
+  			.build_or_panic()
+  	}
+  }
+
+}