Add lock_instruction common benchmark

Author: HenriqueNogara

pallets/settlement/src/benchmarking.rs

@@ -14,6 +14,7 @@
 // along with this program. If not, see <http://www.gnu.org/licenses/>.
 
 pub use frame_benchmarking::{account, benchmarks};
+use frame_support::storage::with_transaction as frame_support_with_transaction;
 use frame_support::traits::{Get, TryCollect};
 use frame_system::RawOrigin;
 use scale_info::prelude::format;
@@ -29,7 +30,7 @@ use polymesh_primitives::checked_inc::CheckedInc;
 use polymesh_primitives::constants::currency::ONE_UNIT;
 use polymesh_primitives::constants::ENSURED_MAX_LEN;
 use polymesh_primitives::settlement::ReceiptMetadata;
-use polymesh_primitives::{IdentityId, Memo, NFTId, NFTs, PortfolioId, Ticker};
+use polymesh_primitives::{IdentityId, Memo, NFTId, NFTs, PortfolioId, Ticker, WeightMeter};
 
 use crate::*;
 
@@ -875,4 +876,47 @@ benchmarks! {
         InstructionStatuses::<T>::insert(inst_id, InstructionStatus::Rejected(System::<T>::block_number()));
     }
 
+    lock_instruction_common {
+        let f in 1..T::MaxNumberOfFungibleAssets::get();
+        let n in 0..T::MaxNumberOfNFTs::get();
+        let o in 0..T::MaxNumberOfOffChainAssets::get();
+
+        let m = T::MaxInstructionMediators::get();
+
+        let alice = UserBuilder::<T>::default().generate_did().build("Alice");
+        let bob = UserBuilder::<T>::default().generate_did().build("Bob");
+        let settlement_type = SettlementType::SettleAfterLock;
+        let venue_id = create_venue_::<T>(alice.did(), vec![alice.account(), bob.account()]);
+
+        let inst_id = InstructionId(1);
+        let parameters = setup_execute_instruction::<T>(&alice, &bob, settlement_type, venue_id, f, n, o, m, true, true);
+    }: {
+        let caller_did =
+            pallet_identity::Pallet::<T>::ensure_perms(parameters.asset_mediators[0].clone().origin.into()).unwrap();
+        Pallet::<T>::ensure_mediator(&inst_id, &caller_did).unwrap();
+
+        let _ = InstructionDetails::<T>::get(&inst_id);
+        let inst_memo = InstructionMemos::<T>::get(&inst_id);
+
+        let inst_legs: Vec<_> = InstructionLegs::<T>::iter_prefix(&inst_id).collect();
+        let _ = AssetCount::from_legs(&inst_legs);
+
+        frame_support_with_transaction(|| {
+            Pallet::<T>::release_locks(&inst_id, &inst_legs).unwrap();
+            Pallet::<T>::transfer_assets(
+                inst_id,
+                &inst_legs,
+                inst_memo,
+                caller_did,
+                &mut WeightMeter::max_limit_no_minimum()
+            )
+            .unwrap();
+            TransactionOutcome::Rollback(Ok::<(), DispatchError>(()))
+        })
+        .unwrap();
+
+        InstructionStatuses::<T>::insert(inst_id, InstructionStatus::LockedForExecution);
+        LockedTimestamp::<T>::insert(inst_id, pallet_timestamp::Pallet::<T>::get());
+    }
+
 }

pallets/settlement/src/lib.rs

