Include permmisions complexity in extrinsic weight. (#1192)

Author: Neopallium

pallets/common/src/traits/identity.rs

@@ -33,8 +33,8 @@ use frame_support::{
     Parameter,
 };
 use polymesh_primitives::{
-    secondary_key::api::SecondaryKey, AuthorizationData, IdentityClaim, IdentityId, InvestorUid,
-    Permissions, Signatory, Ticker,
+    secondary_key::api::{LegacyPermissions, SecondaryKey},
+    AuthorizationData, IdentityClaim, IdentityId, InvestorUid, Permissions, Signatory, Ticker,
 };
 use sp_core::H512;
 use sp_runtime::traits::{Dispatchable, IdentifyAccount, Member, Verify};
@@ -87,6 +87,12 @@ pub trait WeightInfo {
     fn add_claim() -> Weight;
     fn revoke_claim() -> Weight;
     fn set_permission_to_signer() -> Weight;
+    /// Complexity Parameters:
+    /// `a` = Number of (A)ssets
+    /// `p` = Number of (P)ortfolios
+    /// `l` = Number of pa(L)lets
+    /// `e` = Number of (E)xtrinsics
+    fn permissions_cost(a: u32, p: u32, l: u32, e: u32) -> Weight;
     fn freeze_secondary_keys() -> Weight;
     fn unfreeze_secondary_keys() -> Weight;
     fn add_authorization() -> Weight;
@@ -95,6 +101,44 @@ pub trait WeightInfo {
     fn add_investor_uniqueness_claim() -> Weight;
     fn add_investor_uniqueness_claim_v2() -> Weight;
     fn revoke_claim_by_index() -> Weight;
+
+    // Helpers for extrinsics with Permissions.
+    fn add_secondary_keys_full<AccountId>(
+        additional_keys: &[SecondaryKeyWithAuth<AccountId>],
+    ) -> Weight {
+        let perm_cost = additional_keys.iter().fold(0u64, |cost, key_with_auth| {
+            let (assets, portfolios, pallets, extrinsics) =
+                key_with_auth.secondary_key.permissions.get_weights();
+            let perm_cost = Self::permissions_cost(assets, portfolios, pallets, extrinsics);
+            cost.saturating_add(perm_cost)
+        });
+        perm_cost.saturating_add(Self::add_secondary_keys_with_authorization(
+            additional_keys.len() as u32,
+        ))
+    }
+
+    fn add_authorization_full<AccountId>(data: &AuthorizationData<AccountId>) -> Weight {
+        let perm_cost = match data {
+            AuthorizationData::JoinIdentity(perms) => {
+                let (assets, portfolios, pallets, extrinsics) = perms.get_weights();
+                Self::permissions_cost(assets, portfolios, pallets, extrinsics)
+            }
+            _ => 0,
+        };
+
+        perm_cost.saturating_add(Self::add_authorization())
+    }
+
+    fn set_permission_to_signer_full(perms: &Permissions) -> Weight {
+        let (assets, portfolios, pallets, extrinsics) = perms.get_weights();
+        Self::permissions_cost(assets, portfolios, pallets, extrinsics)
+            .saturating_add(Self::set_permission_to_signer())
+    }
+    fn legacy_set_permission_to_signer_full(perms: &LegacyPermissions) -> Weight {
+        let (assets, portfolios, pallets, extrinsics) = perms.get_weights();
+        Self::permissions_cost(assets, portfolios, pallets, extrinsics)
+            .saturating_add(Self::set_permission_to_signer())
+    }
 }
 
 /// The module's configuration trait.

pallets/identity/src/benchmarking.rs

@@ -25,8 +25,10 @@ use polymesh_common_utilities::{
 };
 use polymesh_primitives::{
     investor_zkproof_data::{v1, v2},
-    AuthorizationData, Claim, CountryCode, IdentityId, InvestorUid, Permissions, Scope, ScopeId,
-    SecondaryKey, Signatory,
+    secondary_key::DispatchableNames,
+    AssetPermissions, AuthorizationData, Claim, CountryCode, DispatchableName,
+    ExtrinsicPermissions, IdentityId, InvestorUid, PalletName, PalletPermissions, Permissions,
+    PortfolioId, PortfolioNumber, PortfolioPermissions, Scope, ScopeId, SecondaryKey, Signatory,
 };
 use sp_core::H512;
 use sp_std::prelude::*;
@@ -132,11 +134,19 @@ pub fn generate_secondary_keys<T: Config>(n: usize) -> Vec<SecondaryKey<T::Accou
 #[cfg(feature = "running-ci")]
 mod limits {
     pub const MAX_SECONDARY_KEYS: u32 = 2;
+    pub const MAX_ASSETS: u32 = 4;
+    pub const MAX_PORTFOLIOS: u32 = 4;
+    pub const MAX_PALLETS: u32 = 4;
+    pub const MAX_EXTRINSICS: u32 = 4;
 }
 
 #[cfg(not(feature = "running-ci"))]
 mod limits {
     pub const MAX_SECONDARY_KEYS: u32 = 100;
+    pub const MAX_ASSETS: u32 = 100;
+    pub const MAX_PORTFOLIOS: u32 = 100;
+    pub const MAX_PALLETS: u32 = 100;
+    pub const MAX_EXTRINSICS: u32 = 100;
 }
 
 use limits::*;
@@ -295,6 +305,50 @@ benchmarks! {
         Module::<T>::unsafe_join_identity(target.did(), Permissions::empty(), key.account());
     }: _(target.origin, signatory, Permissions::default().into())
 
+    permissions_cost {
+        // Number of assets/portfolios/pallets/extrinsics.
+        let a in 0 .. MAX_ASSETS; // a=(A)ssets
+        let p in 0 .. MAX_PORTFOLIOS; // p=(P)ortfolios
+        let l in 0 .. MAX_PALLETS; // l=pa(L)lets
+        let e in 0 .. MAX_EXTRINSICS; // e=(E)xtrinsics
+
+        let asset = AssetPermissions::elems(
+            (0..a as u64).map(Ticker::generate_into)
+        );
+        let portfolio = PortfolioPermissions::elems(
+            (0..p as u128).map(|did| {
+                PortfolioId::user_portfolio(did.into(), PortfolioNumber(0))
+            })
+        );
+        let dispatchable_names = DispatchableNames::elems(
+            (0..e as u64).map(|e| {
+                DispatchableName(Ticker::generate(e))
+            })
+        );
+        let extrinsic = ExtrinsicPermissions::elems(
+            (0..l as u64).map(|p| {
+                PalletPermissions {
+                    pallet_name: PalletName(Ticker::generate(p)),
+                    dispatchable_names: dispatchable_names.clone(),
+                }
+            })
+        );
+
+        let permissions = Permissions {
+            asset,
+            extrinsic,
+            portfolio
+        };
+
+        let orig = permissions.clone();
+    }: {
+        let enc = permissions.encode();
+        // Panic the benchmarks if decoding fails.
+        let perm = Permissions::decode(&mut enc.as_slice())
+            .expect("Permissions should decode correctly.");
+        assert_eq!(orig, perm);
+    }
+
     freeze_secondary_keys {
         let caller = user::<T>("caller", 0);
     }: _(caller.origin)

pallets/identity/src/lib.rs

@@ -397,15 +397,15 @@ decl_module! {
         /// Sets permissions for an specific `target_key` key.
         ///
         /// Only the primary key of an identity is able to set secondary key permissions.
-        #[weight = <T as Config>::WeightInfo::set_permission_to_signer()]
+        #[weight = <T as Config>::WeightInfo::set_permission_to_signer_full(&perms)]
         pub fn set_permission_to_signer(origin, signer: Signatory<T::AccountId>, perms: Permissions) {
             Self::base_set_permission_to_signer(origin, signer, perms)?;
         }
 
         /// This function is a workaround for https://github.com/polkadot-js/apps/issues/3632
         /// It sets permissions for an specific `target_key` key.
         /// Only the primary key of an identity is able to set secondary key permissions.
-        #[weight = <T as Config>::WeightInfo::set_permission_to_signer()]
+        #[weight = <T as Config>::WeightInfo::legacy_set_permission_to_signer_full(&permissions)]
         pub fn legacy_set_permission_to_signer(
             origin,
             signer: Signatory<T::AccountId>,
@@ -431,7 +431,7 @@ decl_module! {
 
         // Manage generic authorizations
         /// Adds an authorization.
-        #[weight = <T as Config>::WeightInfo::add_authorization()]
+        #[weight = <T as Config>::WeightInfo::add_authorization_full::<T::AccountId>(&data)]
         pub fn add_authorization(
             origin,
             target: Signatory<T::AccountId>,
@@ -465,7 +465,7 @@ decl_module! {
         /// Failure
         ///     - It can only called by primary key owner.
         ///     - Keys should be able to linked to any identity.
-        #[weight = <T as Config>::WeightInfo::add_secondary_keys_with_authorization(additional_keys.len() as u32)]
+        #[weight = <T as Config>::WeightInfo::add_secondary_keys_full::<T::AccountId>(&additional_keys)]
         pub fn add_secondary_keys_with_authorization(
             origin,
             additional_keys: Vec<SecondaryKeyWithAuth<T::AccountId>>,

pallets/weights/src/pallet_identity.rs

@@ -118,6 +118,17 @@ impl pallet_identity::WeightInfo for WeightInfo {
             .saturating_add(DbWeight::get().reads(4 as Weight))
             .saturating_add(DbWeight::get().writes(1 as Weight))
     }
+    fn permissions_cost(a: u32, p: u32, l: u32, e: u32) -> Weight {
+        (0 as Weight)
+            // Standard Error: 200_000
+            .saturating_add((1_254_000 as Weight).saturating_mul(a as Weight))
+            // Standard Error: 200_000
+            .saturating_add((1_027_000 as Weight).saturating_mul(p as Weight))
+            // Standard Error: 200_000
+            .saturating_add((75_415_000 as Weight).saturating_mul(l as Weight))
+            // Standard Error: 200_000
+            .saturating_add((72_009_000 as Weight).saturating_mul(e as Weight))
+    }
     fn freeze_secondary_keys() -> Weight {
         (56_201_000 as Weight)
             .saturating_add(DbWeight::get().reads(4 as Weight))

primitives/src/secondary_key.rs

@@ -20,6 +20,7 @@ use sp_runtime::{Deserialize, Serialize};
 use sp_std::{
     cmp::{Ord, Ordering, PartialOrd},
     collections::btree_set::BTreeSet,
+    convert::TryInto,
     iter,
     mem::size_of,
 };
@@ -88,6 +89,11 @@ impl PalletPermissions {
                 cost.saturating_add(name_complexity(&dispatch_name))
             })
     }
+
+    /// Return the number of dispatchable names.
+    pub fn dispatchables_len(&self) -> usize {
+        self.dispatchable_names.complexity()
+    }
 }
 
 /// Extrinsic permissions.
@@ -180,6 +186,28 @@ impl Permissions {
                     .saturating_mul(size_of::<PortfolioId>()),
             )
     }
+
+    /// Return number of assets, portfolios, pallets, and extrinsics.
+    ///
+    /// This is used for weight calculation.
+    pub fn get_weights(&self) -> (u32, u32, u32, u32) {
+        // Count the number of assets.
+        let assets = self.asset.complexity().try_into().unwrap_or(u32::MAX);
+        // Count the number of portfolios.
+        let portfolios = self.portfolio.complexity().try_into().unwrap_or(u32::MAX);
+        // Count the number of pallets.
+        let pallets = self.extrinsic.complexity().try_into().unwrap_or(u32::MAX);
+        // Count the total number of extrinsics.
+        let extrinsics = self
+            .extrinsic
+            .fold(0usize, |count, pallet| {
+                count.saturating_add(pallet.dispatchables_len())
+            })
+            .try_into()
+            .unwrap_or(u32::MAX);
+
+        (assets, portfolios, pallets, extrinsics)
+    }
 }
 
 /// It supports different elements as a signer.
@@ -373,6 +401,7 @@ pub mod api {
     use codec::{Decode, Encode};
     #[cfg(feature = "std")]
     use sp_runtime::{Deserialize, Serialize};
+    use sp_std::convert::TryInto;
     use sp_std::vec::Vec;
 
     /// A permission to call functions within a given pallet.
@@ -419,6 +448,34 @@ pub mod api {
                 portfolio: SubsetRestriction::empty(),
             }
         }
+
+        /// Return number of assets, portfolios, pallets, and extrinsics.
+        ///
+        /// This is used for weight calculation.
+        pub fn get_weights(&self) -> (u32, u32, u32, u32) {
+            // Count the number of assets.
+            let assets = self.asset.complexity().try_into().unwrap_or(u32::MAX);
+            // Count the number of portfolios.
+            let portfolios = self.portfolio.complexity().try_into().unwrap_or(u32::MAX);
+            // Count the number of pallets and total number of extrinsics.
+            let (pallets, extrinsics) = match &self.extrinsic.0 {
+                Some(pallets) => {
+                    let num_pallets = pallets.len().try_into().unwrap_or(u32::MAX);
+                    // Count all extrinsics.
+                    let extrinsics = pallets
+                        .iter()
+                        .fold(0usize, |count, pallet| {
+                            count.saturating_add(pallet.dispatchable_names.len())
+                        })
+                        .try_into()
+                        .unwrap_or(u32::MAX);
+                    (num_pallets, extrinsics)
+                }
+                None => (0, 0),
+            };
+
+            (assets, portfolios, pallets, extrinsics)
+        }
     }
 
     /// The same secondary key object without the extra trait constraints.