feat(fc-pallet-pass): first benchmark

pallets/pass/src/benchmarking.rs

@@ -3,24 +3,56 @@
 use super::*;
 use crate::Pallet;
 use frame_benchmarking::v2::*;
+use sp_runtime::traits::Hash;
 
-fn assert_last_event<T: Config<I>, I: 'static>(generic_event: <T as Config<I>>::RuntimeEvent) {
-    frame_system::Pallet::<T>::assert_last_event(generic_event.into());
+type RuntimeEventFor<T, I> = <T as Config<I>>::RuntimeEvent;
+
+fn assert_has_event<T: Config<I>, I: 'static>(generic_event: RuntimeEventFor<T, I>) {
+    frame_system::Pallet::<T>::assert_has_event(generic_event.into());
+}
+
+fn setup_signers<T: frame_system::Config>() -> (T::AccountId, T::AccountId) {
+    (
+        frame_benchmarking::account("signer", 0, 0),
+        frame_benchmarking::account("signer", 1, 0),
+    )
 }
 
-#[benchmarks]
+fn hash<T: frame_system::Config>(b: &[u8]) -> HashedUserId
+where
+    T::Hash: Into<HashedUserId>,
+{
+    T::Hashing::hash(b).into()
+}
+
+#[instance_benchmarks(
+where
+    T: frame_system::Config + crate::Config<I>,
+    T::Hash: Into<HashedUserId>,
+    RuntimeEventFor<T, I>: From<frame_system::Event<T>>,
+)]
 mod benchmarks {
     use super::*;
 
     #[benchmark]
-    pub fn register() {
+    pub fn register() -> Result<(), BenchmarkError> {
         // Setup code
+        let (one, _) = setup_signers::<T>();
+        let user_id = hash::<T>(&*b"my-account");
+        let account_id = Pallet::<T, I>::account_id_for(user_id)?;
+        let device_id = [0u8; 32];
 
         #[extrinsic_call]
-        _(RawOrigin::Root);
+        _(
+            RawOrigin::Signed(one),
+            user_id,
+            T::BenchmarkHelper::device_attestation(device_id),
+        );
 
         // Verification code
-        assert_last_event::<T>(Event::Success.into());
+        assert_has_event::<T, I>(Event::Registered { who: account_id }.into());
+
+        Ok(())
     }
 
     impl_benchmark_test_suite!(Pallet, crate::mock::new_test_ext(), crate::mock::Test);

pallets/pass/src/lib.rs

@@ -59,6 +59,9 @@ pub mod pallet {
         type MaxSessionDuration: Get<BlockNumberFor<Self>>;
 
         type RegisterOrigin: EnsureOriginWithArg<Self::RuntimeOrigin, HashedUserId>;
+
+        #[cfg(feature = "runtime-benchmarks")]
+        type BenchmarkHelper: BenchmarkHelper<Self, I>;
     }
 
     #[pallet::pallet]

pallets/pass/src/mock.rs

@@ -1,6 +1,6 @@
 //! Test environment for pallet pass.
 
-use crate::{self as pallet_pass, Config};
+use crate::{self as pallet_pass, Config, CredentialOf, DeviceAttestationOf};
 pub use authenticators::*;
 use codec::{Decode, Encode, MaxEncodedLen};
 use fc_traits_authn::{composite_authenticators, util::AuthorityFromPalletId, Challenger};
@@ -100,6 +100,28 @@ impl Config for Test {
     type PalletId = PassPalletId;
     type PalletsOrigin = OriginCaller;
     type MaxSessionDuration = ConstU64<10>;
+    #[cfg(feature = "runtime-benchmarks")]
+    type BenchmarkHelper = BenchmarkHelper;
+}
+
+#[cfg(feature = "runtime-benchmarks")]
+pub struct BenchmarkHelper;
+
+#[cfg(feature = "runtime-benchmarks")]
+impl pallet_pass::BenchmarkHelper<Test> for BenchmarkHelper {
+    fn device_attestation(device_id: DeviceId) -> DeviceAttestationOf<Test, ()> {
+        PassDeviceAttestation::AuthenticatorA(authenticator_a::DeviceAttestation {
+            device_id,
+            challenge: AuthenticatorA::generate(&()),
+        })
+    }
+
+    fn credential(user_id: HashedUserId) -> CredentialOf<Test, ()> {
+        PassCredential::AuthenticatorA(authenticator_a::Credential {
+            user_id,
+            challenge: AuthenticatorA::generate(&()),
+        })
+    }
 }
 
 pub fn new_test_ext() -> sp_io::TestExternalities {

pallets/pass/src/types.rs

@@ -1,10 +1,23 @@
 use crate::Config;
+use fc_traits_authn::HashedUserId;
 use sp_runtime::traits::StaticLookup;
 
 // pub type HashedUserId<T> = <T as frame_system::Config>::Hash;
+pub type ContextOf<T, I> =
+    <<<T as Config<I>>::Authenticator as fc_traits_authn::Authenticator>::Challenger as fc_traits_authn::Challenger>::Context;
 pub type DeviceOf<T, I> =
     <<T as Config<I>>::Authenticator as fc_traits_authn::Authenticator>::Device;
 pub type CredentialOf<T, I> = <DeviceOf<T, I> as fc_traits_authn::UserAuthenticator>::Credential;
 pub type DeviceAttestationOf<T, I> =
     <<T as Config<I>>::Authenticator as fc_traits_authn::Authenticator>::DeviceAttestation;
 pub type AccountIdLookupOf<T> = <<T as frame_system::Config>::Lookup as StaticLookup>::Source;
+
+#[cfg(feature = "runtime-benchmarks")]
+pub trait BenchmarkHelper<T, I = ()>
+where
+    T: Config<I>,
+    I: 'static,
+{
+    fn device_attestation(device_id: fc_traits_authn::DeviceId) -> DeviceAttestationOf<T, I>;
+    fn credential(user_id: HashedUserId) -> CredentialOf<T, I>;
+}