@@ -3148,6 +3148,15 @@ impl<T: Config> Pallet<T> {
         inst_legs.sort_by_key(|leg| leg.0);
         let inst_asset_count = AssetCount::from_legs(&inst_legs);
 
+        Self::check_accrue(
+            weight_meter,
+            <T as Config>::WeightInfo::lock_instruction_common(
+                inst_asset_count.fungible(),
+                inst_asset_count.non_fungible(),
+                inst_asset_count.off_chain(),
+            ),
+        )?;
+
         Self::validate_execute_instruction_pre_conditions(
             &inst_id,
             &inst_legs,

pallets/weights/src/pallet_settlement.rs

@@ -1119,7 +1119,76 @@ impl pallet_settlement::WeightInfo for SubstrateWeight {
             .saturating_add(DbWeight::get().writes((1_u64).saturating_mul(f.into())))
             .saturating_add(DbWeight::get().writes((1_u64).saturating_mul(n.into())))
     }
-    fn lock_instruction_common(_f: u32, _n: u32, _o: u32) -> Weight {
-        Weight::zero()
+    // Storage: Identity KeyRecords (r:1 w:0)
+    // Proof: Identity KeyRecords (max_values: None, max_size: Some(73), added: 2548, mode: MaxEncodedLen)
+    // Storage: Settlement InstructionMediatorsAffirmations (r:1 w:0)
+    // Proof: Settlement InstructionMediatorsAffirmations (max_values: None, max_size: Some(58), added: 2533, mode: MaxEncodedLen)
+    // Storage: Settlement InstructionDetails (r:1 w:0)
+    // Proof: Settlement InstructionDetails (max_values: None, max_size: Some(65), added: 2540, mode: MaxEncodedLen)
+    // Storage: Settlement InstructionMemos (r:1 w:0)
+    // Proof: Settlement InstructionMemos (max_values: None, max_size: Some(48), added: 2523, mode: MaxEncodedLen)
+    // Storage: Settlement InstructionLegs (r:121 w:0)
+    // Proof Skipped: Settlement InstructionLegs (max_values: None, max_size: None, mode: Measured)
+    // Storage: Settlement InstructionLegStatus (r:120 w:0)
+    // Proof: Settlement InstructionLegStatus (max_values: None, max_size: Some(73), added: 2548, mode: MaxEncodedLen)
+    // Storage: Portfolio PortfolioLockedNFT (r:100 w:0)
+    // Proof: Portfolio PortfolioLockedNFT (max_values: None, max_size: Some(90), added: 2565, mode: MaxEncodedLen)
+    // Storage: Portfolio PortfolioLockedAssets (r:10 w:0)
+    // Proof: Portfolio PortfolioLockedAssets (max_values: None, max_size: Some(97), added: 2572, mode: MaxEncodedLen)
+    // Storage: Nft CollectionAsset (r:100 w:0)
+    // Proof: Nft CollectionAsset (max_values: None, max_size: Some(40), added: 2515, mode: MaxEncodedLen)
+    // Storage: Nft NumberOfNFTs (r:200 w:0)
+    // Proof: Nft NumberOfNFTs (max_values: None, max_size: Some(72), added: 2547, mode: MaxEncodedLen)
+    // Storage: Portfolio PortfolioNFT (r:100 w:0)
+    // Proof: Portfolio PortfolioNFT (max_values: None, max_size: Some(90), added: 2565, mode: MaxEncodedLen)
+    // Storage: Asset Frozen (r:110 w:0)
+    // Proof: Asset Frozen (max_values: None, max_size: Some(33), added: 2508, mode: MaxEncodedLen)
+    // Storage: Timestamp Now (r:1 w:0)
+    // Proof: Timestamp Now (max_values: Some(1), max_size: Some(8), added: 503, mode: MaxEncodedLen)
+    // Storage: CddServiceProviders ActiveMembers (r:1 w:0)
+    // Proof Skipped: CddServiceProviders ActiveMembers (max_values: Some(1), max_size: None, mode: Measured)
+    // Storage: Identity Claims (r:4 w:0)
+    // Proof Skipped: Identity Claims (max_values: None, max_size: None, mode: Measured)
+    // Storage: ComplianceManager AssetCompliances (r:110 w:0)
+    // Proof Skipped: ComplianceManager AssetCompliances (max_values: None, max_size: None, mode: Measured)
+    // Storage: Asset Assets (r:10 w:0)
+    // Proof Skipped: Asset Assets (max_values: None, max_size: None, mode: Measured)
+    // Storage: Asset BalanceOf (r:20 w:0)
+    // Proof: Asset BalanceOf (max_values: None, max_size: Some(80), added: 2555, mode: MaxEncodedLen)
+    // Storage: Portfolio Portfolios (r:20 w:0)
+    // Proof Skipped: Portfolio Portfolios (max_values: None, max_size: None, mode: Measured)
+    // Storage: Portfolio PortfolioAssetBalances (r:20 w:0)
+    // Proof: Portfolio PortfolioAssetBalances (max_values: None, max_size: Some(97), added: 2572, mode: MaxEncodedLen)
+    // Storage: Statistics AssetTransferCompliances (r:10 w:0)
+    // Proof: Statistics AssetTransferCompliances (max_values: None, max_size: Some(246), added: 2721, mode: MaxEncodedLen)
+    // Storage: Checkpoint CachedNextCheckpoints (r:10 w:0)
+    // Proof Skipped: Checkpoint CachedNextCheckpoints (max_values: None, max_size: None, mode: Measured)
+    // Storage: Checkpoint CheckpointIdSequence (r:10 w:0)
+    // Proof: Checkpoint CheckpointIdSequence (max_values: None, max_size: Some(40), added: 2515, mode: MaxEncodedLen)
+    // Storage: Portfolio PortfolioAssetCount (r:10 w:0)
+    // Proof: Portfolio PortfolioAssetCount (max_values: None, max_size: Some(57), added: 2532, mode: MaxEncodedLen)
+    // Storage: Statistics ActiveAssetStats (r:10 w:0)
+    // Proof: Statistics ActiveAssetStats (max_values: None, max_size: Some(423), added: 2898, mode: MaxEncodedLen)
+    // Storage: Settlement InstructionStatuses (r:0 w:1)
+    // Proof: Settlement InstructionStatuses (max_values: None, max_size: Some(21), added: 2496, mode: MaxEncodedLen)
+    // Storage: Settlement LockedTimestamp (r:0 w:1)
+    // Proof: Settlement LockedTimestamp (max_values: None, max_size: Some(24), added: 2499, mode: MaxEncodedLen)
+    /// The range of component `f` is `[1, 10]`.
+    /// The range of component `n` is `[0, 100]`.
+    /// The range of component `o` is `[0, 10]`.
+    fn lock_instruction_common(f: u32, n: u32, o: u32) -> Weight {
+        // Minimum execution time: 1_808_704 nanoseconds.
+        Weight::from_ref_time(56_320_006)
+            // Standard Error: 1_710_336
+            .saturating_add(Weight::from_ref_time(151_928_134).saturating_mul(f.into()))
+            // Standard Error: 158_210
+            .saturating_add(Weight::from_ref_time(126_987_606).saturating_mul(n.into()))
+            // Standard Error: 1_549_300
+            .saturating_add(Weight::from_ref_time(10_140_105).saturating_mul(o.into()))
+            .saturating_add(DbWeight::get().reads(11))
+            .saturating_add(DbWeight::get().reads((17_u64).saturating_mul(f.into())))
+            .saturating_add(DbWeight::get().reads((9_u64).saturating_mul(n.into())))
+            .saturating_add(DbWeight::get().reads((2_u64).saturating_mul(o.into())))
+            .saturating_add(DbWeight::get().writes(2))
     }
 }