Block same DID transfers; Remove Constant; Fix Benchmark (#1938)

## changelog
### other
 - Block same DID transfers if asset is frozen; 
 - Remove max proposals from the committee pallet; 
 - Fix contracts benchmark

Author: HenriqueNogara

pallets/asset/src/lib.rs

@@ -3247,11 +3247,7 @@ impl<T: AssetConfig> Pallet<T> {
             return Ok(());
         }
 
-        // Verifies that the asset is not frozen
-        ensure!(
-            !Frozen::<T>::get(asset_id),
-            Error::<T>::InvalidTransferFrozenAsset
-        );
+        Self::ensure_asset_is_not_frozen(&asset_id)?;
 
         ensure!(
             IdentityPallet::<T>::is_did_active(receiver_did),
@@ -3278,6 +3274,15 @@ impl<T: AssetConfig> Pallet<T> {
         Ok(())
     }
 
+    /// Returns `Ok` if the asset is not frozen.
+    pub fn ensure_asset_is_not_frozen(asset_id: &AssetId) -> DispatchResult {
+        ensure!(
+            !Frozen::<T>::get(asset_id),
+            Error::<T>::InvalidTransferFrozenAsset
+        );
+        Ok(())
+    }
+
     /// Returns a vector containing all errors for the transfer. An empty vec means there's no error.
     pub fn asset_transfer_report(
         sender: &AssetHolder,
@@ -4217,6 +4222,10 @@ impl<T: AssetConfig> AssetFnTrait<T::AccountId> for Pallet<T> {
         <T as Config>::WeightInfo::spend_allowance()
     }
 
+    fn asset_is_not_frozen(asset_id: &AssetId) -> DispatchResult {
+        Self::ensure_asset_is_not_frozen(asset_id)
+    }
+
     #[cfg(feature = "runtime-benchmarks")]
     fn register_unique_ticker(caller: T::AccountId, ticker: Ticker) -> DispatchResult {
         let origin = RawOrigin::Signed(caller);

pallets/committee/src/benchmarking.rs

@@ -30,6 +30,8 @@ const PROPOSAL_PADDING_WORDS: usize = 1_000;
 // aye vote leads to acceptance of that proposal.
 const PROPOSAL_ALMOST_APPROVED: u32 = COMMITTEE_MEMBERS_MAX - 3;
 
+const PROPOSALS_MAX: u32 = 500;
+
 fn make_proposal<T, I>(
     n: u32,
 ) -> (

pallets/committee/src/lib.rs

@@ -77,12 +77,6 @@ use polymesh_primitives::traits::GovernanceGroupTrait;
 use polymesh_primitives::{IdentityId, MaybeBlock, SystematicIssuers, GC_DID};
 
 type IdentityPallet<T> = pallet_identity::Pallet<T>;
-
-/// The maximum number of concurrently active proposals defined for the sake of weight computation.
-/// This is not defined as a trait parameter but rather as a plain constant because this value has
-/// to be the same for all instances.
-pub const PROPOSALS_MAX: u32 = 500;
-
 pub trait WeightInfo {
     fn set_vote_threshold() -> Weight;
     fn set_release_coordinator() -> Weight;
@@ -642,12 +636,6 @@ pub mod pallet {
             // 1. Ensure `origin` is a committee member.
             let did = Self::ensure_is_member(origin)?;
 
-            // 1.1 Ensure proposal limit has not been reached.
-            ensure!(
-                ProposalCount::<T, I>::get() < PROPOSALS_MAX,
-                Error::<T, I>::ProposalsLimitReached
-            );
-
             // 2. Get hash & reject duplicate proposals.
             let proposal_hash = T::Hashing::hash_of(&proposal);
             ensure!(

pallets/contracts/src/benchmarking.rs

@@ -148,6 +148,7 @@ where
         key_len: u32,
         output_len: usize,
     ) -> Self {
+        let mut in_ptr: i32 = 0;
         let code = WasmModule::<T>::from(ModuleDefinition {
             memory: Some(ImportedMemory::max::<T>()),
             imported_functions: vec![ImportedFunction {
@@ -166,18 +167,19 @@ where
                     value: output_len.to_le_bytes().into(),
                 },
             ],
-            call_body: Some(body::repeated(
-                repetitions,
-                &[
+            call_body: Some(body::repeated_with_locals_using(&[], repetitions, || {
+                let current_in_ptr = in_ptr;
+                in_ptr += key_len as i32;
+                [
                     Instruction::I32Const(FuncId::GetKeyDid.into()),
-                    Instruction::I32Const(0),
+                    Instruction::I32Const(current_in_ptr),
                     Instruction::I32Const(key_len as i32),
                     Instruction::I32Const(input.len() as i32 + 4),
                     Instruction::I32Const(input.len() as i32),
                     Instruction::Call(0),
                     Instruction::Drop,
-                ],
-            )),
+                ]
+            })),
             ..Default::default()
         });
         Self::new(code)

pallets/nft/src/lib.rs

@@ -687,11 +687,7 @@ impl<T: Config> Pallet<T> {
             return Ok(());
         }
 
-        // Verifies that the asset is not frozen
-        ensure!(
-            !Frozen::<T>::get(nfts.asset_id()),
-            Error::<T>::InvalidNFTTransferFrozenAsset
-        );
+        pallet_asset::Pallet::<T>::ensure_asset_is_not_frozen(nfts.asset_id())?;
 
         // Verifies if the receiver has an active DID.
         ensure!(

pallets/portfolio/src/lib.rs

@@ -919,10 +919,12 @@ impl<T: Config> Pallet<T> {
                         unique_assets.insert(asset_id),
                         Error::<T>::NoDuplicateAssetsAllowed
                     );
+                    T::AssetFn::asset_is_not_frozen(asset_id)?;
                     Self::ensure_sufficient_balance(sender_portfolio, &asset_id, *amount)?;
                 }
                 FundDescription::NonFungible(nfts) => {
                     ensure!(nfts.len() > 0, Error::<T>::EmptyTransfer);
+                    T::AssetFn::asset_is_not_frozen(nfts.asset_id())?;
                     Self::ensure_valid_nfts(sender_portfolio, nfts.asset_id(), nfts.ids())?;
                 }
             }

pallets/settlement/src/lib.rs

@@ -1619,6 +1619,7 @@ impl<T: Config> Pallet<T> {
             match fund.description {
                 FundDescription::Fungible { asset_id, amount } => {
                     ensure!(amount > 0, Error::<T>::ZeroAmount);
+                    Asset::<T>::ensure_asset_is_not_frozen(&asset_id)?;
                     Asset::<T>::ensure_sufficient_balance(&resolved_from, &asset_id, amount)?;
                     Asset::<T>::transfer_holders_balance(
                         resolved_from.clone(),

primitives/src/traits/asset.rs

@@ -42,6 +42,9 @@ pub trait AssetFnTrait<AccountId> {
     /// Charged dynamically only when the caller is a spender (not the asset owner).
     fn spend_allowance_weight() -> Weight;
 
+    /// Returns `Ok` if the asset is not frozen.
+    fn asset_is_not_frozen(asset_id: &AssetId) -> DispatchResult;
+
     #[cfg(feature = "runtime-benchmarks")]
     fn register_unique_ticker(caller: AccountId, ticker: Ticker) -> DispatchResult;