From a3095a7fde9bca925dd187a249e9872a432c166b Mon Sep 17 00:00:00 2001 From: mustermeiszer Date: Tue, 7 Mar 2023 10:11:04 +0100 Subject: [PATCH 01/55] Add missing pallets to centrifuge - loans not yet --- runtime/centrifuge/Cargo.toml | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+) diff --git a/runtime/centrifuge/Cargo.toml b/runtime/centrifuge/Cargo.toml index 5791d74f80..d51e1e84a3 100644 --- a/runtime/centrifuge/Cargo.toml +++ b/runtime/centrifuge/Cargo.toml @@ -96,9 +96,14 @@ pallet-collator-allowlist = { path = "../../pallets/collator-allowlist", default pallet-crowdloan-claim = { path = "../../pallets/crowdloan-claim", default-features = false } pallet-crowdloan-reward = { path = "../../pallets/crowdloan-reward", default-features = false } pallet-fees = { path = "../../pallets/fees", default-features = false } +pallet-interest-accrual = { path = "../../pallets/interest-accrual", default-features = false } +pallet-investments = { path = "../../pallets/investments", default-features = false } pallet-migration-manager = { path = "../../pallets/migration", default-features = false } pallet-nft = { path = "../../pallets/nft", default-features = false } pallet-restricted-tokens = { path = "../../pallets/restricted-tokens", default-features = false } +pallet-pool-registry = { path = "../../pallets/pool-registry", default-features = false } +pallet-pool-system = { path = "../../pallets/pool-system", default-features = false } +pallet-permissions = { path = "../../pallets/permissions", default-features = false } runtime-common = { path = "../common", default-features = false } # bridge pallets @@ -148,9 +153,14 @@ std = [ "pallet-fees/std", "pallet-fees/std", "pallet-identity/std", + "pallet-interest-accrual/std", + "pallet-investments/std", "pallet-migration-manager/std", "pallet-multisig/std", "pallet-nft/std", + "pallet-permissions/std", + "pallet-pool-registry/std", + "pallet-pool-system/std", "pallet-preimage/std", "pallet-proxy/std", "pallet-randomness-collective-flip/std", @@ -210,10 +220,15 @@ runtime-benchmarks = [ "pallet-elections-phragmen/runtime-benchmarks", "pallet-fees/runtime-benchmarks", "pallet-identity/runtime-benchmarks", + "pallet-interest-accrual/runtime-benchmarks", + "pallet-investments/runtime-benchmarks", "pallet-migration-manager/runtime-benchmarks", "pallet-multisig/runtime-benchmarks", "pallet-preimage/runtime-benchmarks", "pallet-proxy/runtime-benchmarks", + "pallet-permissions/runtime-benchmarks", + "pallet-pool-system/runtime-benchmarks", + "pallet-pool-registry/runtime-benchmarks", "pallet-restricted-tokens/runtime-benchmarks", "pallet-scheduler/runtime-benchmarks", "pallet-timestamp/runtime-benchmarks", @@ -272,9 +287,14 @@ try-runtime = [ "pallet-elections-phragmen/try-runtime", "pallet-fees/try-runtime", "pallet-identity/try-runtime", + "pallet-interest-accrual/try-runtime", + "pallet-investments/try-runtime", "pallet-migration-manager/try-runtime", "pallet-multisig/try-runtime", "pallet-nft/try-runtime", + "pallet-permissions/try-runtime", + "pallet-pool-system/try-runtime", + "pallet-pool-registry/try-runtime", "pallet-preimage/try-runtime", "pallet-proxy/try-runtime", "pallet-randomness-collective-flip/try-runtime", From d459aca78626b8382b7ea99a40968c15f63c41af Mon Sep 17 00:00:00 2001 From: mustermeiszer Date: Tue, 7 Mar 2023 10:13:15 +0100 Subject: [PATCH 02/55] Clean up feature list Centrifuge --- runtime/centrifuge/Cargo.toml | 50 +++++++++++++++++------------------ 1 file changed, 24 insertions(+), 26 deletions(-) diff --git a/runtime/centrifuge/Cargo.toml b/runtime/centrifuge/Cargo.toml index d51e1e84a3..0e0caa98d0 100644 --- a/runtime/centrifuge/Cargo.toml +++ b/runtime/centrifuge/Cargo.toml @@ -125,9 +125,13 @@ std = [ "cumulus-pallet-parachain-system/std", "cumulus-pallet-xcm/std", "cumulus-pallet-xcmp-queue/std", + "cumulus-primitives-core/std", "cumulus-primitives-timestamp/std", + "cumulus-primitives-utility/std", + "frame-benchmarking/std", "frame-executive/std", "frame-support/std", + "frame-system-benchmarking/std", "frame-system-rpc-runtime-api/std", "frame-system/std", "frame-try-runtime/std", @@ -151,7 +155,6 @@ std = [ "pallet-democracy/std", "pallet-elections-phragmen/std", "pallet-fees/std", - "pallet-fees/std", "pallet-identity/std", "pallet-interest-accrual/std", "pallet-investments/std", @@ -178,6 +181,7 @@ std = [ "polkadot-parachain/std", "polkadot-runtime-common/std", "runtime-common/std", + "scale-info/std", "sp-api/std", "sp-block-builder/std", "sp-consensus-aura/std", @@ -193,24 +197,26 @@ std = [ "xcm-builder/std", "xcm-executor/std", "xcm/std", - "cumulus-primitives-core/std", - "cumulus-primitives-utility/std", - "frame-benchmarking/std", - "frame-system-benchmarking/std", - "scale-info/std", ] runtime-benchmarks = [ - "hex-literal", - "frame-benchmarking", - "frame-system-benchmarking/runtime-benchmarks", + "cfg-primitives/runtime-benchmarks", + "cfg-traits/runtime-benchmarks", "cfg-types/runtime-benchmarks", "chainbridge/runtime-benchmarks", + "cumulus-pallet-parachain-system/runtime-benchmarks", + "cumulus-pallet-xcmp-queue/runtime-benchmarks", "frame-benchmarking/runtime-benchmarks", "frame-support/runtime-benchmarks", + "frame-system-benchmarking/runtime-benchmarks", "frame-system/runtime-benchmarks", + "hex-literal", + "orml-asset-registry/runtime-benchmarks", + "orml-tokens/runtime-benchmarks", + "orml-xtokens/runtime-benchmarks", "pallet-anchors/runtime-benchmarks", "pallet-balances/runtime-benchmarks", + "pallet-bridge/runtime-benchmarks", "pallet-collator-allowlist/runtime-benchmarks", "pallet-collator-selection/runtime-benchmarks", "pallet-collective/runtime-benchmarks", @@ -224,11 +230,12 @@ runtime-benchmarks = [ "pallet-investments/runtime-benchmarks", "pallet-migration-manager/runtime-benchmarks", "pallet-multisig/runtime-benchmarks", - "pallet-preimage/runtime-benchmarks", - "pallet-proxy/runtime-benchmarks", + "pallet-nft/runtime-benchmarks", "pallet-permissions/runtime-benchmarks", - "pallet-pool-system/runtime-benchmarks", "pallet-pool-registry/runtime-benchmarks", + "pallet-pool-system/runtime-benchmarks", + "pallet-preimage/runtime-benchmarks", + "pallet-proxy/runtime-benchmarks", "pallet-restricted-tokens/runtime-benchmarks", "pallet-scheduler/runtime-benchmarks", "pallet-timestamp/runtime-benchmarks", @@ -236,20 +243,11 @@ runtime-benchmarks = [ "pallet-utility/runtime-benchmarks", "pallet-vesting/runtime-benchmarks", "pallet-xcm/runtime-benchmarks", - "runtime-common/runtime-benchmarks", - "xcm-builder/runtime-benchmarks", - "cfg-primitives/runtime-benchmarks", - "cfg-traits/runtime-benchmarks", - "cumulus-pallet-parachain-system/runtime-benchmarks", - "cumulus-pallet-xcmp-queue/runtime-benchmarks", - "orml-asset-registry/runtime-benchmarks", - "orml-tokens/runtime-benchmarks", - "orml-xtokens/runtime-benchmarks", - "pallet-bridge/runtime-benchmarks", - "pallet-nft/runtime-benchmarks", "polkadot-parachain/runtime-benchmarks", "polkadot-runtime-common/runtime-benchmarks", + "runtime-common/runtime-benchmarks", "sp-runtime/runtime-benchmarks", + "xcm-builder/runtime-benchmarks", "xcm-executor/runtime-benchmarks", ] @@ -257,7 +255,7 @@ try-runtime = [ "cfg-primitives/try-runtime", "cfg-traits/try-runtime", "cfg-types/try-runtime", - "polkadot-runtime-common/try-runtime", + "chainbridge/try-runtime", "cumulus-pallet-aura-ext/try-runtime", "cumulus-pallet-dmp-queue/try-runtime", "cumulus-pallet-parachain-system/try-runtime", @@ -267,7 +265,6 @@ try-runtime = [ "frame-support/try-runtime", "frame-system/try-runtime", "frame-try-runtime", - "chainbridge/try-runtime", "orml-asset-registry/try-runtime", "orml-tokens/try-runtime", "orml-xcm/try-runtime", @@ -293,8 +290,8 @@ try-runtime = [ "pallet-multisig/try-runtime", "pallet-nft/try-runtime", "pallet-permissions/try-runtime", - "pallet-pool-system/try-runtime", "pallet-pool-registry/try-runtime", + "pallet-pool-system/try-runtime", "pallet-preimage/try-runtime", "pallet-proxy/try-runtime", "pallet-randomness-collective-flip/try-runtime", @@ -308,6 +305,7 @@ try-runtime = [ "pallet-vesting/try-runtime", "pallet-xcm/try-runtime", "parachain-info/try-runtime", + "polkadot-runtime-common/try-runtime", "runtime-common/try-runtime", ] From 8a2435935410b4c0f9c40690bbfff36d9b600d7b Mon Sep 17 00:00:00 2001 From: mustermeiszer Date: Tue, 7 Mar 2023 12:55:52 +0100 Subject: [PATCH 03/55] Add most pallets, not loans yet --- pallets/loans/src/mock.rs | 1 - pallets/permissions/src/lib.rs | 4 - pallets/permissions/src/mock.rs | 1 - pallets/pool-system/src/mock.rs | 1 - runtime/altair/src/lib.rs | 1 - runtime/centrifuge/src/lib.rs | 300 +++++++++++++++++++++++++++++++- runtime/development/src/lib.rs | 2 - 7 files changed, 299 insertions(+), 11 deletions(-) diff --git a/pallets/loans/src/mock.rs b/pallets/loans/src/mock.rs index 698e6aaeb5..0866312552 100644 --- a/pallets/loans/src/mock.rs +++ b/pallets/loans/src/mock.rs @@ -352,7 +352,6 @@ impl pallet_permissions::Config for Runtime { type AdminOrigin = EnsureSignedBy; type Editors = Everything; type MaxRolesPerScope = MaxRoles; - type MaxTranches = MaxTranches; type Role = Role; type RuntimeEvent = RuntimeEvent; type Scope = PermissionScope; diff --git a/pallets/permissions/src/lib.rs b/pallets/permissions/src/lib.rs index 65fe9958cc..b3f5a41173 100644 --- a/pallets/permissions/src/lib.rs +++ b/pallets/permissions/src/lib.rs @@ -66,10 +66,6 @@ pub mod pallet { #[pallet::constant] type MaxRolesPerScope: Get; - /// The maximum number of tranches. - #[pallet::constant] - type MaxTranches: Get; - type WeightInfo: WeightInfo; } diff --git a/pallets/permissions/src/mock.rs b/pallets/permissions/src/mock.rs index c7718a0444..41b4f29b4a 100644 --- a/pallets/permissions/src/mock.rs +++ b/pallets/permissions/src/mock.rs @@ -294,7 +294,6 @@ impl pallet_permissions::Config for Runtime { type AdminOrigin = AdminOrigin; type Editors = Editors; type MaxRolesPerScope = MaxRoles; - type MaxTranches = MaxTranches; type Role = Role; type RuntimeEvent = RuntimeEvent; type Scope = Scope; diff --git a/pallets/pool-system/src/mock.rs b/pallets/pool-system/src/mock.rs index b0a75f6f32..cbccde3189 100644 --- a/pallets/pool-system/src/mock.rs +++ b/pallets/pool-system/src/mock.rs @@ -80,7 +80,6 @@ impl pallet_permissions::Config for Runtime { type AdminOrigin = EnsureSignedBy; type Editors = frame_support::traits::Everything; type MaxRolesPerScope = MaxRoles; - type MaxTranches = MaxTranches; type Role = Role; type RuntimeEvent = RuntimeEvent; type Scope = PermissionScope; diff --git a/runtime/altair/src/lib.rs b/runtime/altair/src/lib.rs index b0a9641570..169d9ab06f 100644 --- a/runtime/altair/src/lib.rs +++ b/runtime/altair/src/lib.rs @@ -929,7 +929,6 @@ impl pallet_permissions::Config for Runtime { type AdminOrigin = EnsureRootOr; type Editors = Editors; type MaxRolesPerScope = MaxRolesPerPool; - type MaxTranches = MaxTranches; type Role = Role; type RuntimeEvent = RuntimeEvent; type Scope = PermissionScope; diff --git a/runtime/centrifuge/src/lib.rs b/runtime/centrifuge/src/lib.rs index db4cf5a85a..2a3bb27a98 100644 --- a/runtime/centrifuge/src/lib.rs +++ b/runtime/centrifuge/src/lib.rs @@ -19,7 +19,14 @@ #![allow(clippy::identity_op)] pub use cfg_primitives::{constants::*, types::*}; -use cfg_types::{fee_keys::FeeKey, tokens::CustomMetadata}; +use cfg_types::{ + consts::pools::{MaxTrancheNameLengthBytes, MaxTrancheSymbolLengthBytes}, + fee_keys::FeeKey, + fixed_point::Rate, + permissions::{PermissionRoles, PermissionScope, Role}, + time::TimeProvider, + tokens::{CustomMetadata, TrancheCurrency}, +}; use codec::{Decode, Encode, MaxEncodedLen}; use frame_support::{ construct_runtime, @@ -43,6 +50,11 @@ use orml_traits::{currency::MutationHooks, parameter_type_with_key}; use pallet_anchors::AnchorData; pub use pallet_balances::Call as BalancesCall; use pallet_collective::{EnsureMember, EnsureProportionAtLeast, EnsureProportionMoreThan}; +use pallet_pool_system::{ + pool_types::{PoolDetails, ScheduledUpdateDetails}, + tranches::{TrancheIndex, TrancheLoc, TrancheSolution}, + EpochSolution, +}; use pallet_restricted_tokens::{FungibleInspectPassthrough, FungiblesInspectPassthrough}; pub use pallet_timestamp::Call as TimestampCall; pub use pallet_transaction_payment::{CurrencyAdapter, Multiplier, TargetedFeeAdjustment}; @@ -494,6 +506,14 @@ pub enum ProxyType { /// Deprecated ProxyType, that we are keeping due to the migration _Staking, NonProxy, + Borrow, + Price, + Invest, + ProxyManagement, + KeystoreManagement, + PodOperation, + PodAuth, + PermissionManagement, } impl Default for ProxyType { fn default() -> Self { @@ -557,6 +577,58 @@ impl InstanceFilter for ProxyType { matches!(c, RuntimeCall::Proxy(pallet_proxy::Call::proxy { .. })) || !matches!(c, RuntimeCall::Proxy(..)) } + ProxyType::Borrow => matches!( + c, + RuntimeCall::Loans(pallet_loans::Call::create{..}) | + RuntimeCall::Loans(pallet_loans::Call::borrow{..}) | + RuntimeCall::Loans(pallet_loans::Call::repay{..}) | + RuntimeCall::Loans(pallet_loans::Call::write_off{..}) | + RuntimeCall::Loans(pallet_loans::Call::close{..}) | + // Borrowers should be able to close and execute an epoch + // in order to get liquidity from repayments in previous epochs. + RuntimeCall::Loans(pallet_loans::Call::update_nav{..}) | + RuntimeCall::PoolSystem(pallet_pool_system::Call::close_epoch{..}) | + RuntimeCall::PoolSystem(pallet_pool_system::Call::submit_solution{..}) | + RuntimeCall::PoolSystem(pallet_pool_system::Call::execute_epoch{..}) | + RuntimeCall::Utility(pallet_utility::Call::batch_all{..}) | + RuntimeCall::Utility(pallet_utility::Call::batch{..}) + ), + ProxyType::Price => matches!(c, RuntimeCall::Loans(pallet_loans::Call::price { .. })), + ProxyType::Invest => matches!( + c, + RuntimeCall::Investments(pallet_investments::Call::update_invest_order{..}) | + RuntimeCall::Investments(pallet_investments::Call::update_redeem_order{..}) | + RuntimeCall::Investments(pallet_investments::Call::collect_investments{..}) | + RuntimeCall::Investments(pallet_investments::Call::collect_redemptions{..}) | + // Investors should be able to close and execute an epoch + // in order to get their orders fulfilled. + RuntimeCall::Loans(pallet_loans::Call::update_nav{..}) | + RuntimeCall::PoolSystem(pallet_pool_system::Call::close_epoch{..}) | + RuntimeCall::PoolSystem(pallet_pool_system::Call::submit_solution{..}) | + RuntimeCall::PoolSystem(pallet_pool_system::Call::execute_epoch{..}) | + RuntimeCall::Utility(pallet_utility::Call::batch_all{..}) | + RuntimeCall::Utility(pallet_utility::Call::batch{..}) + ), + ProxyType::ProxyManagement => matches!(c, RuntimeCall::Proxy(..)), + ProxyType::KeystoreManagement => matches!( + c, + RuntimeCall::Keystore(pallet_keystore::Call::add_keys { .. }) + | RuntimeCall::Keystore(pallet_keystore::Call::revoke_keys { .. }) + ), + ProxyType::PodOperation => matches!( + c, + RuntimeCall::Uniques(..) + | RuntimeCall::Anchor(..) + | RuntimeCall::Utility(pallet_utility::Call::batch_all { .. }) + ), + // This type of proxy is used only for authenticating with the centrifuge POD, + // having it here also allows us to validate authentication with on-chain data. + ProxyType::PodAuth => false, + ProxyType::PermissionManagement => matches!( + c, + RuntimeCall::Permissions(pallet_permissions::Call::add { .. }) + | RuntimeCall::Permissions(pallet_permissions::Call::remove { .. }) + ), } } @@ -1000,6 +1072,151 @@ impl pallet_collator_selection::Config for Runtime { type WeightInfo = pallet_collator_selection::weights::SubstrateWeight; } +impl pallet_pool_registry::Config for Runtime { + type Balance = Balance; + type CurrencyId = CurrencyId; + type InterestRate = Rate; + type MaxSizeMetadata = MaxSizeMetadata; + type MaxTokenNameLength = MaxTrancheNameLengthBytes; + type MaxTokenSymbolLength = MaxTrancheSymbolLengthBytes; + type MaxTranches = MaxTranches; + type ModifyPool = pallet_pool_system::Pallet; + type Permission = Permissions; + type PoolCreateOrigin = EnsureRoot; + type PoolId = PoolId; + type Rate = Rate; + type RuntimeEvent = RuntimeEvent; + type TrancheId = TrancheId; + type WeightInfo = weights::pallet_pool_registry::WeightInfo; +} + +// Pool config parameters +parameter_types! { + pub const PoolPalletId: frame_support::PalletId = cfg_types::ids::POOLS_PALLET_ID; + + /// The index with which this pallet is instantiated in this runtime. + pub PoolPalletIndex: u8 = ::index() as u8; + + pub const MinUpdateDelay: u64 = 0; // no delay + pub const ChallengeTime: BlockNumber = if cfg!(feature = "runtime-benchmarks") { + // Disable challenge time in benchmarks + 0 + } else { + 2 * MINUTES + }; + + // Defaults for pool parameters + pub const DefaultMinEpochTime: u64 = 5 * SECONDS_PER_MINUTE; // 5 minutes + pub const DefaultMaxNAVAge: u64 = 1 * SECONDS_PER_MINUTE; // 1 minute + + // Runtime-defined constraints for pool parameters + pub const MinEpochTimeLowerBound: u64 = 1; // at least 1 second (i.e. do not allow multiple epochs closed in 1 block) + pub const MinEpochTimeUpperBound: u64 = 30 * SECONDS_PER_DAY; // 1 month + pub const MaxNAVAgeUpperBound: u64 = SECONDS_PER_HOUR; // 1 hour + + // Pool metadata limit + #[derive(scale_info::TypeInfo, Eq, PartialEq, Debug, Clone, Copy )] + pub const MaxSizeMetadata: u32 = 46; // length of IPFS hash + + // Deposit to create a pool. This covers pool data, loan data, and permissions data. + // TODO: Define deposit? + pub const PoolDeposit: Balance = 100 * CFG; +} + +impl pallet_pool_system::Config for Runtime { + type AssetRegistry = OrmlAssetRegistry; + type Balance = Balance; + type ChallengeTime = ChallengeTime; + type Currency = Balances; + type CurrencyId = CurrencyId; + type DefaultMaxNAVAge = DefaultMaxNAVAge; + type DefaultMinEpochTime = DefaultMinEpochTime; + type EpochId = PoolEpochId; + type Investments = Investments; + type MaxNAVAgeUpperBound = MaxNAVAgeUpperBound; + type MaxSizeMetadata = MaxSizeMetadata; + type MaxTokenNameLength = MaxTrancheNameLengthBytes; + type MaxTokenSymbolLength = MaxTrancheSymbolLengthBytes; + type MaxTranches = MaxTranches; + type MinEpochTimeLowerBound = MinEpochTimeLowerBound; + type MinEpochTimeUpperBound = MinEpochTimeUpperBound; + type MinUpdateDelay = MinUpdateDelay; + type NAV = (); + // TODO: Add actual pallet-loans, after https://github.com/centrifuge/centrifuge-chain/pull/1180 is merged + type PalletId = PoolPalletId; + type PalletIndex = PoolPalletIndex; + type ParachainId = ParachainInfo; + type Permission = Permissions; + type PoolCreateOrigin = EnsureRoot; + type PoolCurrency = PoolCurrency; + type PoolDeposit = PoolDeposit; + type PoolId = PoolId; + type Rate = Rate; + type RuntimeEvent = RuntimeEvent; + type Time = Timestamp; + type Tokens = Tokens; + type TrancheCurrency = TrancheCurrency; + type TrancheId = TrancheId; + type TrancheWeight = TrancheWeight; + type UpdateGuard = UpdateGuard; + type WeightInfo = weights::pallet_pool_system::WeightInfo; +} + +parameter_types! { + #[cfg_attr(feature = "std", derive(frame_support::Serialize, frame_support::Deserialize))] + pub const MaxTranches: u32 = 5; + + // How much time should lapse before a tranche investor can be removed + #[derive(Debug, Eq, PartialEq, scale_info::TypeInfo, Clone)] + pub const MinDelay: Moment = 7 * SECONDS_PER_DAY; + + #[derive(Debug, Eq, PartialEq, scale_info::TypeInfo, Clone)] + pub const MaxRolesPerPool: u32 = 1_000; +} + +impl pallet_permissions::Config for Runtime { + type AdminOrigin = EnsureRootOr; + type Editors = Editors; + type MaxRolesPerScope = MaxRolesPerPool; + type Role = Role; + type RuntimeEvent = RuntimeEvent; + type Scope = PermissionScope; + type Storage = + PermissionRoles, MinDelay, TrancheId, MaxTranches, Moment>; + type WeightInfo = weights::pallet_permissions::WeightInfo; +} + +parameter_types! { + pub const MaxOutstandingCollects: u32 = 10; +} +impl pallet_investments::Config for Runtime { + type Accountant = PoolSystem; + type Amount = Balance; + type BalanceRatio = Rate; + type InvestmentId = TrancheCurrency; + type MaxOutstandingCollects = MaxOutstandingCollects; + type PreConditions = IsTrancheInvestor; + type RuntimeEvent = RuntimeEvent; + type Tokens = Tokens; + type WeightInfo = (); +} + +impl pallet_interest_accrual::Config for Runtime { + type Balance = Balance; + type InterestRate = Rate; + // TODO: This is a stopgap value until we can calculate it correctly with updated benchmarks. See #1024 + type MaxRateCount = MaxActiveLoansPerPool; + type RuntimeEvent = RuntimeEvent; + type Time = Timestamp; + type Weights = (); +} + +parameter_types! { + pub const LoansPalletId: PalletId = cfg_types::ids::LOANS_PALLET_ID; + pub const MaxActiveLoansPerPool: u32 = 50; + pub const MaxWriteOffGroups: u32 = 10; +} + // Frame Order in this block dictates the index of each one in the metadata // Any addition should be done at the bottom // Any deletion affects the following frames during runtime upgrades @@ -1065,6 +1282,18 @@ construct_runtime!( OrmlTokens: orml_tokens::{Pallet, Storage, Event, Config} = 151, OrmlAssetRegistry: orml_asset_registry::{Pallet, Storage, Call, Event, Config} = 152, OrmlXcm: orml_xcm::{Pallet, Storage, Call, Event} = 153, + + // Synced pallets across all runtimes - Range: 180-240 + // WHY: * integrations liek fireblocks will need to know the index in the enum + // * makes it easier, without parsing complete metadata + // * makes it in-sync for XCM integrations -- same enum variant again + // TODO: Research how to change this in Altair... + PoolRegistry: pallet_pool_registry::{Pallet, Call, Storage, Event} = 180, + PoolSystem: pallet_pool_system::{Pallet, Call, Storage, Event} = 181, + Permissions: pallet_permissions::{Pallet, Call, Storage, Event} = 182, + Investments: pallet_investments::{Pallet, Call, Storage, Event} = 183, + InterestAccrual: pallet_interest_accrual::{Pallet, Storage, Event, Config} = 184, + } ); @@ -1214,6 +1443,67 @@ impl_runtime_apis! { } } + // PoolsApi + impl runtime_common::apis::PoolsApi for Runtime { + fn currency(pool_id: PoolId) -> Option{ + pallet_pool_system::Pool::::get(pool_id).map(|details| details.currency) + } + + fn inspect_epoch_solution(pool_id: PoolId, solution: Vec) -> Option>{ + let pool = pallet_pool_system::Pool::::get(pool_id)?; + let epoch_execution_info = pallet_pool_system::EpochExecution::::get(pool_id)?; + pallet_pool_system::Pallet::::score_solution( + &pool, + &epoch_execution_info, + &solution + ).ok() + } + + fn tranche_token_price(pool_id: PoolId, tranche: TrancheLoc) -> Option{ + let now = as UnixTime>::now().as_secs(); + let mut pool = pallet_pool_system::Pool::::get(pool_id)?; + let nav: Balance = pallet_loans::Pallet::::update_nav_of_pool(pool_id) + .ok() + .map(|(latest, _)| latest.into())?; + let total_assets = pool.reserve.total.saturating_add(nav); + let index: usize = pool.tranches.tranche_index(&tranche)?.try_into().ok()?; + let prices = pool + .tranches + .calculate_prices::<_, OrmlTokens, _>(total_assets, now) + .ok()?; + prices.get(index).cloned() + } + + fn tranche_token_prices(pool_id: PoolId) -> Option>{ + let now = as UnixTime>::now().as_secs(); + let mut pool = pallet_pool_system::Pool::::get(pool_id)?; + let nav: Balance = pallet_loans::Pallet::::update_nav_of_pool(pool_id) + .ok() + .map(|(latest, _)| latest.into())?; + let total_assets = pool.reserve.total.saturating_add(nav); + pool + .tranches + .calculate_prices::(total_assets, now) + .ok() + } + + fn tranche_ids(pool_id: PoolId) -> Option>{ + let pool = pallet_pool_system::Pool::::get(pool_id)?; + Some(pool.tranches.ids_residual_top()) + } + + fn tranche_id(pool_id: PoolId, tranche_index: TrancheIndex) -> Option{ + let pool = pallet_pool_system::Pool::::get(pool_id)?; + let index: usize = tranche_index.try_into().ok()?; + pool.tranches.ids_residual_top().get(index).cloned() + } + + fn tranche_currency(pool_id: PoolId, tranche_loc: TrancheLoc) -> Option{ + let pool = pallet_pool_system::Pool::::get(pool_id)?; + pool.tranches.tranche_currency(tranche_loc).map(Into::into) + } + } + #[cfg(feature = "runtime-benchmarks")] impl frame_benchmarking::Benchmark for Runtime { @@ -1246,6 +1536,10 @@ impl_runtime_apis! { list_benchmark!(list, extra, pallet_crowdloan_claim, CrowdloanClaim); list_benchmark!(list, extra, pallet_crowdloan_reward, CrowdloanReward); list_benchmark!(list, extra, pallet_collator_allowlist, CollatorAllowlist); + list_benchmark!(list, extra, pallet_pool_registry, PoolRegistry); + list_benchmark!(list, extra, pallet_pool_system, PoolSystem); + list_benchmark!(list, extra, pallet_permissions, Permissions); + list_benchmark!(list, extra, pallet_interest_accrual, InterestAccrual); let storage_info = AllPalletsWithSystem::storage_info(); @@ -1299,6 +1593,10 @@ impl_runtime_apis! { add_benchmark!(params, batches, pallet_crowdloan_claim, CrowdloanClaim); add_benchmark!(params, batches, pallet_crowdloan_reward, CrowdloanReward); add_benchmark!(params, batches, pallet_collator_allowlist, CollatorAllowlist); + add_benchmark!(params, batches, pallet_pool_registry, PoolRegistry); + add_benchmark!(params, batches, pallet_pool_system, PoolSystem); + add_benchmark!(params, batches, pallet_permissions, Permissions); + add_benchmark!(params, batches, pallet_interest_accrual, InterestAccrual); if batches.is_empty() { return Err("Benchmark not found for this pallet.".into()) } Ok(batches) diff --git a/runtime/development/src/lib.rs b/runtime/development/src/lib.rs index 78de8adf7c..8eefd201cb 100644 --- a/runtime/development/src/lib.rs +++ b/runtime/development/src/lib.rs @@ -1280,7 +1280,6 @@ impl pallet_loans_ref::Config for Runtime { } parameter_types! { - #[derive(Encode, Decode, Debug, Eq, PartialEq, PartialOrd, scale_info::TypeInfo, Clone)] #[cfg_attr(feature = "std", derive(frame_support::Serialize, frame_support::Deserialize))] pub const MaxTranches: u32 = 5; @@ -1296,7 +1295,6 @@ impl pallet_permissions::Config for Runtime { type AdminOrigin = EnsureRootOr; type Editors = Editors; type MaxRolesPerScope = MaxRolesPerPool; - type MaxTranches = MaxTranches; type Role = Role; type RuntimeEvent = RuntimeEvent; type Scope = PermissionScope; From 4247dbdd6143692b551710f99fac341662e4aa8d Mon Sep 17 00:00:00 2001 From: Branan Riley Date: Wed, 8 Mar 2023 15:58:00 -0800 Subject: [PATCH 04/55] Add Keystore and Uniques to Centrifuge runtime --- runtime/centrifuge/Cargo.toml | 8 +++++ runtime/centrifuge/src/lib.rs | 55 ++++++++++++++++++++++++++++++++++- 2 files changed, 62 insertions(+), 1 deletion(-) diff --git a/runtime/centrifuge/Cargo.toml b/runtime/centrifuge/Cargo.toml index 0e0caa98d0..4c6fd895e1 100644 --- a/runtime/centrifuge/Cargo.toml +++ b/runtime/centrifuge/Cargo.toml @@ -74,6 +74,7 @@ pallet-timestamp = { git = "https://github.com/paritytech/substrate", default-fe pallet-transaction-payment = { git = "https://github.com/paritytech/substrate", default-features = false, branch = "polkadot-v0.9.32" } pallet-transaction-payment-rpc-runtime-api = { git = "https://github.com/paritytech/substrate", default-features = false, branch = "polkadot-v0.9.32" } pallet-treasury = { git = "https://github.com/paritytech/substrate", default-features = false, branch = "polkadot-v0.9.32" } +pallet-uniques = { git = "https://github.com/paritytech/substrate", default-features = false, branch = "polkadot-v0.9.32" } pallet-utility = { git = "https://github.com/paritytech/substrate", default-features = false, branch = "polkadot-v0.9.32" } pallet-vesting = { git = "https://github.com/paritytech/substrate", default-features = false, branch = "polkadot-v0.9.32" } @@ -98,6 +99,7 @@ pallet-crowdloan-reward = { path = "../../pallets/crowdloan-reward", default-fea pallet-fees = { path = "../../pallets/fees", default-features = false } pallet-interest-accrual = { path = "../../pallets/interest-accrual", default-features = false } pallet-investments = { path = "../../pallets/investments", default-features = false } +pallet-keystore = { path = "../../pallets/keystore", default-features = false } pallet-migration-manager = { path = "../../pallets/migration", default-features = false } pallet-nft = { path = "../../pallets/nft", default-features = false } pallet-restricted-tokens = { path = "../../pallets/restricted-tokens", default-features = false } @@ -158,6 +160,7 @@ std = [ "pallet-identity/std", "pallet-interest-accrual/std", "pallet-investments/std", + "pallet-keystore/std", "pallet-migration-manager/std", "pallet-multisig/std", "pallet-nft/std", @@ -174,6 +177,7 @@ std = [ "pallet-transaction-payment-rpc-runtime-api/std", "pallet-transaction-payment/std", "pallet-treasury/std", + "pallet-uniques/std", "pallet-utility/std", "pallet-vesting/std", "pallet-xcm/std", @@ -228,6 +232,7 @@ runtime-benchmarks = [ "pallet-identity/runtime-benchmarks", "pallet-interest-accrual/runtime-benchmarks", "pallet-investments/runtime-benchmarks", + "pallet-keystore/runtime-benchmarks", "pallet-migration-manager/runtime-benchmarks", "pallet-multisig/runtime-benchmarks", "pallet-nft/runtime-benchmarks", @@ -240,6 +245,7 @@ runtime-benchmarks = [ "pallet-scheduler/runtime-benchmarks", "pallet-timestamp/runtime-benchmarks", "pallet-treasury/runtime-benchmarks", + "pallet-uniques/runtime-benchmarks", "pallet-utility/runtime-benchmarks", "pallet-vesting/runtime-benchmarks", "pallet-xcm/runtime-benchmarks", @@ -286,6 +292,7 @@ try-runtime = [ "pallet-identity/try-runtime", "pallet-interest-accrual/try-runtime", "pallet-investments/try-runtime", + "pallet-keystore/try-runtime", "pallet-migration-manager/try-runtime", "pallet-multisig/try-runtime", "pallet-nft/try-runtime", @@ -301,6 +308,7 @@ try-runtime = [ "pallet-timestamp/try-runtime", "pallet-transaction-payment/try-runtime", "pallet-treasury/try-runtime", + "pallet-uniques/try-runtime", "pallet-utility/try-runtime", "pallet-vesting/try-runtime", "pallet-xcm/try-runtime", diff --git a/runtime/centrifuge/src/lib.rs b/runtime/centrifuge/src/lib.rs index 2a3bb27a98..77b6d22cef 100644 --- a/runtime/centrifuge/src/lib.rs +++ b/runtime/centrifuge/src/lib.rs @@ -1217,6 +1217,58 @@ parameter_types! { pub const MaxWriteOffGroups: u32 = 10; } +parameter_types! { + pub const MaxKeys: u32 = 10; + pub const DefaultKeyDeposit: Balance = 100 * CFG; +} + +impl pallet_keystore::pallet::Config for Runtime { + type AdminOrigin = EnsureRootOr; + type Balance = Balance; + type Currency = Balances; + type DefaultKeyDeposit = DefaultKeyDeposit; + type MaxKeys = MaxKeys; + type RuntimeEvent = RuntimeEvent; + type WeightInfo = weights::pallet_keystore::WeightInfo; +} + +parameter_types! { + // per byte deposit is 0.01 AIR + pub const DepositPerByte: Balance = CENTI_CFG; + // Base deposit to add attribute is 0.1 AIR + pub const AttributeDepositBase: Balance = 10 * CENTI_CFG; + // Base deposit to add metadata is 0.1 AIR + pub const MetadataDepositBase: Balance = 10 * CENTI_CFG; + // Deposit to create a class is 1 AIR + pub const CollectionDeposit: Balance = CFG; + // Deposit to create a class is 0.1 AIR + pub const ItemDeposit: Balance = 10 * CENTI_CFG; + // Maximum limit of bytes for Metadata, Attribute key and Value + pub const Limit: u32 = 256; +} + +impl pallet_uniques::Config for Runtime { + type AttributeDepositBase = AttributeDepositBase; + type CollectionDeposit = CollectionDeposit; + type CollectionId = CollectionId; + type CreateOrigin = AsEnsureOriginWithArg>; + type Currency = Balances; + type DepositPerByte = DepositPerByte; + // a straight majority of council can act as force origin + type ForceOrigin = EnsureRoot; + #[cfg(feature = "runtime-benchmarks")] + type Helper = (); + type ItemDeposit = ItemDeposit; + type ItemId = ItemId; + type KeyLimit = Limit; + type Locker = (); + type MetadataDepositBase = MetadataDepositBase; + type RuntimeEvent = RuntimeEvent; + type StringLimit = Limit; + type ValueLimit = Limit; + type WeightInfo = weights::pallet_uniques::WeightInfo; +} + // Frame Order in this block dictates the index of each one in the metadata // Any addition should be done at the bottom // Any deletion affects the following frames during runtime upgrades @@ -1293,7 +1345,8 @@ construct_runtime!( Permissions: pallet_permissions::{Pallet, Call, Storage, Event} = 182, Investments: pallet_investments::{Pallet, Call, Storage, Event} = 183, InterestAccrual: pallet_interest_accrual::{Pallet, Storage, Event, Config} = 184, - + Uniques: pallet_uniques::{Pallet, Call, Storage, Event} = 185, + Keystore: pallet_keystore::{Pallet, Call, Storage, Event} = 186, } ); From a4cbc68f9e69a2dea7a74a68ca228680540531b0 Mon Sep 17 00:00:00 2001 From: Branan Riley Date: Wed, 8 Mar 2023 15:59:24 -0800 Subject: [PATCH 05/55] TMP add pallet-loans --- runtime/centrifuge/Cargo.toml | 4 ++++ runtime/centrifuge/src/lib.rs | 20 ++++++++++++++++++++ 2 files changed, 24 insertions(+) diff --git a/runtime/centrifuge/Cargo.toml b/runtime/centrifuge/Cargo.toml index 4c6fd895e1..ec5fcd48fd 100644 --- a/runtime/centrifuge/Cargo.toml +++ b/runtime/centrifuge/Cargo.toml @@ -100,6 +100,7 @@ pallet-fees = { path = "../../pallets/fees", default-features = false } pallet-interest-accrual = { path = "../../pallets/interest-accrual", default-features = false } pallet-investments = { path = "../../pallets/investments", default-features = false } pallet-keystore = { path = "../../pallets/keystore", default-features = false } +pallet-loans = { path = "../../pallets/loans", default-features = false } pallet-migration-manager = { path = "../../pallets/migration", default-features = false } pallet-nft = { path = "../../pallets/nft", default-features = false } pallet-restricted-tokens = { path = "../../pallets/restricted-tokens", default-features = false } @@ -160,6 +161,7 @@ std = [ "pallet-identity/std", "pallet-interest-accrual/std", "pallet-investments/std", + "pallet-loans/std", "pallet-keystore/std", "pallet-migration-manager/std", "pallet-multisig/std", @@ -232,6 +234,7 @@ runtime-benchmarks = [ "pallet-identity/runtime-benchmarks", "pallet-interest-accrual/runtime-benchmarks", "pallet-investments/runtime-benchmarks", + "pallet-loans/runtime-benchmarks", "pallet-keystore/runtime-benchmarks", "pallet-migration-manager/runtime-benchmarks", "pallet-multisig/runtime-benchmarks", @@ -292,6 +295,7 @@ try-runtime = [ "pallet-identity/try-runtime", "pallet-interest-accrual/try-runtime", "pallet-investments/try-runtime", + "pallet-loans/try-runtime", "pallet-keystore/try-runtime", "pallet-migration-manager/try-runtime", "pallet-multisig/try-runtime", diff --git a/runtime/centrifuge/src/lib.rs b/runtime/centrifuge/src/lib.rs index 77b6d22cef..5d3a1b0ff3 100644 --- a/runtime/centrifuge/src/lib.rs +++ b/runtime/centrifuge/src/lib.rs @@ -1217,6 +1217,25 @@ parameter_types! { pub const MaxWriteOffGroups: u32 = 10; } +impl pallet_loans::Config for Runtime { + type Balance = Balance; + type BlockNumberProvider = System; + type ClassId = CollectionId; + type CurrencyId = CurrencyId; + type InterestAccrual = InterestAccrual; + type LoanId = ItemId; + type LoansPalletId = LoansPalletId; + type MaxActiveLoansPerPool = MaxActiveLoansPerPool; + type MaxWriteOffGroups = MaxWriteOffGroups; + type NonFungible = Uniques; + type Permission = Permissions; + type Pool = PoolSystem; + type Rate = Rate; + type RuntimeEvent = RuntimeEvent; + type Time = Timestamp; + type WeightInfo = pallet_loans::weights::SubstrateWeight; +} + parameter_types! { pub const MaxKeys: u32 = 10; pub const DefaultKeyDeposit: Balance = 100 * CFG; @@ -1347,6 +1366,7 @@ construct_runtime!( InterestAccrual: pallet_interest_accrual::{Pallet, Storage, Event, Config} = 184, Uniques: pallet_uniques::{Pallet, Call, Storage, Event} = 185, Keystore: pallet_keystore::{Pallet, Call, Storage, Event} = 186, + Loans: pallet_loans::{Pallet, Call, Storage, Event} = 187, } ); From a1495f65caa4a0c13febe5f8f04b2b769cac0692 Mon Sep 17 00:00:00 2001 From: Branan Riley Date: Wed, 8 Mar 2023 16:04:40 -0800 Subject: [PATCH 06/55] Use per-pallet weights for unbenched pallets --- runtime/centrifuge/src/lib.rs | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/runtime/centrifuge/src/lib.rs b/runtime/centrifuge/src/lib.rs index 5d3a1b0ff3..42e064a1c2 100644 --- a/runtime/centrifuge/src/lib.rs +++ b/runtime/centrifuge/src/lib.rs @@ -1087,7 +1087,7 @@ impl pallet_pool_registry::Config for Runtime { type Rate = Rate; type RuntimeEvent = RuntimeEvent; type TrancheId = TrancheId; - type WeightInfo = weights::pallet_pool_registry::WeightInfo; + type WeightInfo = pallet_pool_registry::weights::SubstrateWeight; } // Pool config parameters @@ -1159,7 +1159,7 @@ impl pallet_pool_system::Config for Runtime { type TrancheId = TrancheId; type TrancheWeight = TrancheWeight; type UpdateGuard = UpdateGuard; - type WeightInfo = weights::pallet_pool_system::WeightInfo; + type WeightInfo = pallet_pool_system::weights::SubstrateWeight; } parameter_types! { @@ -1183,7 +1183,7 @@ impl pallet_permissions::Config for Runtime { type Scope = PermissionScope; type Storage = PermissionRoles, MinDelay, TrancheId, MaxTranches, Moment>; - type WeightInfo = weights::pallet_permissions::WeightInfo; + type WeightInfo = pallet_permissions::weights::SubstrateWeight; } parameter_types! { @@ -1248,7 +1248,7 @@ impl pallet_keystore::pallet::Config for Runtime { type DefaultKeyDeposit = DefaultKeyDeposit; type MaxKeys = MaxKeys; type RuntimeEvent = RuntimeEvent; - type WeightInfo = weights::pallet_keystore::WeightInfo; + type WeightInfo = pallet_keystore::weights::SubstrateWeight; } parameter_types! { @@ -1285,7 +1285,7 @@ impl pallet_uniques::Config for Runtime { type RuntimeEvent = RuntimeEvent; type StringLimit = Limit; type ValueLimit = Limit; - type WeightInfo = weights::pallet_uniques::WeightInfo; + type WeightInfo = pallet_uniques::weights::SubstrateWeight; } // Frame Order in this block dictates the index of each one in the metadata From 04ffb9cbca8672a6ba31eab53decc1079731289c Mon Sep 17 00:00:00 2001 From: Branan Riley Date: Wed, 8 Mar 2023 16:09:39 -0800 Subject: [PATCH 07/55] Add missing imports --- runtime/centrifuge/src/lib.rs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/runtime/centrifuge/src/lib.rs b/runtime/centrifuge/src/lib.rs index 42e064a1c2..b405c9226c 100644 --- a/runtime/centrifuge/src/lib.rs +++ b/runtime/centrifuge/src/lib.rs @@ -33,8 +33,8 @@ use frame_support::{ dispatch::DispatchClass, parameter_types, traits::{ - ConstU32, EqualPrivilegeOnly, InstanceFilter, LockIdentifier, U128CurrencyToVote, - WithdrawReasons, + AsEnsureOriginWithArg, ConstU32, EqualPrivilegeOnly, InstanceFilter, LockIdentifier, + PalletInfoAccess, U128CurrencyToVote, UnixTime, WithdrawReasons, }, weights::{ constants::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight}, @@ -44,7 +44,7 @@ use frame_support::{ }; use frame_system::{ limits::{BlockLength, BlockWeights}, - EnsureRoot, + EnsureRoot, EnsureSigned, }; use orml_traits::{currency::MutationHooks, parameter_type_with_key}; use pallet_anchors::AnchorData; From 75d6db7151d33636e2e75e271f744ccd9a7ed2cd Mon Sep 17 00:00:00 2001 From: Branan Riley Date: Wed, 8 Mar 2023 16:10:10 -0800 Subject: [PATCH 08/55] EnsureRoot --- runtime/centrifuge/src/lib.rs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/runtime/centrifuge/src/lib.rs b/runtime/centrifuge/src/lib.rs index b405c9226c..09f5e006cc 100644 --- a/runtime/centrifuge/src/lib.rs +++ b/runtime/centrifuge/src/lib.rs @@ -1082,7 +1082,7 @@ impl pallet_pool_registry::Config for Runtime { type MaxTranches = MaxTranches; type ModifyPool = pallet_pool_system::Pallet; type Permission = Permissions; - type PoolCreateOrigin = EnsureRoot; + type PoolCreateOrigin = EnsureRoot; type PoolId = PoolId; type Rate = Rate; type RuntimeEvent = RuntimeEvent; @@ -1147,7 +1147,7 @@ impl pallet_pool_system::Config for Runtime { type PalletIndex = PoolPalletIndex; type ParachainId = ParachainInfo; type Permission = Permissions; - type PoolCreateOrigin = EnsureRoot; + type PoolCreateOrigin = EnsureRoot; type PoolCurrency = PoolCurrency; type PoolDeposit = PoolDeposit; type PoolId = PoolId; @@ -1274,7 +1274,7 @@ impl pallet_uniques::Config for Runtime { type Currency = Balances; type DepositPerByte = DepositPerByte; // a straight majority of council can act as force origin - type ForceOrigin = EnsureRoot; + type ForceOrigin = EnsureRoot; #[cfg(feature = "runtime-benchmarks")] type Helper = (); type ItemDeposit = ItemDeposit; From 5bb2fc6c7d2d60c28dedf4e89c19ad5c66bf1759 Mon Sep 17 00:00:00 2001 From: Branan Riley Date: Wed, 8 Mar 2023 16:21:51 -0800 Subject: [PATCH 09/55] Add remaining impls --- runtime/centrifuge/src/lib.rs | 226 +++++++++++++++++++++++++++++++--- 1 file changed, 206 insertions(+), 20 deletions(-) diff --git a/runtime/centrifuge/src/lib.rs b/runtime/centrifuge/src/lib.rs index 09f5e006cc..1338eb9368 100644 --- a/runtime/centrifuge/src/lib.rs +++ b/runtime/centrifuge/src/lib.rs @@ -19,11 +19,14 @@ #![allow(clippy::identity_op)] pub use cfg_primitives::{constants::*, types::*}; +use cfg_traits::{ + OrderManager, Permissions as PermissionsT, PoolUpdateGuard, PreConditions, TrancheCurrency as _, +}; use cfg_types::{ consts::pools::{MaxTrancheNameLengthBytes, MaxTrancheSymbolLengthBytes}, fee_keys::FeeKey, fixed_point::Rate, - permissions::{PermissionRoles, PermissionScope, Role}, + permissions::{PermissionRoles, PermissionScope, PermissionedCurrencyRole, PoolRole, Role}, time::TimeProvider, tokens::{CustomMetadata, TrancheCurrency}, }; @@ -31,7 +34,9 @@ use codec::{Decode, Encode, MaxEncodedLen}; use frame_support::{ construct_runtime, dispatch::DispatchClass, + pallet_prelude::{DispatchError, DispatchResult}, parameter_types, + sp_std::marker::PhantomData, traits::{ AsEnsureOriginWithArg, ConstU32, EqualPrivilegeOnly, InstanceFilter, LockIdentifier, PalletInfoAccess, U128CurrencyToVote, UnixTime, WithdrawReasons, @@ -50,6 +55,7 @@ use orml_traits::{currency::MutationHooks, parameter_type_with_key}; use pallet_anchors::AnchorData; pub use pallet_balances::Call as BalancesCall; use pallet_collective::{EnsureMember, EnsureProportionAtLeast, EnsureProportionMoreThan}; +use pallet_investments::OrderType; use pallet_pool_system::{ pool_types::{PoolDetails, ScheduledUpdateDetails}, tranches::{TrancheIndex, TrancheLoc, TrancheSolution}, @@ -68,7 +74,7 @@ use sp_inherents::{CheckInherentsResult, InherentData}; pub use sp_runtime::BuildStorage; use sp_runtime::{ create_runtime_str, generic, impl_opaque_keys, - traits::{AccountIdConversion, BlakeTwo256, Block as BlockT, ConvertInto}, + traits::{AccountIdConversion, BlakeTwo256, Block as BlockT, ConvertInto, Zero}, transaction_validity::{TransactionSource, TransactionValidity}, ApplyExtrinsicResult, Perbill, Permill, }; @@ -1072,24 +1078,6 @@ impl pallet_collator_selection::Config for Runtime { type WeightInfo = pallet_collator_selection::weights::SubstrateWeight; } -impl pallet_pool_registry::Config for Runtime { - type Balance = Balance; - type CurrencyId = CurrencyId; - type InterestRate = Rate; - type MaxSizeMetadata = MaxSizeMetadata; - type MaxTokenNameLength = MaxTrancheNameLengthBytes; - type MaxTokenSymbolLength = MaxTrancheSymbolLengthBytes; - type MaxTranches = MaxTranches; - type ModifyPool = pallet_pool_system::Pallet; - type Permission = Permissions; - type PoolCreateOrigin = EnsureRoot; - type PoolId = PoolId; - type Rate = Rate; - type RuntimeEvent = RuntimeEvent; - type TrancheId = TrancheId; - type WeightInfo = pallet_pool_registry::weights::SubstrateWeight; -} - // Pool config parameters parameter_types! { pub const PoolPalletId: frame_support::PalletId = cfg_types::ids::POOLS_PALLET_ID; @@ -1123,6 +1111,110 @@ parameter_types! { pub const PoolDeposit: Balance = 100 * CFG; } +pub struct PoolCurrency; +impl Contains for PoolCurrency { + fn contains(id: &CurrencyId) -> bool { + match id { + CurrencyId::Tranche(_, _) | CurrencyId::Native | CurrencyId::KSM => false, + CurrencyId::AUSD => true, + CurrencyId::ForeignAsset(_) => OrmlAssetRegistry::metadata(&id) + .map(|m| m.additional.pool_currency) + .unwrap_or(false), + } + } +} + +pub struct UpdateGuard; +impl PoolUpdateGuard for UpdateGuard { + type Moment = Moment; + type PoolDetails = PoolDetails< + CurrencyId, + TrancheCurrency, + u32, + Balance, + Rate, + MaxSizeMetadata, + TrancheWeight, + TrancheId, + PoolId, + MaxTranches, + >; + type ScheduledUpdateDetails = ScheduledUpdateDetails< + Rate, + MaxTrancheNameLengthBytes, + MaxTrancheSymbolLengthBytes, + MaxTranches, + >; + + fn released( + pool: &Self::PoolDetails, + update: &Self::ScheduledUpdateDetails, + now: Self::Moment, + ) -> bool { + if now < update.scheduled_time { + return false; + } + + // The epoch in which the redemptions were fulfilled, + // should have closed after the scheduled time already, + // to ensure that investors had the `MinUpdateDelay` + // to submit their redemption orders. + if now < pool.epoch.last_closed { + return false; + } + + let pool_id = pool.tranches.of_pool(); + + // We do not allow releasing updates during epoch + // closing. + // + // This is needed as: + // - investment side starts new order round with zero orders at epoch_closing + // - the pool might only fulfill x < 100% of redemptions + // -> not all redemptions would be fulfilled after epoch_execution + if PoolSystem::epoch_targets(pool_id).is_some() { + return false; + } + + // There should be no outstanding redemption orders. + let acc_outstanding_redemptions = pool + .tranches + .ids_non_residual_top() + .iter() + .map(|tranche_id| { + let investment_id = TrancheCurrency::generate(pool_id, *tranche_id); + Investments::redeem_orders(investment_id).amount + }) + .fold(Balance::zero(), |acc, redemption| { + acc.saturating_add(redemption) + }); + + if acc_outstanding_redemptions != 0u128 { + return false; + } + + true + } +} + +impl pallet_pool_registry::Config for Runtime { + type Balance = Balance; + type CurrencyId = CurrencyId; + type InterestRate = Rate; + type MaxSizeMetadata = MaxSizeMetadata; + type MaxTokenNameLength = MaxTrancheNameLengthBytes; + type MaxTokenSymbolLength = MaxTrancheSymbolLengthBytes; + type MaxTranches = MaxTranches; + type ModifyPool = pallet_pool_system::Pallet; + type Permission = Permissions; + type PoolCreateOrigin = EnsureRoot; + type PoolId = PoolId; + type Rate = Rate; + type RuntimeEvent = RuntimeEvent; + type TrancheId = TrancheId; + type WeightInfo = pallet_pool_registry::weights::SubstrateWeight; +} + impl pallet_pool_system::Config for Runtime { type AssetRegistry = OrmlAssetRegistry; type Balance = Balance; @@ -1174,6 +1266,49 @@ parameter_types! { pub const MaxRolesPerPool: u32 = 1_000; } +pub struct Editors; +impl + Contains<( + AccountId, + Option>, + PermissionScope, + Role, + )> for Editors +{ + fn contains( + t: &( + AccountId, + Option>, + PermissionScope, + Role, + ), + ) -> bool { + let (_editor, maybe_role, _scope, role) = t; + if let Some(with_role) = maybe_role { + match *with_role { + Role::PoolRole(PoolRole::PoolAdmin) => match *role { + // PoolAdmins can manage all other admins, but not tranche investors + Role::PoolRole(PoolRole::TrancheInvestor(_, _)) => false, + Role::PoolRole(..) => true, + _ => false, + }, + Role::PoolRole(PoolRole::MemberListAdmin) => matches!( + *role, + // MemberlistAdmins can manage tranche investors + Role::PoolRole(PoolRole::TrancheInvestor(_, _)) + ), + Role::PermissionedCurrencyRole(PermissionedCurrencyRole::Manager) => matches!( + *role, + Role::PermissionedCurrencyRole(PermissionedCurrencyRole::Holder(_)) + ), + _ => false, + } + } else { + false + } + } +} + impl pallet_permissions::Config for Runtime { type AdminOrigin = EnsureRootOr; type Editors = Editors; @@ -1189,6 +1324,57 @@ impl pallet_permissions::Config for Runtime { parameter_types! { pub const MaxOutstandingCollects: u32 = 10; } + +/// Checks whether the given `who` has the role +/// of a `TrancehInvestor` for the given pool. +pub struct IsTrancheInvestor(PhantomData<(P, T)>); +impl< + P: PermissionsT, Role = Role>, + T: UnixTime, + > PreConditions> for IsTrancheInvestor +{ + type Result = DispatchResult; + + fn check(order: OrderType) -> Self::Result { + let is_tranche_investor = match order { + OrderType::Investment { + who, + investment_id: tranche, + .. + } => P::has( + PermissionScope::Pool(tranche.of_pool()), + who, + Role::PoolRole(PoolRole::TrancheInvestor( + tranche.of_tranche(), + T::now().as_secs(), + )), + ), + OrderType::Redemption { + who, + investment_id: tranche, + .. + } => P::has( + PermissionScope::Pool(tranche.of_pool()), + who, + Role::PoolRole(PoolRole::TrancheInvestor( + tranche.of_tranche(), + T::now().as_secs(), + )), + ), + }; + + if is_tranche_investor { + Ok(()) + } else { + // TODO: We should adapt the permissions pallets interface to return an error instead of a boolen. This makes the redundant has not role error + // that downstream pallets always need to generate not needed anymore. + Err(DispatchError::Other( + "Account does not have the TrancheInvestor permission.", + )) + } + } +} + impl pallet_investments::Config for Runtime { type Accountant = PoolSystem; type Amount = Balance; From e19a8b77b5c364af937f45d652ac2ea196623eb3 Mon Sep 17 00:00:00 2001 From: Branan Riley Date: Wed, 8 Mar 2023 16:32:11 -0800 Subject: [PATCH 10/55] Restore Encode/Decode impls for MaxTranches This is needed in order to make it available to the RPCs --- runtime/centrifuge/src/lib.rs | 1 + runtime/development/src/lib.rs | 1 + 2 files changed, 2 insertions(+) diff --git a/runtime/centrifuge/src/lib.rs b/runtime/centrifuge/src/lib.rs index 1338eb9368..df4b738760 100644 --- a/runtime/centrifuge/src/lib.rs +++ b/runtime/centrifuge/src/lib.rs @@ -1255,6 +1255,7 @@ impl pallet_pool_system::Config for Runtime { } parameter_types! { + #[derive(Encode, Decode, Debug, Eq, PartialEq, PartialOrd, scale_info::TypeInfo, Clone)] #[cfg_attr(feature = "std", derive(frame_support::Serialize, frame_support::Deserialize))] pub const MaxTranches: u32 = 5; diff --git a/runtime/development/src/lib.rs b/runtime/development/src/lib.rs index 8eefd201cb..2561dd1aad 100644 --- a/runtime/development/src/lib.rs +++ b/runtime/development/src/lib.rs @@ -1280,6 +1280,7 @@ impl pallet_loans_ref::Config for Runtime { } parameter_types! { + #[derive(Encode, Decode, Debug, Eq, PartialEq, PartialOrd, scale_info::TypeInfo, Clone)] #[cfg_attr(feature = "std", derive(frame_support::Serialize, frame_support::Deserialize))] pub const MaxTranches: u32 = 5; From 1c63eb734b297a7d109d942dd3c268c93282c77b Mon Sep 17 00:00:00 2001 From: Branan Riley Date: Wed, 8 Mar 2023 16:49:57 -0800 Subject: [PATCH 11/55] Add serde for conditional {De}serialize impls --- runtime/centrifuge/Cargo.toml | 2 ++ 1 file changed, 2 insertions(+) diff --git a/runtime/centrifuge/Cargo.toml b/runtime/centrifuge/Cargo.toml index ec5fcd48fd..c13677e6fa 100644 --- a/runtime/centrifuge/Cargo.toml +++ b/runtime/centrifuge/Cargo.toml @@ -13,6 +13,7 @@ repository = "https://github.com/centrifuge/centrifuge-chain" codec = { package = "parity-scale-codec", version = "3.0", default-features = false, features = ["derive"] } hex-literal = { version = "0.3.4", optional = true } scale-info = { version = "2.3.0", default-features = false, features = ["derive"] } +serde = { version = "1.0.119", optional = true } static_assertions = "1.1.0" # parachain @@ -188,6 +189,7 @@ std = [ "polkadot-runtime-common/std", "runtime-common/std", "scale-info/std", + "serde", "sp-api/std", "sp-block-builder/std", "sp-consensus-aura/std", From eecb743421ae033f1104eb1fd52f6c287505b758 Mon Sep 17 00:00:00 2001 From: Branan Riley Date: Wed, 8 Mar 2023 16:50:13 -0800 Subject: [PATCH 12/55] Add uniques/keystores to benchmarks --- runtime/centrifuge/src/lib.rs | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/runtime/centrifuge/src/lib.rs b/runtime/centrifuge/src/lib.rs index df4b738760..3089ed4229 100644 --- a/runtime/centrifuge/src/lib.rs +++ b/runtime/centrifuge/src/lib.rs @@ -1800,6 +1800,8 @@ impl_runtime_apis! { list_benchmark!(list, extra, pallet_pool_system, PoolSystem); list_benchmark!(list, extra, pallet_permissions, Permissions); list_benchmark!(list, extra, pallet_interest_accrual, InterestAccrual); + list_benchmark!(list, extra, pallet_uniquess, Permissions); + list_benchmark!(list, extra, pallet_keystore, InterestAccrual); let storage_info = AllPalletsWithSystem::storage_info(); @@ -1857,6 +1859,8 @@ impl_runtime_apis! { add_benchmark!(params, batches, pallet_pool_system, PoolSystem); add_benchmark!(params, batches, pallet_permissions, Permissions); add_benchmark!(params, batches, pallet_interest_accrual, InterestAccrual); + add_benchmark!(params, batches, pallet_uniques, InterestAccrual); + add_benchmark!(params, batches, pallet_keystore, InterestAccrual); if batches.is_empty() { return Err("Benchmark not found for this pallet.".into()) } Ok(batches) From 1a9554fefce928986a2c0ae4c1e349b5898fb50d Mon Sep 17 00:00:00 2001 From: Branan Riley Date: Wed, 8 Mar 2023 16:51:02 -0800 Subject: [PATCH 13/55] Add interest_accrual to centrifuge genesis --- src/chain_spec.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/src/chain_spec.rs b/src/chain_spec.rs index 9ada4a749b..b28f0ed756 100644 --- a/src/chain_spec.rs +++ b/src/chain_spec.rs @@ -867,6 +867,7 @@ fn centrifuge_genesis( threshold: 1, }, treasury: Default::default(), + interest_accrual: Default::default(), } } From 6aea06e119f2b667a7e1fe9924897bd86f1c1baf Mon Sep 17 00:00:00 2001 From: Branan Riley Date: Wed, 8 Mar 2023 18:55:34 -0800 Subject: [PATCH 14/55] Fix PoolCreateOrigin for benchmarks --- runtime/centrifuge/src/lib.rs | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/runtime/centrifuge/src/lib.rs b/runtime/centrifuge/src/lib.rs index 3089ed4229..04c4d0452d 100644 --- a/runtime/centrifuge/src/lib.rs +++ b/runtime/centrifuge/src/lib.rs @@ -1197,6 +1197,13 @@ impl PoolUpdateGuard for UpdateGuard { } } +// The pool benchmarks can't handle a required root origin (yet). +// TODO: Fix those benchmarks and remove this +#[cfg(not(feature = "runtime-benchmarks"))] +type PoolCreateOrigin = EnsureRoot; +#[cfg(feature = "runtime-benchmarks")] +type PoolCreateOrigin = EnsureSigned; + impl pallet_pool_registry::Config for Runtime { type Balance = Balance; type CurrencyId = CurrencyId; @@ -1207,7 +1214,7 @@ impl pallet_pool_registry::Config for Runtime { type MaxTranches = MaxTranches; type ModifyPool = pallet_pool_system::Pallet; type Permission = Permissions; - type PoolCreateOrigin = EnsureRoot; + type PoolCreateOrigin = PoolCreateOrigin; type PoolId = PoolId; type Rate = Rate; type RuntimeEvent = RuntimeEvent; From 1740bdfa99166ad83f969ed97e63ebd3f76da060 Mon Sep 17 00:00:00 2001 From: Branan Riley Date: Wed, 8 Mar 2023 21:42:10 -0800 Subject: [PATCH 15/55] Actually run all the benches --- Cargo.lock | 9 +++++++++ runtime/centrifuge/src/lib.rs | 18 +++++++++++++----- 2 files changed, 22 insertions(+), 5 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 5dea2382cc..1d28fc9e55 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1004,9 +1004,16 @@ dependencies = [ "pallet-elections-phragmen", "pallet-fees", "pallet-identity", + "pallet-interest-accrual", + "pallet-investments", + "pallet-keystore", + "pallet-loans", "pallet-migration-manager", "pallet-multisig", "pallet-nft", + "pallet-permissions", + "pallet-pool-registry", + "pallet-pool-system", "pallet-preimage", "pallet-proxy", "pallet-randomness-collective-flip", @@ -1017,6 +1024,7 @@ dependencies = [ "pallet-transaction-payment", "pallet-transaction-payment-rpc-runtime-api", "pallet-treasury", + "pallet-uniques", "pallet-utility", "pallet-vesting", "pallet-xcm", @@ -1026,6 +1034,7 @@ dependencies = [ "polkadot-runtime-common", "runtime-common", "scale-info", + "serde", "sp-api", "sp-block-builder", "sp-consensus-aura", diff --git a/runtime/centrifuge/src/lib.rs b/runtime/centrifuge/src/lib.rs index 04c4d0452d..0ec04049c5 100644 --- a/runtime/centrifuge/src/lib.rs +++ b/runtime/centrifuge/src/lib.rs @@ -1240,7 +1240,7 @@ impl pallet_pool_system::Config for Runtime { type MinEpochTimeLowerBound = MinEpochTimeLowerBound; type MinEpochTimeUpperBound = MinEpochTimeUpperBound; type MinUpdateDelay = MinUpdateDelay; - type NAV = (); + type NAV = Loans; // TODO: Add actual pallet-loans, after https://github.com/centrifuge/centrifuge-chain/pull/1180 is merged type PalletId = PoolPalletId; type PalletIndex = PoolPalletIndex; @@ -1781,6 +1781,7 @@ impl_runtime_apis! { use frame_benchmarking::{list_benchmark, Benchmarking, BenchmarkList}; use frame_support::traits::StorageInfoTrait; use frame_system_benchmarking::Pallet as SystemBench; + use pallet_loans::benchmarking::Pallet as LoansPallet; let mut list = Vec::::new(); @@ -1807,8 +1808,9 @@ impl_runtime_apis! { list_benchmark!(list, extra, pallet_pool_system, PoolSystem); list_benchmark!(list, extra, pallet_permissions, Permissions); list_benchmark!(list, extra, pallet_interest_accrual, InterestAccrual); - list_benchmark!(list, extra, pallet_uniquess, Permissions); - list_benchmark!(list, extra, pallet_keystore, InterestAccrual); + list_benchmark!(list, extra, pallet_uniquess, Uniques); + list_benchmark!(list, extra, pallet_keystore, Keystore); + list_benchmark!(list, extra, pallet_loans, LoansPallet::); let storage_info = AllPalletsWithSystem::storage_info(); @@ -1840,6 +1842,11 @@ impl_runtime_apis! { let mut batches = Vec::::new(); let params = (&config, &whitelist); + use pallet_loans::benchmarking::Pallet as LoansPallet; + impl pallet_loans::benchmarking::Config for Runtime { + type IM = Investments; + } + // It should be called Anchors to make the runtime_benchmarks.sh script works type Anchors = Anchor; @@ -1866,8 +1873,9 @@ impl_runtime_apis! { add_benchmark!(params, batches, pallet_pool_system, PoolSystem); add_benchmark!(params, batches, pallet_permissions, Permissions); add_benchmark!(params, batches, pallet_interest_accrual, InterestAccrual); - add_benchmark!(params, batches, pallet_uniques, InterestAccrual); - add_benchmark!(params, batches, pallet_keystore, InterestAccrual); + add_benchmark!(params, batches, pallet_uniques, Uniques); + add_benchmark!(params, batches, pallet_keystore, Keystore); + add_benchmark!(params, batches, pallet_loans, LoansPallet::); if batches.is_empty() { return Err("Benchmark not found for this pallet.".into()) } Ok(batches) From efe18cd3d89910e4af68234537e227e3374b8561 Mon Sep 17 00:00:00 2001 From: Branan Riley Date: Wed, 8 Mar 2023 21:49:26 -0800 Subject: [PATCH 16/55] Enable Pools RPC endpoints on centrifuge chain --- src/service.rs | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/src/service.rs b/src/service.rs index c59c93268f..a45abe56e9 100644 --- a/src/service.rs +++ b/src/service.rs @@ -651,7 +651,10 @@ pub async fn start_centrifuge_node( |client, pool, deny_unsafe| { let mut module = rpc::create_full(client.clone(), pool, deny_unsafe)?; module - .merge(Anchors::new(client).into_rpc()) + .merge(Anchors::new(client.clone()).into_rpc()) + .map_err(|e| sc_service::Error::Application(e.into()))?; + module + .merge(Pools::new(client).into_rpc()) .map_err(|e| sc_service::Error::Application(e.into()))?; Ok(module) }, From eb7232c1e8a7f984c5cbf467a71c93226568e58d Mon Sep 17 00:00:00 2001 From: mustermeiszer Date: Thu, 9 Mar 2023 10:11:20 +0100 Subject: [PATCH 17/55] Adapt paramets from Jeroen suggestion --- runtime/centrifuge/src/lib.rs | 18 ++++++++++-------- 1 file changed, 10 insertions(+), 8 deletions(-) diff --git a/runtime/centrifuge/src/lib.rs b/runtime/centrifuge/src/lib.rs index 0ec04049c5..ac92fdb16b 100644 --- a/runtime/centrifuge/src/lib.rs +++ b/runtime/centrifuge/src/lib.rs @@ -634,6 +634,8 @@ impl InstanceFilter for ProxyType { c, RuntimeCall::Permissions(pallet_permissions::Call::add { .. }) | RuntimeCall::Permissions(pallet_permissions::Call::remove { .. }) + | RuntimeCall::Utility(pallet_utility::Call::batch_all { .. }) + | RuntimeCall::Utility(pallet_utility::Call::batch { .. }) ), } } @@ -1085,22 +1087,22 @@ parameter_types! { /// The index with which this pallet is instantiated in this runtime. pub PoolPalletIndex: u8 = ::index() as u8; - pub const MinUpdateDelay: u64 = 0; // no delay + pub const MinUpdateDelay: u64 = 7 * SECONDS_PER_DAY; // 7 days notice pub const ChallengeTime: BlockNumber = if cfg!(feature = "runtime-benchmarks") { // Disable challenge time in benchmarks 0 } else { - 2 * MINUTES + 30 * MINUTES }; // Defaults for pool parameters - pub const DefaultMinEpochTime: u64 = 5 * SECONDS_PER_MINUTE; // 5 minutes - pub const DefaultMaxNAVAge: u64 = 1 * SECONDS_PER_MINUTE; // 1 minute + pub const DefaultMinEpochTime: u64 = 23 * SECONDS_PER_HOUR + 50 * SECONDS_PER_MINUTE; // 23h and 50 minutes + pub const DefaultMaxNAVAge: u64 = 0; // forcing update_nav + close epoch in same block // Runtime-defined constraints for pool parameters - pub const MinEpochTimeLowerBound: u64 = 1; // at least 1 second (i.e. do not allow multiple epochs closed in 1 block) + pub const MinEpochTimeLowerBound: u64 = 1 * SECONDS_PER_HOUR; // at least 1 second (i.e. do not allow multiple epochs closed in 1 block) pub const MinEpochTimeUpperBound: u64 = 30 * SECONDS_PER_DAY; // 1 month - pub const MaxNAVAgeUpperBound: u64 = SECONDS_PER_HOUR; // 1 hour + pub const MaxNAVAgeUpperBound: u64 = 1 * SECONDS_PER_HOUR; // 1 hour // Pool metadata limit #[derive(scale_info::TypeInfo, Eq, PartialEq, Debug, Clone, Copy )] @@ -1271,7 +1273,7 @@ parameter_types! { pub const MinDelay: Moment = 7 * SECONDS_PER_DAY; #[derive(Debug, Eq, PartialEq, scale_info::TypeInfo, Clone)] - pub const MaxRolesPerPool: u32 = 1_000; + pub const MaxRolesPerPool: u32 = 10_000; } pub struct Editors; @@ -1408,7 +1410,7 @@ impl pallet_interest_accrual::Config for Runtime { parameter_types! { pub const LoansPalletId: PalletId = cfg_types::ids::LOANS_PALLET_ID; pub const MaxActiveLoansPerPool: u32 = 50; - pub const MaxWriteOffGroups: u32 = 10; + pub const MaxWriteOffGroups: u32 = 100; } impl pallet_loans::Config for Runtime { From e7282e1ba2aaf91e4906459184c17044745c0ab4 Mon Sep 17 00:00:00 2001 From: mustermeiszer Date: Wed, 15 Mar 2023 09:24:13 +0100 Subject: [PATCH 18/55] fix: issuance issues for creating blocking redeem order --- pallets/pool-registry/src/benchmarking.rs | 4 ++-- pallets/pool-system/src/benchmarking.rs | 16 ++++++++++++---- 2 files changed, 14 insertions(+), 6 deletions(-) diff --git a/pallets/pool-registry/src/benchmarking.rs b/pallets/pool-registry/src/benchmarking.rs index 3cbfb0df9a..66f93b952f 100644 --- a/pallets/pool-registry/src/benchmarking.rs +++ b/pallets/pool-registry/src/benchmarking.rs @@ -114,7 +114,7 @@ benchmarks! { // Submit redemption order so the update isn't executed let amount = MAX_RESERVE / 2; - let investor = create_investor::(0, TRANCHE)?; + let investor = create_investor::(0, TRANCHE, Some(amount))?; let locator = get_tranche_id::(TRANCHE); pallet_investments::Pallet::::update_redeem_order(RawOrigin::Signed(investor.clone()).into(), TrancheCurrency::generate(POOL, locator), amount)?; @@ -179,7 +179,7 @@ benchmarks! { }; // Invest so we can redeem later - let investor = create_investor::(0, TRANCHE)?; + let investor = create_investor::(0, TRANCHE, Some(1))?; let locator = get_tranche_id::(TRANCHE); // Submit redemption order so the update isn't immediately executed pallet_investments::Pallet::::update_redeem_order(RawOrigin::Signed(investor.clone()).into(), TrancheCurrency::generate(POOL, locator), 1)?; diff --git a/pallets/pool-system/src/benchmarking.rs b/pallets/pool-system/src/benchmarking.rs index 9edb9a2d63..8457c93039 100644 --- a/pallets/pool-system/src/benchmarking.rs +++ b/pallets/pool-system/src/benchmarking.rs @@ -89,7 +89,7 @@ benchmarks! { T::NAV::initialise(RawOrigin::Signed(admin.clone()).into(), POOL, 0.into())?; unrestrict_epoch_close::(); let investment = MAX_RESERVE * 2; - let investor = create_investor::(0, TRANCHE)?; + let investor = create_investor::(0, TRANCHE, None)?; let origin = RawOrigin::Signed(investor.clone()).into(); pallet_investments::Pallet::::update_invest_order(origin, TrancheCurrency::generate(POOL, get_tranche_id::(TRANCHE)), investment)?; }: close_epoch(RawOrigin::Signed(admin.clone()), POOL) @@ -106,7 +106,7 @@ benchmarks! { T::NAV::initialise(RawOrigin::Signed(admin.clone()).into(), POOL, 0.into())?; unrestrict_epoch_close::(); let investment = MAX_RESERVE / 2; - let investor = create_investor::(0, TRANCHE)?; + let investor = create_investor::(0, TRANCHE, None)?; let origin = RawOrigin::Signed(investor.clone()).into(); pallet_investments::Pallet::::update_invest_order(origin, TrancheCurrency::generate(POOL, get_tranche_id::(TRANCHE)), investment)?; }: close_epoch(RawOrigin::Signed(admin.clone()), POOL) @@ -123,7 +123,7 @@ benchmarks! { T::NAV::initialise(RawOrigin::Signed(admin.clone()).into(), POOL, 0.into())?; unrestrict_epoch_close::(); let investment = MAX_RESERVE * 2; - let investor = create_investor::(0, TRANCHE)?; + let investor = create_investor::(0, TRANCHE, None)?; let origin = RawOrigin::Signed(investor.clone()).into(); pallet_investments::Pallet::::update_invest_order(origin, TrancheCurrency::generate(POOL, get_tranche_id::(TRANCHE)), investment)?; let admin_origin = RawOrigin::Signed(admin.clone()).into(); @@ -150,7 +150,7 @@ benchmarks! { T::NAV::initialise(RawOrigin::Signed(admin.clone()).into(), POOL, 0.into())?; unrestrict_epoch_close::(); let investment = MAX_RESERVE * 2; - let investor = create_investor::(0, TRANCHE)?; + let investor = create_investor::(0, TRANCHE, None)?; let origin = RawOrigin::Signed(investor.clone()).into(); pallet_investments::Pallet::::update_invest_order(origin, TrancheCurrency::generate(POOL, get_tranche_id::(TRANCHE)), investment)?; let admin_origin = RawOrigin::Signed(admin.clone()).into(); @@ -219,6 +219,7 @@ pub fn create_investor< >( id: u32, tranche: TrancheIndex, + with_tranche_tokens: Option, ) -> Result where <::Lookup as sp_runtime::traits::StaticLookup>::Source: @@ -233,6 +234,13 @@ where Role::PoolRole(PoolRole::TrancheInvestor(tranche_id, 0x0FFF_FFFF_FFFF_FFFF)), )?; T::Tokens::mint_into(CurrencyId::AUSD, &investor.clone().into(), MINT_AMOUNT)?; + if let Some(amount) = with_tranche_tokens { + T::Tokens::mint_into( + CurrencyId::Tranche(POOL, tranche_id), + &investor.clone().into(), + amount, + )?; + } Ok(investor) } From 888eadf56486e2cc24397c3fd31f349ffd2f91b3 Mon Sep 17 00:00:00 2001 From: mustermeiszer Date: Wed, 15 Mar 2023 11:13:06 +0100 Subject: [PATCH 19/55] change: Remove check in guard, updates note submission, not schedule * Removing the check if the MinUpdateDelay is passed, as this is part of the pallet-pool-system checks already * ScheduledUpdateDetails now note the time of submission of an update rather than the time when it is scheduled. logically, there is no "scheduled" time as the update can still be blocked by redemptions or other stuff in the future --- pallets/pool-registry/src/benchmarking.rs | 41 ++++------------------- pallets/pool-registry/src/mock.rs | 4 --- pallets/pool-system/src/impls.rs | 27 +++++---------- pallets/pool-system/src/mock.rs | 4 --- pallets/pool-system/src/pool_types.rs | 2 +- runtime/altair/src/lib.rs | 4 --- runtime/centrifuge/src/lib.rs | 4 --- runtime/development/src/lib.rs | 4 --- 8 files changed, 17 insertions(+), 73 deletions(-) diff --git a/pallets/pool-registry/src/benchmarking.rs b/pallets/pool-registry/src/benchmarking.rs index 66f93b952f..9ce7861cad 100644 --- a/pallets/pool-registry/src/benchmarking.rs +++ b/pallets/pool-registry/src/benchmarking.rs @@ -108,10 +108,6 @@ benchmarks! { prepare_asset_registry::(); create_pool::(n, admin.clone())?; - let pool = get_pool::(); - let default_min_epoch_time = pool.parameters.min_epoch_time; - let default_max_nav_age = pool.parameters.max_nav_age; - // Submit redemption order so the update isn't executed let amount = MAX_RESERVE / 2; let investor = create_investor::(0, TRANCHE, Some(amount))?; @@ -125,13 +121,13 @@ benchmarks! { tranche_metadata: Change::NoChange, }; - update_pool::(changes.clone())?; + //update_pool::(changes.clone())?; }: update(RawOrigin::Signed(admin), POOL, changes.clone()) verify { // Should be the old values let pool = get_pool::(); - assert_eq!(pool.parameters.min_epoch_time, default_min_epoch_time); - assert_eq!(pool.parameters.max_nav_age, default_max_nav_age); + assert_eq!(pool.parameters.min_epoch_time, T::DefaultMinEpochTime::get()); + assert_eq!(pool.parameters.max_nav_age, T::DefaultMaxNAVAge::get()); let actual_update = get_scheduled_update::(); assert_eq!(actual_update.changes, changes); @@ -145,12 +141,12 @@ benchmarks! { create_pool::(n, admin.clone())?; let changes = PoolChanges { - tranches: Change::NewValue(build_update_tranches::(n)), + tranches: Change::NewValue(tranches.clone()), min_epoch_time: Change::NewValue(SECS_PER_DAY), max_nav_age: Change::NewValue(SECS_PER_HOUR), tranche_metadata: Change::NewValue(build_update_tranche_metadata::()), }; - update_pool::(changes.clone())?; + //update_pool::(changes.clone())?; }: update(RawOrigin::Signed(admin), POOL, changes) verify { // No redemption order was submitted and the MinUpdateDelay is 0 for benchmarks, @@ -225,29 +221,6 @@ fn build_update_tranche_metadata( fn build_update_tranches( num_tranches: u32, -) -> BoundedVec, T::MaxTranches> { - let mut tranches = build_bench_update_tranches::(num_tranches); - - for tranche in &mut tranches { - tranche.tranche_type = match tranche.tranche_type { - TrancheType::Residual => TrancheType::Residual, - TrancheType::NonResidual { - interest_rate_per_sec, - min_risk_buffer, - } => { - let min_risk_buffer = Perquintill::from_parts(min_risk_buffer.deconstruct() * 2); - TrancheType::NonResidual { - interest_rate_per_sec, - min_risk_buffer, - } - } - } - } - tranches -} - -fn build_bench_update_tranches( - num_tranches: u32, ) -> BoundedVec, T::MaxTranches> { let senior_interest_rate = T::InterestRate::saturating_from_rational(5, 100) / T::InterestRate::saturating_from_integer(SECS_PER_YEAR); @@ -255,9 +228,9 @@ fn build_bench_update_tranches( .map(|tranche_id| TrancheUpdate { tranche_type: TrancheType::NonResidual { interest_rate_per_sec: senior_interest_rate - / T::InterestRate::saturating_from_integer(tranche_id) + / T::InterestRate::saturating_from_integer(tranche_id * 2) + One::one(), - min_risk_buffer: Perquintill::from_percent(tranche_id.into()), + min_risk_buffer: Perquintill::from_percent((tranche_id * 2).into()), }, seniority: None, }) diff --git a/pallets/pool-registry/src/mock.rs b/pallets/pool-registry/src/mock.rs index d943d989ff..052c19d963 100644 --- a/pallets/pool-registry/src/mock.rs +++ b/pallets/pool-registry/src/mock.rs @@ -361,10 +361,6 @@ impl PoolUpdateGuard for UpdateGuard { update: &Self::ScheduledUpdateDetails, now: Self::Moment, ) -> bool { - if now < update.scheduled_time { - return false; - } - // The epoch in which the redemptions were fulfilled, // should have closed after the scheduled time already, // to ensure that investors had the `MinUpdateDelay` diff --git a/pallets/pool-system/src/impls.rs b/pallets/pool-system/src/impls.rs index 0d1729a046..b9929f7c12 100644 --- a/pallets/pool-system/src/impls.rs +++ b/pallets/pool-system/src/impls.rs @@ -174,17 +174,6 @@ impl PoolMutate for Pallet { .map_err(|_| Error::::FailedToRegisterTrancheMetadata)?; } - let min_epoch_time = sp_std::cmp::min( - sp_std::cmp::max( - T::DefaultMinEpochTime::get(), - T::MinEpochTimeLowerBound::get(), - ), - T::MinEpochTimeUpperBound::get(), - ); - - let max_nav_age = - sp_std::cmp::min(T::DefaultMaxNAVAge::get(), T::MaxNAVAgeUpperBound::get()); - let pool_details = PoolDetails { currency, tranches, @@ -195,8 +184,8 @@ impl PoolMutate for Pallet { last_executed: Zero::zero(), }, parameters: PoolParameters { - min_epoch_time, - max_nav_age, + min_epoch_time: T::DefaultMinEpochTime::get(), + max_nav_age: T::DefaultMaxNAVAge::get(), }, reserve: ReserveDetails { max: max_reserve, @@ -241,6 +230,7 @@ impl PoolMutate for Pallet { Error::::InvalidTrancheUpdate ); + // TODO: Remove this implicit behaviour. See https://github.com/centrifuge/centrifuge-chain/issues/1171 if changes.min_epoch_time == Change::NoChange && changes.max_nav_age == Change::NoChange && changes.tranches == Change::NoChange @@ -279,7 +269,7 @@ impl PoolMutate for Pallet { let update = ScheduledUpdateDetails { changes: changes.clone(), - scheduled_time: now.saturating_add(T::MinUpdateDelay::get()), + submitted_at: now, }; let num_tranches = pool.tranches.num_tranches().try_into().unwrap(); @@ -296,6 +286,8 @@ impl PoolMutate for Pallet { } fn execute_update(pool_id: T::PoolId) -> Result { + let pool = Pool::::try_get(pool_id).map_err(|_| Error::::NoSuchPool)?; + ensure!( EpochExecution::::try_get(pool_id).is_err(), Error::::InSubmissionPeriod @@ -304,15 +296,14 @@ impl PoolMutate for Pallet { let update = ScheduledUpdate::::try_get(pool_id).map_err(|_| Error::::NoScheduledUpdate)?; + let now = Self::now(); ensure!( - Self::now() >= update.scheduled_time, + now >= update.submitted_at.ensure_add(T::MinUpdateDelay::get()), Error::::ScheduledTimeHasNotPassed ); - let pool = Pool::::try_get(pool_id).map_err(|_| Error::::NoSuchPool)?; - ensure!( - T::UpdateGuard::released(&pool, &update, Self::now()), + T::UpdateGuard::released(&pool, &update, now), Error::::UpdatePrerequesitesNotFulfilled ); diff --git a/pallets/pool-system/src/mock.rs b/pallets/pool-system/src/mock.rs index cbccde3189..c71e44f41d 100644 --- a/pallets/pool-system/src/mock.rs +++ b/pallets/pool-system/src/mock.rs @@ -377,10 +377,6 @@ impl PoolUpdateGuard for UpdateGuard { update: &Self::ScheduledUpdateDetails, now: Self::Moment, ) -> bool { - if now < update.scheduled_time { - return false; - } - // The epoch in which the redemptions were fulfilled, // should have closed after the scheduled time already, // to ensure that investors had the `MinUpdateDelay` diff --git a/pallets/pool-system/src/pool_types.rs b/pallets/pool-system/src/pool_types.rs index 37c87ffe82..55e3b96ea7 100644 --- a/pallets/pool-system/src/pool_types.rs +++ b/pallets/pool-system/src/pool_types.rs @@ -95,7 +95,7 @@ where MaxTranches: Get, { pub changes: PoolChanges, - pub scheduled_time: Moment, + pub submitted_at: Moment, } /// A representation of a pool identifier that can be converted to an account address diff --git a/runtime/altair/src/lib.rs b/runtime/altair/src/lib.rs index 169d9ab06f..6159dfc112 100644 --- a/runtime/altair/src/lib.rs +++ b/runtime/altair/src/lib.rs @@ -1269,10 +1269,6 @@ impl PoolUpdateGuard for UpdateGuard { update: &Self::ScheduledUpdateDetails, now: Self::Moment, ) -> bool { - if now < update.scheduled_time { - return false; - } - // The epoch in which the redemptions were fulfilled, // should have closed after the scheduled time already, // to ensure that investors had the `MinUpdateDelay` diff --git a/runtime/centrifuge/src/lib.rs b/runtime/centrifuge/src/lib.rs index ac92fdb16b..21a4ffa777 100644 --- a/runtime/centrifuge/src/lib.rs +++ b/runtime/centrifuge/src/lib.rs @@ -1153,10 +1153,6 @@ impl PoolUpdateGuard for UpdateGuard { update: &Self::ScheduledUpdateDetails, now: Self::Moment, ) -> bool { - if now < update.scheduled_time { - return false; - } - // The epoch in which the redemptions were fulfilled, // should have closed after the scheduled time already, // to ensure that investors had the `MinUpdateDelay` diff --git a/runtime/development/src/lib.rs b/runtime/development/src/lib.rs index 2561dd1aad..fed24e83f8 100644 --- a/runtime/development/src/lib.rs +++ b/runtime/development/src/lib.rs @@ -1072,10 +1072,6 @@ impl PoolUpdateGuard for UpdateGuard { update: &Self::ScheduledUpdateDetails, now: Self::Moment, ) -> bool { - if now < update.scheduled_time { - return false; - } - // The epoch in which the redemptions were fulfilled, // should have closed after the scheduled time already, // to ensure that investors had the `MinUpdateDelay` From ba5315421bd74f58ea75135a9254539a89ae948e Mon Sep 17 00:00:00 2001 From: mustermeiszer Date: Wed, 15 Mar 2023 11:16:38 +0100 Subject: [PATCH 20/55] change: Remove impossible to fulfill check The check in the update guard was checking whether the time of the last closed epoch is larger than now. Which is impossible to fulfill. Epochs can not be closed closed in the future if now is now... --- runtime/altair/src/lib.rs | 8 -------- runtime/centrifuge/src/lib.rs | 8 -------- runtime/development/src/lib.rs | 8 -------- 3 files changed, 24 deletions(-) diff --git a/runtime/altair/src/lib.rs b/runtime/altair/src/lib.rs index 6159dfc112..232aea0f5c 100644 --- a/runtime/altair/src/lib.rs +++ b/runtime/altair/src/lib.rs @@ -1269,14 +1269,6 @@ impl PoolUpdateGuard for UpdateGuard { update: &Self::ScheduledUpdateDetails, now: Self::Moment, ) -> bool { - // The epoch in which the redemptions were fulfilled, - // should have closed after the scheduled time already, - // to ensure that investors had the `MinUpdateDelay` - // to submit their redemption orders. - if now < pool.epoch.last_closed { - return false; - } - let pool_id = pool.tranches.of_pool(); // We do not allow releasing updates during epoch diff --git a/runtime/centrifuge/src/lib.rs b/runtime/centrifuge/src/lib.rs index 21a4ffa777..2e1ad0f641 100644 --- a/runtime/centrifuge/src/lib.rs +++ b/runtime/centrifuge/src/lib.rs @@ -1153,14 +1153,6 @@ impl PoolUpdateGuard for UpdateGuard { update: &Self::ScheduledUpdateDetails, now: Self::Moment, ) -> bool { - // The epoch in which the redemptions were fulfilled, - // should have closed after the scheduled time already, - // to ensure that investors had the `MinUpdateDelay` - // to submit their redemption orders. - if now < pool.epoch.last_closed { - return false; - } - let pool_id = pool.tranches.of_pool(); // We do not allow releasing updates during epoch diff --git a/runtime/development/src/lib.rs b/runtime/development/src/lib.rs index fed24e83f8..b54aec311b 100644 --- a/runtime/development/src/lib.rs +++ b/runtime/development/src/lib.rs @@ -1072,14 +1072,6 @@ impl PoolUpdateGuard for UpdateGuard { update: &Self::ScheduledUpdateDetails, now: Self::Moment, ) -> bool { - // The epoch in which the redemptions were fulfilled, - // should have closed after the scheduled time already, - // to ensure that investors had the `MinUpdateDelay` - // to submit their redemption orders. - if now < pool.epoch.last_closed { - return false; - } - let pool_id = pool.tranches.of_pool(); // We do not allow releasing updates during epoch From 7f6eb4a9c0d53b48bf949c297b3f3fc86560afa0 Mon Sep 17 00:00:00 2001 From: mustermeiszer Date: Wed, 15 Mar 2023 11:23:27 +0100 Subject: [PATCH 21/55] feat: Add correct check if epoch was closed in between --- runtime/altair/src/lib.rs | 10 +++++++++- runtime/centrifuge/src/lib.rs | 10 +++++++++- runtime/development/src/lib.rs | 10 +++++++++- 3 files changed, 27 insertions(+), 3 deletions(-) diff --git a/runtime/altair/src/lib.rs b/runtime/altair/src/lib.rs index 232aea0f5c..09bef65e9e 100644 --- a/runtime/altair/src/lib.rs +++ b/runtime/altair/src/lib.rs @@ -1269,8 +1269,16 @@ impl PoolUpdateGuard for UpdateGuard { update: &Self::ScheduledUpdateDetails, now: Self::Moment, ) -> bool { - let pool_id = pool.tranches.of_pool(); + // - We check whether between the submission of the + // update this call there has been an epoch close + // event. + // - We check for greater in order to forbid batching + // those two in one block + if update.submitted_at > pool.epoch.last_closed { + return false; + } + let pool_id = pool.tranches.of_pool(); // We do not allow releasing updates during epoch // closing. // diff --git a/runtime/centrifuge/src/lib.rs b/runtime/centrifuge/src/lib.rs index 2e1ad0f641..090713943a 100644 --- a/runtime/centrifuge/src/lib.rs +++ b/runtime/centrifuge/src/lib.rs @@ -1153,8 +1153,16 @@ impl PoolUpdateGuard for UpdateGuard { update: &Self::ScheduledUpdateDetails, now: Self::Moment, ) -> bool { - let pool_id = pool.tranches.of_pool(); + // - We check whether between the submission of the + // update this call there has been an epoch close + // event. + // - We check for greater in order to forbid batching + // those two in one block + if update.submitted_at > pool.epoch.last_closed { + return false; + } + let pool_id = pool.tranches.of_pool(); // We do not allow releasing updates during epoch // closing. // diff --git a/runtime/development/src/lib.rs b/runtime/development/src/lib.rs index b54aec311b..a5e97ee600 100644 --- a/runtime/development/src/lib.rs +++ b/runtime/development/src/lib.rs @@ -1072,8 +1072,16 @@ impl PoolUpdateGuard for UpdateGuard { update: &Self::ScheduledUpdateDetails, now: Self::Moment, ) -> bool { - let pool_id = pool.tranches.of_pool(); + // - We check whether between the submission of the + // update this call there has been an epoch close + // event. + // - We check for greater in order to forbid batching + // those two in one block + if update.submitted_at > pool.epoch.last_closed { + return false; + } + let pool_id = pool.tranches.of_pool(); // We do not allow releasing updates during epoch // closing. // From 0011592fed445a4a76f0c921181743a06fe80f6b Mon Sep 17 00:00:00 2001 From: mustermeiszer Date: Wed, 15 Mar 2023 11:41:24 +0100 Subject: [PATCH 22/55] fix: runtime settings altair, centrifuge for pool params --- runtime/centrifuge/src/lib.rs | 24 ++++++++++++++++++------ runtime/development/src/lib.rs | 9 ++++++++- 2 files changed, 26 insertions(+), 7 deletions(-) diff --git a/runtime/centrifuge/src/lib.rs b/runtime/centrifuge/src/lib.rs index 090713943a..19eea334c9 100644 --- a/runtime/centrifuge/src/lib.rs +++ b/runtime/centrifuge/src/lib.rs @@ -1087,12 +1087,16 @@ parameter_types! { /// The index with which this pallet is instantiated in this runtime. pub PoolPalletIndex: u8 = ::index() as u8; - pub const MinUpdateDelay: u64 = 7 * SECONDS_PER_DAY; // 7 days notice + pub const MinUpdateDelay: u64 = pub const ChallengeTime: BlockNumber = if cfg!(feature = "runtime-benchmarks") { + 0 // Dissable update delay in benchmarks + } else { + 7 * SECONDS_PER_DAY // 7 days notice + }; + pub const ChallengeTime: BlockNumber = if cfg!(feature = "runtime-benchmarks") { - // Disable challenge time in benchmarks - 0 + 0 // Disable challenge time in benchmarks } else { - 30 * MINUTES + 30 * MINUTES // half an hour to challenge solutions }; // Defaults for pool parameters @@ -1100,9 +1104,17 @@ parameter_types! { pub const DefaultMaxNAVAge: u64 = 0; // forcing update_nav + close epoch in same block // Runtime-defined constraints for pool parameters - pub const MinEpochTimeLowerBound: u64 = 1 * SECONDS_PER_HOUR; // at least 1 second (i.e. do not allow multiple epochs closed in 1 block) + pub const MinEpochTimeLowerBound: u64 = if cfg!(feature = "runtime-benchmarks") { + 0 // Allow short epoch time in benchmarks and multiple close in one block + } else { + 1 * SECONDS_PER_HOUR // 1 hour + }; pub const MinEpochTimeUpperBound: u64 = 30 * SECONDS_PER_DAY; // 1 month - pub const MaxNAVAgeUpperBound: u64 = 1 * SECONDS_PER_HOUR; // 1 hour + pub const MaxNAVAgeUpperBound: u64 = if cfg!(feature = "runtime-benchmarks") { + 1 * SECONDS_PER_HOUR // Allow an aged NAV in benchmarks + } else { + 0 + }; // Pool metadata limit #[derive(scale_info::TypeInfo, Eq, PartialEq, Debug, Clone, Copy )] diff --git a/runtime/development/src/lib.rs b/runtime/development/src/lib.rs index a5e97ee600..eed82d1d2f 100644 --- a/runtime/development/src/lib.rs +++ b/runtime/development/src/lib.rs @@ -951,7 +951,14 @@ parameter_types! { /// The index with which this pallet is instantiated in this runtime. pub PoolPalletIndex: u8 = ::index() as u8; - pub const MinUpdateDelay: u64 = 0; // no delay + pub const MinUpdateDelay: u64 = pub const ChallengeTime: BlockNumber = if cfg!(feature = "runtime-benchmarks") { + // Dissable update delay in benchmarks + 0 + } else { + // Same as Lower bound for epochs. + 1 + }; + pub const ChallengeTime: BlockNumber = if cfg!(feature = "runtime-benchmarks") { // Disable challenge time in benchmarks 0 From d5ba981738997055df42fa81c038d06004bd6811 Mon Sep 17 00:00:00 2001 From: mustermeiszer Date: Wed, 15 Mar 2023 15:51:39 +0100 Subject: [PATCH 23/55] fix: registry-benchmarks --- pallets/loans/src/test_utils.rs | 5 +-- pallets/pool-registry/Cargo.toml | 2 ++ pallets/pool-registry/src/benchmarking.rs | 17 ++++++--- pallets/pool-registry/src/weights.rs | 42 +++++++++++------------ pallets/pool-system/src/impls.rs | 2 +- runtime/altair/src/lib.rs | 6 ++-- runtime/centrifuge/src/lib.rs | 25 ++++++++++---- runtime/development/src/lib.rs | 8 ++--- 8 files changed, 62 insertions(+), 45 deletions(-) diff --git a/pallets/loans/src/test_utils.rs b/pallets/loans/src/test_utils.rs index 71c1200063..97b8f8d589 100644 --- a/pallets/loans/src/test_utils.rs +++ b/pallets/loans/src/test_utils.rs @@ -31,10 +31,7 @@ use frame_support::{ use frame_system::RawOrigin; #[cfg(feature = "runtime-benchmarks")] use pallet_pool_system::tranches::TrancheLoc; -use pallet_pool_system::{ - tranches::{TrancheInput, TrancheMetadata, TrancheType}, - Pallet as PoolPallet, Pool as PoolStorage, -}; +use pallet_pool_system::tranches::{TrancheInput, TrancheMetadata, TrancheType}; use sp_runtime::{ traits::{AccountIdConversion, Zero}, Perquintill, diff --git a/pallets/pool-registry/Cargo.toml b/pallets/pool-registry/Cargo.toml index ef51433658..2c74357ab2 100644 --- a/pallets/pool-registry/Cargo.toml +++ b/pallets/pool-registry/Cargo.toml @@ -27,6 +27,7 @@ pallet-pool-system = { path = "../pool-system", default-features = false } # Benchmarking dependencies - optional frame-benchmarking = { git = "https://github.com/paritytech/substrate", default-features = false, optional = true, branch = "polkadot-v0.9.32" } +pallet-timestamp = { git = "https://github.com/paritytech/substrate", default-features = false, optional = true, branch = "polkadot-v0.9.32" } pallet-investments = { path = "../investments", default-features = false, optional = true } cfg-primitives = { path = "../../libs/primitives", default-features = false } @@ -58,6 +59,7 @@ runtime-benchmarks = [ "frame-system/runtime-benchmarks", "orml-asset-registry/runtime-benchmarks", "sp-runtime/runtime-benchmarks", + "pallet-timestamp/runtime-benchmarks" ] std = [ "codec/std", diff --git a/pallets/pool-registry/src/benchmarking.rs b/pallets/pool-registry/src/benchmarking.rs index 9ce7861cad..4b3d427a36 100644 --- a/pallets/pool-registry/src/benchmarking.rs +++ b/pallets/pool-registry/src/benchmarking.rs @@ -12,7 +12,7 @@ // GNU General Public License for more details. //! Module provides benchmarking for Loan Pallet -use cfg_primitives::PoolEpochId; +use cfg_primitives::{Moment, PoolEpochId}; use cfg_traits::{InvestmentAccountant, InvestmentProperties, TrancheCurrency as _}; use cfg_types::tokens::{CurrencyId, TrancheCurrency}; use frame_benchmarking::benchmarks; @@ -45,7 +45,6 @@ const SECS_PER_DAY: u64 = 24 * SECS_PER_HOUR; const SECS_PER_YEAR: u64 = 365 * SECS_PER_DAY; const TRANCHE: TrancheIndex = 0; - const POOL: u64 = 0; benchmarks! { @@ -64,6 +63,7 @@ benchmarks! { MaxTokenNameLength = ::MaxTokenNameLength, MaxTokenSymbolLength = ::MaxTokenSymbolLength, MaxTranches = ::MaxTranches>, + T: pallet_timestamp::Config, ::Tokens: Inspect, <::Accountant as InvestmentAccountant>::InvestmentInfo: InvestmentProperties, @@ -102,26 +102,28 @@ benchmarks! { } update_no_execution { + // Execution of updates is blocked as no epoch has passed + // since we submitted the update let admin: ::AccountId = create_admin::(0); let n in 1..::MaxTranches::get(); let tranches = build_update_tranches::(n); prepare_asset_registry::(); create_pool::(n, admin.clone())?; + // Submit redemption order so the update isn't executed let amount = MAX_RESERVE / 2; let investor = create_investor::(0, TRANCHE, Some(amount))?; let locator = get_tranche_id::(TRANCHE); pallet_investments::Pallet::::update_redeem_order(RawOrigin::Signed(investor.clone()).into(), TrancheCurrency::generate(POOL, locator), amount)?; + let changes = PoolChanges { tranches: Change::NoChange, min_epoch_time: Change::NewValue(SECS_PER_DAY), max_nav_age: Change::NewValue(SECS_PER_HOUR), tranche_metadata: Change::NoChange, }; - - //update_pool::(changes.clone())?; }: update(RawOrigin::Signed(admin), POOL, changes.clone()) verify { // Should be the old values @@ -146,7 +148,6 @@ benchmarks! { max_nav_age: Change::NewValue(SECS_PER_HOUR), tranche_metadata: Change::NewValue(build_update_tranche_metadata::()), }; - //update_pool::(changes.clone())?; }: update(RawOrigin::Signed(admin), POOL, changes) verify { // No redemption order was submitted and the MinUpdateDelay is 0 for benchmarks, @@ -246,6 +247,12 @@ fn build_update_tranches( tranches.try_into().expect("num_tranches <= T::MaxTranches") } +fn pass_time>(time: Moment) { + let now = pallet_timestamp::Now::::get(); + let new_now = now + time; + pallet_timestamp::Now::::set(new_now); +} + // TODO: Enable once ModifyPool is not fully mocked // impl_benchmark_test_suite!( // Pallet, diff --git a/pallets/pool-registry/src/weights.rs b/pallets/pool-registry/src/weights.rs index d96300d8e5..c7325f13dc 100644 --- a/pallets/pool-registry/src/weights.rs +++ b/pallets/pool-registry/src/weights.rs @@ -1,14 +1,14 @@ //! Autogenerated weights for pallet_pool_registry //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-01-04, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` -//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("development"), DB CACHE: 1024 +//! DATE: 2023-03-15, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("centrifuge-dev"), DB CACHE: 1024 // Executed Command: // target/release/centrifuge-chain // benchmark // pallet -// --chain=development +// --chain=centrifuge-dev // --steps=50 // --repeat=20 // --pallet=pallet-pool-registry @@ -41,8 +41,8 @@ pub trait WeightInfo { pub struct SubstrateWeight(PhantomData); impl WeightInfo for SubstrateWeight { fn register(n: u32) -> Weight { - Weight::from_ref_time(128_826_509) // Standard Error: 252_992 - .saturating_add(Weight::from_ref_time(20_905_842).saturating_mul(n as u64)) + Weight::from_ref_time(196_683_469) // Standard Error: 71_911 + .saturating_add(Weight::from_ref_time(42_312_908).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(9 as u64)) .saturating_add(T::DbWeight::get().reads((2 as u64).saturating_mul(n as u64))) .saturating_add(T::DbWeight::get().writes(7 as u64)) @@ -50,31 +50,31 @@ impl WeightInfo for SubstrateWeight { } fn update_no_execution(n: u32) -> Weight { - Weight::from_ref_time(74_333_399) // Standard Error: 113_029 - .saturating_add(Weight::from_ref_time(1_139_172).saturating_mul(n as u64)) + Weight::from_ref_time(122_458_060) // Standard Error: 53_803 + .saturating_add(Weight::from_ref_time(2_399_182).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(4 as u64)) .saturating_add(T::DbWeight::get().reads((1 as u64).saturating_mul(n as u64))) .saturating_add(T::DbWeight::get().writes(1 as u64)) } fn update_and_execute(n: u32) -> Weight { - Weight::from_ref_time(100_640_016) // Standard Error: 201_831 - .saturating_add(Weight::from_ref_time(9_036_361).saturating_mul(n as u64)) + Weight::from_ref_time(172_005_373) // Standard Error: 105_716 + .saturating_add(Weight::from_ref_time(10_616_121).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().reads((1 as u64).saturating_mul(n as u64))) .saturating_add(T::DbWeight::get().writes(3 as u64)) } fn execute_update(n: u32) -> Weight { - Weight::from_ref_time(92_077_129) // Standard Error: 126_707 - .saturating_add(Weight::from_ref_time(8_515_189).saturating_mul(n as u64)) + Weight::from_ref_time(142_676_985) // Standard Error: 75_700 + .saturating_add(Weight::from_ref_time(11_055_957).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().reads((1 as u64).saturating_mul(n as u64))) .saturating_add(T::DbWeight::get().writes(3 as u64)) } fn set_metadata(_n: u32) -> Weight { - Weight::from_ref_time(39_796_451) + Weight::from_ref_time(63_359_749) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } @@ -83,8 +83,8 @@ impl WeightInfo for SubstrateWeight { // For backwards compatibility and tests impl WeightInfo for () { fn register(n: u32) -> Weight { - Weight::from_ref_time(128_826_509) // Standard Error: 252_992 - .saturating_add(Weight::from_ref_time(20_905_842).saturating_mul(n as u64)) + Weight::from_ref_time(196_683_469) // Standard Error: 71_911 + .saturating_add(Weight::from_ref_time(42_312_908).saturating_mul(n as u64)) .saturating_add(RocksDbWeight::get().reads(9 as u64)) .saturating_add(RocksDbWeight::get().reads((2 as u64).saturating_mul(n as u64))) .saturating_add(RocksDbWeight::get().writes(7 as u64)) @@ -92,31 +92,31 @@ impl WeightInfo for () { } fn update_no_execution(n: u32) -> Weight { - Weight::from_ref_time(74_333_399) // Standard Error: 113_029 - .saturating_add(Weight::from_ref_time(1_139_172).saturating_mul(n as u64)) + Weight::from_ref_time(122_458_060) // Standard Error: 53_803 + .saturating_add(Weight::from_ref_time(2_399_182).saturating_mul(n as u64)) .saturating_add(RocksDbWeight::get().reads(4 as u64)) .saturating_add(RocksDbWeight::get().reads((1 as u64).saturating_mul(n as u64))) .saturating_add(RocksDbWeight::get().writes(1 as u64)) } fn update_and_execute(n: u32) -> Weight { - Weight::from_ref_time(100_640_016) // Standard Error: 201_831 - .saturating_add(Weight::from_ref_time(9_036_361).saturating_mul(n as u64)) + Weight::from_ref_time(172_005_373) // Standard Error: 105_716 + .saturating_add(Weight::from_ref_time(10_616_121).saturating_mul(n as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().reads((1 as u64).saturating_mul(n as u64))) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } fn execute_update(n: u32) -> Weight { - Weight::from_ref_time(92_077_129) // Standard Error: 126_707 - .saturating_add(Weight::from_ref_time(8_515_189).saturating_mul(n as u64)) + Weight::from_ref_time(142_676_985) // Standard Error: 75_700 + .saturating_add(Weight::from_ref_time(11_055_957).saturating_mul(n as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().reads((1 as u64).saturating_mul(n as u64))) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } fn set_metadata(_n: u32) -> Weight { - Weight::from_ref_time(39_796_451) + Weight::from_ref_time(63_359_749) .saturating_add(RocksDbWeight::get().reads(1 as u64)) .saturating_add(RocksDbWeight::get().writes(1 as u64)) } diff --git a/pallets/pool-system/src/impls.rs b/pallets/pool-system/src/impls.rs index b9929f7c12..5dd0b6ad66 100644 --- a/pallets/pool-system/src/impls.rs +++ b/pallets/pool-system/src/impls.rs @@ -298,7 +298,7 @@ impl PoolMutate for Pallet { let now = Self::now(); ensure!( - now >= update.submitted_at.ensure_add(T::MinUpdateDelay::get()), + now >= update.submitted_at.ensure_add(T::MinUpdateDelay::get())?, Error::::ScheduledTimeHasNotPassed ); diff --git a/runtime/altair/src/lib.rs b/runtime/altair/src/lib.rs index 09bef65e9e..3b20a0c1ae 100644 --- a/runtime/altair/src/lib.rs +++ b/runtime/altair/src/lib.rs @@ -1267,14 +1267,14 @@ impl PoolUpdateGuard for UpdateGuard { fn released( pool: &Self::PoolDetails, update: &Self::ScheduledUpdateDetails, - now: Self::Moment, + _now: Self::Moment, ) -> bool { // - We check whether between the submission of the // update this call there has been an epoch close // event. - // - We check for greater in order to forbid batching + // - We check for greater equal in order to forbid batching // those two in one block - if update.submitted_at > pool.epoch.last_closed { + if update.submitted_at >= pool.epoch.last_closed { return false; } diff --git a/runtime/centrifuge/src/lib.rs b/runtime/centrifuge/src/lib.rs index 19eea334c9..b2b9f00a98 100644 --- a/runtime/centrifuge/src/lib.rs +++ b/runtime/centrifuge/src/lib.rs @@ -1087,7 +1087,7 @@ parameter_types! { /// The index with which this pallet is instantiated in this runtime. pub PoolPalletIndex: u8 = ::index() as u8; - pub const MinUpdateDelay: u64 = pub const ChallengeTime: BlockNumber = if cfg!(feature = "runtime-benchmarks") { + pub const MinUpdateDelay: u64 = if cfg!(feature = "runtime-benchmarks") { 0 // Dissable update delay in benchmarks } else { 7 * SECONDS_PER_DAY // 7 days notice @@ -1100,8 +1100,17 @@ parameter_types! { }; // Defaults for pool parameters - pub const DefaultMinEpochTime: u64 = 23 * SECONDS_PER_HOUR + 50 * SECONDS_PER_MINUTE; // 23h and 50 minutes - pub const DefaultMaxNAVAge: u64 = 0; // forcing update_nav + close epoch in same block + pub const DefaultMinEpochTime: u64 = if cfg!(feature = "runtime-benchmarks") { + 0 // Allow short epoch time in benchmarks and multiple close in one block + } else { + 23 * SECONDS_PER_HOUR + 50 * SECONDS_PER_MINUTE // 23h and 50 minutes + }; + + pub const DefaultMaxNAVAge: u64 = if cfg!(feature = "runtime-benchmarks") { + 1 * SECONDS_PER_HOUR // 1 hour + } else { + 0 // forcing update_nav + close epoch in same block + }; // Runtime-defined constraints for pool parameters pub const MinEpochTimeLowerBound: u64 = if cfg!(feature = "runtime-benchmarks") { @@ -1163,15 +1172,17 @@ impl PoolUpdateGuard for UpdateGuard { fn released( pool: &Self::PoolDetails, update: &Self::ScheduledUpdateDetails, - now: Self::Moment, + _now: Self::Moment, ) -> bool { // - We check whether between the submission of the // update this call there has been an epoch close // event. - // - We check for greater in order to forbid batching + // - We check for greater equal in order to forbid batching // those two in one block - if update.submitted_at > pool.epoch.last_closed { - return false; + if !cfg!(feature = "runtime-benchmarks") { + if update.submitted_at >= pool.epoch.last_closed { + return false; + } } let pool_id = pool.tranches.of_pool(); diff --git a/runtime/development/src/lib.rs b/runtime/development/src/lib.rs index eed82d1d2f..da0b1ed078 100644 --- a/runtime/development/src/lib.rs +++ b/runtime/development/src/lib.rs @@ -951,7 +951,7 @@ parameter_types! { /// The index with which this pallet is instantiated in this runtime. pub PoolPalletIndex: u8 = ::index() as u8; - pub const MinUpdateDelay: u64 = pub const ChallengeTime: BlockNumber = if cfg!(feature = "runtime-benchmarks") { + pub const MinUpdateDelay: u64 = if cfg!(feature = "runtime-benchmarks") { // Dissable update delay in benchmarks 0 } else { @@ -1077,14 +1077,14 @@ impl PoolUpdateGuard for UpdateGuard { fn released( pool: &Self::PoolDetails, update: &Self::ScheduledUpdateDetails, - now: Self::Moment, + _now: Self::Moment, ) -> bool { // - We check whether between the submission of the // update this call there has been an epoch close // event. - // - We check for greater in order to forbid batching + // - We check for greater equal in order to forbid batching // those two in one block - if update.submitted_at > pool.epoch.last_closed { + if update.submitted_at >= pool.epoch.last_closed { return false; } From e4d94e39e0f07f3ec8d80aef411024f4d01400d0 Mon Sep 17 00:00:00 2001 From: mustermeiszer Date: Wed, 15 Mar 2023 22:39:06 +0100 Subject: [PATCH 24/55] fix: uniques naming, feature guard for PoolUpdateGuard --- runtime/altair/src/lib.rs | 6 ++++-- runtime/centrifuge/src/lib.rs | 2 +- runtime/development/src/lib.rs | 6 ++++-- 3 files changed, 9 insertions(+), 5 deletions(-) diff --git a/runtime/altair/src/lib.rs b/runtime/altair/src/lib.rs index 3b20a0c1ae..83cf27c929 100644 --- a/runtime/altair/src/lib.rs +++ b/runtime/altair/src/lib.rs @@ -1274,8 +1274,10 @@ impl PoolUpdateGuard for UpdateGuard { // event. // - We check for greater equal in order to forbid batching // those two in one block - if update.submitted_at >= pool.epoch.last_closed { - return false; + if !cfg!(feature = "runtime-benchmarks") { + if update.submitted_at >= pool.epoch.last_closed { + return false; + } } let pool_id = pool.tranches.of_pool(); diff --git a/runtime/centrifuge/src/lib.rs b/runtime/centrifuge/src/lib.rs index b2b9f00a98..bafc636ad4 100644 --- a/runtime/centrifuge/src/lib.rs +++ b/runtime/centrifuge/src/lib.rs @@ -1829,7 +1829,7 @@ impl_runtime_apis! { list_benchmark!(list, extra, pallet_pool_system, PoolSystem); list_benchmark!(list, extra, pallet_permissions, Permissions); list_benchmark!(list, extra, pallet_interest_accrual, InterestAccrual); - list_benchmark!(list, extra, pallet_uniquess, Uniques); + list_benchmark!(list, extra, pallet_uniques, Uniques); list_benchmark!(list, extra, pallet_keystore, Keystore); list_benchmark!(list, extra, pallet_loans, LoansPallet::); diff --git a/runtime/development/src/lib.rs b/runtime/development/src/lib.rs index da0b1ed078..0ac6470803 100644 --- a/runtime/development/src/lib.rs +++ b/runtime/development/src/lib.rs @@ -1084,8 +1084,10 @@ impl PoolUpdateGuard for UpdateGuard { // event. // - We check for greater equal in order to forbid batching // those two in one block - if update.submitted_at >= pool.epoch.last_closed { - return false; + if !cfg!(feature = "runtime-benchmarks") { + if update.submitted_at >= pool.epoch.last_closed { + return false; + } } let pool_id = pool.tranches.of_pool(); From 8c89a167873a364eb935404f92108a40bf8fb25e Mon Sep 17 00:00:00 2001 From: lemunozm Date: Fri, 17 Mar 2023 10:20:57 +0100 Subject: [PATCH 25/55] fix taplo & nix --- flake.nix | 2 +- pallets/pool-registry/Cargo.toml | 4 ++-- runtime/centrifuge/Cargo.toml | 4 ++-- 3 files changed, 5 insertions(+), 5 deletions(-) diff --git a/flake.nix b/flake.nix index cf086527d7..9e9492f7a3 100644 --- a/flake.nix +++ b/flake.nix @@ -93,7 +93,7 @@ }; # This is a hash of all the Cargo dependencies, for reproducibility. - cargoSha256 = "sha256-cfGNrb4391DiYSSFr0pB+UxaahZsFopwj5dMxs/1kJM="; + cargoSha256 = "sha256-oFQdoYxrNYH+x5QggsJxb0W+hl/bv9FXopyV62cqE1A="; nativeBuildInputs = with pkgs; [ clang git-mock pkg-config ]; buildInputs = with pkgs; [ openssl ] ++ ( diff --git a/pallets/pool-registry/Cargo.toml b/pallets/pool-registry/Cargo.toml index 2c74357ab2..c64dd4b5f5 100644 --- a/pallets/pool-registry/Cargo.toml +++ b/pallets/pool-registry/Cargo.toml @@ -27,8 +27,8 @@ pallet-pool-system = { path = "../pool-system", default-features = false } # Benchmarking dependencies - optional frame-benchmarking = { git = "https://github.com/paritytech/substrate", default-features = false, optional = true, branch = "polkadot-v0.9.32" } -pallet-timestamp = { git = "https://github.com/paritytech/substrate", default-features = false, optional = true, branch = "polkadot-v0.9.32" } pallet-investments = { path = "../investments", default-features = false, optional = true } +pallet-timestamp = { git = "https://github.com/paritytech/substrate", default-features = false, optional = true, branch = "polkadot-v0.9.32" } cfg-primitives = { path = "../../libs/primitives", default-features = false } cfg-traits = { path = "../../libs/traits", default-features = false } @@ -59,7 +59,7 @@ runtime-benchmarks = [ "frame-system/runtime-benchmarks", "orml-asset-registry/runtime-benchmarks", "sp-runtime/runtime-benchmarks", - "pallet-timestamp/runtime-benchmarks" + "pallet-timestamp/runtime-benchmarks", ] std = [ "codec/std", diff --git a/runtime/centrifuge/Cargo.toml b/runtime/centrifuge/Cargo.toml index c13677e6fa..fba8dcc89c 100644 --- a/runtime/centrifuge/Cargo.toml +++ b/runtime/centrifuge/Cargo.toml @@ -104,10 +104,10 @@ pallet-keystore = { path = "../../pallets/keystore", default-features = false } pallet-loans = { path = "../../pallets/loans", default-features = false } pallet-migration-manager = { path = "../../pallets/migration", default-features = false } pallet-nft = { path = "../../pallets/nft", default-features = false } -pallet-restricted-tokens = { path = "../../pallets/restricted-tokens", default-features = false } +pallet-permissions = { path = "../../pallets/permissions", default-features = false } pallet-pool-registry = { path = "../../pallets/pool-registry", default-features = false } pallet-pool-system = { path = "../../pallets/pool-system", default-features = false } -pallet-permissions = { path = "../../pallets/permissions", default-features = false } +pallet-restricted-tokens = { path = "../../pallets/restricted-tokens", default-features = false } runtime-common = { path = "../common", default-features = false } # bridge pallets From 6f94c500a2771b03e6e4fddee284a364282c4b5c Mon Sep 17 00:00:00 2001 From: mustermeiszer Date: Wed, 22 Mar 2023 17:24:05 +0100 Subject: [PATCH 26/55] Adding filter for restricted tokens --- runtime/centrifuge/src/lib.rs | 45 ++++++++++++++++++++++++++++++++--- 1 file changed, 42 insertions(+), 3 deletions(-) diff --git a/runtime/centrifuge/src/lib.rs b/runtime/centrifuge/src/lib.rs index bafc636ad4..3084c3ed9a 100644 --- a/runtime/centrifuge/src/lib.rs +++ b/runtime/centrifuge/src/lib.rs @@ -26,7 +26,9 @@ use cfg_types::{ consts::pools::{MaxTrancheNameLengthBytes, MaxTrancheSymbolLengthBytes}, fee_keys::FeeKey, fixed_point::Rate, - permissions::{PermissionRoles, PermissionScope, PermissionedCurrencyRole, PoolRole, Role}, + permissions::{ + PermissionRoles, PermissionScope, PermissionedCurrencyRole, PoolRole, Role, UNION, + }, time::TimeProvider, tokens::{CustomMetadata, TrancheCurrency}, }; @@ -61,7 +63,9 @@ use pallet_pool_system::{ tranches::{TrancheIndex, TrancheLoc, TrancheSolution}, EpochSolution, }; -use pallet_restricted_tokens::{FungibleInspectPassthrough, FungiblesInspectPassthrough}; +use pallet_restricted_tokens::{ + FungibleInspectPassthrough, FungiblesInspectPassthrough, TransferDetails, +}; pub use pallet_timestamp::Call as TimestampCall; pub use pallet_transaction_payment::{CurrencyAdapter, Multiplier, TargetedFeeAdjustment}; use pallet_transaction_payment_rpc_runtime_api::{FeeDetails, RuntimeDispatchInfo}; @@ -293,7 +297,7 @@ impl pallet_restricted_tokens::Config for Runtime { type NativeFungible = Balances; type NativeToken = NativeToken; type PreCurrency = cfg_traits::Always; - type PreExtrTransfer = cfg_traits::Always; + type PreExtrTransfer = RestrictedTokens; type PreFungibleInspect = FungibleInspectPassthrough; type PreFungibleInspectHold = cfg_traits::Always; type PreFungibleMutate = cfg_traits::Always; @@ -309,6 +313,38 @@ impl pallet_restricted_tokens::Config for Runtime { type WeightInfo = pallet_restricted_tokens::weights::SubstrateWeight; } +pub struct RestrictedTokens

(PhantomData

); +impl

PreConditions> for RestrictedTokens

+where + P: PermissionsT, Role = Role>, +{ + type Result = bool; + + fn check(details: TransferDetails) -> bool { + let TransferDetails { + send, + recv, + id, + amount: _amount, + } = details; + + match id { + CurrencyId::Tranche(pool_id, tranche_id) => { + P::has( + PermissionScope::Pool(pool_id), + send, + Role::PoolRole(PoolRole::TrancheInvestor(tranche_id, UNION)), + ) && P::has( + PermissionScope::Pool(pool_id), + recv, + Role::PoolRole(PoolRole::TrancheInvestor(tranche_id, UNION)), + ) + } + _ => true, + } + } +} + parameter_types! { pub TreasuryAccount: AccountId = TreasuryPalletId::get().into_account_truncating(); } @@ -1832,6 +1868,8 @@ impl_runtime_apis! { list_benchmark!(list, extra, pallet_uniques, Uniques); list_benchmark!(list, extra, pallet_keystore, Keystore); list_benchmark!(list, extra, pallet_loans, LoansPallet::); + list_benchmark!(list, extra, pallet_restricted_tokens, Tokens); + let storage_info = AllPalletsWithSystem::storage_info(); @@ -1897,6 +1935,7 @@ impl_runtime_apis! { add_benchmark!(params, batches, pallet_uniques, Uniques); add_benchmark!(params, batches, pallet_keystore, Keystore); add_benchmark!(params, batches, pallet_loans, LoansPallet::); + add_benchmark!(params, batches, pallet_restricted_tokens, Tokens); if batches.is_empty() { return Err("Benchmark not found for this pallet.".into()) } Ok(batches) From c8382d21fd575589fd82eecb54acbfa0289a8c8a Mon Sep 17 00:00:00 2001 From: mustermeiszer Date: Wed, 22 Mar 2023 22:13:26 +0100 Subject: [PATCH 27/55] feat: new weights for centrifuge runtime --- .../centrifuge/src/weights/frame_system.rs | 42 +-- runtime/centrifuge/src/weights/mod.rs | 8 + .../centrifuge/src/weights/pallet_anchors.rs | 18 +- .../centrifuge/src/weights/pallet_balances.rs | 30 +- .../src/weights/pallet_collator_allowlist.rs | 10 +- .../src/weights/pallet_collective.rs | 126 ++++---- .../src/weights/pallet_crowdloan_claim.rs | 38 +-- .../src/weights/pallet_crowdloan_reward.rs | 18 +- .../src/weights/pallet_democracy.rs | 112 ++++---- runtime/centrifuge/src/weights/pallet_fees.rs | 6 +- .../centrifuge/src/weights/pallet_identity.rs | 162 +++++------ .../src/weights/pallet_interest_accrual.rs | 40 +++ .../centrifuge/src/weights/pallet_keystore.rs | 64 +++++ .../centrifuge/src/weights/pallet_loans.rs | 262 +++++++++++++++++ .../src/weights/pallet_migration_manager.rs | 32 +-- .../centrifuge/src/weights/pallet_multisig.rs | 70 ++--- .../src/weights/pallet_permissions.rs | 79 +++++ .../src/weights/pallet_pool_registry.rs | 115 ++++++++ .../src/weights/pallet_pool_system.rs | 150 ++++++++++ .../centrifuge/src/weights/pallet_preimage.rs | 62 ++-- .../centrifuge/src/weights/pallet_proxy.rs | 98 +++---- .../src/weights/pallet_restricted_tokens.rs | 109 +++++++ .../src/weights/pallet_scheduler.rs | 74 ++--- .../src/weights/pallet_timestamp.rs | 10 +- .../centrifuge/src/weights/pallet_treasury.rs | 32 +-- .../centrifuge/src/weights/pallet_uniques.rs | 272 ++++++++++++++++++ .../centrifuge/src/weights/pallet_utility.rs | 34 +-- .../centrifuge/src/weights/pallet_vesting.rs | 82 +++--- 28 files changed, 1629 insertions(+), 526 deletions(-) create mode 100644 runtime/centrifuge/src/weights/pallet_interest_accrual.rs create mode 100644 runtime/centrifuge/src/weights/pallet_keystore.rs create mode 100644 runtime/centrifuge/src/weights/pallet_loans.rs create mode 100644 runtime/centrifuge/src/weights/pallet_permissions.rs create mode 100644 runtime/centrifuge/src/weights/pallet_pool_registry.rs create mode 100644 runtime/centrifuge/src/weights/pallet_pool_system.rs create mode 100644 runtime/centrifuge/src/weights/pallet_restricted_tokens.rs create mode 100644 runtime/centrifuge/src/weights/pallet_uniques.rs diff --git a/runtime/centrifuge/src/weights/frame_system.rs b/runtime/centrifuge/src/weights/frame_system.rs index 6c71ba05e0..6e68577690 100644 --- a/runtime/centrifuge/src/weights/frame_system.rs +++ b/runtime/centrifuge/src/weights/frame_system.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `frame_system` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-01-12, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-03-22, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("centrifuge-dev"), DB CACHE: 1024 @@ -32,51 +32,51 @@ pub struct WeightInfo(PhantomData); impl frame_system::WeightInfo for WeightInfo { /// The range of component `b` is `[0, 3932160]`. fn remark(b: u32, ) -> Weight { - // Minimum execution time: 8_000 nanoseconds. - Weight::from_ref_time(18_699_566 as u64) + // Minimum execution time: 11_000 nanoseconds. + Weight::from_ref_time(9_387_856 as u64) // Standard Error: 0 - .saturating_add(Weight::from_ref_time(530 as u64).saturating_mul(b as u64)) + .saturating_add(Weight::from_ref_time(533 as u64).saturating_mul(b as u64)) } /// The range of component `b` is `[0, 3932160]`. fn remark_with_event(b: u32, ) -> Weight { - // Minimum execution time: 25_200 nanoseconds. - Weight::from_ref_time(7_044_024 as u64) + // Minimum execution time: 26_300 nanoseconds. + Weight::from_ref_time(26_600_000 as u64) // Standard Error: 0 - .saturating_add(Weight::from_ref_time(1_900 as u64).saturating_mul(b as u64)) + .saturating_add(Weight::from_ref_time(1_906 as u64).saturating_mul(b as u64)) } // Storage: System Digest (r:1 w:1) // Storage: unknown [0x3a686561707061676573] (r:0 w:1) fn set_heap_pages() -> Weight { - // Minimum execution time: 17_000 nanoseconds. - Weight::from_ref_time(17_400_000 as u64) + // Minimum execution time: 17_501 nanoseconds. + Weight::from_ref_time(17_801_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } // Storage: Skipped Metadata (r:0 w:0) /// The range of component `i` is `[0, 1000]`. fn set_storage(i: u32, ) -> Weight { - // Minimum execution time: 8_200 nanoseconds. - Weight::from_ref_time(8_400_000 as u64) - // Standard Error: 1_013 - .saturating_add(Weight::from_ref_time(1_145_462 as u64).saturating_mul(i as u64)) + // Minimum execution time: 8_400 nanoseconds. + Weight::from_ref_time(8_600_000 as u64) + // Standard Error: 1_072 + .saturating_add(Weight::from_ref_time(1_164_824 as u64).saturating_mul(i as u64)) .saturating_add(T::DbWeight::get().writes((1 as u64).saturating_mul(i as u64))) } // Storage: Skipped Metadata (r:0 w:0) /// The range of component `i` is `[0, 1000]`. fn kill_storage(i: u32, ) -> Weight { - // Minimum execution time: 8_201 nanoseconds. - Weight::from_ref_time(1_369_422 as u64) - // Standard Error: 1_771 - .saturating_add(Weight::from_ref_time(912_473 as u64).saturating_mul(i as u64)) + // Minimum execution time: 8_500 nanoseconds. + Weight::from_ref_time(8_700_000 as u64) + // Standard Error: 1_014 + .saturating_add(Weight::from_ref_time(918_861 as u64).saturating_mul(i as u64)) .saturating_add(T::DbWeight::get().writes((1 as u64).saturating_mul(i as u64))) } // Storage: Skipped Metadata (r:0 w:0) /// The range of component `p` is `[0, 1000]`. fn kill_prefix(p: u32, ) -> Weight { - // Minimum execution time: 11_500 nanoseconds. - Weight::from_ref_time(11_600_000 as u64) - // Standard Error: 1_873 - .saturating_add(Weight::from_ref_time(1_719_294 as u64).saturating_mul(p as u64)) + // Minimum execution time: 12_000 nanoseconds. + Weight::from_ref_time(12_301_000 as u64) + // Standard Error: 1_857 + .saturating_add(Weight::from_ref_time(1_703_292 as u64).saturating_mul(p as u64)) .saturating_add(T::DbWeight::get().writes((1 as u64).saturating_mul(p as u64))) } } diff --git a/runtime/centrifuge/src/weights/mod.rs b/runtime/centrifuge/src/weights/mod.rs index 1d556b1230..08f0d6a480 100644 --- a/runtime/centrifuge/src/weights/mod.rs +++ b/runtime/centrifuge/src/weights/mod.rs @@ -19,12 +19,20 @@ pub mod pallet_crowdloan_reward; pub mod pallet_democracy; pub mod pallet_fees; pub mod pallet_identity; +pub mod pallet_interest_accrual; +pub mod pallet_keystore; +pub mod pallet_loans; pub mod pallet_migration_manager; pub mod pallet_multisig; +pub mod pallet_permissions; +pub mod pallet_pool_registry; +pub mod pallet_pool_system; pub mod pallet_preimage; pub mod pallet_proxy; +pub mod pallet_restricted_tokens; pub mod pallet_scheduler; pub mod pallet_timestamp; pub mod pallet_treasury; +pub mod pallet_uniques; pub mod pallet_utility; pub mod pallet_vesting; diff --git a/runtime/centrifuge/src/weights/pallet_anchors.rs b/runtime/centrifuge/src/weights/pallet_anchors.rs index 2450f19c8c..f466af2fee 100644 --- a/runtime/centrifuge/src/weights/pallet_anchors.rs +++ b/runtime/centrifuge/src/weights/pallet_anchors.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_anchors` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-01-12, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-03-22, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("centrifuge-dev"), DB CACHE: 1024 @@ -34,8 +34,8 @@ impl pallet_anchors::WeightInfo for WeightInfo { // Storage: Anchor PreCommits (r:1 w:1) // Storage: Fees FeeBalances (r:1 w:0) fn pre_commit() -> Weight { - // Minimum execution time: 62_400 nanoseconds. - Weight::from_ref_time(63_300_000 as u64) + // Minimum execution time: 64_202 nanoseconds. + Weight::from_ref_time(64_802_000 as u64) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } @@ -49,15 +49,15 @@ impl pallet_anchors::WeightInfo for WeightInfo { // Storage: Anchor AnchorIndexes (r:0 w:1) // Storage: unknown [0xdb4faa73ca6d2016e53c7156087c176b79b169c409b8a0063a07964f3187f9e9] (r:0 w:1) fn commit() -> Weight { - // Minimum execution time: 94_600 nanoseconds. - Weight::from_ref_time(95_800_000 as u64) + // Minimum execution time: 97_303 nanoseconds. + Weight::from_ref_time(98_403_000 as u64) .saturating_add(T::DbWeight::get().reads(7 as u64)) .saturating_add(T::DbWeight::get().writes(5 as u64)) } // Storage: Anchor PreCommits (r:100 w:100) fn evict_pre_commits() -> Weight { - // Minimum execution time: 2_026_199 nanoseconds. - Weight::from_ref_time(2_040_498_000 as u64) + // Minimum execution time: 2_106_762 nanoseconds. + Weight::from_ref_time(2_128_162_000 as u64) .saturating_add(T::DbWeight::get().reads(100 as u64)) .saturating_add(T::DbWeight::get().writes(100 as u64)) } @@ -269,8 +269,8 @@ impl pallet_anchors::WeightInfo for WeightInfo { // Storage: unknown [0xee60c64e1e32117f948ee71d391f978e8ac98c2bd869322fc25164502e3f7a9b] (r:0 w:1) // Storage: unknown [0xf7e4b8a5415405a940e730546df85583c8c23956d99a3be18e09eebf3639d312] (r:0 w:1) fn evict_anchors() -> Weight { - // Minimum execution time: 2_249_899 nanoseconds. - Weight::from_ref_time(2_285_798_000 as u64) + // Minimum execution time: 2_316_369 nanoseconds. + Weight::from_ref_time(2_344_869_000 as u64) .saturating_add(T::DbWeight::get().reads(404 as u64)) .saturating_add(T::DbWeight::get().writes(402 as u64)) } diff --git a/runtime/centrifuge/src/weights/pallet_balances.rs b/runtime/centrifuge/src/weights/pallet_balances.rs index 0fbbef9fc7..8284d46228 100644 --- a/runtime/centrifuge/src/weights/pallet_balances.rs +++ b/runtime/centrifuge/src/weights/pallet_balances.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_balances` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-01-12, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-03-22, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("centrifuge-dev"), DB CACHE: 1024 @@ -32,50 +32,50 @@ pub struct WeightInfo(PhantomData); impl pallet_balances::WeightInfo for WeightInfo { // Storage: System Account (r:1 w:1) fn transfer() -> Weight { - // Minimum execution time: 86_301 nanoseconds. - Weight::from_ref_time(87_401_000 as u64) + // Minimum execution time: 88_703 nanoseconds. + Weight::from_ref_time(89_503_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: System Account (r:1 w:1) fn transfer_keep_alive() -> Weight { - // Minimum execution time: 64_301 nanoseconds. - Weight::from_ref_time(65_601_000 as u64) + // Minimum execution time: 65_602 nanoseconds. + Weight::from_ref_time(66_302_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: System Account (r:1 w:1) fn set_balance_creating() -> Weight { - // Minimum execution time: 45_901 nanoseconds. - Weight::from_ref_time(46_601_000 as u64) + // Minimum execution time: 48_101 nanoseconds. + Weight::from_ref_time(48_602_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: System Account (r:1 w:1) fn set_balance_killing() -> Weight { - // Minimum execution time: 52_001 nanoseconds. - Weight::from_ref_time(52_801_000 as u64) + // Minimum execution time: 54_101 nanoseconds. + Weight::from_ref_time(55_001_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: System Account (r:2 w:2) fn force_transfer() -> Weight { - // Minimum execution time: 84_801 nanoseconds. - Weight::from_ref_time(86_101_000 as u64) + // Minimum execution time: 87_803 nanoseconds. + Weight::from_ref_time(88_903_000 as u64) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } // Storage: System Account (r:1 w:1) fn transfer_all() -> Weight { - // Minimum execution time: 74_901 nanoseconds. - Weight::from_ref_time(75_900_000 as u64) + // Minimum execution time: 76_902 nanoseconds. + Weight::from_ref_time(77_503_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: System Account (r:1 w:1) fn force_unreserve() -> Weight { - // Minimum execution time: 40_301 nanoseconds. - Weight::from_ref_time(40_801_000 as u64) + // Minimum execution time: 41_101 nanoseconds. + Weight::from_ref_time(41_501_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } diff --git a/runtime/centrifuge/src/weights/pallet_collator_allowlist.rs b/runtime/centrifuge/src/weights/pallet_collator_allowlist.rs index d621fda8a4..cc57b0b993 100644 --- a/runtime/centrifuge/src/weights/pallet_collator_allowlist.rs +++ b/runtime/centrifuge/src/weights/pallet_collator_allowlist.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_collator_allowlist` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-01-12, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-03-22, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("centrifuge-dev"), DB CACHE: 1024 @@ -33,15 +33,15 @@ impl pallet_collator_allowlist::WeightInfo for WeightIn // Storage: Session NextKeys (r:1 w:0) // Storage: CollatorAllowlist Allowlist (r:1 w:1) fn add() -> Weight { - // Minimum execution time: 41_901 nanoseconds. - Weight::from_ref_time(42_900_000 as u64) + // Minimum execution time: 43_601 nanoseconds. + Weight::from_ref_time(44_401_000 as u64) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: CollatorAllowlist Allowlist (r:1 w:1) fn remove() -> Weight { - // Minimum execution time: 35_000 nanoseconds. - Weight::from_ref_time(35_900_000 as u64) + // Minimum execution time: 36_301 nanoseconds. + Weight::from_ref_time(37_001_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } diff --git a/runtime/centrifuge/src/weights/pallet_collective.rs b/runtime/centrifuge/src/weights/pallet_collective.rs index 321645f24a..797c146cda 100644 --- a/runtime/centrifuge/src/weights/pallet_collective.rs +++ b/runtime/centrifuge/src/weights/pallet_collective.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_collective` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-01-12, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-03-22, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("centrifuge-dev"), DB CACHE: 1024 @@ -38,12 +38,12 @@ impl pallet_collective::WeightInfo for WeightInfo { /// The range of component `n` is `[0, 100]`. /// The range of component `p` is `[0, 100]`. fn set_members(m: u32, _n: u32, p: u32, ) -> Weight { - // Minimum execution time: 31_301 nanoseconds. - Weight::from_ref_time(31_700_000 as u64) - // Standard Error: 96_734 - .saturating_add(Weight::from_ref_time(7_412_019 as u64).saturating_mul(m as u64)) - // Standard Error: 96_734 - .saturating_add(Weight::from_ref_time(12_329_179 as u64).saturating_mul(p as u64)) + // Minimum execution time: 31_701 nanoseconds. + Weight::from_ref_time(32_201_000 as u64) + // Standard Error: 99_244 + .saturating_add(Weight::from_ref_time(7_380_754 as u64).saturating_mul(m as u64)) + // Standard Error: 99_244 + .saturating_add(Weight::from_ref_time(12_634_195 as u64).saturating_mul(p as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().reads((1 as u64).saturating_mul(p as u64))) .saturating_add(T::DbWeight::get().writes(2 as u64)) @@ -53,12 +53,12 @@ impl pallet_collective::WeightInfo for WeightInfo { /// The range of component `b` is `[1, 1024]`. /// The range of component `m` is `[1, 100]`. fn execute(b: u32, m: u32, ) -> Weight { - // Minimum execution time: 40_901 nanoseconds. - Weight::from_ref_time(40_375_971 as u64) - // Standard Error: 84 - .saturating_add(Weight::from_ref_time(2_100 as u64).saturating_mul(b as u64)) - // Standard Error: 874 - .saturating_add(Weight::from_ref_time(22_341 as u64).saturating_mul(m as u64)) + // Minimum execution time: 40_800 nanoseconds. + Weight::from_ref_time(40_541_285 as u64) + // Standard Error: 162 + .saturating_add(Weight::from_ref_time(2_434 as u64).saturating_mul(b as u64)) + // Standard Error: 1_676 + .saturating_add(Weight::from_ref_time(24_543 as u64).saturating_mul(m as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) } // Storage: Council Members (r:1 w:0) @@ -66,12 +66,12 @@ impl pallet_collective::WeightInfo for WeightInfo { /// The range of component `b` is `[1, 1024]`. /// The range of component `m` is `[1, 100]`. fn propose_execute(b: u32, m: u32, ) -> Weight { - // Minimum execution time: 44_800 nanoseconds. - Weight::from_ref_time(43_091_430 as u64) - // Standard Error: 128 - .saturating_add(Weight::from_ref_time(2_612 as u64).saturating_mul(b as u64)) - // Standard Error: 1_326 - .saturating_add(Weight::from_ref_time(43_906 as u64).saturating_mul(m as u64)) + // Minimum execution time: 44_501 nanoseconds. + Weight::from_ref_time(45_038_368 as u64) + // Standard Error: 217 + .saturating_add(Weight::from_ref_time(2_088 as u64).saturating_mul(b as u64)) + // Standard Error: 2_242 + .saturating_add(Weight::from_ref_time(34_125 as u64).saturating_mul(m as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) } // Storage: Council Members (r:1 w:0) @@ -83,14 +83,14 @@ impl pallet_collective::WeightInfo for WeightInfo { /// The range of component `m` is `[2, 100]`. /// The range of component `p` is `[1, 100]`. fn propose_proposed(b: u32, m: u32, p: u32, ) -> Weight { - // Minimum execution time: 56_500 nanoseconds. - Weight::from_ref_time(49_910_173 as u64) - // Standard Error: 293 - .saturating_add(Weight::from_ref_time(8_307 as u64).saturating_mul(b as u64)) - // Standard Error: 3_068 - .saturating_add(Weight::from_ref_time(68_457 as u64).saturating_mul(m as u64)) - // Standard Error: 3_029 - .saturating_add(Weight::from_ref_time(430_074 as u64).saturating_mul(p as u64)) + // Minimum execution time: 57_700 nanoseconds. + Weight::from_ref_time(53_147_330 as u64) + // Standard Error: 273 + .saturating_add(Weight::from_ref_time(9_038 as u64).saturating_mul(b as u64)) + // Standard Error: 2_861 + .saturating_add(Weight::from_ref_time(45_225 as u64).saturating_mul(m as u64)) + // Standard Error: 2_824 + .saturating_add(Weight::from_ref_time(426_273 as u64).saturating_mul(p as u64)) .saturating_add(T::DbWeight::get().reads(4 as u64)) .saturating_add(T::DbWeight::get().writes(4 as u64)) } @@ -98,10 +98,10 @@ impl pallet_collective::WeightInfo for WeightInfo { // Storage: Council Voting (r:1 w:1) /// The range of component `m` is `[5, 100]`. fn vote(m: u32, ) -> Weight { - // Minimum execution time: 62_701 nanoseconds. - Weight::from_ref_time(70_530_905 as u64) - // Standard Error: 3_277 - .saturating_add(Weight::from_ref_time(63_730 as u64).saturating_mul(m as u64)) + // Minimum execution time: 62_400 nanoseconds. + Weight::from_ref_time(69_097_339 as u64) + // Standard Error: 4_424 + .saturating_add(Weight::from_ref_time(100_100 as u64).saturating_mul(m as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } @@ -112,12 +112,12 @@ impl pallet_collective::WeightInfo for WeightInfo { /// The range of component `m` is `[4, 100]`. /// The range of component `p` is `[1, 100]`. fn close_early_disapproved(m: u32, p: u32, ) -> Weight { - // Minimum execution time: 60_501 nanoseconds. - Weight::from_ref_time(64_915_934 as u64) - // Standard Error: 3_172 - .saturating_add(Weight::from_ref_time(31_693 as u64).saturating_mul(m as u64)) - // Standard Error: 3_093 - .saturating_add(Weight::from_ref_time(352_279 as u64).saturating_mul(p as u64)) + // Minimum execution time: 61_600 nanoseconds. + Weight::from_ref_time(63_795_512 as u64) + // Standard Error: 2_361 + .saturating_add(Weight::from_ref_time(40_085 as u64).saturating_mul(m as u64)) + // Standard Error: 2_302 + .saturating_add(Weight::from_ref_time(379_929 as u64).saturating_mul(p as u64)) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -129,14 +129,14 @@ impl pallet_collective::WeightInfo for WeightInfo { /// The range of component `m` is `[4, 100]`. /// The range of component `p` is `[1, 100]`. fn close_early_approved(b: u32, m: u32, p: u32, ) -> Weight { - // Minimum execution time: 82_401 nanoseconds. - Weight::from_ref_time(74_141_715 as u64) - // Standard Error: 264 - .saturating_add(Weight::from_ref_time(8_163 as u64).saturating_mul(b as u64)) - // Standard Error: 2_798 - .saturating_add(Weight::from_ref_time(83_200 as u64).saturating_mul(m as u64)) - // Standard Error: 2_727 - .saturating_add(Weight::from_ref_time(423_046 as u64).saturating_mul(p as u64)) + // Minimum execution time: 82_601 nanoseconds. + Weight::from_ref_time(78_304_032 as u64) + // Standard Error: 323 + .saturating_add(Weight::from_ref_time(5_974 as u64).saturating_mul(b as u64)) + // Standard Error: 3_426 + .saturating_add(Weight::from_ref_time(65_693 as u64).saturating_mul(m as u64)) + // Standard Error: 3_340 + .saturating_add(Weight::from_ref_time(424_371 as u64).saturating_mul(p as u64)) .saturating_add(T::DbWeight::get().reads(4 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -148,12 +148,12 @@ impl pallet_collective::WeightInfo for WeightInfo { /// The range of component `m` is `[4, 100]`. /// The range of component `p` is `[1, 100]`. fn close_disapproved(m: u32, p: u32, ) -> Weight { - // Minimum execution time: 65_700 nanoseconds. - Weight::from_ref_time(64_576_520 as u64) - // Standard Error: 2_937 - .saturating_add(Weight::from_ref_time(60_345 as u64).saturating_mul(m as u64)) - // Standard Error: 2_864 - .saturating_add(Weight::from_ref_time(410_171 as u64).saturating_mul(p as u64)) + // Minimum execution time: 66_400 nanoseconds. + Weight::from_ref_time(66_445_151 as u64) + // Standard Error: 2_345 + .saturating_add(Weight::from_ref_time(63_290 as u64).saturating_mul(m as u64)) + // Standard Error: 2_287 + .saturating_add(Weight::from_ref_time(382_840 as u64).saturating_mul(p as u64)) .saturating_add(T::DbWeight::get().reads(4 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -166,14 +166,14 @@ impl pallet_collective::WeightInfo for WeightInfo { /// The range of component `m` is `[4, 100]`. /// The range of component `p` is `[1, 100]`. fn close_approved(b: u32, m: u32, p: u32, ) -> Weight { - // Minimum execution time: 86_800 nanoseconds. - Weight::from_ref_time(84_525_443 as u64) - // Standard Error: 366 - .saturating_add(Weight::from_ref_time(5_210 as u64).saturating_mul(b as u64)) - // Standard Error: 3_880 - .saturating_add(Weight::from_ref_time(49_910 as u64).saturating_mul(m as u64)) - // Standard Error: 3_783 - .saturating_add(Weight::from_ref_time(417_982 as u64).saturating_mul(p as u64)) + // Minimum execution time: 87_601 nanoseconds. + Weight::from_ref_time(88_158_241 as u64) + // Standard Error: 301 + .saturating_add(Weight::from_ref_time(3_959 as u64).saturating_mul(b as u64)) + // Standard Error: 3_192 + .saturating_add(Weight::from_ref_time(31_046 as u64).saturating_mul(m as u64)) + // Standard Error: 3_112 + .saturating_add(Weight::from_ref_time(417_207 as u64).saturating_mul(p as u64)) .saturating_add(T::DbWeight::get().reads(5 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -182,10 +182,10 @@ impl pallet_collective::WeightInfo for WeightInfo { // Storage: Council ProposalOf (r:0 w:1) /// The range of component `p` is `[1, 100]`. fn disapprove_proposal(p: u32, ) -> Weight { - // Minimum execution time: 39_601 nanoseconds. - Weight::from_ref_time(44_046_972 as u64) - // Standard Error: 3_141 - .saturating_add(Weight::from_ref_time(388_469 as u64).saturating_mul(p as u64)) + // Minimum execution time: 39_801 nanoseconds. + Weight::from_ref_time(44_533_213 as u64) + // Standard Error: 3_329 + .saturating_add(Weight::from_ref_time(393_758 as u64).saturating_mul(p as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } diff --git a/runtime/centrifuge/src/weights/pallet_crowdloan_claim.rs b/runtime/centrifuge/src/weights/pallet_crowdloan_claim.rs index 0460feb7a2..d49d085313 100644 --- a/runtime/centrifuge/src/weights/pallet_crowdloan_claim.rs +++ b/runtime/centrifuge/src/weights/pallet_crowdloan_claim.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_crowdloan_claim` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-01-12, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-03-22, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("centrifuge-dev"), DB CACHE: 1024 @@ -42,8 +42,8 @@ impl pallet_crowdloan_claim::WeightInfo for WeightInfo< // Storage: System Account (r:2 w:2) // Storage: Balances Locks (r:1 w:1) fn claim_reward_ed25519() -> Weight { - // Minimum execution time: 266_602 nanoseconds. - Weight::from_ref_time(267_702_000 as u64) + // Minimum execution time: 274_202 nanoseconds. + Weight::from_ref_time(276_702_000 as u64) .saturating_add(T::DbWeight::get().reads(12 as u64)) .saturating_add(T::DbWeight::get().writes(5 as u64)) } @@ -59,8 +59,8 @@ impl pallet_crowdloan_claim::WeightInfo for WeightInfo< // Storage: System Account (r:2 w:2) // Storage: Balances Locks (r:1 w:1) fn claim_reward_sr25519() -> Weight { - // Minimum execution time: 269_203 nanoseconds. - Weight::from_ref_time(272_203_000 as u64) + // Minimum execution time: 280_202 nanoseconds. + Weight::from_ref_time(283_302_000 as u64) .saturating_add(T::DbWeight::get().reads(12 as u64)) .saturating_add(T::DbWeight::get().writes(5 as u64)) } @@ -76,8 +76,8 @@ impl pallet_crowdloan_claim::WeightInfo for WeightInfo< // Storage: System Account (r:2 w:2) // Storage: Balances Locks (r:1 w:1) fn claim_reward_ecdsa() -> Weight { - // Minimum execution time: 248_502 nanoseconds. - Weight::from_ref_time(251_303_000 as u64) + // Minimum execution time: 258_302 nanoseconds. + Weight::from_ref_time(259_902_000 as u64) .saturating_add(T::DbWeight::get().reads(12 as u64)) .saturating_add(T::DbWeight::get().writes(5 as u64)) } @@ -89,39 +89,39 @@ impl pallet_crowdloan_claim::WeightInfo for WeightInfo< // Storage: CrowdloanClaim CrowdloanTrieIndex (r:0 w:1) // Storage: CrowdloanClaim LockedAt (r:0 w:1) fn initialize() -> Weight { - // Minimum execution time: 41_800 nanoseconds. - Weight::from_ref_time(42_500_000 as u64) + // Minimum execution time: 42_900 nanoseconds. + Weight::from_ref_time(44_200_000 as u64) .saturating_add(T::DbWeight::get().reads(4 as u64)) .saturating_add(T::DbWeight::get().writes(6 as u64)) } // Storage: CrowdloanClaim LeaseStart (r:0 w:1) fn set_lease_start() -> Weight { - // Minimum execution time: 25_500 nanoseconds. - Weight::from_ref_time(25_801_000 as u64) + // Minimum execution time: 26_300 nanoseconds. + Weight::from_ref_time(26_900_000 as u64) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: CrowdloanClaim LeasePeriod (r:0 w:1) fn set_lease_period() -> Weight { - // Minimum execution time: 25_600 nanoseconds. - Weight::from_ref_time(26_300_000 as u64) + // Minimum execution time: 26_000 nanoseconds. + Weight::from_ref_time(26_600_000 as u64) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: CrowdloanClaim Contributions (r:0 w:1) fn set_contributions_root() -> Weight { - // Minimum execution time: 26_700 nanoseconds. - Weight::from_ref_time(27_401_000 as u64) + // Minimum execution time: 27_900 nanoseconds. + Weight::from_ref_time(28_400_000 as u64) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: CrowdloanClaim LockedAt (r:0 w:1) fn set_locked_at() -> Weight { - // Minimum execution time: 25_601 nanoseconds. - Weight::from_ref_time(26_100_000 as u64) + // Minimum execution time: 26_300 nanoseconds. + Weight::from_ref_time(26_800_000 as u64) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: CrowdloanClaim CrowdloanTrieIndex (r:0 w:1) fn set_crowdloan_trie_index() -> Weight { - // Minimum execution time: 25_800 nanoseconds. - Weight::from_ref_time(26_301_000 as u64) + // Minimum execution time: 26_100 nanoseconds. + Weight::from_ref_time(26_800_000 as u64) .saturating_add(T::DbWeight::get().writes(1 as u64)) } } diff --git a/runtime/centrifuge/src/weights/pallet_crowdloan_reward.rs b/runtime/centrifuge/src/weights/pallet_crowdloan_reward.rs index ec26418de9..d47d77e9ad 100644 --- a/runtime/centrifuge/src/weights/pallet_crowdloan_reward.rs +++ b/runtime/centrifuge/src/weights/pallet_crowdloan_reward.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_crowdloan_reward` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-01-12, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-03-22, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("centrifuge-dev"), DB CACHE: 1024 @@ -34,26 +34,26 @@ impl pallet_crowdloan_reward::WeightInfo for WeightInfo // Storage: CrowdloanReward VestingPeriod (r:0 w:1) // Storage: CrowdloanReward DirectPayoutRatio (r:0 w:1) fn initialize() -> Weight { - // Minimum execution time: 28_300 nanoseconds. - Weight::from_ref_time(28_501_000 as u64) + // Minimum execution time: 29_200 nanoseconds. + Weight::from_ref_time(29_800_000 as u64) .saturating_add(T::DbWeight::get().writes(3 as u64)) } // Storage: CrowdloanReward VestingStart (r:0 w:1) fn set_vesting_start() -> Weight { - // Minimum execution time: 25_400 nanoseconds. - Weight::from_ref_time(26_001_000 as u64) + // Minimum execution time: 26_600 nanoseconds. + Weight::from_ref_time(27_100_000 as u64) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: CrowdloanReward VestingPeriod (r:0 w:1) fn set_vesting_period() -> Weight { - // Minimum execution time: 25_600 nanoseconds. - Weight::from_ref_time(26_101_000 as u64) + // Minimum execution time: 26_200 nanoseconds. + Weight::from_ref_time(26_600_000 as u64) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: CrowdloanReward DirectPayoutRatio (r:0 w:1) fn set_direct_payout_ratio() -> Weight { - // Minimum execution time: 25_400 nanoseconds. - Weight::from_ref_time(26_100_000 as u64) + // Minimum execution time: 26_200 nanoseconds. + Weight::from_ref_time(26_900_000 as u64) .saturating_add(T::DbWeight::get().writes(1 as u64)) } } diff --git a/runtime/centrifuge/src/weights/pallet_democracy.rs b/runtime/centrifuge/src/weights/pallet_democracy.rs index c4821fcf47..32889bbad1 100644 --- a/runtime/centrifuge/src/weights/pallet_democracy.rs +++ b/runtime/centrifuge/src/weights/pallet_democracy.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_democracy` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-01-12, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-03-22, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("centrifuge-dev"), DB CACHE: 1024 @@ -35,15 +35,15 @@ impl pallet_democracy::WeightInfo for WeightInfo { // Storage: Democracy Blacklist (r:1 w:0) // Storage: Democracy DepositOf (r:0 w:1) fn propose() -> Weight { - // Minimum execution time: 94_800 nanoseconds. - Weight::from_ref_time(98_301_000 as u64) + // Minimum execution time: 96_101 nanoseconds. + Weight::from_ref_time(99_501_000 as u64) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } // Storage: Democracy DepositOf (r:1 w:1) fn second() -> Weight { // Minimum execution time: 88_000 nanoseconds. - Weight::from_ref_time(90_801_000 as u64) + Weight::from_ref_time(91_701_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } @@ -51,8 +51,8 @@ impl pallet_democracy::WeightInfo for WeightInfo { // Storage: Democracy VotingOf (r:1 w:1) // Storage: Balances Locks (r:1 w:1) fn vote_new() -> Weight { - // Minimum execution time: 107_801 nanoseconds. - Weight::from_ref_time(109_701_000 as u64) + // Minimum execution time: 112_100 nanoseconds. + Weight::from_ref_time(115_201_000 as u64) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -60,16 +60,16 @@ impl pallet_democracy::WeightInfo for WeightInfo { // Storage: Democracy VotingOf (r:1 w:1) // Storage: Balances Locks (r:1 w:1) fn vote_existing() -> Weight { - // Minimum execution time: 108_501 nanoseconds. - Weight::from_ref_time(110_001_000 as u64) + // Minimum execution time: 110_601 nanoseconds. + Weight::from_ref_time(113_000_000 as u64) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } // Storage: Democracy ReferendumInfoOf (r:1 w:1) // Storage: Democracy Cancellations (r:1 w:1) fn emergency_cancel() -> Weight { - // Minimum execution time: 42_600 nanoseconds. - Weight::from_ref_time(43_200_000 as u64) + // Minimum execution time: 43_500 nanoseconds. + Weight::from_ref_time(44_001_000 as u64) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } @@ -80,28 +80,28 @@ impl pallet_democracy::WeightInfo for WeightInfo { // Storage: Democracy ReferendumInfoOf (r:1 w:1) // Storage: Democracy Blacklist (r:0 w:1) fn blacklist() -> Weight { - // Minimum execution time: 171_302 nanoseconds. - Weight::from_ref_time(175_402_000 as u64) + // Minimum execution time: 165_000 nanoseconds. + Weight::from_ref_time(171_001_000 as u64) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(7 as u64)) } // Storage: Democracy NextExternal (r:1 w:1) // Storage: Democracy Blacklist (r:1 w:0) fn external_propose() -> Weight { - // Minimum execution time: 32_300 nanoseconds. - Weight::from_ref_time(33_301_000 as u64) + // Minimum execution time: 32_901 nanoseconds. + Weight::from_ref_time(33_600_000 as u64) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Democracy NextExternal (r:0 w:1) fn external_propose_majority() -> Weight { // Minimum execution time: 10_700 nanoseconds. - Weight::from_ref_time(11_100_000 as u64) + Weight::from_ref_time(11_000_000 as u64) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Democracy NextExternal (r:0 w:1) fn external_propose_default() -> Weight { - // Minimum execution time: 10_600 nanoseconds. + // Minimum execution time: 10_700 nanoseconds. Weight::from_ref_time(10_900_000 as u64) .saturating_add(T::DbWeight::get().writes(1 as u64)) } @@ -109,15 +109,15 @@ impl pallet_democracy::WeightInfo for WeightInfo { // Storage: Democracy ReferendumCount (r:1 w:1) // Storage: Democracy ReferendumInfoOf (r:0 w:1) fn fast_track() -> Weight { - // Minimum execution time: 42_801 nanoseconds. - Weight::from_ref_time(43_600_000 as u64) + // Minimum execution time: 43_100 nanoseconds. + Weight::from_ref_time(43_500_000 as u64) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } // Storage: Democracy NextExternal (r:1 w:1) // Storage: Democracy Blacklist (r:1 w:1) fn veto_external() -> Weight { - // Minimum execution time: 51_801 nanoseconds. + // Minimum execution time: 51_900 nanoseconds. Weight::from_ref_time(52_601_000 as u64) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) @@ -126,15 +126,15 @@ impl pallet_democracy::WeightInfo for WeightInfo { // Storage: Democracy DepositOf (r:1 w:1) // Storage: System Account (r:2 w:2) fn cancel_proposal() -> Weight { - // Minimum execution time: 140_102 nanoseconds. - Weight::from_ref_time(148_202_000 as u64) + // Minimum execution time: 140_600 nanoseconds. + Weight::from_ref_time(152_601_000 as u64) .saturating_add(T::DbWeight::get().reads(4 as u64)) .saturating_add(T::DbWeight::get().writes(4 as u64)) } // Storage: Democracy ReferendumInfoOf (r:0 w:1) fn cancel_referendum() -> Weight { - // Minimum execution time: 28_100 nanoseconds. - Weight::from_ref_time(28_600_000 as u64) + // Minimum execution time: 28_600 nanoseconds. + Weight::from_ref_time(29_100_000 as u64) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Democracy LowestUnbaked (r:1 w:1) @@ -142,10 +142,10 @@ impl pallet_democracy::WeightInfo for WeightInfo { // Storage: Democracy ReferendumInfoOf (r:2 w:0) /// The range of component `r` is `[0, 99]`. fn on_initialize_base(r: u32, ) -> Weight { - // Minimum execution time: 12_500 nanoseconds. - Weight::from_ref_time(18_397_196 as u64) - // Standard Error: 6_107 - .saturating_add(Weight::from_ref_time(4_101_557 as u64).saturating_mul(r as u64)) + // Minimum execution time: 12_600 nanoseconds. + Weight::from_ref_time(18_957_989 as u64) + // Standard Error: 5_746 + .saturating_add(Weight::from_ref_time(4_130_078 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().reads((1 as u64).saturating_mul(r as u64))) .saturating_add(T::DbWeight::get().writes(1 as u64)) @@ -158,10 +158,10 @@ impl pallet_democracy::WeightInfo for WeightInfo { // Storage: Democracy ReferendumInfoOf (r:2 w:0) /// The range of component `r` is `[0, 99]`. fn on_initialize_base_with_launch_period(r: u32, ) -> Weight { - // Minimum execution time: 17_300 nanoseconds. - Weight::from_ref_time(24_171_244 as u64) - // Standard Error: 8_557 - .saturating_add(Weight::from_ref_time(4_099_587 as u64).saturating_mul(r as u64)) + // Minimum execution time: 17_700 nanoseconds. + Weight::from_ref_time(24_911_416 as u64) + // Standard Error: 7_376 + .saturating_add(Weight::from_ref_time(4_117_291 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(5 as u64)) .saturating_add(T::DbWeight::get().reads((1 as u64).saturating_mul(r as u64))) .saturating_add(T::DbWeight::get().writes(1 as u64)) @@ -171,10 +171,10 @@ impl pallet_democracy::WeightInfo for WeightInfo { // Storage: Democracy ReferendumInfoOf (r:2 w:2) /// The range of component `r` is `[0, 99]`. fn delegate(r: u32, ) -> Weight { - // Minimum execution time: 82_901 nanoseconds. - Weight::from_ref_time(90_099_579 as u64) - // Standard Error: 9_932 - .saturating_add(Weight::from_ref_time(6_212_354 as u64).saturating_mul(r as u64)) + // Minimum execution time: 84_700 nanoseconds. + Weight::from_ref_time(90_654_379 as u64) + // Standard Error: 9_764 + .saturating_add(Weight::from_ref_time(6_314_017 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(4 as u64)) .saturating_add(T::DbWeight::get().reads((1 as u64).saturating_mul(r as u64))) .saturating_add(T::DbWeight::get().writes(4 as u64)) @@ -184,10 +184,10 @@ impl pallet_democracy::WeightInfo for WeightInfo { // Storage: Democracy ReferendumInfoOf (r:2 w:2) /// The range of component `r` is `[0, 99]`. fn undelegate(r: u32, ) -> Weight { - // Minimum execution time: 49_601 nanoseconds. - Weight::from_ref_time(52_519_085 as u64) - // Standard Error: 8_913 - .saturating_add(Weight::from_ref_time(6_192_104 as u64).saturating_mul(r as u64)) + // Minimum execution time: 50_300 nanoseconds. + Weight::from_ref_time(52_560_121 as u64) + // Standard Error: 9_337 + .saturating_add(Weight::from_ref_time(6_304_108 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().reads((1 as u64).saturating_mul(r as u64))) .saturating_add(T::DbWeight::get().writes(2 as u64)) @@ -195,8 +195,8 @@ impl pallet_democracy::WeightInfo for WeightInfo { } // Storage: Democracy PublicProps (r:0 w:1) fn clear_public_proposals() -> Weight { - // Minimum execution time: 12_300 nanoseconds. - Weight::from_ref_time(12_501_000 as u64) + // Minimum execution time: 12_200 nanoseconds. + Weight::from_ref_time(12_700_000 as u64) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Democracy VotingOf (r:1 w:1) @@ -204,10 +204,10 @@ impl pallet_democracy::WeightInfo for WeightInfo { // Storage: System Account (r:1 w:1) /// The range of component `r` is `[0, 99]`. fn unlock_remove(r: u32, ) -> Weight { - // Minimum execution time: 49_200 nanoseconds. - Weight::from_ref_time(60_703_861 as u64) - // Standard Error: 3_068 - .saturating_add(Weight::from_ref_time(157_951 as u64).saturating_mul(r as u64)) + // Minimum execution time: 51_000 nanoseconds. + Weight::from_ref_time(61_722_949 as u64) + // Standard Error: 3_046 + .saturating_add(Weight::from_ref_time(170_410 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -216,10 +216,10 @@ impl pallet_democracy::WeightInfo for WeightInfo { // Storage: System Account (r:1 w:1) /// The range of component `r` is `[0, 99]`. fn unlock_set(r: u32, ) -> Weight { - // Minimum execution time: 57_200 nanoseconds. - Weight::from_ref_time(59_560_514 as u64) - // Standard Error: 1_783 - .saturating_add(Weight::from_ref_time(235_886 as u64).saturating_mul(r as u64)) + // Minimum execution time: 59_000 nanoseconds. + Weight::from_ref_time(61_312_704 as u64) + // Standard Error: 2_161 + .saturating_add(Weight::from_ref_time(231_415 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -227,10 +227,10 @@ impl pallet_democracy::WeightInfo for WeightInfo { // Storage: Democracy VotingOf (r:1 w:1) /// The range of component `r` is `[1, 100]`. fn remove_vote(r: u32, ) -> Weight { - // Minimum execution time: 33_100 nanoseconds. - Weight::from_ref_time(36_013_987 as u64) - // Standard Error: 1_946 - .saturating_add(Weight::from_ref_time(250_725 as u64).saturating_mul(r as u64)) + // Minimum execution time: 33_500 nanoseconds. + Weight::from_ref_time(37_251_298 as u64) + // Standard Error: 3_036 + .saturating_add(Weight::from_ref_time(231_660 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } @@ -239,9 +239,9 @@ impl pallet_democracy::WeightInfo for WeightInfo { /// The range of component `r` is `[1, 100]`. fn remove_other_vote(r: u32, ) -> Weight { // Minimum execution time: 33_100 nanoseconds. - Weight::from_ref_time(35_946_047 as u64) - // Standard Error: 1_815 - .saturating_add(Weight::from_ref_time(249_476 as u64).saturating_mul(r as u64)) + Weight::from_ref_time(36_226_839 as u64) + // Standard Error: 1_864 + .saturating_add(Weight::from_ref_time(242_230 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } diff --git a/runtime/centrifuge/src/weights/pallet_fees.rs b/runtime/centrifuge/src/weights/pallet_fees.rs index ee82914dcb..1909c651bd 100644 --- a/runtime/centrifuge/src/weights/pallet_fees.rs +++ b/runtime/centrifuge/src/weights/pallet_fees.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_fees` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-01-12, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-03-22, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("centrifuge-dev"), DB CACHE: 1024 @@ -32,8 +32,8 @@ pub struct WeightInfo(PhantomData); impl pallet_fees::WeightInfo for WeightInfo { // Storage: Fees FeeBalances (r:0 w:1) fn set_fee() -> Weight { - // Minimum execution time: 27_500 nanoseconds. - Weight::from_ref_time(28_300_000 as u64) + // Minimum execution time: 28_201 nanoseconds. + Weight::from_ref_time(28_900_000 as u64) .saturating_add(T::DbWeight::get().writes(1 as u64)) } } diff --git a/runtime/centrifuge/src/weights/pallet_identity.rs b/runtime/centrifuge/src/weights/pallet_identity.rs index e6ed14c389..be56b64985 100644 --- a/runtime/centrifuge/src/weights/pallet_identity.rs +++ b/runtime/centrifuge/src/weights/pallet_identity.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_identity` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-01-12, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-03-22, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("centrifuge-dev"), DB CACHE: 1024 @@ -33,10 +33,10 @@ impl pallet_identity::WeightInfo for WeightInfo { // Storage: Identity Registrars (r:1 w:1) /// The range of component `r` is `[1, 19]`. fn add_registrar(r: u32, ) -> Weight { - // Minimum execution time: 34_800 nanoseconds. - Weight::from_ref_time(36_475_964 as u64) - // Standard Error: 13_427 - .saturating_add(Weight::from_ref_time(338_952 as u64).saturating_mul(r as u64)) + // Minimum execution time: 35_401 nanoseconds. + Weight::from_ref_time(37_079_394 as u64) + // Standard Error: 5_246 + .saturating_add(Weight::from_ref_time(363_522 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } @@ -44,12 +44,12 @@ impl pallet_identity::WeightInfo for WeightInfo { /// The range of component `r` is `[1, 20]`. /// The range of component `x` is `[0, 100]`. fn set_identity(r: u32, x: u32, ) -> Weight { - // Minimum execution time: 73_500 nanoseconds. - Weight::from_ref_time(68_340_544 as u64) - // Standard Error: 9_024 - .saturating_add(Weight::from_ref_time(358_542 as u64).saturating_mul(r as u64)) - // Standard Error: 1_760 - .saturating_add(Weight::from_ref_time(698_747 as u64).saturating_mul(x as u64)) + // Minimum execution time: 75_701 nanoseconds. + Weight::from_ref_time(71_718_053 as u64) + // Standard Error: 6_258 + .saturating_add(Weight::from_ref_time(345_307 as u64).saturating_mul(r as u64)) + // Standard Error: 1_221 + .saturating_add(Weight::from_ref_time(720_084 as u64).saturating_mul(x as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } @@ -58,10 +58,10 @@ impl pallet_identity::WeightInfo for WeightInfo { // Storage: Identity SuperOf (r:2 w:2) /// The range of component `s` is `[0, 100]`. fn set_subs_new(s: u32, ) -> Weight { - // Minimum execution time: 22_100 nanoseconds. - Weight::from_ref_time(57_180_296 as u64) - // Standard Error: 12_370 - .saturating_add(Weight::from_ref_time(4_909_022 as u64).saturating_mul(s as u64)) + // Minimum execution time: 23_100 nanoseconds. + Weight::from_ref_time(60_266_376 as u64) + // Standard Error: 17_736 + .saturating_add(Weight::from_ref_time(5_159_463 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().reads((1 as u64).saturating_mul(s as u64))) .saturating_add(T::DbWeight::get().writes(1 as u64)) @@ -72,10 +72,10 @@ impl pallet_identity::WeightInfo for WeightInfo { // Storage: Identity SuperOf (r:0 w:2) /// The range of component `p` is `[0, 100]`. fn set_subs_old(p: u32, ) -> Weight { - // Minimum execution time: 21_600 nanoseconds. - Weight::from_ref_time(56_090_280 as u64) - // Standard Error: 10_531 - .saturating_add(Weight::from_ref_time(2_110_288 as u64).saturating_mul(p as u64)) + // Minimum execution time: 22_900 nanoseconds. + Weight::from_ref_time(58_841_562 as u64) + // Standard Error: 9_887 + .saturating_add(Weight::from_ref_time(2_217_884 as u64).saturating_mul(p as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) .saturating_add(T::DbWeight::get().writes((1 as u64).saturating_mul(p as u64))) @@ -87,14 +87,14 @@ impl pallet_identity::WeightInfo for WeightInfo { /// The range of component `s` is `[0, 100]`. /// The range of component `x` is `[0, 100]`. fn clear_identity(r: u32, s: u32, x: u32, ) -> Weight { - // Minimum execution time: 106_301 nanoseconds. - Weight::from_ref_time(70_064_194 as u64) - // Standard Error: 12_522 - .saturating_add(Weight::from_ref_time(252_804 as u64).saturating_mul(r as u64)) - // Standard Error: 2_445 - .saturating_add(Weight::from_ref_time(2_067_002 as u64).saturating_mul(s as u64)) - // Standard Error: 2_445 - .saturating_add(Weight::from_ref_time(366_073 as u64).saturating_mul(x as u64)) + // Minimum execution time: 102_201 nanoseconds. + Weight::from_ref_time(68_567_855 as u64) + // Standard Error: 13_883 + .saturating_add(Weight::from_ref_time(420_920 as u64).saturating_mul(r as u64)) + // Standard Error: 2_711 + .saturating_add(Weight::from_ref_time(2_202_259 as u64).saturating_mul(s as u64)) + // Standard Error: 2_711 + .saturating_add(Weight::from_ref_time(380_412 as u64).saturating_mul(x as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) .saturating_add(T::DbWeight::get().writes((1 as u64).saturating_mul(s as u64))) @@ -104,12 +104,12 @@ impl pallet_identity::WeightInfo for WeightInfo { /// The range of component `r` is `[1, 20]`. /// The range of component `x` is `[0, 100]`. fn request_judgement(r: u32, x: u32, ) -> Weight { - // Minimum execution time: 75_500 nanoseconds. - Weight::from_ref_time(71_031_853 as u64) - // Standard Error: 6_390 - .saturating_add(Weight::from_ref_time(336_765 as u64).saturating_mul(r as u64)) - // Standard Error: 1_246 - .saturating_add(Weight::from_ref_time(706_619 as u64).saturating_mul(x as u64)) + // Minimum execution time: 76_512 nanoseconds. + Weight::from_ref_time(75_273_871 as u64) + // Standard Error: 7_566 + .saturating_add(Weight::from_ref_time(277_423 as u64).saturating_mul(r as u64)) + // Standard Error: 1_476 + .saturating_add(Weight::from_ref_time(741_498 as u64).saturating_mul(x as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } @@ -117,42 +117,42 @@ impl pallet_identity::WeightInfo for WeightInfo { /// The range of component `r` is `[1, 20]`. /// The range of component `x` is `[0, 100]`. fn cancel_request(r: u32, x: u32, ) -> Weight { - // Minimum execution time: 68_200 nanoseconds. - Weight::from_ref_time(66_781_006 as u64) - // Standard Error: 10_934 - .saturating_add(Weight::from_ref_time(220_954 as u64).saturating_mul(r as u64)) - // Standard Error: 2_133 - .saturating_add(Weight::from_ref_time(708_078 as u64).saturating_mul(x as u64)) + // Minimum execution time: 70_802 nanoseconds. + Weight::from_ref_time(68_976_038 as u64) + // Standard Error: 7_348 + .saturating_add(Weight::from_ref_time(281_328 as u64).saturating_mul(r as u64)) + // Standard Error: 1_433 + .saturating_add(Weight::from_ref_time(734_303 as u64).saturating_mul(x as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Identity Registrars (r:1 w:1) /// The range of component `r` is `[1, 19]`. fn set_fee(r: u32, ) -> Weight { - // Minimum execution time: 18_700 nanoseconds. - Weight::from_ref_time(19_687_041 as u64) - // Standard Error: 6_274 - .saturating_add(Weight::from_ref_time(263_254 as u64).saturating_mul(r as u64)) + // Minimum execution time: 19_401 nanoseconds. + Weight::from_ref_time(20_412_791 as u64) + // Standard Error: 3_962 + .saturating_add(Weight::from_ref_time(288_594 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Identity Registrars (r:1 w:1) /// The range of component `r` is `[1, 19]`. fn set_account_id(r: u32, ) -> Weight { - // Minimum execution time: 19_000 nanoseconds. - Weight::from_ref_time(20_062_240 as u64) - // Standard Error: 3_449 - .saturating_add(Weight::from_ref_time(247_477 as u64).saturating_mul(r as u64)) + // Minimum execution time: 20_001 nanoseconds. + Weight::from_ref_time(20_943_860 as u64) + // Standard Error: 4_596 + .saturating_add(Weight::from_ref_time(258_487 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Identity Registrars (r:1 w:1) /// The range of component `r` is `[1, 19]`. fn set_fields(r: u32, ) -> Weight { - // Minimum execution time: 18_600 nanoseconds. - Weight::from_ref_time(19_727_301 as u64) - // Standard Error: 3_242 - .saturating_add(Weight::from_ref_time(251_945 as u64).saturating_mul(r as u64)) + // Minimum execution time: 19_501 nanoseconds. + Weight::from_ref_time(20_415_003 as u64) + // Standard Error: 6_271 + .saturating_add(Weight::from_ref_time(293_809 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } @@ -161,12 +161,12 @@ impl pallet_identity::WeightInfo for WeightInfo { /// The range of component `r` is `[1, 19]`. /// The range of component `x` is `[0, 100]`. fn provide_judgement(r: u32, x: u32, ) -> Weight { - // Minimum execution time: 55_801 nanoseconds. - Weight::from_ref_time(53_078_487 as u64) - // Standard Error: 17_404 - .saturating_add(Weight::from_ref_time(315_367 as u64).saturating_mul(r as u64)) - // Standard Error: 3_220 - .saturating_add(Weight::from_ref_time(1_159_158 as u64).saturating_mul(x as u64)) + // Minimum execution time: 58_402 nanoseconds. + Weight::from_ref_time(55_989_832 as u64) + // Standard Error: 7_115 + .saturating_add(Weight::from_ref_time(316_865 as u64).saturating_mul(r as u64)) + // Standard Error: 1_316 + .saturating_add(Weight::from_ref_time(1_187_536 as u64).saturating_mul(x as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } @@ -178,14 +178,14 @@ impl pallet_identity::WeightInfo for WeightInfo { /// The range of component `s` is `[0, 100]`. /// The range of component `x` is `[0, 100]`. fn kill_identity(r: u32, s: u32, x: u32, ) -> Weight { - // Minimum execution time: 127_501 nanoseconds. - Weight::from_ref_time(87_386_461 as u64) - // Standard Error: 9_378 - .saturating_add(Weight::from_ref_time(409_329 as u64).saturating_mul(r as u64)) - // Standard Error: 1_831 - .saturating_add(Weight::from_ref_time(2_075_397 as u64).saturating_mul(s as u64)) - // Standard Error: 1_831 - .saturating_add(Weight::from_ref_time(370_368 as u64).saturating_mul(x as u64)) + // Minimum execution time: 133_304 nanoseconds. + Weight::from_ref_time(92_739_819 as u64) + // Standard Error: 18_885 + .saturating_add(Weight::from_ref_time(404_821 as u64).saturating_mul(r as u64)) + // Standard Error: 3_688 + .saturating_add(Weight::from_ref_time(2_170_287 as u64).saturating_mul(s as u64)) + // Standard Error: 3_688 + .saturating_add(Weight::from_ref_time(419_284 as u64).saturating_mul(x as u64)) .saturating_add(T::DbWeight::get().reads(4 as u64)) .saturating_add(T::DbWeight::get().writes(4 as u64)) .saturating_add(T::DbWeight::get().writes((1 as u64).saturating_mul(s as u64))) @@ -195,10 +195,10 @@ impl pallet_identity::WeightInfo for WeightInfo { // Storage: Identity SubsOf (r:1 w:1) /// The range of component `s` is `[0, 99]`. fn add_sub(s: u32, ) -> Weight { - // Minimum execution time: 64_401 nanoseconds. - Weight::from_ref_time(72_209_766 as u64) - // Standard Error: 4_433 - .saturating_add(Weight::from_ref_time(224_390 as u64).saturating_mul(s as u64)) + // Minimum execution time: 68_303 nanoseconds. + Weight::from_ref_time(76_509_144 as u64) + // Standard Error: 3_640 + .saturating_add(Weight::from_ref_time(214_351 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } @@ -206,10 +206,10 @@ impl pallet_identity::WeightInfo for WeightInfo { // Storage: Identity SuperOf (r:1 w:1) /// The range of component `s` is `[1, 100]`. fn rename_sub(s: u32, ) -> Weight { - // Minimum execution time: 28_100 nanoseconds. - Weight::from_ref_time(30_868_086 as u64) - // Standard Error: 1_871 - .saturating_add(Weight::from_ref_time(127_920 as u64).saturating_mul(s as u64)) + // Minimum execution time: 29_301 nanoseconds. + Weight::from_ref_time(32_363_624 as u64) + // Standard Error: 1_999 + .saturating_add(Weight::from_ref_time(131_579 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } @@ -218,10 +218,10 @@ impl pallet_identity::WeightInfo for WeightInfo { // Storage: Identity SubsOf (r:1 w:1) /// The range of component `s` is `[1, 100]`. fn remove_sub(s: u32, ) -> Weight { - // Minimum execution time: 69_796 nanoseconds. - Weight::from_ref_time(73_857_099 as u64) - // Standard Error: 2_424 - .saturating_add(Weight::from_ref_time(204_980 as u64).saturating_mul(s as u64)) + // Minimum execution time: 73_603 nanoseconds. + Weight::from_ref_time(78_780_282 as u64) + // Standard Error: 3_889 + .saturating_add(Weight::from_ref_time(205_179 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } @@ -229,10 +229,10 @@ impl pallet_identity::WeightInfo for WeightInfo { // Storage: Identity SubsOf (r:1 w:1) /// The range of component `s` is `[0, 99]`. fn quit_sub(s: u32, ) -> Weight { - // Minimum execution time: 48_901 nanoseconds. - Weight::from_ref_time(55_653_393 as u64) - // Standard Error: 5_274 - .saturating_add(Weight::from_ref_time(166_789 as u64).saturating_mul(s as u64)) + // Minimum execution time: 51_402 nanoseconds. + Weight::from_ref_time(57_088_362 as u64) + // Standard Error: 3_913 + .saturating_add(Weight::from_ref_time(192_293 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } diff --git a/runtime/centrifuge/src/weights/pallet_interest_accrual.rs b/runtime/centrifuge/src/weights/pallet_interest_accrual.rs new file mode 100644 index 0000000000..810b46db61 --- /dev/null +++ b/runtime/centrifuge/src/weights/pallet_interest_accrual.rs @@ -0,0 +1,40 @@ + +//! Autogenerated weights for `pallet_interest_accrual` +//! +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev +//! DATE: 2023-03-22, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` +//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("centrifuge-dev"), DB CACHE: 1024 + +// Executed Command: +// target/release/centrifuge-chain +// benchmark +// pallet +// --chain=centrifuge-dev +// --steps=50 +// --repeat=20 +// --pallet=pallet_interest_accrual +// --extrinsic=* +// --execution=wasm +// --wasm-execution=compiled +// --heap-pages=4096 +// --output=/tmp/runtime/centrifuge/src/weights/pallet_interest_accrual.rs + +#![cfg_attr(rustfmt, rustfmt_skip)] +#![allow(unused_parens)] +#![allow(unused_imports)] + +use frame_support::{traits::Get, weights::Weight}; +use sp_std::marker::PhantomData; + +/// Weight functions for `pallet_interest_accrual`. +pub struct WeightInfo(PhantomData); +impl pallet_interest_accrual::WeightInfo for WeightInfo { + /// The range of component `n` is `[1, 25]`. + fn calculate_accumulated_rate(n: u32, ) -> Weight { + // Minimum execution time: 900 nanoseconds. + Weight::from_ref_time(900_000 as u64) + // Standard Error: 2_696 + .saturating_add(Weight::from_ref_time(987_963 as u64).saturating_mul(n as u64)) + } +} diff --git a/runtime/centrifuge/src/weights/pallet_keystore.rs b/runtime/centrifuge/src/weights/pallet_keystore.rs new file mode 100644 index 0000000000..8710125003 --- /dev/null +++ b/runtime/centrifuge/src/weights/pallet_keystore.rs @@ -0,0 +1,64 @@ + +//! Autogenerated weights for `pallet_keystore` +//! +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev +//! DATE: 2023-03-22, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` +//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("centrifuge-dev"), DB CACHE: 1024 + +// Executed Command: +// target/release/centrifuge-chain +// benchmark +// pallet +// --chain=centrifuge-dev +// --steps=50 +// --repeat=20 +// --pallet=pallet_keystore +// --extrinsic=* +// --execution=wasm +// --wasm-execution=compiled +// --heap-pages=4096 +// --output=/tmp/runtime/centrifuge/src/weights/pallet_keystore.rs + +#![cfg_attr(rustfmt, rustfmt_skip)] +#![allow(unused_parens)] +#![allow(unused_imports)] + +use frame_support::{traits::Get, weights::Weight}; +use sp_std::marker::PhantomData; + +/// Weight functions for `pallet_keystore`. +pub struct WeightInfo(PhantomData); +impl pallet_keystore::WeightInfo for WeightInfo { + // Storage: Keystore KeyDeposit (r:1 w:0) + // Storage: System Account (r:1 w:1) + // Storage: Keystore Keys (r:1 w:1) + // Storage: Keystore LastKeyByPurpose (r:0 w:1) + /// The range of component `n` is `[1, 10]`. + fn add_keys(n: u32, ) -> Weight { + // Minimum execution time: 59_803 nanoseconds. + Weight::from_ref_time(37_974_118 as u64) + // Standard Error: 36_800 + .saturating_add(Weight::from_ref_time(28_036_103 as u64).saturating_mul(n as u64)) + .saturating_add(T::DbWeight::get().reads(2 as u64)) + .saturating_add(T::DbWeight::get().reads((1 as u64).saturating_mul(n as u64))) + .saturating_add(T::DbWeight::get().writes(2 as u64)) + .saturating_add(T::DbWeight::get().writes((1 as u64).saturating_mul(n as u64))) + } + // Storage: Keystore Keys (r:1 w:1) + /// The range of component `n` is `[1, 10]`. + fn revoke_keys(n: u32, ) -> Weight { + // Minimum execution time: 40_102 nanoseconds. + Weight::from_ref_time(27_299_204 as u64) + // Standard Error: 35_114 + .saturating_add(Weight::from_ref_time(15_880_893 as u64).saturating_mul(n as u64)) + .saturating_add(T::DbWeight::get().reads((1 as u64).saturating_mul(n as u64))) + .saturating_add(T::DbWeight::get().writes((1 as u64).saturating_mul(n as u64))) + } + // Storage: Keystore KeyDeposit (r:0 w:1) + fn set_deposit() -> Weight { + // Minimum execution time: 27_501 nanoseconds. + Weight::from_ref_time(28_101_000 as u64) + .saturating_add(T::DbWeight::get().writes(1 as u64)) + } +} diff --git a/runtime/centrifuge/src/weights/pallet_loans.rs b/runtime/centrifuge/src/weights/pallet_loans.rs new file mode 100644 index 0000000000..a71cd624f6 --- /dev/null +++ b/runtime/centrifuge/src/weights/pallet_loans.rs @@ -0,0 +1,262 @@ + +//! Autogenerated weights for `pallet_loans` +//! +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev +//! DATE: 2023-03-22, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` +//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("centrifuge-dev"), DB CACHE: 1024 + +// Executed Command: +// target/release/centrifuge-chain +// benchmark +// pallet +// --chain=centrifuge-dev +// --steps=50 +// --repeat=20 +// --pallet=pallet_loans +// --extrinsic=* +// --execution=wasm +// --wasm-execution=compiled +// --heap-pages=4096 +// --output=/tmp/runtime/centrifuge/src/weights/pallet_loans.rs + +#![cfg_attr(rustfmt, rustfmt_skip)] +#![allow(unused_parens)] +#![allow(unused_imports)] + +use frame_support::{traits::Get, weights::Weight}; +use sp_std::marker::PhantomData; + +/// Weight functions for `pallet_loans`. +pub struct WeightInfo(PhantomData); +impl pallet_loans::WeightInfo for WeightInfo { + // Storage: Permissions Permission (r:1 w:0) + // Storage: PoolSystem Pool (r:1 w:0) + // Storage: Loans PoolToLoanNftClass (r:1 w:1) + // Storage: Timestamp Now (r:1 w:0) + // Storage: Loans PoolNAV (r:0 w:1) + // Storage: Loans LoanNftClassToPool (r:0 w:1) + fn initialise_pool() -> Weight { + // Minimum execution time: 75_203 nanoseconds. + Weight::from_ref_time(76_803_000 as u64) + .saturating_add(T::DbWeight::get().reads(4 as u64)) + .saturating_add(T::DbWeight::get().writes(3 as u64)) + } + // Storage: Permissions Permission (r:1 w:0) + // Storage: Uniques Asset (r:2 w:2) + // Storage: Loans LoanNftClassToPool (r:1 w:0) + // Storage: Loans NextLoanId (r:1 w:1) + // Storage: Loans PoolToLoanNftClass (r:1 w:0) + // Storage: Uniques Class (r:2 w:1) + // Storage: Uniques CollectionMaxSupply (r:1 w:0) + // Storage: Loans Loan (r:0 w:1) + // Storage: Uniques Account (r:0 w:3) + // Storage: Uniques ItemPriceOf (r:0 w:1) + fn create() -> Weight { + // Minimum execution time: 173_306 nanoseconds. + Weight::from_ref_time(175_507_000 as u64) + .saturating_add(T::DbWeight::get().reads(9 as u64)) + .saturating_add(T::DbWeight::get().writes(9 as u64)) + } + // Storage: Loans Loan (r:1 w:1) + // Storage: Permissions Permission (r:1 w:0) + // Storage: Timestamp Now (r:1 w:0) + // Storage: InterestAccrual Rates (r:1 w:1) + // Storage: Loans ActiveLoans (r:1 w:1) + // Storage: InterestAccrual LastUpdated (r:1 w:0) + // Storage: Loans PoolWriteOffGroups (r:1 w:0) + // Storage: Loans PoolNAV (r:1 w:1) + /// The range of component `n` is `[1, 50]`. + /// The range of component `m` is `[1, 50]`. + fn price(n: u32, m: u32, ) -> Weight { + // Minimum execution time: 134_805 nanoseconds. + Weight::from_ref_time(118_993_413 as u64) + // Standard Error: 10_037 + .saturating_add(Weight::from_ref_time(1_157_489 as u64).saturating_mul(n as u64)) + // Standard Error: 10_037 + .saturating_add(Weight::from_ref_time(440_575 as u64).saturating_mul(m as u64)) + .saturating_add(T::DbWeight::get().reads(8 as u64)) + .saturating_add(T::DbWeight::get().writes(4 as u64)) + } + // Storage: Permissions Permission (r:1 w:0) + // Storage: Loans PoolToLoanNftClass (r:1 w:0) + // Storage: Loans PoolWriteOffGroups (r:1 w:1) + fn add_write_off_group() -> Weight { + // Minimum execution time: 71_102 nanoseconds. + Weight::from_ref_time(73_203_000 as u64) + .saturating_add(T::DbWeight::get().reads(3 as u64)) + .saturating_add(T::DbWeight::get().writes(1 as u64)) + } + // Storage: Loans PoolToLoanNftClass (r:1 w:0) + // Storage: Uniques Asset (r:1 w:0) + // Storage: Loans Loan (r:1 w:0) + // Storage: Loans ActiveLoans (r:1 w:1) + // Storage: Timestamp Now (r:1 w:0) + // Storage: InterestAccrual Rates (r:1 w:0) + // Storage: InterestAccrual LastUpdated (r:1 w:0) + // Storage: Loans PoolNAV (r:1 w:1) + // Storage: PoolSystem Pool (r:1 w:1) + // Storage: OrmlTokens Accounts (r:2 w:2) + // Storage: System Account (r:1 w:0) + /// The range of component `n` is `[1, 50]`. + /// The range of component `m` is `[1, 50]`. + fn initial_borrow(n: u32, m: u32, ) -> Weight { + // Minimum execution time: 237_608 nanoseconds. + Weight::from_ref_time(239_401_446 as u64) + // Standard Error: 13_924 + .saturating_add(Weight::from_ref_time(1_019_000 as u64).saturating_mul(n as u64)) + // Standard Error: 13_924 + .saturating_add(Weight::from_ref_time(149_810 as u64).saturating_mul(m as u64)) + .saturating_add(T::DbWeight::get().reads(12 as u64)) + .saturating_add(T::DbWeight::get().writes(5 as u64)) + } + // Storage: Loans PoolToLoanNftClass (r:1 w:0) + // Storage: Uniques Asset (r:1 w:0) + // Storage: Loans Loan (r:1 w:0) + // Storage: Loans ActiveLoans (r:1 w:1) + // Storage: Timestamp Now (r:1 w:0) + // Storage: InterestAccrual Rates (r:1 w:0) + // Storage: InterestAccrual LastUpdated (r:1 w:0) + // Storage: Loans PoolNAV (r:1 w:1) + // Storage: PoolSystem Pool (r:1 w:1) + // Storage: OrmlTokens Accounts (r:2 w:2) + // Storage: System Account (r:1 w:0) + /// The range of component `n` is `[1, 50]`. + /// The range of component `m` is `[1, 50]`. + fn further_borrows(n: u32, m: u32, ) -> Weight { + // Minimum execution time: 333_610 nanoseconds. + Weight::from_ref_time(333_270_782 as u64) + // Standard Error: 14_630 + .saturating_add(Weight::from_ref_time(761_872 as u64).saturating_mul(n as u64)) + // Standard Error: 14_630 + .saturating_add(Weight::from_ref_time(171_850 as u64).saturating_mul(m as u64)) + .saturating_add(T::DbWeight::get().reads(12 as u64)) + .saturating_add(T::DbWeight::get().writes(5 as u64)) + } + // Storage: Loans PoolToLoanNftClass (r:1 w:0) + // Storage: Uniques Asset (r:1 w:0) + // Storage: Loans Loan (r:1 w:0) + // Storage: Loans ActiveLoans (r:1 w:1) + // Storage: Timestamp Now (r:1 w:0) + // Storage: Loans PoolWriteOffGroups (r:1 w:0) + // Storage: InterestAccrual Rates (r:1 w:0) + // Storage: InterestAccrual LastUpdated (r:1 w:0) + // Storage: Loans PoolNAV (r:1 w:1) + // Storage: PoolSystem Pool (r:1 w:1) + // Storage: OrmlTokens Accounts (r:2 w:2) + /// The range of component `n` is `[1, 50]`. + /// The range of component `m` is `[1, 50]`. + fn repay(n: u32, m: u32, ) -> Weight { + // Minimum execution time: 289_207 nanoseconds. + Weight::from_ref_time(288_708_375 as u64) + // Standard Error: 10_712 + .saturating_add(Weight::from_ref_time(834_934 as u64).saturating_mul(n as u64)) + // Standard Error: 10_712 + .saturating_add(Weight::from_ref_time(154_924 as u64).saturating_mul(m as u64)) + .saturating_add(T::DbWeight::get().reads(12 as u64)) + .saturating_add(T::DbWeight::get().writes(5 as u64)) + } + // Storage: Loans Loan (r:1 w:0) + // Storage: Loans ActiveLoans (r:1 w:1) + // Storage: Loans PoolWriteOffGroups (r:1 w:0) + // Storage: Timestamp Now (r:1 w:0) + // Storage: InterestAccrual Rates (r:1 w:1) + // Storage: InterestAccrual LastUpdated (r:1 w:0) + // Storage: Loans PoolNAV (r:1 w:1) + /// The range of component `n` is `[1, 50]`. + /// The range of component `m` is `[1, 100]`. + /// The range of component `o` is `[1, 49]`. + fn write_off(n: u32, m: u32, o: u32, ) -> Weight { + // Minimum execution time: 196_705 nanoseconds. + Weight::from_ref_time(189_322_169 as u64) + // Standard Error: 9_601 + .saturating_add(Weight::from_ref_time(834_064 as u64).saturating_mul(n as u64)) + // Standard Error: 4_740 + .saturating_add(Weight::from_ref_time(49_870 as u64).saturating_mul(m as u64)) + // Standard Error: 9_615 + .saturating_add(Weight::from_ref_time(168_517 as u64).saturating_mul(o as u64)) + .saturating_add(T::DbWeight::get().reads(7 as u64)) + .saturating_add(T::DbWeight::get().writes(3 as u64)) + } + // Storage: Permissions Permission (r:1 w:0) + // Storage: Loans Loan (r:1 w:0) + // Storage: Loans ActiveLoans (r:1 w:1) + // Storage: Loans PoolWriteOffGroups (r:1 w:0) + // Storage: InterestAccrual Rates (r:1 w:1) + // Storage: InterestAccrual LastUpdated (r:1 w:0) + // Storage: Timestamp Now (r:1 w:0) + // Storage: Loans PoolNAV (r:1 w:1) + /// The range of component `n` is `[1, 50]`. + /// The range of component `m` is `[1, 49]`. + fn admin_write_off(n: u32, m: u32, ) -> Weight { + // Minimum execution time: 207_103 nanoseconds. + Weight::from_ref_time(200_268_020 as u64) + // Standard Error: 10_661 + .saturating_add(Weight::from_ref_time(806_425 as u64).saturating_mul(n as u64)) + // Standard Error: 10_676 + .saturating_add(Weight::from_ref_time(293_812 as u64).saturating_mul(m as u64)) + .saturating_add(T::DbWeight::get().reads(8 as u64)) + .saturating_add(T::DbWeight::get().writes(3 as u64)) + } + // Storage: Loans PoolToLoanNftClass (r:1 w:0) + // Storage: Uniques Asset (r:2 w:2) + // Storage: Loans Loan (r:1 w:1) + // Storage: Loans ActiveLoans (r:1 w:1) + // Storage: Loans PoolWriteOffGroups (r:1 w:0) + // Storage: Uniques Class (r:2 w:1) + // Storage: InterestAccrual Rates (r:1 w:1) + // Storage: Loans ClosedLoans (r:0 w:1) + // Storage: Uniques Account (r:0 w:3) + // Storage: Uniques ItemPriceOf (r:0 w:2) + /// The range of component `n` is `[1, 50]`. + /// The range of component `m` is `[1, 50]`. + fn repay_and_close(n: u32, m: u32, ) -> Weight { + // Minimum execution time: 193_503 nanoseconds. + Weight::from_ref_time(199_328_934 as u64) + // Standard Error: 14_071 + .saturating_add(Weight::from_ref_time(992_455 as u64).saturating_mul(n as u64)) + // Standard Error: 14_071 + .saturating_add(Weight::from_ref_time(86_300 as u64).saturating_mul(m as u64)) + .saturating_add(T::DbWeight::get().reads(9 as u64)) + .saturating_add(T::DbWeight::get().writes(12 as u64)) + } + // Storage: Loans PoolToLoanNftClass (r:1 w:0) + // Storage: Uniques Asset (r:2 w:2) + // Storage: Loans Loan (r:1 w:1) + // Storage: Loans ActiveLoans (r:1 w:1) + // Storage: Loans PoolWriteOffGroups (r:1 w:0) + // Storage: Uniques Class (r:2 w:1) + // Storage: InterestAccrual Rates (r:1 w:1) + // Storage: Loans ClosedLoans (r:0 w:1) + // Storage: Uniques Account (r:0 w:3) + // Storage: Uniques ItemPriceOf (r:0 w:2) + /// The range of component `n` is `[1, 50]`. + /// The range of component `m` is `[1, 49]`. + fn write_off_and_close(n: u32, m: u32, ) -> Weight { + // Minimum execution time: 197_702 nanoseconds. + Weight::from_ref_time(197_135_893 as u64) + // Standard Error: 12_445 + .saturating_add(Weight::from_ref_time(979_877 as u64).saturating_mul(n as u64)) + // Standard Error: 12_463 + .saturating_add(Weight::from_ref_time(129_477 as u64).saturating_mul(m as u64)) + .saturating_add(T::DbWeight::get().reads(9 as u64)) + .saturating_add(T::DbWeight::get().writes(12 as u64)) + } + // Storage: Loans PoolWriteOffGroups (r:1 w:0) + // Storage: InterestAccrual Rates (r:1 w:0) + // Storage: Loans ActiveLoans (r:1 w:1) + // Storage: Timestamp Now (r:1 w:0) + // Storage: Loans PoolNAV (r:0 w:1) + /// The range of component `n` is `[1, 50]`. + /// The range of component `m` is `[1, 50]`. + fn update_nav(n: u32, m: u32, ) -> Weight { + // Minimum execution time: 130_302 nanoseconds. + Weight::from_ref_time(83_317_734 as u64) + // Standard Error: 27_700 + .saturating_add(Weight::from_ref_time(45_266_774 as u64).saturating_mul(n as u64)) + // Standard Error: 27_700 + .saturating_add(Weight::from_ref_time(374_824 as u64).saturating_mul(m as u64)) + .saturating_add(T::DbWeight::get().reads(4 as u64)) + .saturating_add(T::DbWeight::get().writes(2 as u64)) + } +} diff --git a/runtime/centrifuge/src/weights/pallet_migration_manager.rs b/runtime/centrifuge/src/weights/pallet_migration_manager.rs index 841769cba1..a427a8351e 100644 --- a/runtime/centrifuge/src/weights/pallet_migration_manager.rs +++ b/runtime/centrifuge/src/weights/pallet_migration_manager.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_migration_manager` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-01-12, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-03-22, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("centrifuge-dev"), DB CACHE: 1024 @@ -32,8 +32,8 @@ pub struct WeightInfo(PhantomData); impl pallet_migration_manager::WeightInfo for WeightInfo { // Storage: Migration Status (r:1 w:1) fn finalize() -> Weight { - // Minimum execution time: 34_701 nanoseconds. - Weight::from_ref_time(35_401_000 as u64) + // Minimum execution time: 35_799 nanoseconds. + Weight::from_ref_time(36_500_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } @@ -42,17 +42,17 @@ impl pallet_migration_manager::WeightInfo for WeightInf /// The range of component `n` is `[1, 100]`. fn migrate_system_account(n: u32, ) -> Weight { // Minimum execution time: 38_000 nanoseconds. - Weight::from_ref_time(39_617_178 as u64) - // Standard Error: 3_682 - .saturating_add(Weight::from_ref_time(1_437_267 as u64).saturating_mul(n as u64)) + Weight::from_ref_time(39_524_089 as u64) + // Standard Error: 7_234 + .saturating_add(Weight::from_ref_time(1_512_020 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) .saturating_add(T::DbWeight::get().writes((1 as u64).saturating_mul(n as u64))) } // Storage: Migration Status (r:1 w:1) fn migrate_balances_issuance() -> Weight { - // Minimum execution time: 40_101 nanoseconds. - Weight::from_ref_time(40_801_000 as u64) + // Minimum execution time: 48_201 nanoseconds. + Weight::from_ref_time(49_201_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } @@ -62,10 +62,10 @@ impl pallet_migration_manager::WeightInfo for WeightInf // Storage: System Account (r:1 w:1) /// The range of component `n` is `[1, 10]`. fn migrate_vesting_vesting(n: u32, ) -> Weight { - // Minimum execution time: 200_901 nanoseconds. - Weight::from_ref_time(177_051_473 as u64) - // Standard Error: 96_582 - .saturating_add(Weight::from_ref_time(41_073_946 as u64).saturating_mul(n as u64)) + // Minimum execution time: 237_602 nanoseconds. + Weight::from_ref_time(220_659_367 as u64) + // Standard Error: 137_812 + .saturating_add(Weight::from_ref_time(45_191_108 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().reads((3 as u64).saturating_mul(n as u64))) .saturating_add(T::DbWeight::get().writes(1 as u64)) @@ -75,10 +75,10 @@ impl pallet_migration_manager::WeightInfo for WeightInf // Storage: Proxy Proxies (r:0 w:1) /// The range of component `n` is `[1, 10]`. fn migrate_proxy_proxies(n: u32, ) -> Weight { - // Minimum execution time: 148_000 nanoseconds. - Weight::from_ref_time(150_194_685 as u64) - // Standard Error: 70_559 - .saturating_add(Weight::from_ref_time(8_326_988 as u64).saturating_mul(n as u64)) + // Minimum execution time: 175_001 nanoseconds. + Weight::from_ref_time(205_704_995 as u64) + // Standard Error: 119_696 + .saturating_add(Weight::from_ref_time(7_910_828 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) .saturating_add(T::DbWeight::get().writes((1 as u64).saturating_mul(n as u64))) diff --git a/runtime/centrifuge/src/weights/pallet_multisig.rs b/runtime/centrifuge/src/weights/pallet_multisig.rs index 683e5d4862..96703454ad 100644 --- a/runtime/centrifuge/src/weights/pallet_multisig.rs +++ b/runtime/centrifuge/src/weights/pallet_multisig.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_multisig` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-01-12, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-03-22, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("centrifuge-dev"), DB CACHE: 1024 @@ -32,22 +32,22 @@ pub struct WeightInfo(PhantomData); impl pallet_multisig::WeightInfo for WeightInfo { /// The range of component `z` is `[0, 10000]`. fn as_multi_threshold_1(z: u32, ) -> Weight { - // Minimum execution time: 33_200 nanoseconds. - Weight::from_ref_time(37_476_215 as u64) - // Standard Error: 19 - .saturating_add(Weight::from_ref_time(859 as u64).saturating_mul(z as u64)) + // Minimum execution time: 36_500 nanoseconds. + Weight::from_ref_time(38_885_179 as u64) + // Standard Error: 11 + .saturating_add(Weight::from_ref_time(720 as u64).saturating_mul(z as u64)) } // Storage: Multisig Multisigs (r:1 w:1) // Storage: unknown [0x3a65787472696e7369635f696e646578] (r:1 w:0) /// The range of component `s` is `[2, 100]`. /// The range of component `z` is `[0, 10000]`. fn as_multi_create(s: u32, z: u32, ) -> Weight { - // Minimum execution time: 87_300 nanoseconds. - Weight::from_ref_time(70_126_982 as u64) - // Standard Error: 1_787 - .saturating_add(Weight::from_ref_time(227_726 as u64).saturating_mul(s as u64)) - // Standard Error: 17 - .saturating_add(Weight::from_ref_time(2_061 as u64).saturating_mul(z as u64)) + // Minimum execution time: 88_900 nanoseconds. + Weight::from_ref_time(74_121_200 as u64) + // Standard Error: 4_049 + .saturating_add(Weight::from_ref_time(201_472 as u64).saturating_mul(s as u64)) + // Standard Error: 39 + .saturating_add(Weight::from_ref_time(2_022 as u64).saturating_mul(z as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } @@ -55,12 +55,12 @@ impl pallet_multisig::WeightInfo for WeightInfo { /// The range of component `s` is `[3, 100]`. /// The range of component `z` is `[0, 10000]`. fn as_multi_approve(s: u32, z: u32, ) -> Weight { - // Minimum execution time: 68_801 nanoseconds. - Weight::from_ref_time(50_560_515 as u64) - // Standard Error: 1_764 - .saturating_add(Weight::from_ref_time(212_170 as u64).saturating_mul(s as u64)) - // Standard Error: 17 - .saturating_add(Weight::from_ref_time(2_042 as u64).saturating_mul(z as u64)) + // Minimum execution time: 69_301 nanoseconds. + Weight::from_ref_time(51_326_096 as u64) + // Standard Error: 2_457 + .saturating_add(Weight::from_ref_time(221_776 as u64).saturating_mul(s as u64)) + // Standard Error: 24 + .saturating_add(Weight::from_ref_time(2_085 as u64).saturating_mul(z as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } @@ -69,12 +69,12 @@ impl pallet_multisig::WeightInfo for WeightInfo { /// The range of component `s` is `[2, 100]`. /// The range of component `z` is `[0, 10000]`. fn as_multi_complete(s: u32, z: u32, ) -> Weight { - // Minimum execution time: 90_101 nanoseconds. - Weight::from_ref_time(73_305_189 as u64) - // Standard Error: 1_816 - .saturating_add(Weight::from_ref_time(248_068 as u64).saturating_mul(s as u64)) - // Standard Error: 17 - .saturating_add(Weight::from_ref_time(2_138 as u64).saturating_mul(z as u64)) + // Minimum execution time: 93_101 nanoseconds. + Weight::from_ref_time(70_472_970 as u64) + // Standard Error: 2_702 + .saturating_add(Weight::from_ref_time(320_270 as u64).saturating_mul(s as u64)) + // Standard Error: 26 + .saturating_add(Weight::from_ref_time(2_499 as u64).saturating_mul(z as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } @@ -82,30 +82,30 @@ impl pallet_multisig::WeightInfo for WeightInfo { // Storage: unknown [0x3a65787472696e7369635f696e646578] (r:1 w:0) /// The range of component `s` is `[2, 100]`. fn approve_as_multi_create(s: u32, ) -> Weight { - // Minimum execution time: 64_100 nanoseconds. - Weight::from_ref_time(67_368_897 as u64) - // Standard Error: 3_462 - .saturating_add(Weight::from_ref_time(195_373 as u64).saturating_mul(s as u64)) + // Minimum execution time: 66_500 nanoseconds. + Weight::from_ref_time(69_063_614 as u64) + // Standard Error: 2_804 + .saturating_add(Weight::from_ref_time(221_996 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Multisig Multisigs (r:1 w:1) /// The range of component `s` is `[2, 100]`. fn approve_as_multi_approve(s: u32, ) -> Weight { - // Minimum execution time: 44_601 nanoseconds. - Weight::from_ref_time(46_825_041 as u64) - // Standard Error: 3_294 - .saturating_add(Weight::from_ref_time(219_857 as u64).saturating_mul(s as u64)) + // Minimum execution time: 46_801 nanoseconds. + Weight::from_ref_time(48_758_188 as u64) + // Standard Error: 1_857 + .saturating_add(Weight::from_ref_time(217_168 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Multisig Multisigs (r:1 w:1) /// The range of component `s` is `[2, 100]`. fn cancel_as_multi(s: u32, ) -> Weight { - // Minimum execution time: 63_101 nanoseconds. - Weight::from_ref_time(65_179_286 as u64) - // Standard Error: 1_432 - .saturating_add(Weight::from_ref_time(218_882 as u64).saturating_mul(s as u64)) + // Minimum execution time: 66_001 nanoseconds. + Weight::from_ref_time(69_037_727 as u64) + // Standard Error: 3_988 + .saturating_add(Weight::from_ref_time(208_119 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } diff --git a/runtime/centrifuge/src/weights/pallet_permissions.rs b/runtime/centrifuge/src/weights/pallet_permissions.rs new file mode 100644 index 0000000000..2031f15ec7 --- /dev/null +++ b/runtime/centrifuge/src/weights/pallet_permissions.rs @@ -0,0 +1,79 @@ + +//! Autogenerated weights for `pallet_permissions` +//! +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev +//! DATE: 2023-03-22, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` +//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("centrifuge-dev"), DB CACHE: 1024 + +// Executed Command: +// target/release/centrifuge-chain +// benchmark +// pallet +// --chain=centrifuge-dev +// --steps=50 +// --repeat=20 +// --pallet=pallet_permissions +// --extrinsic=* +// --execution=wasm +// --wasm-execution=compiled +// --heap-pages=4096 +// --output=/tmp/runtime/centrifuge/src/weights/pallet_permissions.rs + +#![cfg_attr(rustfmt, rustfmt_skip)] +#![allow(unused_parens)] +#![allow(unused_imports)] + +use frame_support::{traits::Get, weights::Weight}; +use sp_std::marker::PhantomData; + +/// Weight functions for `pallet_permissions`. +pub struct WeightInfo(PhantomData); +impl pallet_permissions::WeightInfo for WeightInfo { + // Storage: Permissions PermissionCount (r:1 w:1) + // Storage: Permissions Permission (r:1 w:1) + fn add_as_admin() -> Weight { + // Minimum execution time: 40_900 nanoseconds. + Weight::from_ref_time(41_501_000 as u64) + .saturating_add(T::DbWeight::get().reads(2 as u64)) + .saturating_add(T::DbWeight::get().writes(2 as u64)) + } + // Storage: Permissions Permission (r:2 w:1) + // Storage: Permissions PermissionCount (r:1 w:1) + fn add_as_editor() -> Weight { + // Minimum execution time: 51_000 nanoseconds. + Weight::from_ref_time(51_701_000 as u64) + .saturating_add(T::DbWeight::get().reads(3 as u64)) + .saturating_add(T::DbWeight::get().writes(2 as u64)) + } + // Storage: Permissions PermissionCount (r:1 w:1) + // Storage: Permissions Permission (r:1 w:1) + fn remove_as_admin() -> Weight { + // Minimum execution time: 44_700 nanoseconds. + Weight::from_ref_time(45_700_000 as u64) + .saturating_add(T::DbWeight::get().reads(2 as u64)) + .saturating_add(T::DbWeight::get().writes(2 as u64)) + } + // Storage: Permissions Permission (r:2 w:1) + // Storage: Permissions PermissionCount (r:1 w:1) + fn remove_as_editor() -> Weight { + // Minimum execution time: 54_101 nanoseconds. + Weight::from_ref_time(55_001_000 as u64) + .saturating_add(T::DbWeight::get().reads(3 as u64)) + .saturating_add(T::DbWeight::get().writes(2 as u64)) + } + // Storage: Permissions Permission (r:1 w:1) + fn purge() -> Weight { + // Minimum execution time: 40_600 nanoseconds. + Weight::from_ref_time(41_500_000 as u64) + .saturating_add(T::DbWeight::get().reads(1 as u64)) + .saturating_add(T::DbWeight::get().writes(1 as u64)) + } + // Storage: Permissions Permission (r:1 w:1) + fn admin_purge() -> Weight { + // Minimum execution time: 41_100 nanoseconds. + Weight::from_ref_time(41_700_000 as u64) + .saturating_add(T::DbWeight::get().reads(1 as u64)) + .saturating_add(T::DbWeight::get().writes(1 as u64)) + } +} diff --git a/runtime/centrifuge/src/weights/pallet_pool_registry.rs b/runtime/centrifuge/src/weights/pallet_pool_registry.rs new file mode 100644 index 0000000000..7c1af53c4f --- /dev/null +++ b/runtime/centrifuge/src/weights/pallet_pool_registry.rs @@ -0,0 +1,115 @@ + +//! Autogenerated weights for `pallet_pool_registry` +//! +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev +//! DATE: 2023-03-22, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` +//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("centrifuge-dev"), DB CACHE: 1024 + +// Executed Command: +// target/release/centrifuge-chain +// benchmark +// pallet +// --chain=centrifuge-dev +// --steps=50 +// --repeat=20 +// --pallet=pallet_pool_registry +// --extrinsic=* +// --execution=wasm +// --wasm-execution=compiled +// --heap-pages=4096 +// --output=/tmp/runtime/centrifuge/src/weights/pallet_pool_registry.rs + +#![cfg_attr(rustfmt, rustfmt_skip)] +#![allow(unused_parens)] +#![allow(unused_imports)] + +use frame_support::{traits::Get, weights::Weight}; +use sp_std::marker::PhantomData; + +/// Weight functions for `pallet_pool_registry`. +pub struct WeightInfo(PhantomData); +impl pallet_pool_registry::WeightInfo for WeightInfo { + // Storage: PoolRegistry Pools (r:1 w:1) + // Storage: PoolSystem Pool (r:1 w:1) + // Storage: System Account (r:1 w:1) + // Storage: PoolSystem AccountDeposit (r:1 w:1) + // Storage: Timestamp Now (r:1 w:0) + // Storage: OrmlAssetRegistry Metadata (r:2 w:1) + // Storage: ParachainInfo ParachainId (r:1 w:0) + // Storage: OrmlAssetRegistry LocationToAssetId (r:1 w:1) + // Storage: Permissions PermissionCount (r:1 w:1) + // Storage: Permissions Permission (r:1 w:1) + // Storage: PoolSystem PoolDeposit (r:0 w:1) + /// The range of component `n` is `[1, 5]`. + fn register(n: u32, ) -> Weight { + // Minimum execution time: 153_701 nanoseconds. + Weight::from_ref_time(130_621_961 as u64) + // Standard Error: 47_463 + .saturating_add(Weight::from_ref_time(27_412_623 as u64).saturating_mul(n as u64)) + .saturating_add(T::DbWeight::get().reads(9 as u64)) + .saturating_add(T::DbWeight::get().reads((2 as u64).saturating_mul(n as u64))) + .saturating_add(T::DbWeight::get().writes(7 as u64)) + .saturating_add(T::DbWeight::get().writes((2 as u64).saturating_mul(n as u64))) + } + // Storage: Permissions Permission (r:1 w:0) + // Storage: PoolSystem EpochExecution (r:1 w:0) + // Storage: PoolSystem Pool (r:1 w:0) + // Storage: Timestamp Now (r:1 w:0) + // Storage: Investments ActiveRedeemOrders (r:1 w:0) + // Storage: PoolSystem ScheduledUpdate (r:0 w:1) + /// The range of component `n` is `[1, 5]`. + fn update_no_execution(n: u32, ) -> Weight { + // Minimum execution time: 80_700 nanoseconds. + Weight::from_ref_time(79_392_700 as u64) + // Standard Error: 19_932 + .saturating_add(Weight::from_ref_time(3_055_725 as u64).saturating_mul(n as u64)) + .saturating_add(T::DbWeight::get().reads(4 as u64)) + .saturating_add(T::DbWeight::get().reads((1 as u64).saturating_mul(n as u64))) + .saturating_add(T::DbWeight::get().writes(1 as u64)) + } + // Storage: Permissions Permission (r:1 w:0) + // Storage: PoolSystem EpochExecution (r:1 w:0) + // Storage: PoolSystem Pool (r:1 w:1) + // Storage: Timestamp Now (r:1 w:0) + // Storage: Investments ActiveRedeemOrders (r:1 w:0) + // Storage: OrmlAssetRegistry Metadata (r:2 w:1) + // Storage: PoolSystem ScheduledUpdate (r:0 w:1) + /// The range of component `n` is `[1, 5]`. + fn update_and_execute(n: u32, ) -> Weight { + // Minimum execution time: 120_600 nanoseconds. + Weight::from_ref_time(114_181_198 as u64) + // Standard Error: 41_942 + .saturating_add(Weight::from_ref_time(9_471_671 as u64).saturating_mul(n as u64)) + .saturating_add(T::DbWeight::get().reads(6 as u64)) + .saturating_add(T::DbWeight::get().reads((1 as u64).saturating_mul(n as u64))) + .saturating_add(T::DbWeight::get().writes(3 as u64)) + } + // Storage: PoolSystem Pool (r:1 w:1) + // Storage: PoolSystem EpochExecution (r:1 w:0) + // Storage: PoolSystem ScheduledUpdate (r:1 w:1) + // Storage: Timestamp Now (r:1 w:0) + // Storage: Investments ActiveRedeemOrders (r:1 w:0) + // Storage: OrmlAssetRegistry Metadata (r:2 w:1) + /// The range of component `n` is `[1, 5]`. + fn execute_update(n: u32, ) -> Weight { + // Minimum execution time: 108_001 nanoseconds. + Weight::from_ref_time(100_506_669 as u64) + // Standard Error: 37_522 + .saturating_add(Weight::from_ref_time(9_769_407 as u64).saturating_mul(n as u64)) + .saturating_add(T::DbWeight::get().reads(6 as u64)) + .saturating_add(T::DbWeight::get().reads((1 as u64).saturating_mul(n as u64))) + .saturating_add(T::DbWeight::get().writes(3 as u64)) + } + // Storage: Permissions Permission (r:1 w:0) + // Storage: PoolRegistry PoolMetadata (r:0 w:1) + /// The range of component `n` is `[0, 46]`. + fn set_metadata(n: u32, ) -> Weight { + // Minimum execution time: 44_700 nanoseconds. + Weight::from_ref_time(46_564_432 as u64) + // Standard Error: 7_447 + .saturating_add(Weight::from_ref_time(12_968 as u64).saturating_mul(n as u64)) + .saturating_add(T::DbWeight::get().reads(1 as u64)) + .saturating_add(T::DbWeight::get().writes(1 as u64)) + } +} diff --git a/runtime/centrifuge/src/weights/pallet_pool_system.rs b/runtime/centrifuge/src/weights/pallet_pool_system.rs new file mode 100644 index 0000000000..7a960c5ac3 --- /dev/null +++ b/runtime/centrifuge/src/weights/pallet_pool_system.rs @@ -0,0 +1,150 @@ + +//! Autogenerated weights for `pallet_pool_system` +//! +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev +//! DATE: 2023-03-22, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` +//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("centrifuge-dev"), DB CACHE: 1024 + +// Executed Command: +// target/release/centrifuge-chain +// benchmark +// pallet +// --chain=centrifuge-dev +// --steps=50 +// --repeat=20 +// --pallet=pallet_pool_system +// --extrinsic=* +// --execution=wasm +// --wasm-execution=compiled +// --heap-pages=4096 +// --output=/tmp/runtime/centrifuge/src/weights/pallet_pool_system.rs + +#![cfg_attr(rustfmt, rustfmt_skip)] +#![allow(unused_parens)] +#![allow(unused_imports)] + +use frame_support::{traits::Get, weights::Weight}; +use sp_std::marker::PhantomData; + +/// Weight functions for `pallet_pool_system`. +pub struct WeightInfo(PhantomData); +impl pallet_pool_system::WeightInfo for WeightInfo { + // Storage: Permissions Permission (r:1 w:0) + // Storage: PoolSystem Pool (r:1 w:1) + fn set_max_reserve() -> Weight { + // Minimum execution time: 56_200 nanoseconds. + Weight::from_ref_time(56_900_000 as u64) + .saturating_add(T::DbWeight::get().reads(2 as u64)) + .saturating_add(T::DbWeight::get().writes(1 as u64)) + } + // Storage: PoolSystem Pool (r:1 w:1) + // Storage: PoolSystem EpochExecution (r:1 w:0) + // Storage: Timestamp Now (r:1 w:0) + // Storage: Loans PoolNAV (r:1 w:0) + // Storage: OrmlTokens TotalIssuance (r:1 w:0) + // Storage: Investments ActiveInvestOrders (r:1 w:1) + // Storage: Investments InProcessingInvestOrders (r:1 w:1) + // Storage: Investments InvestOrderId (r:1 w:1) + // Storage: Investments ActiveRedeemOrders (r:1 w:1) + // Storage: Investments InProcessingRedeemOrders (r:1 w:1) + // Storage: Investments RedeemOrderId (r:1 w:1) + // Storage: OrmlTokens Accounts (r:1 w:0) + // Storage: Investments ClearedInvestOrders (r:0 w:1) + // Storage: Investments ClearedRedeemOrders (r:0 w:1) + /// The range of component `n` is `[1, 5]`. + fn close_epoch_no_orders(n: u32, ) -> Weight { + // Minimum execution time: 182_601 nanoseconds. + Weight::from_ref_time(85_167_982 as u64) + // Standard Error: 140_693 + .saturating_add(Weight::from_ref_time(101_639_110 as u64).saturating_mul(n as u64)) + .saturating_add(T::DbWeight::get().reads(4 as u64)) + .saturating_add(T::DbWeight::get().reads((8 as u64).saturating_mul(n as u64))) + .saturating_add(T::DbWeight::get().writes(1 as u64)) + .saturating_add(T::DbWeight::get().writes((8 as u64).saturating_mul(n as u64))) + } + // Storage: PoolSystem Pool (r:1 w:1) + // Storage: PoolSystem EpochExecution (r:1 w:1) + // Storage: Timestamp Now (r:1 w:0) + // Storage: Loans PoolNAV (r:1 w:0) + // Storage: OrmlTokens TotalIssuance (r:1 w:0) + // Storage: Investments ActiveInvestOrders (r:1 w:1) + // Storage: Investments InProcessingInvestOrders (r:1 w:1) + // Storage: Investments InvestOrderId (r:1 w:1) + // Storage: Investments ActiveRedeemOrders (r:1 w:1) + // Storage: Investments InProcessingRedeemOrders (r:1 w:1) + // Storage: Investments RedeemOrderId (r:1 w:1) + /// The range of component `n` is `[1, 5]`. + fn close_epoch_no_execution(n: u32, ) -> Weight { + // Minimum execution time: 130_101 nanoseconds. + Weight::from_ref_time(89_571_176 as u64) + // Standard Error: 45_773 + .saturating_add(Weight::from_ref_time(43_623_255 as u64).saturating_mul(n as u64)) + .saturating_add(T::DbWeight::get().reads(4 as u64)) + .saturating_add(T::DbWeight::get().reads((7 as u64).saturating_mul(n as u64))) + .saturating_add(T::DbWeight::get().writes(2 as u64)) + .saturating_add(T::DbWeight::get().writes((6 as u64).saturating_mul(n as u64))) + } + // Storage: PoolSystem Pool (r:1 w:1) + // Storage: PoolSystem EpochExecution (r:1 w:0) + // Storage: Timestamp Now (r:1 w:0) + // Storage: Loans PoolNAV (r:1 w:0) + // Storage: OrmlTokens TotalIssuance (r:1 w:1) + // Storage: Investments ActiveInvestOrders (r:1 w:1) + // Storage: Investments InProcessingInvestOrders (r:1 w:1) + // Storage: Investments InvestOrderId (r:1 w:1) + // Storage: Investments ActiveRedeemOrders (r:1 w:1) + // Storage: Investments InProcessingRedeemOrders (r:1 w:1) + // Storage: Investments RedeemOrderId (r:1 w:1) + // Storage: OrmlTokens Accounts (r:3 w:3) + // Storage: System Account (r:2 w:2) + // Storage: Investments ClearedInvestOrders (r:0 w:1) + // Storage: Investments ClearedRedeemOrders (r:0 w:1) + /// The range of component `n` is `[1, 5]`. + fn close_epoch_execute(n: u32, ) -> Weight { + // Minimum execution time: 293_902 nanoseconds. + Weight::from_ref_time(200_363_518 as u64) + // Standard Error: 79_791 + .saturating_add(Weight::from_ref_time(103_612_030 as u64).saturating_mul(n as u64)) + .saturating_add(T::DbWeight::get().reads(8 as u64)) + .saturating_add(T::DbWeight::get().reads((8 as u64).saturating_mul(n as u64))) + .saturating_add(T::DbWeight::get().writes(7 as u64)) + .saturating_add(T::DbWeight::get().writes((8 as u64).saturating_mul(n as u64))) + } + // Storage: PoolSystem EpochExecution (r:1 w:1) + // Storage: PoolSystem Pool (r:1 w:0) + /// The range of component `n` is `[1, 5]`. + fn submit_solution(n: u32, ) -> Weight { + // Minimum execution time: 58_000 nanoseconds. + Weight::from_ref_time(57_087_548 as u64) + // Standard Error: 21_709 + .saturating_add(Weight::from_ref_time(2_821_394 as u64).saturating_mul(n as u64)) + .saturating_add(T::DbWeight::get().reads(2 as u64)) + .saturating_add(T::DbWeight::get().writes(1 as u64)) + } + // Storage: PoolSystem EpochExecution (r:1 w:1) + // Storage: PoolSystem Pool (r:1 w:1) + // Storage: Investments InProcessingInvestOrders (r:1 w:1) + // Storage: OrmlTokens Accounts (r:3 w:3) + // Storage: System Account (r:2 w:2) + // Storage: OrmlTokens TotalIssuance (r:1 w:1) + // Storage: Investments InvestOrderId (r:1 w:0) + // Storage: Investments ActiveInvestOrders (r:1 w:1) + // Storage: Investments InProcessingRedeemOrders (r:1 w:1) + // Storage: Investments RedeemOrderId (r:1 w:0) + // Storage: Investments ActiveRedeemOrders (r:1 w:1) + // Storage: Timestamp Now (r:1 w:0) + // Storage: Investments ClearedInvestOrders (r:0 w:1) + // Storage: Investments ClearedRedeemOrders (r:0 w:1) + /// The range of component `n` is `[1, 5]`. + fn execute_epoch(n: u32, ) -> Weight { + // Minimum execution time: 250_901 nanoseconds. + Weight::from_ref_time(178_608_862 as u64) + // Standard Error: 133_102 + .saturating_add(Weight::from_ref_time(75_793_573 as u64).saturating_mul(n as u64)) + .saturating_add(T::DbWeight::get().reads(8 as u64)) + .saturating_add(T::DbWeight::get().reads((7 as u64).saturating_mul(n as u64))) + .saturating_add(T::DbWeight::get().writes(8 as u64)) + .saturating_add(T::DbWeight::get().writes((6 as u64).saturating_mul(n as u64))) + } +} diff --git a/runtime/centrifuge/src/weights/pallet_preimage.rs b/runtime/centrifuge/src/weights/pallet_preimage.rs index 0891a196ad..4f82c3792a 100644 --- a/runtime/centrifuge/src/weights/pallet_preimage.rs +++ b/runtime/centrifuge/src/weights/pallet_preimage.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_preimage` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-01-12, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-03-22, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("centrifuge-dev"), DB CACHE: 1024 @@ -34,10 +34,10 @@ impl pallet_preimage::WeightInfo for WeightInfo { // Storage: Preimage PreimageFor (r:0 w:1) /// The range of component `s` is `[0, 4194304]`. fn note_preimage(s: u32, ) -> Weight { - // Minimum execution time: 59_600 nanoseconds. - Weight::from_ref_time(60_101_000 as u64) - // Standard Error: 1 - .saturating_add(Weight::from_ref_time(2_294 as u64).saturating_mul(s as u64)) + // Minimum execution time: 61_800 nanoseconds. + Weight::from_ref_time(62_501_000 as u64) + // Standard Error: 3 + .saturating_add(Weight::from_ref_time(2_507 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } @@ -45,10 +45,10 @@ impl pallet_preimage::WeightInfo for WeightInfo { // Storage: Preimage PreimageFor (r:0 w:1) /// The range of component `s` is `[0, 4194304]`. fn note_requested_preimage(s: u32, ) -> Weight { - // Minimum execution time: 41_400 nanoseconds. - Weight::from_ref_time(41_701_000 as u64) - // Standard Error: 1 - .saturating_add(Weight::from_ref_time(2_273 as u64).saturating_mul(s as u64)) + // Minimum execution time: 42_700 nanoseconds. + Weight::from_ref_time(43_000_000 as u64) + // Standard Error: 2 + .saturating_add(Weight::from_ref_time(2_448 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } @@ -56,76 +56,76 @@ impl pallet_preimage::WeightInfo for WeightInfo { // Storage: Preimage PreimageFor (r:0 w:1) /// The range of component `s` is `[0, 4194304]`. fn note_no_deposit_preimage(s: u32, ) -> Weight { - // Minimum execution time: 38_500 nanoseconds. - Weight::from_ref_time(39_000_000 as u64) - // Standard Error: 1 - .saturating_add(Weight::from_ref_time(2_285 as u64).saturating_mul(s as u64)) + // Minimum execution time: 40_200 nanoseconds. + Weight::from_ref_time(40_401_000 as u64) + // Standard Error: 2 + .saturating_add(Weight::from_ref_time(2_440 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } // Storage: Preimage StatusFor (r:1 w:1) // Storage: Preimage PreimageFor (r:0 w:1) fn unnote_preimage() -> Weight { - // Minimum execution time: 91_400 nanoseconds. - Weight::from_ref_time(95_501_000 as u64) + // Minimum execution time: 101_400 nanoseconds. + Weight::from_ref_time(111_301_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } // Storage: Preimage StatusFor (r:1 w:1) // Storage: Preimage PreimageFor (r:0 w:1) fn unnote_no_deposit_preimage() -> Weight { - // Minimum execution time: 64_901 nanoseconds. - Weight::from_ref_time(71_301_000 as u64) + // Minimum execution time: 82_601 nanoseconds. + Weight::from_ref_time(95_601_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } // Storage: Preimage StatusFor (r:1 w:1) fn request_preimage() -> Weight { - // Minimum execution time: 59_900 nanoseconds. - Weight::from_ref_time(66_300_000 as u64) + // Minimum execution time: 89_801 nanoseconds. + Weight::from_ref_time(95_201_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Preimage StatusFor (r:1 w:1) fn request_no_deposit_preimage() -> Weight { - // Minimum execution time: 35_400 nanoseconds. - Weight::from_ref_time(41_701_000 as u64) + // Minimum execution time: 53_100 nanoseconds. + Weight::from_ref_time(59_300_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Preimage StatusFor (r:1 w:1) fn request_unnoted_preimage() -> Weight { - // Minimum execution time: 39_501 nanoseconds. - Weight::from_ref_time(41_801_000 as u64) + // Minimum execution time: 52_000 nanoseconds. + Weight::from_ref_time(57_000_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Preimage StatusFor (r:1 w:1) fn request_requested_preimage() -> Weight { - // Minimum execution time: 19_800 nanoseconds. - Weight::from_ref_time(20_400_000 as u64) + // Minimum execution time: 20_900 nanoseconds. + Weight::from_ref_time(21_800_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Preimage StatusFor (r:1 w:1) // Storage: Preimage PreimageFor (r:0 w:1) fn unrequest_preimage() -> Weight { - // Minimum execution time: 61_000 nanoseconds. - Weight::from_ref_time(64_701_000 as u64) + // Minimum execution time: 76_001 nanoseconds. + Weight::from_ref_time(87_501_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } // Storage: Preimage StatusFor (r:1 w:1) fn unrequest_unnoted_preimage() -> Weight { - // Minimum execution time: 19_300 nanoseconds. - Weight::from_ref_time(20_101_000 as u64) + // Minimum execution time: 19_700 nanoseconds. + Weight::from_ref_time(20_600_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Preimage StatusFor (r:1 w:1) fn unrequest_multi_referenced_preimage() -> Weight { - // Minimum execution time: 19_000 nanoseconds. - Weight::from_ref_time(19_801_000 as u64) + // Minimum execution time: 20_100 nanoseconds. + Weight::from_ref_time(21_200_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } diff --git a/runtime/centrifuge/src/weights/pallet_proxy.rs b/runtime/centrifuge/src/weights/pallet_proxy.rs index 14bb961f0c..068dd6485e 100644 --- a/runtime/centrifuge/src/weights/pallet_proxy.rs +++ b/runtime/centrifuge/src/weights/pallet_proxy.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_proxy` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-01-12, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-03-22, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("centrifuge-dev"), DB CACHE: 1024 @@ -33,10 +33,10 @@ impl pallet_proxy::WeightInfo for WeightInfo { // Storage: Proxy Proxies (r:1 w:0) /// The range of component `p` is `[1, 31]`. fn proxy(p: u32, ) -> Weight { - // Minimum execution time: 42_000 nanoseconds. - Weight::from_ref_time(43_652_718 as u64) - // Standard Error: 10_860 - .saturating_add(Weight::from_ref_time(61_891 as u64).saturating_mul(p as u64)) + // Minimum execution time: 42_400 nanoseconds. + Weight::from_ref_time(43_926_662 as u64) + // Standard Error: 3_093 + .saturating_add(Weight::from_ref_time(74_366 as u64).saturating_mul(p as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) } // Storage: Proxy Proxies (r:1 w:0) @@ -45,12 +45,12 @@ impl pallet_proxy::WeightInfo for WeightInfo { /// The range of component `a` is `[0, 31]`. /// The range of component `p` is `[1, 31]`. fn proxy_announced(a: u32, p: u32, ) -> Weight { - // Minimum execution time: 76_700 nanoseconds. - Weight::from_ref_time(78_548_716 as u64) - // Standard Error: 5_930 - .saturating_add(Weight::from_ref_time(204_269 as u64).saturating_mul(a as u64)) - // Standard Error: 6_127 - .saturating_add(Weight::from_ref_time(61_477 as u64).saturating_mul(p as u64)) + // Minimum execution time: 79_000 nanoseconds. + Weight::from_ref_time(79_691_053 as u64) + // Standard Error: 4_663 + .saturating_add(Weight::from_ref_time(258_288 as u64).saturating_mul(a as u64)) + // Standard Error: 4_818 + .saturating_add(Weight::from_ref_time(71_358 as u64).saturating_mul(p as u64)) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } @@ -59,12 +59,12 @@ impl pallet_proxy::WeightInfo for WeightInfo { /// The range of component `a` is `[0, 31]`. /// The range of component `p` is `[1, 31]`. fn remove_announcement(a: u32, p: u32, ) -> Weight { - // Minimum execution time: 51_701 nanoseconds. - Weight::from_ref_time(53_016_384 as u64) - // Standard Error: 3_888 - .saturating_add(Weight::from_ref_time(286_356 as u64).saturating_mul(a as u64)) - // Standard Error: 4_017 - .saturating_add(Weight::from_ref_time(23_046 as u64).saturating_mul(p as u64)) + // Minimum execution time: 53_100 nanoseconds. + Weight::from_ref_time(55_559_154 as u64) + // Standard Error: 4_627 + .saturating_add(Weight::from_ref_time(263_035 as u64).saturating_mul(a as u64)) + // Standard Error: 4_780 + .saturating_add(Weight::from_ref_time(14_790 as u64).saturating_mul(p as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } @@ -73,12 +73,12 @@ impl pallet_proxy::WeightInfo for WeightInfo { /// The range of component `a` is `[0, 31]`. /// The range of component `p` is `[1, 31]`. fn reject_announcement(a: u32, p: u32, ) -> Weight { - // Minimum execution time: 51_700 nanoseconds. - Weight::from_ref_time(53_404_970 as u64) - // Standard Error: 4_922 - .saturating_add(Weight::from_ref_time(265_600 as u64).saturating_mul(a as u64)) - // Standard Error: 5_085 - .saturating_add(Weight::from_ref_time(26_356 as u64).saturating_mul(p as u64)) + // Minimum execution time: 52_400 nanoseconds. + Weight::from_ref_time(54_486_188 as u64) + // Standard Error: 5_056 + .saturating_add(Weight::from_ref_time(285_431 as u64).saturating_mul(a as u64)) + // Standard Error: 5_224 + .saturating_add(Weight::from_ref_time(40_751 as u64).saturating_mul(p as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } @@ -88,61 +88,63 @@ impl pallet_proxy::WeightInfo for WeightInfo { /// The range of component `a` is `[0, 31]`. /// The range of component `p` is `[1, 31]`. fn announce(a: u32, p: u32, ) -> Weight { - // Minimum execution time: 67_300 nanoseconds. - Weight::from_ref_time(68_589_538 as u64) - // Standard Error: 3_114 - .saturating_add(Weight::from_ref_time(254_680 as u64).saturating_mul(a as u64)) - // Standard Error: 3_218 - .saturating_add(Weight::from_ref_time(76_254 as u64).saturating_mul(p as u64)) + // Minimum execution time: 69_900 nanoseconds. + Weight::from_ref_time(74_953_492 as u64) + // Standard Error: 14_621 + .saturating_add(Weight::from_ref_time(161_849 as u64).saturating_mul(a as u64)) + // Standard Error: 15_106 + .saturating_add(Weight::from_ref_time(40_496 as u64).saturating_mul(p as u64)) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } // Storage: Proxy Proxies (r:1 w:1) /// The range of component `p` is `[1, 31]`. fn add_proxy(p: u32, ) -> Weight { - // Minimum execution time: 56_701 nanoseconds. - Weight::from_ref_time(58_228_297 as u64) - // Standard Error: 2_350 - .saturating_add(Weight::from_ref_time(107_893 as u64).saturating_mul(p as u64)) + // Minimum execution time: 59_001 nanoseconds. + Weight::from_ref_time(60_103_703 as u64) + // Standard Error: 5_775 + .saturating_add(Weight::from_ref_time(131_225 as u64).saturating_mul(p as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Proxy Proxies (r:1 w:1) /// The range of component `p` is `[1, 31]`. fn remove_proxy(p: u32, ) -> Weight { - // Minimum execution time: 56_001 nanoseconds. - Weight::from_ref_time(59_784_331 as u64) - // Standard Error: 49_161 - .saturating_add(Weight::from_ref_time(193_316 as u64).saturating_mul(p as u64)) + // Minimum execution time: 58_201 nanoseconds. + Weight::from_ref_time(62_360_424 as u64) + // Standard Error: 10_934 + .saturating_add(Weight::from_ref_time(52_492 as u64).saturating_mul(p as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Proxy Proxies (r:1 w:1) /// The range of component `p` is `[1, 31]`. fn remove_proxies(p: u32, ) -> Weight { - // Minimum execution time: 49_001 nanoseconds. - Weight::from_ref_time(50_401_197 as u64) - // Standard Error: 9_392 - .saturating_add(Weight::from_ref_time(62_430 as u64).saturating_mul(p as u64)) + // Minimum execution time: 49_700 nanoseconds. + Weight::from_ref_time(51_609_645 as u64) + // Standard Error: 1_983 + .saturating_add(Weight::from_ref_time(86_869 as u64).saturating_mul(p as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: unknown [0x3a65787472696e7369635f696e646578] (r:1 w:0) // Storage: Proxy Proxies (r:1 w:1) /// The range of component `p` is `[1, 31]`. - fn create_pure(_p: u32, ) -> Weight { - // Minimum execution time: 61_501 nanoseconds. - Weight::from_ref_time(64_701_684 as u64) + fn create_pure(p: u32, ) -> Weight { + // Minimum execution time: 60_800 nanoseconds. + Weight::from_ref_time(64_937_851 as u64) + // Standard Error: 8_139 + .saturating_add(Weight::from_ref_time(67_749 as u64).saturating_mul(p as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Proxy Proxies (r:1 w:1) /// The range of component `p` is `[0, 30]`. fn kill_pure(p: u32, ) -> Weight { - // Minimum execution time: 50_900 nanoseconds. - Weight::from_ref_time(52_222_356 as u64) - // Standard Error: 9_741 - .saturating_add(Weight::from_ref_time(95_010 as u64).saturating_mul(p as u64)) + // Minimum execution time: 51_500 nanoseconds. + Weight::from_ref_time(53_565_592 as u64) + // Standard Error: 3_139 + .saturating_add(Weight::from_ref_time(89_977 as u64).saturating_mul(p as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } diff --git a/runtime/centrifuge/src/weights/pallet_restricted_tokens.rs b/runtime/centrifuge/src/weights/pallet_restricted_tokens.rs new file mode 100644 index 0000000000..fbd7eb469f --- /dev/null +++ b/runtime/centrifuge/src/weights/pallet_restricted_tokens.rs @@ -0,0 +1,109 @@ + +//! Autogenerated weights for `pallet_restricted_tokens` +//! +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev +//! DATE: 2023-03-22, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` +//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("centrifuge-dev"), DB CACHE: 1024 + +// Executed Command: +// target/release/centrifuge-chain +// benchmark +// pallet +// --chain=centrifuge-dev +// --steps=50 +// --repeat=20 +// --pallet=pallet_restricted_tokens +// --extrinsic=* +// --execution=wasm +// --wasm-execution=compiled +// --heap-pages=4096 +// --output=/tmp/runtime/centrifuge/src/weights/pallet_restricted_tokens.rs + +#![cfg_attr(rustfmt, rustfmt_skip)] +#![allow(unused_parens)] +#![allow(unused_imports)] + +use frame_support::{traits::Get, weights::Weight}; +use sp_std::marker::PhantomData; + +/// Weight functions for `pallet_restricted_tokens`. +pub struct WeightInfo(PhantomData); +impl pallet_restricted_tokens::WeightInfo for WeightInfo { + // Storage: System Account (r:1 w:1) + fn transfer_native() -> Weight { + // Minimum execution time: 82_100 nanoseconds. + Weight::from_ref_time(82_900_000 as u64) + .saturating_add(T::DbWeight::get().reads(1 as u64)) + .saturating_add(T::DbWeight::get().writes(1 as u64)) + } + // Storage: OrmlTokens Accounts (r:2 w:2) + // Storage: System Account (r:1 w:1) + fn transfer_other() -> Weight { + // Minimum execution time: 87_000 nanoseconds. + Weight::from_ref_time(88_101_000 as u64) + .saturating_add(T::DbWeight::get().reads(3 as u64)) + .saturating_add(T::DbWeight::get().writes(3 as u64)) + } + // Storage: System Account (r:1 w:1) + fn transfer_keep_alive_native() -> Weight { + // Minimum execution time: 74_901 nanoseconds. + Weight::from_ref_time(75_501_000 as u64) + .saturating_add(T::DbWeight::get().reads(1 as u64)) + .saturating_add(T::DbWeight::get().writes(1 as u64)) + } + // Storage: OrmlTokens Accounts (r:2 w:2) + // Storage: System Account (r:1 w:1) + fn transfer_keep_alive_other() -> Weight { + // Minimum execution time: 81_000 nanoseconds. + Weight::from_ref_time(82_101_000 as u64) + .saturating_add(T::DbWeight::get().reads(3 as u64)) + .saturating_add(T::DbWeight::get().writes(3 as u64)) + } + // Storage: System Account (r:1 w:1) + fn transfer_all_native() -> Weight { + // Minimum execution time: 86_600 nanoseconds. + Weight::from_ref_time(87_801_000 as u64) + .saturating_add(T::DbWeight::get().reads(1 as u64)) + .saturating_add(T::DbWeight::get().writes(1 as u64)) + } + // Storage: OrmlTokens Accounts (r:2 w:2) + // Storage: System Account (r:1 w:1) + fn transfer_all_other() -> Weight { + // Minimum execution time: 91_400 nanoseconds. + Weight::from_ref_time(92_800_000 as u64) + .saturating_add(T::DbWeight::get().reads(3 as u64)) + .saturating_add(T::DbWeight::get().writes(3 as u64)) + } + // Storage: System Account (r:1 w:1) + fn force_transfer_native() -> Weight { + // Minimum execution time: 81_600 nanoseconds. + Weight::from_ref_time(82_601_000 as u64) + .saturating_add(T::DbWeight::get().reads(1 as u64)) + .saturating_add(T::DbWeight::get().writes(1 as u64)) + } + // Storage: OrmlTokens Accounts (r:2 w:2) + // Storage: System Account (r:1 w:1) + fn force_transfer_other() -> Weight { + // Minimum execution time: 86_200 nanoseconds. + Weight::from_ref_time(88_000_000 as u64) + .saturating_add(T::DbWeight::get().reads(3 as u64)) + .saturating_add(T::DbWeight::get().writes(3 as u64)) + } + // Storage: System Account (r:1 w:1) + fn set_balance_native() -> Weight { + // Minimum execution time: 85_401 nanoseconds. + Weight::from_ref_time(86_501_000 as u64) + .saturating_add(T::DbWeight::get().reads(1 as u64)) + .saturating_add(T::DbWeight::get().writes(1 as u64)) + } + // Storage: OrmlTokens Accounts (r:1 w:1) + // Storage: OrmlTokens TotalIssuance (r:1 w:1) + // Storage: System Account (r:1 w:1) + fn set_balance_other() -> Weight { + // Minimum execution time: 98_601 nanoseconds. + Weight::from_ref_time(99_700_000 as u64) + .saturating_add(T::DbWeight::get().reads(3 as u64)) + .saturating_add(T::DbWeight::get().writes(3 as u64)) + } +} diff --git a/runtime/centrifuge/src/weights/pallet_scheduler.rs b/runtime/centrifuge/src/weights/pallet_scheduler.rs index 6272cfdeb6..792d2623fe 100644 --- a/runtime/centrifuge/src/weights/pallet_scheduler.rs +++ b/runtime/centrifuge/src/weights/pallet_scheduler.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_scheduler` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-01-12, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-03-22, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("centrifuge-dev"), DB CACHE: 1024 @@ -32,61 +32,61 @@ pub struct WeightInfo(PhantomData); impl pallet_scheduler::WeightInfo for WeightInfo { // Storage: Scheduler IncompleteSince (r:1 w:1) fn service_agendas_base() -> Weight { - // Minimum execution time: 8_700 nanoseconds. - Weight::from_ref_time(8_900_000 as u64) + // Minimum execution time: 8_900 nanoseconds. + Weight::from_ref_time(9_300_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Scheduler Agenda (r:1 w:1) /// The range of component `s` is `[0, 50]`. fn service_agenda_base(s: u32, ) -> Weight { - // Minimum execution time: 7_800 nanoseconds. - Weight::from_ref_time(15_251_915 as u64) - // Standard Error: 4_739 - .saturating_add(Weight::from_ref_time(1_054_768 as u64).saturating_mul(s as u64)) + // Minimum execution time: 8_200 nanoseconds. + Weight::from_ref_time(15_762_428 as u64) + // Standard Error: 4_574 + .saturating_add(Weight::from_ref_time(1_048_040 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } fn service_task_base() -> Weight { - // Minimum execution time: 25_000 nanoseconds. - Weight::from_ref_time(25_400_000 as u64) + // Minimum execution time: 19_100 nanoseconds. + Weight::from_ref_time(19_400_000 as u64) } // Storage: Preimage PreimageFor (r:1 w:1) // Storage: Preimage StatusFor (r:1 w:1) /// The range of component `s` is `[128, 4194304]`. fn service_task_fetched(s: u32, ) -> Weight { - // Minimum execution time: 43_600 nanoseconds. - Weight::from_ref_time(43_701_000 as u64) - // Standard Error: 2 - .saturating_add(Weight::from_ref_time(1_632 as u64).saturating_mul(s as u64)) + // Minimum execution time: 44_200 nanoseconds. + Weight::from_ref_time(44_500_000 as u64) + // Standard Error: 4 + .saturating_add(Weight::from_ref_time(1_697 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } // Storage: Scheduler Lookup (r:0 w:1) fn service_task_named() -> Weight { - // Minimum execution time: 21_900 nanoseconds. - Weight::from_ref_time(22_301_000 as u64) + // Minimum execution time: 21_600 nanoseconds. + Weight::from_ref_time(22_700_000 as u64) .saturating_add(T::DbWeight::get().writes(1 as u64)) } fn service_task_periodic() -> Weight { - // Minimum execution time: 18_900 nanoseconds. - Weight::from_ref_time(19_201_000 as u64) + // Minimum execution time: 17_600 nanoseconds. + Weight::from_ref_time(19_400_000 as u64) } fn execute_dispatch_signed() -> Weight { - // Minimum execution time: 9_300 nanoseconds. - Weight::from_ref_time(9_500_000 as u64) + // Minimum execution time: 8_700 nanoseconds. + Weight::from_ref_time(9_300_000 as u64) } fn execute_dispatch_unsigned() -> Weight { - // Minimum execution time: 9_200 nanoseconds. - Weight::from_ref_time(9_400_000 as u64) + // Minimum execution time: 9_400 nanoseconds. + Weight::from_ref_time(9_700_000 as u64) } // Storage: Scheduler Agenda (r:1 w:1) /// The range of component `s` is `[0, 49]`. fn schedule(s: u32, ) -> Weight { - // Minimum execution time: 35_000 nanoseconds. - Weight::from_ref_time(43_464_233 as u64) - // Standard Error: 9_994 - .saturating_add(Weight::from_ref_time(1_076_173 as u64).saturating_mul(s as u64)) + // Minimum execution time: 32_600 nanoseconds. + Weight::from_ref_time(49_825_420 as u64) + // Standard Error: 23_539 + .saturating_add(Weight::from_ref_time(902_679 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } @@ -94,10 +94,10 @@ impl pallet_scheduler::WeightInfo for WeightInfo { // Storage: Scheduler Lookup (r:0 w:1) /// The range of component `s` is `[1, 50]`. fn cancel(s: u32, ) -> Weight { - // Minimum execution time: 38_900 nanoseconds. - Weight::from_ref_time(42_002_840 as u64) - // Standard Error: 7_015 - .saturating_add(Weight::from_ref_time(1_085_938 as u64).saturating_mul(s as u64)) + // Minimum execution time: 40_000 nanoseconds. + Weight::from_ref_time(43_216_468 as u64) + // Standard Error: 4_672 + .saturating_add(Weight::from_ref_time(1_064_635 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } @@ -105,10 +105,10 @@ impl pallet_scheduler::WeightInfo for WeightInfo { // Storage: Scheduler Agenda (r:1 w:1) /// The range of component `s` is `[0, 49]`. fn schedule_named(s: u32, ) -> Weight { - // Minimum execution time: 40_401 nanoseconds. - Weight::from_ref_time(49_499_682 as u64) - // Standard Error: 10_101 - .saturating_add(Weight::from_ref_time(1_146_865 as u64).saturating_mul(s as u64)) + // Minimum execution time: 41_400 nanoseconds. + Weight::from_ref_time(50_423_549 as u64) + // Standard Error: 8_770 + .saturating_add(Weight::from_ref_time(1_138_627 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } @@ -116,10 +116,10 @@ impl pallet_scheduler::WeightInfo for WeightInfo { // Storage: Scheduler Agenda (r:1 w:1) /// The range of component `s` is `[1, 50]`. fn cancel_named(s: u32, ) -> Weight { - // Minimum execution time: 41_301 nanoseconds. - Weight::from_ref_time(45_488_912 as u64) - // Standard Error: 5_946 - .saturating_add(Weight::from_ref_time(1_120_735 as u64).saturating_mul(s as u64)) + // Minimum execution time: 42_100 nanoseconds. + Weight::from_ref_time(45_976_767 as u64) + // Standard Error: 4_769 + .saturating_add(Weight::from_ref_time(1_116_536 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } diff --git a/runtime/centrifuge/src/weights/pallet_timestamp.rs b/runtime/centrifuge/src/weights/pallet_timestamp.rs index 062120c089..124e09e19f 100644 --- a/runtime/centrifuge/src/weights/pallet_timestamp.rs +++ b/runtime/centrifuge/src/weights/pallet_timestamp.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_timestamp` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-01-12, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-03-22, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("centrifuge-dev"), DB CACHE: 1024 @@ -33,13 +33,13 @@ impl pallet_timestamp::WeightInfo for WeightInfo { // Storage: Timestamp Now (r:1 w:1) // Storage: Aura CurrentSlot (r:1 w:0) fn set() -> Weight { - // Minimum execution time: 19_600 nanoseconds. - Weight::from_ref_time(20_300_000 as u64) + // Minimum execution time: 26_801 nanoseconds. + Weight::from_ref_time(27_500_000 as u64) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } fn on_finalize() -> Weight { - // Minimum execution time: 8_700 nanoseconds. - Weight::from_ref_time(8_901_000 as u64) + // Minimum execution time: 9_100 nanoseconds. + Weight::from_ref_time(9_201_000 as u64) } } diff --git a/runtime/centrifuge/src/weights/pallet_treasury.rs b/runtime/centrifuge/src/weights/pallet_treasury.rs index e02ee7afe4..23b40b05d3 100644 --- a/runtime/centrifuge/src/weights/pallet_treasury.rs +++ b/runtime/centrifuge/src/weights/pallet_treasury.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_treasury` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-01-12, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-03-22, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("centrifuge-dev"), DB CACHE: 1024 @@ -32,21 +32,21 @@ pub struct WeightInfo(PhantomData); impl pallet_treasury::WeightInfo for WeightInfo { fn spend() -> Weight { // Minimum execution time: 400 nanoseconds. - Weight::from_ref_time(500_000 as u64) + Weight::from_ref_time(400_000 as u64) } // Storage: Treasury ProposalCount (r:1 w:1) // Storage: Treasury Proposals (r:0 w:1) fn propose_spend() -> Weight { - // Minimum execution time: 56_100 nanoseconds. - Weight::from_ref_time(57_000_000 as u64) + // Minimum execution time: 57_200 nanoseconds. + Weight::from_ref_time(58_500_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } // Storage: Treasury Proposals (r:1 w:1) // Storage: System Account (r:2 w:2) fn reject_proposal() -> Weight { - // Minimum execution time: 79_001 nanoseconds. - Weight::from_ref_time(80_100_000 as u64) + // Minimum execution time: 81_301 nanoseconds. + Weight::from_ref_time(82_600_000 as u64) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -54,17 +54,17 @@ impl pallet_treasury::WeightInfo for WeightInfo { // Storage: Treasury Approvals (r:1 w:1) /// The range of component `p` is `[0, 99]`. fn approve_proposal(p: u32, ) -> Weight { - // Minimum execution time: 21_900 nanoseconds. - Weight::from_ref_time(28_324_723 as u64) - // Standard Error: 2_765 - .saturating_add(Weight::from_ref_time(255_236 as u64).saturating_mul(p as u64)) + // Minimum execution time: 22_900 nanoseconds. + Weight::from_ref_time(30_793_836 as u64) + // Standard Error: 4_582 + .saturating_add(Weight::from_ref_time(210_204 as u64).saturating_mul(p as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Treasury Approvals (r:1 w:1) fn remove_approval() -> Weight { - // Minimum execution time: 18_500 nanoseconds. - Weight::from_ref_time(19_200_000 as u64) + // Minimum execution time: 19_199 nanoseconds. + Weight::from_ref_time(19_600_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } @@ -73,10 +73,10 @@ impl pallet_treasury::WeightInfo for WeightInfo { // Storage: Treasury Proposals (r:2 w:0) /// The range of component `p` is `[0, 100]`. fn on_initialize_proposals(p: u32, ) -> Weight { - // Minimum execution time: 50_701 nanoseconds. - Weight::from_ref_time(45_597_648 as u64) - // Standard Error: 8_961 - .saturating_add(Weight::from_ref_time(4_098_391 as u64).saturating_mul(p as u64)) + // Minimum execution time: 49_000 nanoseconds. + Weight::from_ref_time(48_851_589 as u64) + // Standard Error: 6_408 + .saturating_add(Weight::from_ref_time(4_139_638 as u64).saturating_mul(p as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().reads((1 as u64).saturating_mul(p as u64))) .saturating_add(T::DbWeight::get().writes(1 as u64)) diff --git a/runtime/centrifuge/src/weights/pallet_uniques.rs b/runtime/centrifuge/src/weights/pallet_uniques.rs new file mode 100644 index 0000000000..6d6077faf6 --- /dev/null +++ b/runtime/centrifuge/src/weights/pallet_uniques.rs @@ -0,0 +1,272 @@ + +//! Autogenerated weights for `pallet_uniques` +//! +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev +//! DATE: 2023-03-22, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` +//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("centrifuge-dev"), DB CACHE: 1024 + +// Executed Command: +// target/release/centrifuge-chain +// benchmark +// pallet +// --chain=centrifuge-dev +// --steps=50 +// --repeat=20 +// --pallet=pallet_uniques +// --extrinsic=* +// --execution=wasm +// --wasm-execution=compiled +// --heap-pages=4096 +// --output=/tmp/runtime/centrifuge/src/weights/pallet_uniques.rs + +#![cfg_attr(rustfmt, rustfmt_skip)] +#![allow(unused_parens)] +#![allow(unused_imports)] + +use frame_support::{traits::Get, weights::Weight}; +use sp_std::marker::PhantomData; + +/// Weight functions for `pallet_uniques`. +pub struct WeightInfo(PhantomData); +impl pallet_uniques::WeightInfo for WeightInfo { + // Storage: Uniques Class (r:1 w:1) + // Storage: Uniques ClassAccount (r:0 w:1) + fn create() -> Weight { + // Minimum execution time: 60_400 nanoseconds. + Weight::from_ref_time(61_000_000 as u64) + .saturating_add(T::DbWeight::get().reads(1 as u64)) + .saturating_add(T::DbWeight::get().writes(2 as u64)) + } + // Storage: Uniques Class (r:1 w:1) + // Storage: Uniques ClassAccount (r:0 w:1) + fn force_create() -> Weight { + // Minimum execution time: 37_900 nanoseconds. + Weight::from_ref_time(38_800_000 as u64) + .saturating_add(T::DbWeight::get().reads(1 as u64)) + .saturating_add(T::DbWeight::get().writes(2 as u64)) + } + // Storage: Uniques Class (r:1 w:1) + // Storage: Uniques Asset (r:1 w:0) + // Storage: Uniques ClassAccount (r:0 w:1) + // Storage: Uniques Attribute (r:0 w:1000) + // Storage: Uniques ClassMetadataOf (r:0 w:1) + // Storage: Uniques InstanceMetadataOf (r:0 w:1000) + // Storage: Uniques CollectionMaxSupply (r:0 w:1) + // Storage: Uniques Account (r:0 w:20) + /// The range of component `n` is `[0, 1000]`. + /// The range of component `m` is `[0, 1000]`. + /// The range of component `a` is `[0, 1000]`. + fn destroy(n: u32, m: u32, a: u32, ) -> Weight { + // Minimum execution time: 4_248_015 nanoseconds. + Weight::from_ref_time(4_313_915_000 as u64) + // Standard Error: 59_146 + .saturating_add(Weight::from_ref_time(17_747_711 as u64).saturating_mul(n as u64)) + // Standard Error: 59_146 + .saturating_add(Weight::from_ref_time(581_513 as u64).saturating_mul(m as u64)) + // Standard Error: 59_146 + .saturating_add(Weight::from_ref_time(809_617 as u64).saturating_mul(a as u64)) + .saturating_add(T::DbWeight::get().reads(2 as u64)) + .saturating_add(T::DbWeight::get().reads((1 as u64).saturating_mul(n as u64))) + .saturating_add(T::DbWeight::get().writes(4 as u64)) + .saturating_add(T::DbWeight::get().writes((2 as u64).saturating_mul(n as u64))) + .saturating_add(T::DbWeight::get().writes((1 as u64).saturating_mul(m as u64))) + .saturating_add(T::DbWeight::get().writes((1 as u64).saturating_mul(a as u64))) + } + // Storage: Uniques Asset (r:1 w:1) + // Storage: Uniques Class (r:1 w:1) + // Storage: Uniques CollectionMaxSupply (r:1 w:0) + // Storage: Uniques Account (r:0 w:1) + fn mint() -> Weight { + // Minimum execution time: 74_400 nanoseconds. + Weight::from_ref_time(75_500_000 as u64) + .saturating_add(T::DbWeight::get().reads(3 as u64)) + .saturating_add(T::DbWeight::get().writes(3 as u64)) + } + // Storage: Uniques Class (r:1 w:1) + // Storage: Uniques Asset (r:1 w:1) + // Storage: Uniques Account (r:0 w:1) + // Storage: Uniques ItemPriceOf (r:0 w:1) + fn burn() -> Weight { + // Minimum execution time: 78_000 nanoseconds. + Weight::from_ref_time(79_001_000 as u64) + .saturating_add(T::DbWeight::get().reads(2 as u64)) + .saturating_add(T::DbWeight::get().writes(4 as u64)) + } + // Storage: Uniques Class (r:1 w:0) + // Storage: Uniques Asset (r:1 w:1) + // Storage: Uniques Account (r:0 w:2) + // Storage: Uniques ItemPriceOf (r:0 w:1) + fn transfer() -> Weight { + // Minimum execution time: 61_100 nanoseconds. + Weight::from_ref_time(61_700_000 as u64) + .saturating_add(T::DbWeight::get().reads(2 as u64)) + .saturating_add(T::DbWeight::get().writes(4 as u64)) + } + // Storage: Uniques Class (r:1 w:1) + // Storage: Uniques Asset (r:102 w:102) + /// The range of component `i` is `[0, 5000]`. + fn redeposit(i: u32, ) -> Weight { + // Minimum execution time: 39_101 nanoseconds. + Weight::from_ref_time(39_501_000 as u64) + // Standard Error: 18_907 + .saturating_add(Weight::from_ref_time(23_594_077 as u64).saturating_mul(i as u64)) + .saturating_add(T::DbWeight::get().reads(1 as u64)) + .saturating_add(T::DbWeight::get().reads((1 as u64).saturating_mul(i as u64))) + .saturating_add(T::DbWeight::get().writes(1 as u64)) + .saturating_add(T::DbWeight::get().writes((1 as u64).saturating_mul(i as u64))) + } + // Storage: Uniques Asset (r:1 w:1) + // Storage: Uniques Class (r:1 w:0) + fn freeze() -> Weight { + // Minimum execution time: 46_101 nanoseconds. + Weight::from_ref_time(46_701_000 as u64) + .saturating_add(T::DbWeight::get().reads(2 as u64)) + .saturating_add(T::DbWeight::get().writes(1 as u64)) + } + // Storage: Uniques Asset (r:1 w:1) + // Storage: Uniques Class (r:1 w:0) + fn thaw() -> Weight { + // Minimum execution time: 46_001 nanoseconds. + Weight::from_ref_time(46_501_000 as u64) + .saturating_add(T::DbWeight::get().reads(2 as u64)) + .saturating_add(T::DbWeight::get().writes(1 as u64)) + } + // Storage: Uniques Class (r:1 w:1) + fn freeze_collection() -> Weight { + // Minimum execution time: 37_101 nanoseconds. + Weight::from_ref_time(37_800_000 as u64) + .saturating_add(T::DbWeight::get().reads(1 as u64)) + .saturating_add(T::DbWeight::get().writes(1 as u64)) + } + // Storage: Uniques Class (r:1 w:1) + fn thaw_collection() -> Weight { + // Minimum execution time: 37_300 nanoseconds. + Weight::from_ref_time(37_800_000 as u64) + .saturating_add(T::DbWeight::get().reads(1 as u64)) + .saturating_add(T::DbWeight::get().writes(1 as u64)) + } + // Storage: Uniques OwnershipAcceptance (r:1 w:1) + // Storage: Uniques Class (r:1 w:1) + // Storage: Uniques ClassAccount (r:0 w:2) + fn transfer_ownership() -> Weight { + // Minimum execution time: 51_900 nanoseconds. + Weight::from_ref_time(52_401_000 as u64) + .saturating_add(T::DbWeight::get().reads(2 as u64)) + .saturating_add(T::DbWeight::get().writes(4 as u64)) + } + // Storage: Uniques Class (r:1 w:1) + fn set_team() -> Weight { + // Minimum execution time: 38_301 nanoseconds. + Weight::from_ref_time(39_101_000 as u64) + .saturating_add(T::DbWeight::get().reads(1 as u64)) + .saturating_add(T::DbWeight::get().writes(1 as u64)) + } + // Storage: Uniques Class (r:1 w:1) + // Storage: Uniques ClassAccount (r:0 w:1) + fn force_item_status() -> Weight { + // Minimum execution time: 42_700 nanoseconds. + Weight::from_ref_time(43_401_000 as u64) + .saturating_add(T::DbWeight::get().reads(1 as u64)) + .saturating_add(T::DbWeight::get().writes(2 as u64)) + } + // Storage: Uniques Class (r:1 w:1) + // Storage: Uniques InstanceMetadataOf (r:1 w:0) + // Storage: Uniques Attribute (r:1 w:1) + fn set_attribute() -> Weight { + // Minimum execution time: 88_301 nanoseconds. + Weight::from_ref_time(89_601_000 as u64) + .saturating_add(T::DbWeight::get().reads(3 as u64)) + .saturating_add(T::DbWeight::get().writes(2 as u64)) + } + // Storage: Uniques Class (r:1 w:1) + // Storage: Uniques InstanceMetadataOf (r:1 w:0) + // Storage: Uniques Attribute (r:1 w:1) + fn clear_attribute() -> Weight { + // Minimum execution time: 87_102 nanoseconds. + Weight::from_ref_time(88_401_000 as u64) + .saturating_add(T::DbWeight::get().reads(3 as u64)) + .saturating_add(T::DbWeight::get().writes(2 as u64)) + } + // Storage: Uniques Class (r:1 w:1) + // Storage: Uniques InstanceMetadataOf (r:1 w:1) + fn set_metadata() -> Weight { + // Minimum execution time: 68_401 nanoseconds. + Weight::from_ref_time(69_401_000 as u64) + .saturating_add(T::DbWeight::get().reads(2 as u64)) + .saturating_add(T::DbWeight::get().writes(2 as u64)) + } + // Storage: Uniques Class (r:1 w:1) + // Storage: Uniques InstanceMetadataOf (r:1 w:1) + fn clear_metadata() -> Weight { + // Minimum execution time: 70_501 nanoseconds. + Weight::from_ref_time(71_301_000 as u64) + .saturating_add(T::DbWeight::get().reads(2 as u64)) + .saturating_add(T::DbWeight::get().writes(2 as u64)) + } + // Storage: Uniques Class (r:1 w:1) + // Storage: Uniques ClassMetadataOf (r:1 w:1) + fn set_collection_metadata() -> Weight { + // Minimum execution time: 66_801 nanoseconds. + Weight::from_ref_time(67_601_000 as u64) + .saturating_add(T::DbWeight::get().reads(2 as u64)) + .saturating_add(T::DbWeight::get().writes(2 as u64)) + } + // Storage: Uniques Class (r:1 w:0) + // Storage: Uniques ClassMetadataOf (r:1 w:1) + fn clear_collection_metadata() -> Weight { + // Minimum execution time: 64_902 nanoseconds. + Weight::from_ref_time(65_801_000 as u64) + .saturating_add(T::DbWeight::get().reads(2 as u64)) + .saturating_add(T::DbWeight::get().writes(1 as u64)) + } + // Storage: Uniques Class (r:1 w:0) + // Storage: Uniques Asset (r:1 w:1) + fn approve_transfer() -> Weight { + // Minimum execution time: 47_901 nanoseconds. + Weight::from_ref_time(48_601_000 as u64) + .saturating_add(T::DbWeight::get().reads(2 as u64)) + .saturating_add(T::DbWeight::get().writes(1 as u64)) + } + // Storage: Uniques Class (r:1 w:0) + // Storage: Uniques Asset (r:1 w:1) + fn cancel_approval() -> Weight { + // Minimum execution time: 47_900 nanoseconds. + Weight::from_ref_time(48_400_000 as u64) + .saturating_add(T::DbWeight::get().reads(2 as u64)) + .saturating_add(T::DbWeight::get().writes(1 as u64)) + } + // Storage: Uniques OwnershipAcceptance (r:1 w:1) + fn set_accept_ownership() -> Weight { + // Minimum execution time: 43_700 nanoseconds. + Weight::from_ref_time(44_401_000 as u64) + .saturating_add(T::DbWeight::get().reads(1 as u64)) + .saturating_add(T::DbWeight::get().writes(1 as u64)) + } + // Storage: Uniques CollectionMaxSupply (r:1 w:1) + // Storage: Uniques Class (r:1 w:0) + fn set_collection_max_supply() -> Weight { + // Minimum execution time: 41_701 nanoseconds. + Weight::from_ref_time(42_201_000 as u64) + .saturating_add(T::DbWeight::get().reads(2 as u64)) + .saturating_add(T::DbWeight::get().writes(1 as u64)) + } + // Storage: Uniques Asset (r:1 w:0) + // Storage: Uniques ItemPriceOf (r:0 w:1) + fn set_price() -> Weight { + // Minimum execution time: 42_301 nanoseconds. + Weight::from_ref_time(42_901_000 as u64) + .saturating_add(T::DbWeight::get().reads(1 as u64)) + .saturating_add(T::DbWeight::get().writes(1 as u64)) + } + // Storage: Uniques Asset (r:1 w:1) + // Storage: Uniques ItemPriceOf (r:1 w:1) + // Storage: Uniques Class (r:1 w:0) + // Storage: Uniques Account (r:0 w:2) + fn buy_item() -> Weight { + // Minimum execution time: 79_901 nanoseconds. + Weight::from_ref_time(80_901_000 as u64) + .saturating_add(T::DbWeight::get().reads(3 as u64)) + .saturating_add(T::DbWeight::get().writes(4 as u64)) + } +} diff --git a/runtime/centrifuge/src/weights/pallet_utility.rs b/runtime/centrifuge/src/weights/pallet_utility.rs index 35df637943..ff89c1264a 100644 --- a/runtime/centrifuge/src/weights/pallet_utility.rs +++ b/runtime/centrifuge/src/weights/pallet_utility.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_utility` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-01-12, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-03-22, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("centrifuge-dev"), DB CACHE: 1024 @@ -32,31 +32,31 @@ pub struct WeightInfo(PhantomData); impl pallet_utility::WeightInfo for WeightInfo { /// The range of component `c` is `[0, 1000]`. fn batch(c: u32, ) -> Weight { - // Minimum execution time: 24_701 nanoseconds. - Weight::from_ref_time(38_731_874 as u64) - // Standard Error: 3_466 - .saturating_add(Weight::from_ref_time(8_912_203 as u64).saturating_mul(c as u64)) + // Minimum execution time: 25_300 nanoseconds. + Weight::from_ref_time(43_984_599 as u64) + // Standard Error: 3_528 + .saturating_add(Weight::from_ref_time(8_946_930 as u64).saturating_mul(c as u64)) } fn as_derivative() -> Weight { - // Minimum execution time: 14_300 nanoseconds. - Weight::from_ref_time(14_701_000 as u64) + // Minimum execution time: 19_700 nanoseconds. + Weight::from_ref_time(20_100_000 as u64) } /// The range of component `c` is `[0, 1000]`. fn batch_all(c: u32, ) -> Weight { - // Minimum execution time: 25_000 nanoseconds. - Weight::from_ref_time(32_079_332 as u64) - // Standard Error: 3_657 - .saturating_add(Weight::from_ref_time(9_352_509 as u64).saturating_mul(c as u64)) + // Minimum execution time: 24_801 nanoseconds. + Weight::from_ref_time(38_543_565 as u64) + // Standard Error: 3_463 + .saturating_add(Weight::from_ref_time(9_410_755 as u64).saturating_mul(c as u64)) } fn dispatch_as() -> Weight { - // Minimum execution time: 29_100 nanoseconds. - Weight::from_ref_time(30_000_000 as u64) + // Minimum execution time: 30_600 nanoseconds. + Weight::from_ref_time(31_601_000 as u64) } /// The range of component `c` is `[0, 1000]`. fn force_batch(c: u32, ) -> Weight { - // Minimum execution time: 24_501 nanoseconds. - Weight::from_ref_time(39_164_823 as u64) - // Standard Error: 3_635 - .saturating_add(Weight::from_ref_time(8_926_085 as u64).saturating_mul(c as u64)) + // Minimum execution time: 25_200 nanoseconds. + Weight::from_ref_time(39_005_739 as u64) + // Standard Error: 3_181 + .saturating_add(Weight::from_ref_time(8_978_664 as u64).saturating_mul(c as u64)) } } diff --git a/runtime/centrifuge/src/weights/pallet_vesting.rs b/runtime/centrifuge/src/weights/pallet_vesting.rs index b7767bbde2..2e21e44b78 100644 --- a/runtime/centrifuge/src/weights/pallet_vesting.rs +++ b/runtime/centrifuge/src/weights/pallet_vesting.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_vesting` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-01-12, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-03-22, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("centrifuge-dev"), DB CACHE: 1024 @@ -35,12 +35,12 @@ impl pallet_vesting::WeightInfo for WeightInfo { /// The range of component `l` is `[0, 49]`. /// The range of component `s` is `[1, 3]`. fn vest_locked(l: u32, s: u32, ) -> Weight { - // Minimum execution time: 69_801 nanoseconds. - Weight::from_ref_time(70_990_393 as u64) - // Standard Error: 5_934 - .saturating_add(Weight::from_ref_time(92_095 as u64).saturating_mul(l as u64)) - // Standard Error: 113_704 - .saturating_add(Weight::from_ref_time(462_486 as u64).saturating_mul(s as u64)) + // Minimum execution time: 72_401 nanoseconds. + Weight::from_ref_time(73_754_374 as u64) + // Standard Error: 6_074 + .saturating_add(Weight::from_ref_time(96_059 as u64).saturating_mul(l as u64)) + // Standard Error: 116_395 + .saturating_add(Weight::from_ref_time(489_512 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } @@ -49,12 +49,12 @@ impl pallet_vesting::WeightInfo for WeightInfo { /// The range of component `l` is `[0, 49]`. /// The range of component `s` is `[1, 3]`. fn vest_unlocked(l: u32, s: u32, ) -> Weight { - // Minimum execution time: 69_701 nanoseconds. - Weight::from_ref_time(70_684_719 as u64) - // Standard Error: 2_091 - .saturating_add(Weight::from_ref_time(83_572 as u64).saturating_mul(l as u64)) - // Standard Error: 40_066 - .saturating_add(Weight::from_ref_time(115_812 as u64).saturating_mul(s as u64)) + // Minimum execution time: 72_101 nanoseconds. + Weight::from_ref_time(73_063_601 as u64) + // Standard Error: 4_860 + .saturating_add(Weight::from_ref_time(82_669 as u64).saturating_mul(l as u64)) + // Standard Error: 93_134 + .saturating_add(Weight::from_ref_time(369_768 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } @@ -64,12 +64,12 @@ impl pallet_vesting::WeightInfo for WeightInfo { /// The range of component `l` is `[0, 49]`. /// The range of component `s` is `[1, 3]`. fn vest_other_locked(l: u32, s: u32, ) -> Weight { - // Minimum execution time: 68_701 nanoseconds. - Weight::from_ref_time(72_268_622 as u64) - // Standard Error: 8_738 - .saturating_add(Weight::from_ref_time(53_140 as u64).saturating_mul(l as u64)) - // Standard Error: 167_439 - .saturating_add(Weight::from_ref_time(117_651 as u64).saturating_mul(s as u64)) + // Minimum execution time: 72_200 nanoseconds. + Weight::from_ref_time(72_411_361 as u64) + // Standard Error: 3_395 + .saturating_add(Weight::from_ref_time(101_124 as u64).saturating_mul(l as u64)) + // Standard Error: 65_055 + .saturating_add(Weight::from_ref_time(504_635 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -78,11 +78,13 @@ impl pallet_vesting::WeightInfo for WeightInfo { // Storage: System Account (r:1 w:1) /// The range of component `l` is `[0, 49]`. /// The range of component `s` is `[1, 3]`. - fn vest_other_unlocked(l: u32, _s: u32, ) -> Weight { - // Minimum execution time: 68_600 nanoseconds. - Weight::from_ref_time(73_781_602 as u64) - // Standard Error: 11_766 - .saturating_add(Weight::from_ref_time(18_475 as u64).saturating_mul(l as u64)) + fn vest_other_unlocked(l: u32, s: u32, ) -> Weight { + // Minimum execution time: 71_101 nanoseconds. + Weight::from_ref_time(75_115_899 as u64) + // Standard Error: 12_065 + .saturating_add(Weight::from_ref_time(40_630 as u64).saturating_mul(l as u64)) + // Standard Error: 231_182 + .saturating_add(Weight::from_ref_time(217_014 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -92,8 +94,8 @@ impl pallet_vesting::WeightInfo for WeightInfo { /// The range of component `l` is `[0, 49]`. /// The range of component `s` is `[0, 2]`. fn vested_transfer(_l: u32, _s: u32, ) -> Weight { - // Minimum execution time: 98_401 nanoseconds. - Weight::from_ref_time(120_609_165 as u64) + // Minimum execution time: 101_201 nanoseconds. + Weight::from_ref_time(121_350_657 as u64) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -103,8 +105,8 @@ impl pallet_vesting::WeightInfo for WeightInfo { /// The range of component `l` is `[0, 49]`. /// The range of component `s` is `[0, 2]`. fn force_vested_transfer(_l: u32, _s: u32, ) -> Weight { - // Minimum execution time: 97_401 nanoseconds. - Weight::from_ref_time(118_657_250 as u64) + // Minimum execution time: 100_401 nanoseconds. + Weight::from_ref_time(120_143_883 as u64) .saturating_add(T::DbWeight::get().reads(4 as u64)) .saturating_add(T::DbWeight::get().writes(4 as u64)) } @@ -114,12 +116,12 @@ impl pallet_vesting::WeightInfo for WeightInfo { /// The range of component `l` is `[0, 49]`. /// The range of component `s` is `[2, 3]`. fn not_unlocking_merge_schedules(l: u32, s: u32, ) -> Weight { - // Minimum execution time: 71_401 nanoseconds. - Weight::from_ref_time(73_060_345 as u64) - // Standard Error: 10_510 - .saturating_add(Weight::from_ref_time(75_574 as u64).saturating_mul(l as u64)) - // Standard Error: 335_198 - .saturating_add(Weight::from_ref_time(504_624 as u64).saturating_mul(s as u64)) + // Minimum execution time: 73_800 nanoseconds. + Weight::from_ref_time(77_773_276 as u64) + // Standard Error: 9_836 + .saturating_add(Weight::from_ref_time(56_071 as u64).saturating_mul(l as u64)) + // Standard Error: 313_726 + .saturating_add(Weight::from_ref_time(20_199 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -129,12 +131,12 @@ impl pallet_vesting::WeightInfo for WeightInfo { /// The range of component `l` is `[0, 49]`. /// The range of component `s` is `[2, 3]`. fn unlocking_merge_schedules(l: u32, s: u32, ) -> Weight { - // Minimum execution time: 71_301 nanoseconds. - Weight::from_ref_time(70_358_103 as u64) - // Standard Error: 10_366 - .saturating_add(Weight::from_ref_time(98_173 as u64).saturating_mul(l as u64)) - // Standard Error: 330_614 - .saturating_add(Weight::from_ref_time(1_291_916 as u64).saturating_mul(s as u64)) + // Minimum execution time: 73_801 nanoseconds. + Weight::from_ref_time(73_311_367 as u64) + // Standard Error: 7_146 + .saturating_add(Weight::from_ref_time(109_182 as u64).saturating_mul(l as u64)) + // Standard Error: 227_925 + .saturating_add(Weight::from_ref_time(1_018_378 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } From fca17d1a2fc2ed91175c3ec2a073ee49745c51ff Mon Sep 17 00:00:00 2001 From: mustermeiszer Date: Wed, 22 Mar 2023 22:37:40 +0100 Subject: [PATCH 28/55] feat: use newly benched weights --- runtime/centrifuge/src/lib.rs | 23 +++++++++++++---------- 1 file changed, 13 insertions(+), 10 deletions(-) diff --git a/runtime/centrifuge/src/lib.rs b/runtime/centrifuge/src/lib.rs index 3084c3ed9a..e9aa769c8d 100644 --- a/runtime/centrifuge/src/lib.rs +++ b/runtime/centrifuge/src/lib.rs @@ -310,7 +310,7 @@ impl pallet_restricted_tokens::Config for Runtime { type PreFungiblesTransfer = cfg_traits::Always; type PreReservableCurrency = cfg_traits::Always; type RuntimeEvent = RuntimeEvent; - type WeightInfo = pallet_restricted_tokens::weights::SubstrateWeight; + type WeightInfo = weights::pallet_restricted_tokens::WeightInfo; } pub struct RestrictedTokens

(PhantomData

); @@ -381,6 +381,7 @@ impl orml_tokens::Config for Runtime { type MaxReserves = MaxReserves; type ReserveIdentifier = [u8; 8]; type RuntimeEvent = RuntimeEvent; + // NOTE: Call NOT exposed, default weights are fine type WeightInfo = (); } @@ -482,6 +483,7 @@ impl pallet_session::Config for Runtime { type ValidatorId = ::AccountId; // we don't have stash and controller, thus we don't need the convert as well. type ValidatorIdOf = pallet_collator_selection::IdentityCollator; + // TODO: Wait for block rewards that fix this type WeightInfo = pallet_session::weights::SubstrateWeight; } @@ -774,7 +776,7 @@ parameter_types! { // Make sure that there are no more than `MAX_MEMBERS` members elected via elections-phragmen. const_assert!(DesiredMembers::get() <= CouncilMaxMembers::get()); - +// TODO: Can we remove phragmen? impl pallet_elections_phragmen::Config for Runtime { /// How much should be locked up in order to submit one's candidacy. type CandidacyBond = CandidacyBond; @@ -991,7 +993,7 @@ impl pallet_collator_allowlist::Config for Runtime { type RuntimeEvent = RuntimeEvent; type ValidatorId = AccountId; type ValidatorRegistration = Session; - type WeightInfo = pallet_collator_allowlist::weights::SubstrateWeight; + type WeightInfo = weights::pallet_collator_allowlist::WeightInfo; } parameter_types! { @@ -1040,6 +1042,7 @@ impl chainbridge::Config for Runtime { type ProposalLifetime = ProposalLifetime; type RelayerVoteThreshold = RelayerVoteThreshold; type RuntimeEvent = RuntimeEvent; + // TODO: Fix benchmarks type WeightInfo = (); } @@ -1276,7 +1279,7 @@ impl pallet_pool_registry::Config for Runtime { type Rate = Rate; type RuntimeEvent = RuntimeEvent; type TrancheId = TrancheId; - type WeightInfo = pallet_pool_registry::weights::SubstrateWeight; + type WeightInfo = weights::pallet_pool_registry::WeightInfo; } impl pallet_pool_system::Config for Runtime { @@ -1315,7 +1318,7 @@ impl pallet_pool_system::Config for Runtime { type TrancheId = TrancheId; type TrancheWeight = TrancheWeight; type UpdateGuard = UpdateGuard; - type WeightInfo = pallet_pool_system::weights::SubstrateWeight; + type WeightInfo = weights::pallet_pool_system::WeightInfo; } parameter_types! { @@ -1383,7 +1386,7 @@ impl pallet_permissions::Config for Runtime { type Scope = PermissionScope; type Storage = PermissionRoles, MinDelay, TrancheId, MaxTranches, Moment>; - type WeightInfo = pallet_permissions::weights::SubstrateWeight; + type WeightInfo = weights::pallet_permissions::WeightInfo; } parameter_types! { @@ -1459,7 +1462,7 @@ impl pallet_interest_accrual::Config for Runtime { type MaxRateCount = MaxActiveLoansPerPool; type RuntimeEvent = RuntimeEvent; type Time = Timestamp; - type Weights = (); + type Weights = weights::pallet_interest_accrual::WeightInfo; } parameter_types! { @@ -1484,7 +1487,7 @@ impl pallet_loans::Config for Runtime { type Rate = Rate; type RuntimeEvent = RuntimeEvent; type Time = Timestamp; - type WeightInfo = pallet_loans::weights::SubstrateWeight; + type WeightInfo = weights::pallet_loans::WeightInfo; } parameter_types! { @@ -1499,7 +1502,7 @@ impl pallet_keystore::pallet::Config for Runtime { type DefaultKeyDeposit = DefaultKeyDeposit; type MaxKeys = MaxKeys; type RuntimeEvent = RuntimeEvent; - type WeightInfo = pallet_keystore::weights::SubstrateWeight; + type WeightInfo = weights::pallet_keystore::WeightInfo; } parameter_types! { @@ -1536,7 +1539,7 @@ impl pallet_uniques::Config for Runtime { type RuntimeEvent = RuntimeEvent; type StringLimit = Limit; type ValueLimit = Limit; - type WeightInfo = pallet_uniques::weights::SubstrateWeight; + type WeightInfo = weights::pallet_uniques::WeightInfo; } // Frame Order in this block dictates the index of each one in the metadata From 1e97c2894d84e929369ffb7fd3e2851b14e83012 Mon Sep 17 00:00:00 2001 From: mustermeiszer Date: Wed, 22 Mar 2023 23:14:32 +0100 Subject: [PATCH 29/55] feat: adapt parameters --- runtime/centrifuge/src/lib.rs | 25 ++++++++++++------------- 1 file changed, 12 insertions(+), 13 deletions(-) diff --git a/runtime/centrifuge/src/lib.rs b/runtime/centrifuge/src/lib.rs index e9aa769c8d..9226f131c2 100644 --- a/runtime/centrifuge/src/lib.rs +++ b/runtime/centrifuge/src/lib.rs @@ -1169,8 +1169,7 @@ parameter_types! { pub const MaxSizeMetadata: u32 = 46; // length of IPFS hash // Deposit to create a pool. This covers pool data, loan data, and permissions data. - // TODO: Define deposit? - pub const PoolDeposit: Balance = 100 * CFG; + pub const PoolDeposit: Balance = 1000 * CFG; } pub struct PoolCurrency; @@ -1467,7 +1466,7 @@ impl pallet_interest_accrual::Config for Runtime { parameter_types! { pub const LoansPalletId: PalletId = cfg_types::ids::LOANS_PALLET_ID; - pub const MaxActiveLoansPerPool: u32 = 50; + pub const MaxActiveLoansPerPool: u32 = 1000; pub const MaxWriteOffGroups: u32 = 100; } @@ -1506,16 +1505,16 @@ impl pallet_keystore::pallet::Config for Runtime { } parameter_types! { - // per byte deposit is 0.01 AIR - pub const DepositPerByte: Balance = CENTI_CFG; - // Base deposit to add attribute is 0.1 AIR - pub const AttributeDepositBase: Balance = 10 * CENTI_CFG; - // Base deposit to add metadata is 0.1 AIR - pub const MetadataDepositBase: Balance = 10 * CENTI_CFG; - // Deposit to create a class is 1 AIR - pub const CollectionDeposit: Balance = CFG; - // Deposit to create a class is 0.1 AIR - pub const ItemDeposit: Balance = 10 * CENTI_CFG; + // per byte deposit is 0.1 CFG + pub const DepositPerByte: Balance = 10 * CENTI_CFG; + // Base deposit to add attribute is 1 CFG + pub const AttributeDepositBase: Balance = 1 * CFG; + // Base deposit to add metadata is 1 CFG + pub const MetadataDepositBase: Balance = 1 * CFG; + // Deposit to create a class is 10 CFG + pub const CollectionDeposit: Balance = 10 * CFG; + // Deposit to create a class is 1 CFG + pub const ItemDeposit: Balance = 1 * CFG; // Maximum limit of bytes for Metadata, Attribute key and Value pub const Limit: u32 = 256; } From ff17c8d2e9c07b29f177ab1597e3092834265769 Mon Sep 17 00:00:00 2001 From: mustermeiszer Date: Thu, 23 Mar 2023 13:36:42 +0100 Subject: [PATCH 30/55] fix: adapt uniques parameters according to review --- runtime/centrifuge/src/lib.rs | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/runtime/centrifuge/src/lib.rs b/runtime/centrifuge/src/lib.rs index 9226f131c2..98f04c19fd 100644 --- a/runtime/centrifuge/src/lib.rs +++ b/runtime/centrifuge/src/lib.rs @@ -1505,16 +1505,16 @@ impl pallet_keystore::pallet::Config for Runtime { } parameter_types! { - // per byte deposit is 0.1 CFG - pub const DepositPerByte: Balance = 10 * CENTI_CFG; - // Base deposit to add attribute is 1 CFG - pub const AttributeDepositBase: Balance = 1 * CFG; - // Base deposit to add metadata is 1 CFG - pub const MetadataDepositBase: Balance = 1 * CFG; - // Deposit to create a class is 10 CFG - pub const CollectionDeposit: Balance = 10 * CFG; - // Deposit to create a class is 1 CFG - pub const ItemDeposit: Balance = 1 * CFG; + // per byte deposit is 0.01 CFG + pub const DepositPerByte: Balance = 1 * CENTI_CFG; + // Base deposit to add attribute is 0.1 CFG + pub const AttributeDepositBase: Balance = 1 * CENTI_CFG; + // Base deposit to add metadata is 0.1 CFG + pub const MetadataDepositBase: Balance = 1 * CENTI_CFG; + // Deposit to create a class is 100 CFG + pub const CollectionDeposit: Balance = 100 * CFG; + // Deposit to create a class is 0.1 CFG + pub const ItemDeposit: Balance = 1 * CENTI_CFG; // Maximum limit of bytes for Metadata, Attribute key and Value pub const Limit: u32 = 256; } From d38790ee01cfb5f6beb90c6a32efb559e6a0a1b3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Luis=20Enrique=20Mu=C3=B1oz=20Mart=C3=ADn?= Date: Thu, 23 Mar 2023 13:48:05 +0100 Subject: [PATCH 31/55] Add loans to centrifuge runtime (#1254) * add loans to centrifuge * fix loan addition --- Cargo.lock | 2 +- runtime/centrifuge/Cargo.toml | 8 +-- runtime/centrifuge/src/lib.rs | 65 ++++++++----------- runtime/centrifuge/src/weights/mod.rs | 2 +- .../src/weights/pallet_loans_ref.rs | 6 +- 5 files changed, 35 insertions(+), 48 deletions(-) rename runtime/{development => centrifuge}/src/weights/pallet_loans_ref.rs (94%) diff --git a/Cargo.lock b/Cargo.lock index 1d28fc9e55..3249eada4b 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1007,7 +1007,7 @@ dependencies = [ "pallet-interest-accrual", "pallet-investments", "pallet-keystore", - "pallet-loans", + "pallet-loans-ref", "pallet-migration-manager", "pallet-multisig", "pallet-nft", diff --git a/runtime/centrifuge/Cargo.toml b/runtime/centrifuge/Cargo.toml index fba8dcc89c..de49f4b477 100644 --- a/runtime/centrifuge/Cargo.toml +++ b/runtime/centrifuge/Cargo.toml @@ -101,7 +101,7 @@ pallet-fees = { path = "../../pallets/fees", default-features = false } pallet-interest-accrual = { path = "../../pallets/interest-accrual", default-features = false } pallet-investments = { path = "../../pallets/investments", default-features = false } pallet-keystore = { path = "../../pallets/keystore", default-features = false } -pallet-loans = { path = "../../pallets/loans", default-features = false } +pallet-loans-ref = { path = "../../pallets/loans-ref", default-features = false } pallet-migration-manager = { path = "../../pallets/migration", default-features = false } pallet-nft = { path = "../../pallets/nft", default-features = false } pallet-permissions = { path = "../../pallets/permissions", default-features = false } @@ -162,7 +162,7 @@ std = [ "pallet-identity/std", "pallet-interest-accrual/std", "pallet-investments/std", - "pallet-loans/std", + "pallet-loans-ref/std", "pallet-keystore/std", "pallet-migration-manager/std", "pallet-multisig/std", @@ -236,7 +236,7 @@ runtime-benchmarks = [ "pallet-identity/runtime-benchmarks", "pallet-interest-accrual/runtime-benchmarks", "pallet-investments/runtime-benchmarks", - "pallet-loans/runtime-benchmarks", + "pallet-loans-ref/runtime-benchmarks", "pallet-keystore/runtime-benchmarks", "pallet-migration-manager/runtime-benchmarks", "pallet-multisig/runtime-benchmarks", @@ -297,7 +297,7 @@ try-runtime = [ "pallet-identity/try-runtime", "pallet-interest-accrual/try-runtime", "pallet-investments/try-runtime", - "pallet-loans/try-runtime", + "pallet-loans-ref/try-runtime", "pallet-keystore/try-runtime", "pallet-migration-manager/try-runtime", "pallet-multisig/try-runtime", diff --git a/runtime/centrifuge/src/lib.rs b/runtime/centrifuge/src/lib.rs index 98f04c19fd..5c202ce053 100644 --- a/runtime/centrifuge/src/lib.rs +++ b/runtime/centrifuge/src/lib.rs @@ -20,7 +20,8 @@ pub use cfg_primitives::{constants::*, types::*}; use cfg_traits::{ - OrderManager, Permissions as PermissionsT, PoolUpdateGuard, PreConditions, TrancheCurrency as _, + OrderManager, Permissions as PermissionsT, PoolNAV, PoolUpdateGuard, PreConditions, + TrancheCurrency as _, }; use cfg_types::{ consts::pools::{MaxTrancheNameLengthBytes, MaxTrancheSymbolLengthBytes}, @@ -551,7 +552,6 @@ pub enum ProxyType { _Staking, NonProxy, Borrow, - Price, Invest, ProxyManagement, KeystoreManagement, @@ -623,21 +623,20 @@ impl InstanceFilter for ProxyType { } ProxyType::Borrow => matches!( c, - RuntimeCall::Loans(pallet_loans::Call::create{..}) | - RuntimeCall::Loans(pallet_loans::Call::borrow{..}) | - RuntimeCall::Loans(pallet_loans::Call::repay{..}) | - RuntimeCall::Loans(pallet_loans::Call::write_off{..}) | - RuntimeCall::Loans(pallet_loans::Call::close{..}) | + RuntimeCall::Loans(pallet_loans_ref::Call::create{..}) | + RuntimeCall::Loans(pallet_loans_ref::Call::borrow{..}) | + RuntimeCall::Loans(pallet_loans_ref::Call::repay{..}) | + RuntimeCall::Loans(pallet_loans_ref::Call::write_off{..}) | + RuntimeCall::Loans(pallet_loans_ref::Call::close{..}) | // Borrowers should be able to close and execute an epoch // in order to get liquidity from repayments in previous epochs. - RuntimeCall::Loans(pallet_loans::Call::update_nav{..}) | + RuntimeCall::Loans(pallet_loans_ref::Call::update_portfolio_valuation{..}) | RuntimeCall::PoolSystem(pallet_pool_system::Call::close_epoch{..}) | RuntimeCall::PoolSystem(pallet_pool_system::Call::submit_solution{..}) | RuntimeCall::PoolSystem(pallet_pool_system::Call::execute_epoch{..}) | RuntimeCall::Utility(pallet_utility::Call::batch_all{..}) | RuntimeCall::Utility(pallet_utility::Call::batch{..}) ), - ProxyType::Price => matches!(c, RuntimeCall::Loans(pallet_loans::Call::price { .. })), ProxyType::Invest => matches!( c, RuntimeCall::Investments(pallet_investments::Call::update_invest_order{..}) | @@ -646,7 +645,7 @@ impl InstanceFilter for ProxyType { RuntimeCall::Investments(pallet_investments::Call::collect_redemptions{..}) | // Investors should be able to close and execute an epoch // in order to get their orders fulfilled. - RuntimeCall::Loans(pallet_loans::Call::update_nav{..}) | + RuntimeCall::Loans(pallet_loans_ref::Call::update_portfolio_valuation{..}) | RuntimeCall::PoolSystem(pallet_pool_system::Call::close_epoch{..}) | RuntimeCall::PoolSystem(pallet_pool_system::Call::submit_solution{..}) | RuntimeCall::PoolSystem(pallet_pool_system::Call::execute_epoch{..}) | @@ -1467,26 +1466,25 @@ impl pallet_interest_accrual::Config for Runtime { parameter_types! { pub const LoansPalletId: PalletId = cfg_types::ids::LOANS_PALLET_ID; pub const MaxActiveLoansPerPool: u32 = 1000; - pub const MaxWriteOffGroups: u32 = 100; + pub const MaxWriteOffPolicySize: u32 = 100; } -impl pallet_loans::Config for Runtime { +impl pallet_loans_ref::Config for Runtime { type Balance = Balance; - type BlockNumberProvider = System; - type ClassId = CollectionId; + type CollectionId = CollectionId; type CurrencyId = CurrencyId; type InterestAccrual = InterestAccrual; - type LoanId = ItemId; - type LoansPalletId = LoansPalletId; + type ItemId = ItemId; + type LoanId = LoanId; type MaxActiveLoansPerPool = MaxActiveLoansPerPool; - type MaxWriteOffGroups = MaxWriteOffGroups; + type MaxWriteOffPolicySize = MaxWriteOffPolicySize; type NonFungible = Uniques; - type Permission = Permissions; + type Permissions = Permissions; type Pool = PoolSystem; type Rate = Rate; type RuntimeEvent = RuntimeEvent; type Time = Timestamp; - type WeightInfo = weights::pallet_loans::WeightInfo; + type WeightInfo = weights::pallet_loans_ref::WeightInfo; } parameter_types! { @@ -1619,7 +1617,7 @@ construct_runtime!( InterestAccrual: pallet_interest_accrual::{Pallet, Storage, Event, Config} = 184, Uniques: pallet_uniques::{Pallet, Call, Storage, Event} = 185, Keystore: pallet_keystore::{Pallet, Call, Storage, Event} = 186, - Loans: pallet_loans::{Pallet, Call, Storage, Event} = 187, + Loans: pallet_loans_ref::{Pallet, Call, Storage, Event} = 187, } ); @@ -1786,11 +1784,9 @@ impl_runtime_apis! { } fn tranche_token_price(pool_id: PoolId, tranche: TrancheLoc) -> Option{ - let now = as UnixTime>::now().as_secs(); - let mut pool = pallet_pool_system::Pool::::get(pool_id)?; - let nav: Balance = pallet_loans::Pallet::::update_nav_of_pool(pool_id) - .ok() - .map(|(latest, _)| latest.into())?; + let now = ::now().as_secs(); + let mut pool = PoolSystem::pool(pool_id)?; + let nav = Loans::update_nav(pool_id).ok()?; let total_assets = pool.reserve.total.saturating_add(nav); let index: usize = pool.tranches.tranche_index(&tranche)?.try_into().ok()?; let prices = pool @@ -1801,11 +1797,9 @@ impl_runtime_apis! { } fn tranche_token_prices(pool_id: PoolId) -> Option>{ - let now = as UnixTime>::now().as_secs(); - let mut pool = pallet_pool_system::Pool::::get(pool_id)?; - let nav: Balance = pallet_loans::Pallet::::update_nav_of_pool(pool_id) - .ok() - .map(|(latest, _)| latest.into())?; + let now = ::now().as_secs(); + let mut pool = PoolSystem::pool(pool_id)?; + let nav = Loans::update_nav(pool_id).ok()?; let total_assets = pool.reserve.total.saturating_add(nav); pool .tranches @@ -1840,7 +1834,6 @@ impl_runtime_apis! { use frame_benchmarking::{list_benchmark, Benchmarking, BenchmarkList}; use frame_support::traits::StorageInfoTrait; use frame_system_benchmarking::Pallet as SystemBench; - use pallet_loans::benchmarking::Pallet as LoansPallet; let mut list = Vec::::new(); @@ -1869,9 +1862,8 @@ impl_runtime_apis! { list_benchmark!(list, extra, pallet_interest_accrual, InterestAccrual); list_benchmark!(list, extra, pallet_uniques, Uniques); list_benchmark!(list, extra, pallet_keystore, Keystore); - list_benchmark!(list, extra, pallet_loans, LoansPallet::); list_benchmark!(list, extra, pallet_restricted_tokens, Tokens); - + list_benchmark!(list, extra, pallet_loans_ref, Loans); let storage_info = AllPalletsWithSystem::storage_info(); @@ -1903,11 +1895,6 @@ impl_runtime_apis! { let mut batches = Vec::::new(); let params = (&config, &whitelist); - use pallet_loans::benchmarking::Pallet as LoansPallet; - impl pallet_loans::benchmarking::Config for Runtime { - type IM = Investments; - } - // It should be called Anchors to make the runtime_benchmarks.sh script works type Anchors = Anchor; @@ -1936,8 +1923,8 @@ impl_runtime_apis! { add_benchmark!(params, batches, pallet_interest_accrual, InterestAccrual); add_benchmark!(params, batches, pallet_uniques, Uniques); add_benchmark!(params, batches, pallet_keystore, Keystore); - add_benchmark!(params, batches, pallet_loans, LoansPallet::); add_benchmark!(params, batches, pallet_restricted_tokens, Tokens); + add_benchmark!(params, batches, pallet_loans_ref, Loans); if batches.is_empty() { return Err("Benchmark not found for this pallet.".into()) } Ok(batches) diff --git a/runtime/centrifuge/src/weights/mod.rs b/runtime/centrifuge/src/weights/mod.rs index 08f0d6a480..e6b17318d3 100644 --- a/runtime/centrifuge/src/weights/mod.rs +++ b/runtime/centrifuge/src/weights/mod.rs @@ -21,7 +21,7 @@ pub mod pallet_fees; pub mod pallet_identity; pub mod pallet_interest_accrual; pub mod pallet_keystore; -pub mod pallet_loans; +pub mod pallet_loans_ref; pub mod pallet_migration_manager; pub mod pallet_multisig; pub mod pallet_permissions; diff --git a/runtime/development/src/weights/pallet_loans_ref.rs b/runtime/centrifuge/src/weights/pallet_loans_ref.rs similarity index 94% rename from runtime/development/src/weights/pallet_loans_ref.rs rename to runtime/centrifuge/src/weights/pallet_loans_ref.rs index 565551d44f..062bc5c194 100644 --- a/runtime/development/src/weights/pallet_loans_ref.rs +++ b/runtime/centrifuge/src/weights/pallet_loans_ref.rs @@ -4,7 +4,7 @@ //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev //! DATE: 2023-03-09, STEPS: `2`, REPEAT: 1, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `MBP-de-Luis.home`, CPU: `` -//! EXECUTION: None, WASM-EXECUTION: Compiled, CHAIN: Some("development"), DB CACHE: 1024 +//! EXECUTION: None, WASM-EXECUTION: Compiled, CHAIN: Some("centrifuge"), DB CACHE: 1024 // Executed Command: // target/release/centrifuge-chain @@ -12,9 +12,9 @@ // pallet // --pallet=pallet-loans // --chain -// development +// centrifuge // --extrinsic=* -// --output=runtime/development/src/weights/pallet_loans_ref.rs +// --output=runtime/centrifuge/src/weights/pallet_loans_ref.rs #![cfg_attr(rustfmt, rustfmt_skip)] #![allow(unused_parens)] From 40245fdf19f5938e7bd51559817deb2c8b5454a8 Mon Sep 17 00:00:00 2001 From: mustermeiszer Date: Thu, 23 Mar 2023 14:17:30 +0100 Subject: [PATCH 32/55] inter: clion deletes this files content, need to regenerate anyways --- runtime/centrifuge/src/lib.rs | 2 +- runtime/centrifuge/src/weights/mod.rs | 1 - runtime/centrifuge/src/weights/pallet_restricted_tokens.rs | 1 - 3 files changed, 1 insertion(+), 3 deletions(-) delete mode 100644 runtime/centrifuge/src/weights/pallet_restricted_tokens.rs diff --git a/runtime/centrifuge/src/lib.rs b/runtime/centrifuge/src/lib.rs index 5c202ce053..4f5bc4b0b0 100644 --- a/runtime/centrifuge/src/lib.rs +++ b/runtime/centrifuge/src/lib.rs @@ -311,7 +311,7 @@ impl pallet_restricted_tokens::Config for Runtime { type PreFungiblesTransfer = cfg_traits::Always; type PreReservableCurrency = cfg_traits::Always; type RuntimeEvent = RuntimeEvent; - type WeightInfo = weights::pallet_restricted_tokens::WeightInfo; + type WeightInfo = (); } pub struct RestrictedTokens

(PhantomData

); diff --git a/runtime/centrifuge/src/weights/mod.rs b/runtime/centrifuge/src/weights/mod.rs index e6b17318d3..e6651412ab 100644 --- a/runtime/centrifuge/src/weights/mod.rs +++ b/runtime/centrifuge/src/weights/mod.rs @@ -29,7 +29,6 @@ pub mod pallet_pool_registry; pub mod pallet_pool_system; pub mod pallet_preimage; pub mod pallet_proxy; -pub mod pallet_restricted_tokens; pub mod pallet_scheduler; pub mod pallet_timestamp; pub mod pallet_treasury; diff --git a/runtime/centrifuge/src/weights/pallet_restricted_tokens.rs b/runtime/centrifuge/src/weights/pallet_restricted_tokens.rs deleted file mode 100644 index 8b13789179..0000000000 --- a/runtime/centrifuge/src/weights/pallet_restricted_tokens.rs +++ /dev/null @@ -1 +0,0 @@ - From cf1b46521c7f7347527752828b1b44cd5beab170 Mon Sep 17 00:00:00 2001 From: mustermeiszer Date: Thu, 23 Mar 2023 14:30:08 +0100 Subject: [PATCH 33/55] fix: rm warn, check orml-asset-regsitry weights --- pallets/pool-registry/src/benchmarking.rs | 6 -- runtime/centrifuge/src/lib.rs | 3 + .../src/weights/pallet_loans_ref.rs | 82 +++++++++++++++++++ 3 files changed, 85 insertions(+), 6 deletions(-) create mode 100644 runtime/development/src/weights/pallet_loans_ref.rs diff --git a/pallets/pool-registry/src/benchmarking.rs b/pallets/pool-registry/src/benchmarking.rs index 4b3d427a36..4284b1fb75 100644 --- a/pallets/pool-registry/src/benchmarking.rs +++ b/pallets/pool-registry/src/benchmarking.rs @@ -247,12 +247,6 @@ fn build_update_tranches( tranches.try_into().expect("num_tranches <= T::MaxTranches") } -fn pass_time>(time: Moment) { - let now = pallet_timestamp::Now::::get(); - let new_now = now + time; - pallet_timestamp::Now::::set(new_now); -} - // TODO: Enable once ModifyPool is not fully mocked // impl_benchmark_test_suite!( // Pallet, diff --git a/runtime/centrifuge/src/lib.rs b/runtime/centrifuge/src/lib.rs index 4f5bc4b0b0..e0f3dbec46 100644 --- a/runtime/centrifuge/src/lib.rs +++ b/runtime/centrifuge/src/lib.rs @@ -394,6 +394,9 @@ impl orml_asset_registry::Config for Runtime { type Balance = Balance; type CustomMetadata = CustomMetadata; type RuntimeEvent = RuntimeEvent; + // NOTE: Need no weights as spamming is not possible as the + // calls are only callable by `AuthorityOrigin`. In out + // case, pallet-pools and democracy type WeightInfo = (); } diff --git a/runtime/development/src/weights/pallet_loans_ref.rs b/runtime/development/src/weights/pallet_loans_ref.rs new file mode 100644 index 0000000000..062bc5c194 --- /dev/null +++ b/runtime/development/src/weights/pallet_loans_ref.rs @@ -0,0 +1,82 @@ + +//! Autogenerated weights for `pallet_loans_ref` +//! +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev +//! DATE: 2023-03-09, STEPS: `2`, REPEAT: 1, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! HOSTNAME: `MBP-de-Luis.home`, CPU: `` +//! EXECUTION: None, WASM-EXECUTION: Compiled, CHAIN: Some("centrifuge"), DB CACHE: 1024 + +// Executed Command: +// target/release/centrifuge-chain +// benchmark +// pallet +// --pallet=pallet-loans +// --chain +// centrifuge +// --extrinsic=* +// --output=runtime/centrifuge/src/weights/pallet_loans_ref.rs + +#![cfg_attr(rustfmt, rustfmt_skip)] +#![allow(unused_parens)] +#![allow(unused_imports)] + +use frame_support::{traits::Get, weights::Weight}; +use sp_std::marker::PhantomData; + +/// Weight functions for `pallet_loans_ref`. +pub struct WeightInfo(PhantomData); +impl pallet_loans_ref::WeightInfo for WeightInfo { + fn update_portfolio_valuation(n: u32) -> Weight { + Weight::from_ref_time(31_740_408) // Standard Error: 4_421 + .saturating_add(Weight::from_ref_time(5_889_944).saturating_mul(n as u64)) + .saturating_add(T::DbWeight::get().reads(4 as u64)) + .saturating_add(T::DbWeight::get().writes(1 as u64)) + } + + fn create() -> Weight { + Weight::from_ref_time(55_000_000) + .saturating_add(T::DbWeight::get().reads(6 as u64)) + .saturating_add(T::DbWeight::get().writes(6 as u64)) + } + + fn borrow(n: u32) -> Weight { + Weight::from_ref_time(89_980_992) // Standard Error: 6_031 + .saturating_add(Weight::from_ref_time(339_355).saturating_mul(n as u64)) + .saturating_add(T::DbWeight::get().reads(9 as u64)) + .saturating_add(T::DbWeight::get().writes(7 as u64)) + } + + fn repay(n: u32) -> Weight { + Weight::from_ref_time(88_057_556) // Standard Error: 9_218 + .saturating_add(Weight::from_ref_time(296_755).saturating_mul(n as u64)) + .saturating_add(T::DbWeight::get().reads(8 as u64)) + .saturating_add(T::DbWeight::get().writes(5 as u64)) + } + + fn write_off(n: u32) -> Weight { + Weight::from_ref_time(50_179_983) // Standard Error: 1_760 + .saturating_add(Weight::from_ref_time(299_592).saturating_mul(n as u64)) + .saturating_add(T::DbWeight::get().reads(5 as u64)) + .saturating_add(T::DbWeight::get().writes(3 as u64)) + } + + fn admin_write_off(n: u32) -> Weight { + Weight::from_ref_time(63_153_708) // Standard Error: 2_472 + .saturating_add(Weight::from_ref_time(325_868).saturating_mul(n as u64)) + .saturating_add(T::DbWeight::get().reads(6 as u64)) + .saturating_add(T::DbWeight::get().writes(3 as u64)) + } + + fn close(n: u32) -> Weight { + Weight::from_ref_time(55_882_678) // Standard Error: 7_625 + .saturating_add(Weight::from_ref_time(338_879).saturating_mul(n as u64)) + .saturating_add(T::DbWeight::get().reads(5 as u64)) + .saturating_add(T::DbWeight::get().writes(7 as u64)) + } + + fn update_write_off_policy() -> Weight { + Weight::from_ref_time(27_000_000) + .saturating_add(T::DbWeight::get().reads(2 as u64)) + .saturating_add(T::DbWeight::get().writes(1 as u64)) + } +} From 71160aa19d25690c6d34b02813b691be40ef391a Mon Sep 17 00:00:00 2001 From: mustermeiszer Date: Thu, 23 Mar 2023 14:55:06 +0100 Subject: [PATCH 34/55] fix: collator-selection benchmarks --- pallets/collator-allowlist/src/lib.rs | 11 ++++++++++- runtime/centrifuge/src/lib.rs | 2 ++ 2 files changed, 12 insertions(+), 1 deletion(-) diff --git a/pallets/collator-allowlist/src/lib.rs b/pallets/collator-allowlist/src/lib.rs index 0499916214..9fbddd50fb 100644 --- a/pallets/collator-allowlist/src/lib.rs +++ b/pallets/collator-allowlist/src/lib.rs @@ -172,6 +172,15 @@ impl ValidatorRegistration for Pallet { /// - the validator id is present in the allowlist and /// - the validator id is registered in the underlying validator registration center fn is_registered(id: &T::ValidatorId) -> bool { - >::contains_key(id) && T::ValidatorRegistration::is_registered(id) + let contains_key = if cfg!(feature = "runtime-benchmarks") { + // NOTE: We want to return true but count the storage hit + // during benchmarks here. + let _ = >::contains_key(id); + true + } else { + >::contains_key(id) + }; + + contains_key && T::ValidatorRegistration::is_registered(id) } } diff --git a/runtime/centrifuge/src/lib.rs b/runtime/centrifuge/src/lib.rs index e0f3dbec46..78ebb67079 100644 --- a/runtime/centrifuge/src/lib.rs +++ b/runtime/centrifuge/src/lib.rs @@ -1867,6 +1867,7 @@ impl_runtime_apis! { list_benchmark!(list, extra, pallet_keystore, Keystore); list_benchmark!(list, extra, pallet_restricted_tokens, Tokens); list_benchmark!(list, extra, pallet_loans_ref, Loans); + list_benchmark!(list, extra, pallet_collator_selection, CollatorSelection); let storage_info = AllPalletsWithSystem::storage_info(); @@ -1928,6 +1929,7 @@ impl_runtime_apis! { add_benchmark!(params, batches, pallet_keystore, Keystore); add_benchmark!(params, batches, pallet_restricted_tokens, Tokens); add_benchmark!(params, batches, pallet_loans_ref, Loans); + add_benchmark!(params, batches, pallet_collator_selection, CollatorSelection); if batches.is_empty() { return Err("Benchmark not found for this pallet.".into()) } Ok(batches) From ece6a566aed07efb98115306d5d841838f494225 Mon Sep 17 00:00:00 2001 From: mustermeiszer Date: Thu, 23 Mar 2023 15:14:00 +0100 Subject: [PATCH 35/55] fix: xcmp queue benches to centrifuge --- runtime/centrifuge/src/lib.rs | 2 ++ 1 file changed, 2 insertions(+) diff --git a/runtime/centrifuge/src/lib.rs b/runtime/centrifuge/src/lib.rs index 78ebb67079..5674ea56ee 100644 --- a/runtime/centrifuge/src/lib.rs +++ b/runtime/centrifuge/src/lib.rs @@ -1868,6 +1868,7 @@ impl_runtime_apis! { list_benchmark!(list, extra, pallet_restricted_tokens, Tokens); list_benchmark!(list, extra, pallet_loans_ref, Loans); list_benchmark!(list, extra, pallet_collator_selection, CollatorSelection); + list_benchmark!(list, extra, cumulus_pallet_xcmp_queue, XcmpQueue); let storage_info = AllPalletsWithSystem::storage_info(); @@ -1930,6 +1931,7 @@ impl_runtime_apis! { add_benchmark!(params, batches, pallet_restricted_tokens, Tokens); add_benchmark!(params, batches, pallet_loans_ref, Loans); add_benchmark!(params, batches, pallet_collator_selection, CollatorSelection); + add_benchmark!(params, batches, cumulus_pallet_xcmp_queue, XcmpQueue); if batches.is_empty() { return Err("Benchmark not found for this pallet.".into()) } Ok(batches) From f2c6a44a8c6e2e01fb6e43db86af362ffa8f2248 Mon Sep 17 00:00:00 2001 From: mustermeiszer Date: Thu, 23 Mar 2023 15:28:42 +0100 Subject: [PATCH 36/55] feat: intermediate change spec name for upgrade on charcoal --- runtime/centrifuge/src/lib.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/runtime/centrifuge/src/lib.rs b/runtime/centrifuge/src/lib.rs index 5674ea56ee..32450a6ee8 100644 --- a/runtime/centrifuge/src/lib.rs +++ b/runtime/centrifuge/src/lib.rs @@ -114,7 +114,7 @@ impl_opaque_keys! { /// Runtime version. #[sp_version::runtime_version] pub const VERSION: RuntimeVersion = RuntimeVersion { - spec_name: create_runtime_str!("centrifuge"), + spec_name: create_runtime_str!("centrifuge_1018_v1"), impl_name: create_runtime_str!("centrifuge"), authoring_version: 1, spec_version: 1017, From 654b5abefa8a72a14eaa4aae1c33fa17a4ca52d3 Mon Sep 17 00:00:00 2001 From: mustermeiszer Date: Thu, 23 Mar 2023 19:43:53 +0100 Subject: [PATCH 37/55] fix: failing collator-allowlist test with benchmark fix --- pallets/collator-allowlist/src/lib.rs | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/pallets/collator-allowlist/src/lib.rs b/pallets/collator-allowlist/src/lib.rs index 9fbddd50fb..870ddfe4b0 100644 --- a/pallets/collator-allowlist/src/lib.rs +++ b/pallets/collator-allowlist/src/lib.rs @@ -171,6 +171,7 @@ impl ValidatorRegistration for Pallet { /// True iff /// - the validator id is present in the allowlist and /// - the validator id is registered in the underlying validator registration center + #[cfg(not(test))] fn is_registered(id: &T::ValidatorId) -> bool { let contains_key = if cfg!(feature = "runtime-benchmarks") { // NOTE: We want to return true but count the storage hit @@ -183,4 +184,12 @@ impl ValidatorRegistration for Pallet { contains_key && T::ValidatorRegistration::is_registered(id) } + + // NOTE: Running test with `feature = "runtime-benchmarks"` breaks the test + // with the above solution for fixing `pallet-collator-selection` benchmarks + // hence, we have a "non-benchmarking implementation" here + #[cfg(test)] + fn is_registered(id: &T::ValidatorId) -> bool { + >::contains_key(id) && T::ValidatorRegistration::is_registered(id) + } } From 274bb56097ca791ee8297294e47a3589e315eb24 Mon Sep 17 00:00:00 2001 From: mustermeiszer Date: Thu, 23 Mar 2023 20:25:33 +0100 Subject: [PATCH 38/55] feat: update nix hash --- flake.nix | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/flake.nix b/flake.nix index 9e9492f7a3..86fbad0bd6 100644 --- a/flake.nix +++ b/flake.nix @@ -93,7 +93,7 @@ }; # This is a hash of all the Cargo dependencies, for reproducibility. - cargoSha256 = "sha256-oFQdoYxrNYH+x5QggsJxb0W+hl/bv9FXopyV62cqE1A="; + cargoSha256 = "sha256-Q29cYuepnB3LxOSSwzxhnn+yxm+hLxOH5t8N645J0f4="; nativeBuildInputs = with pkgs; [ clang git-mock pkg-config ]; buildInputs = with pkgs; [ openssl ] ++ ( From e2b4b3a3c900739bca9309c2170c63a4fad69c05 Mon Sep 17 00:00:00 2001 From: mustermeiszer Date: Fri, 24 Mar 2023 10:49:44 +0100 Subject: [PATCH 39/55] fiy: clippy lint, allow for readabulity --- runtime/altair/src/lib.rs | 1 + runtime/centrifuge/src/lib.rs | 1 + 2 files changed, 2 insertions(+) diff --git a/runtime/altair/src/lib.rs b/runtime/altair/src/lib.rs index 749be5672d..a080cce725 100644 --- a/runtime/altair/src/lib.rs +++ b/runtime/altair/src/lib.rs @@ -1274,6 +1274,7 @@ impl PoolUpdateGuard for UpdateGuard { // event. // - We check for greater equal in order to forbid batching // those two in one block + #[allow(clippy::all)] if !cfg!(feature = "runtime-benchmarks") { if update.submitted_at >= pool.epoch.last_closed { return false; diff --git a/runtime/centrifuge/src/lib.rs b/runtime/centrifuge/src/lib.rs index 32450a6ee8..356bfaed46 100644 --- a/runtime/centrifuge/src/lib.rs +++ b/runtime/centrifuge/src/lib.rs @@ -1219,6 +1219,7 @@ impl PoolUpdateGuard for UpdateGuard { // event. // - We check for greater equal in order to forbid batching // those two in one block + #[allow(clippy::all)] if !cfg!(feature = "runtime-benchmarks") { if update.submitted_at >= pool.epoch.last_closed { return false; From 81bee18f1b2ed425f72bca218a7c9ac57ff6b6c0 Mon Sep 17 00:00:00 2001 From: mustermeiszer Date: Fri, 24 Mar 2023 12:48:43 +0100 Subject: [PATCH 40/55] fix: xclippy allow not working, using suggestion --- runtime/altair/src/lib.rs | 7 ++----- runtime/centrifuge/src/lib.rs | 7 ++----- 2 files changed, 4 insertions(+), 10 deletions(-) diff --git a/runtime/altair/src/lib.rs b/runtime/altair/src/lib.rs index a080cce725..4578feda97 100644 --- a/runtime/altair/src/lib.rs +++ b/runtime/altair/src/lib.rs @@ -1274,11 +1274,8 @@ impl PoolUpdateGuard for UpdateGuard { // event. // - We check for greater equal in order to forbid batching // those two in one block - #[allow(clippy::all)] - if !cfg!(feature = "runtime-benchmarks") { - if update.submitted_at >= pool.epoch.last_closed { - return false; - } + if !cfg!(feature = "runtime-benchmarks") && update.submitted_at >= pool.epoch.last_closed { + return false; } let pool_id = pool.tranches.of_pool(); diff --git a/runtime/centrifuge/src/lib.rs b/runtime/centrifuge/src/lib.rs index 356bfaed46..84113657c6 100644 --- a/runtime/centrifuge/src/lib.rs +++ b/runtime/centrifuge/src/lib.rs @@ -1219,11 +1219,8 @@ impl PoolUpdateGuard for UpdateGuard { // event. // - We check for greater equal in order to forbid batching // those two in one block - #[allow(clippy::all)] - if !cfg!(feature = "runtime-benchmarks") { - if update.submitted_at >= pool.epoch.last_closed { - return false; - } + if !cfg!(feature = "runtime-benchmarks") && update.submitted_at >= pool.epoch.last_closed { + return false; } let pool_id = pool.tranches.of_pool(); From 8c01c9f1e4d0bd012da8edcc24f9e4b50a1b9fe9 Mon Sep 17 00:00:00 2001 From: mustermeiszer Date: Fri, 24 Mar 2023 15:26:18 +0100 Subject: [PATCH 41/55] fix: clippy development runtime --- runtime/development/src/lib.rs | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/runtime/development/src/lib.rs b/runtime/development/src/lib.rs index 78374107a7..a54f316c87 100644 --- a/runtime/development/src/lib.rs +++ b/runtime/development/src/lib.rs @@ -1084,10 +1084,8 @@ impl PoolUpdateGuard for UpdateGuard { // event. // - We check for greater equal in order to forbid batching // those two in one block - if !cfg!(feature = "runtime-benchmarks") { - if update.submitted_at >= pool.epoch.last_closed { - return false; - } + if !cfg!(feature = "runtime-benchmarks") && update.submitted_at >= pool.epoch.last_closed { + return false; } let pool_id = pool.tranches.of_pool(); From c6f313c55ac8c122259e1b1ceef287720d30512a Mon Sep 17 00:00:00 2001 From: mustermeiszer Date: Fri, 24 Mar 2023 15:39:10 +0100 Subject: [PATCH 42/55] feat: adapt weight to high fix --- pallets/investments/src/lib.rs | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/pallets/investments/src/lib.rs b/pallets/investments/src/lib.rs index 6fd20b74f3..407e42c329 100644 --- a/pallets/investments/src/lib.rs +++ b/pallets/investments/src/lib.rs @@ -459,7 +459,7 @@ pub mod pallet { /// amount is less than the current order, the balance /// will be transferred from the pool to the calling /// account. - #[pallet::weight(80_000_000)] + #[pallet::weight(5_000_000_000)] pub fn update_invest_order( origin: OriginFor, investment_id: T::InvestmentId, @@ -478,7 +478,7 @@ pub mod pallet { /// amount is less than the current order, the balance /// will be transferred from the pool to the calling /// account. - #[pallet::weight(80_000_000)] + #[pallet::weight(5_000_000_000)] pub fn update_redeem_order( origin: OriginFor, investment_id: T::InvestmentId, @@ -492,7 +492,7 @@ pub mod pallet { /// Collect the results of a users invest orders for the given investment. /// If any amounts are not fulfilled they are directly appended to the next active /// order for this investment. - #[pallet::weight(80_000_000)] + #[pallet::weight(5_000_000_000)] pub fn collect_investments( origin: OriginFor, investment_id: T::InvestmentId, @@ -505,7 +505,7 @@ pub mod pallet { /// Collect the results of a users redeem orders for the given investment. /// If any amounts are not fulfilled they are directly appended to the next active /// order for this investment. - #[pallet::weight(80_000_000)] + #[pallet::weight(5_000_000_000)] pub fn collect_redemptions( origin: OriginFor, investment_id: T::InvestmentId, @@ -518,7 +518,7 @@ pub mod pallet { /// Collect the results of another users invest orders for the given investment. /// If any amounts are not fulfilled they are directly appended to the next active /// order for this investment. - #[pallet::weight(80_000_000)] + #[pallet::weight(5_000_000_000)] pub fn collect_investments_for( origin: OriginFor, who: T::AccountId, @@ -532,7 +532,7 @@ pub mod pallet { /// Collect the results of another users redeem orders for the given investment. /// If any amounts are not fulfilled they are directly appended to the next active /// order for this investment. - #[pallet::weight(80_000_000)] + #[pallet::weight(5_000_000_000)] pub fn collect_redemptions_for( origin: OriginFor, who: T::AccountId, From 319b4a9382af7dd4f1799d03dc073a68ef28464b Mon Sep 17 00:00:00 2001 From: mustermeiszer Date: Tue, 28 Mar 2023 08:47:22 +0200 Subject: [PATCH 43/55] feat: update weights centrifuge --- .../src/weights/cumulus_pallet_xcmp_queue.rs | 47 +++++ .../centrifuge/src/weights/frame_system.rs | 44 ++--- runtime/centrifuge/src/weights/mod.rs | 3 + .../centrifuge/src/weights/pallet_anchors.rs | 18 +- .../centrifuge/src/weights/pallet_balances.rs | 30 ++-- .../src/weights/pallet_collator_allowlist.rs | 10 +- .../src/weights/pallet_collator_selection.rs | 110 ++++++++++++ .../src/weights/pallet_collective.rs | 126 +++++++------- .../src/weights/pallet_crowdloan_claim.rs | 36 ++-- .../src/weights/pallet_crowdloan_reward.rs | 18 +- .../src/weights/pallet_democracy.rs | 122 ++++++------- runtime/centrifuge/src/weights/pallet_fees.rs | 6 +- .../centrifuge/src/weights/pallet_identity.rs | 162 +++++++++--------- .../src/weights/pallet_interest_accrual.rs | 8 +- .../centrifuge/src/weights/pallet_keystore.rs | 22 +-- .../src/weights/pallet_loans_ref.rs | 142 +++++++++++---- .../src/weights/pallet_migration_manager.rs | 34 ++-- .../centrifuge/src/weights/pallet_multisig.rs | 70 ++++---- .../src/weights/pallet_permissions.rs | 26 +-- .../src/weights/pallet_pool_registry.rs | 42 ++--- .../src/weights/pallet_pool_system.rs | 52 +++--- .../centrifuge/src/weights/pallet_preimage.rs | 60 +++---- .../centrifuge/src/weights/pallet_proxy.rs | 98 +++++------ .../src/weights/pallet_restricted_tokens.rs | 109 ++++++++++++ .../src/weights/pallet_scheduler.rs | 72 ++++---- .../src/weights/pallet_timestamp.rs | 10 +- .../centrifuge/src/weights/pallet_treasury.rs | 32 ++-- .../centrifuge/src/weights/pallet_uniques.rs | 120 ++++++------- .../centrifuge/src/weights/pallet_utility.rs | 34 ++-- .../centrifuge/src/weights/pallet_vesting.rs | 82 +++++---- 30 files changed, 1040 insertions(+), 705 deletions(-) create mode 100644 runtime/centrifuge/src/weights/cumulus_pallet_xcmp_queue.rs create mode 100644 runtime/centrifuge/src/weights/pallet_collator_selection.rs create mode 100644 runtime/centrifuge/src/weights/pallet_restricted_tokens.rs diff --git a/runtime/centrifuge/src/weights/cumulus_pallet_xcmp_queue.rs b/runtime/centrifuge/src/weights/cumulus_pallet_xcmp_queue.rs new file mode 100644 index 0000000000..ccb7df2f53 --- /dev/null +++ b/runtime/centrifuge/src/weights/cumulus_pallet_xcmp_queue.rs @@ -0,0 +1,47 @@ + +//! Autogenerated weights for `cumulus_pallet_xcmp_queue` +//! +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev +//! DATE: 2023-03-27, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` +//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("centrifuge-dev"), DB CACHE: 1024 + +// Executed Command: +// target/release/centrifuge-chain +// benchmark +// pallet +// --chain=centrifuge-dev +// --steps=50 +// --repeat=20 +// --pallet=cumulus_pallet_xcmp_queue +// --extrinsic=* +// --execution=wasm +// --wasm-execution=compiled +// --heap-pages=4096 +// --output=/tmp/runtime/centrifuge/src/weights/cumulus_pallet_xcmp_queue.rs + +#![cfg_attr(rustfmt, rustfmt_skip)] +#![allow(unused_parens)] +#![allow(unused_imports)] + +use frame_support::{traits::Get, weights::Weight}; +use sp_std::marker::PhantomData; + +/// Weight functions for `cumulus_pallet_xcmp_queue`. +pub struct WeightInfo(PhantomData); +impl cumulus_pallet_xcmp_queue::WeightInfo for WeightInfo { + // Storage: XcmpQueue QueueConfig (r:1 w:1) + fn set_config_with_u32() -> Weight { + // Minimum execution time: 13_901 nanoseconds. + Weight::from_ref_time(14_200_000 as u64) + .saturating_add(T::DbWeight::get().reads(1 as u64)) + .saturating_add(T::DbWeight::get().writes(1 as u64)) + } + // Storage: XcmpQueue QueueConfig (r:1 w:1) + fn set_config_with_weight() -> Weight { + // Minimum execution time: 14_000 nanoseconds. + Weight::from_ref_time(14_301_000 as u64) + .saturating_add(T::DbWeight::get().reads(1 as u64)) + .saturating_add(T::DbWeight::get().writes(1 as u64)) + } +} diff --git a/runtime/centrifuge/src/weights/frame_system.rs b/runtime/centrifuge/src/weights/frame_system.rs index 6e68577690..30fdd41aaf 100644 --- a/runtime/centrifuge/src/weights/frame_system.rs +++ b/runtime/centrifuge/src/weights/frame_system.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `frame_system` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-03-22, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-03-27, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("centrifuge-dev"), DB CACHE: 1024 @@ -32,51 +32,51 @@ pub struct WeightInfo(PhantomData); impl frame_system::WeightInfo for WeightInfo { /// The range of component `b` is `[0, 3932160]`. fn remark(b: u32, ) -> Weight { - // Minimum execution time: 11_000 nanoseconds. - Weight::from_ref_time(9_387_856 as u64) + // Minimum execution time: 10_700 nanoseconds. + Weight::from_ref_time(7_898_599 as u64) // Standard Error: 0 - .saturating_add(Weight::from_ref_time(533 as u64).saturating_mul(b as u64)) + .saturating_add(Weight::from_ref_time(534 as u64).saturating_mul(b as u64)) } /// The range of component `b` is `[0, 3932160]`. fn remark_with_event(b: u32, ) -> Weight { - // Minimum execution time: 26_300 nanoseconds. - Weight::from_ref_time(26_600_000 as u64) - // Standard Error: 0 - .saturating_add(Weight::from_ref_time(1_906 as u64).saturating_mul(b as u64)) + // Minimum execution time: 26_600 nanoseconds. + Weight::from_ref_time(2_721_110 as u64) + // Standard Error: 1 + .saturating_add(Weight::from_ref_time(1_904 as u64).saturating_mul(b as u64)) } // Storage: System Digest (r:1 w:1) // Storage: unknown [0x3a686561707061676573] (r:0 w:1) fn set_heap_pages() -> Weight { - // Minimum execution time: 17_501 nanoseconds. - Weight::from_ref_time(17_801_000 as u64) + // Minimum execution time: 16_600 nanoseconds. + Weight::from_ref_time(17_200_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } // Storage: Skipped Metadata (r:0 w:0) /// The range of component `i` is `[0, 1000]`. fn set_storage(i: u32, ) -> Weight { - // Minimum execution time: 8_400 nanoseconds. - Weight::from_ref_time(8_600_000 as u64) - // Standard Error: 1_072 - .saturating_add(Weight::from_ref_time(1_164_824 as u64).saturating_mul(i as u64)) + // Minimum execution time: 8_101 nanoseconds. + Weight::from_ref_time(8_300_000 as u64) + // Standard Error: 919 + .saturating_add(Weight::from_ref_time(1_135_971 as u64).saturating_mul(i as u64)) .saturating_add(T::DbWeight::get().writes((1 as u64).saturating_mul(i as u64))) } // Storage: Skipped Metadata (r:0 w:0) /// The range of component `i` is `[0, 1000]`. fn kill_storage(i: u32, ) -> Weight { - // Minimum execution time: 8_500 nanoseconds. - Weight::from_ref_time(8_700_000 as u64) - // Standard Error: 1_014 - .saturating_add(Weight::from_ref_time(918_861 as u64).saturating_mul(i as u64)) + // Minimum execution time: 10_400 nanoseconds. + Weight::from_ref_time(2_798_133 as u64) + // Standard Error: 1_547 + .saturating_add(Weight::from_ref_time(899_039 as u64).saturating_mul(i as u64)) .saturating_add(T::DbWeight::get().writes((1 as u64).saturating_mul(i as u64))) } // Storage: Skipped Metadata (r:0 w:0) /// The range of component `p` is `[0, 1000]`. fn kill_prefix(p: u32, ) -> Weight { - // Minimum execution time: 12_000 nanoseconds. - Weight::from_ref_time(12_301_000 as u64) - // Standard Error: 1_857 - .saturating_add(Weight::from_ref_time(1_703_292 as u64).saturating_mul(p as u64)) + // Minimum execution time: 11_600 nanoseconds. + Weight::from_ref_time(591_927 as u64) + // Standard Error: 2_410 + .saturating_add(Weight::from_ref_time(1_672_410 as u64).saturating_mul(p as u64)) .saturating_add(T::DbWeight::get().writes((1 as u64).saturating_mul(p as u64))) } } diff --git a/runtime/centrifuge/src/weights/mod.rs b/runtime/centrifuge/src/weights/mod.rs index e6651412ab..b755e9c78a 100644 --- a/runtime/centrifuge/src/weights/mod.rs +++ b/runtime/centrifuge/src/weights/mod.rs @@ -9,10 +9,12 @@ // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. +pub mod cumulus_pallet_xcmp_queue; pub mod frame_system; pub mod pallet_anchors; pub mod pallet_balances; pub mod pallet_collator_allowlist; +pub mod pallet_collator_selection; pub mod pallet_collective; pub mod pallet_crowdloan_claim; pub mod pallet_crowdloan_reward; @@ -29,6 +31,7 @@ pub mod pallet_pool_registry; pub mod pallet_pool_system; pub mod pallet_preimage; pub mod pallet_proxy; +pub mod pallet_restricted_tokens; pub mod pallet_scheduler; pub mod pallet_timestamp; pub mod pallet_treasury; diff --git a/runtime/centrifuge/src/weights/pallet_anchors.rs b/runtime/centrifuge/src/weights/pallet_anchors.rs index f466af2fee..4c52924fab 100644 --- a/runtime/centrifuge/src/weights/pallet_anchors.rs +++ b/runtime/centrifuge/src/weights/pallet_anchors.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_anchors` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-03-22, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-03-27, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("centrifuge-dev"), DB CACHE: 1024 @@ -34,8 +34,8 @@ impl pallet_anchors::WeightInfo for WeightInfo { // Storage: Anchor PreCommits (r:1 w:1) // Storage: Fees FeeBalances (r:1 w:0) fn pre_commit() -> Weight { - // Minimum execution time: 64_202 nanoseconds. - Weight::from_ref_time(64_802_000 as u64) + // Minimum execution time: 62_201 nanoseconds. + Weight::from_ref_time(64_401_000 as u64) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } @@ -49,15 +49,15 @@ impl pallet_anchors::WeightInfo for WeightInfo { // Storage: Anchor AnchorIndexes (r:0 w:1) // Storage: unknown [0xdb4faa73ca6d2016e53c7156087c176b79b169c409b8a0063a07964f3187f9e9] (r:0 w:1) fn commit() -> Weight { - // Minimum execution time: 97_303 nanoseconds. - Weight::from_ref_time(98_403_000 as u64) + // Minimum execution time: 97_201 nanoseconds. + Weight::from_ref_time(98_102_000 as u64) .saturating_add(T::DbWeight::get().reads(7 as u64)) .saturating_add(T::DbWeight::get().writes(5 as u64)) } // Storage: Anchor PreCommits (r:100 w:100) fn evict_pre_commits() -> Weight { - // Minimum execution time: 2_106_762 nanoseconds. - Weight::from_ref_time(2_128_162_000 as u64) + // Minimum execution time: 2_020_237 nanoseconds. + Weight::from_ref_time(2_044_239_000 as u64) .saturating_add(T::DbWeight::get().reads(100 as u64)) .saturating_add(T::DbWeight::get().writes(100 as u64)) } @@ -269,8 +269,8 @@ impl pallet_anchors::WeightInfo for WeightInfo { // Storage: unknown [0xee60c64e1e32117f948ee71d391f978e8ac98c2bd869322fc25164502e3f7a9b] (r:0 w:1) // Storage: unknown [0xf7e4b8a5415405a940e730546df85583c8c23956d99a3be18e09eebf3639d312] (r:0 w:1) fn evict_anchors() -> Weight { - // Minimum execution time: 2_316_369 nanoseconds. - Weight::from_ref_time(2_344_869_000 as u64) + // Minimum execution time: 2_266_743 nanoseconds. + Weight::from_ref_time(2_287_843_000 as u64) .saturating_add(T::DbWeight::get().reads(404 as u64)) .saturating_add(T::DbWeight::get().writes(402 as u64)) } diff --git a/runtime/centrifuge/src/weights/pallet_balances.rs b/runtime/centrifuge/src/weights/pallet_balances.rs index 8284d46228..65fdf2c1b5 100644 --- a/runtime/centrifuge/src/weights/pallet_balances.rs +++ b/runtime/centrifuge/src/weights/pallet_balances.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_balances` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-03-22, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-03-27, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("centrifuge-dev"), DB CACHE: 1024 @@ -32,50 +32,50 @@ pub struct WeightInfo(PhantomData); impl pallet_balances::WeightInfo for WeightInfo { // Storage: System Account (r:1 w:1) fn transfer() -> Weight { - // Minimum execution time: 88_703 nanoseconds. - Weight::from_ref_time(89_503_000 as u64) + // Minimum execution time: 87_101 nanoseconds. + Weight::from_ref_time(90_501_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: System Account (r:1 w:1) fn transfer_keep_alive() -> Weight { - // Minimum execution time: 65_602 nanoseconds. - Weight::from_ref_time(66_302_000 as u64) + // Minimum execution time: 64_801 nanoseconds. + Weight::from_ref_time(66_001_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: System Account (r:1 w:1) fn set_balance_creating() -> Weight { - // Minimum execution time: 48_101 nanoseconds. - Weight::from_ref_time(48_602_000 as u64) + // Minimum execution time: 48_501 nanoseconds. + Weight::from_ref_time(49_501_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: System Account (r:1 w:1) fn set_balance_killing() -> Weight { - // Minimum execution time: 54_101 nanoseconds. - Weight::from_ref_time(55_001_000 as u64) + // Minimum execution time: 55_001 nanoseconds. + Weight::from_ref_time(55_701_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: System Account (r:2 w:2) fn force_transfer() -> Weight { - // Minimum execution time: 87_803 nanoseconds. - Weight::from_ref_time(88_903_000 as u64) + // Minimum execution time: 84_301 nanoseconds. + Weight::from_ref_time(87_602_000 as u64) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } // Storage: System Account (r:1 w:1) fn transfer_all() -> Weight { - // Minimum execution time: 76_902 nanoseconds. - Weight::from_ref_time(77_503_000 as u64) + // Minimum execution time: 75_702 nanoseconds. + Weight::from_ref_time(77_002_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: System Account (r:1 w:1) fn force_unreserve() -> Weight { - // Minimum execution time: 41_101 nanoseconds. - Weight::from_ref_time(41_501_000 as u64) + // Minimum execution time: 40_901 nanoseconds. + Weight::from_ref_time(54_201_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } diff --git a/runtime/centrifuge/src/weights/pallet_collator_allowlist.rs b/runtime/centrifuge/src/weights/pallet_collator_allowlist.rs index cc57b0b993..54a663a9c9 100644 --- a/runtime/centrifuge/src/weights/pallet_collator_allowlist.rs +++ b/runtime/centrifuge/src/weights/pallet_collator_allowlist.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_collator_allowlist` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-03-22, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-03-27, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("centrifuge-dev"), DB CACHE: 1024 @@ -33,15 +33,15 @@ impl pallet_collator_allowlist::WeightInfo for WeightIn // Storage: Session NextKeys (r:1 w:0) // Storage: CollatorAllowlist Allowlist (r:1 w:1) fn add() -> Weight { - // Minimum execution time: 43_601 nanoseconds. - Weight::from_ref_time(44_401_000 as u64) + // Minimum execution time: 58_701 nanoseconds. + Weight::from_ref_time(60_601_000 as u64) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: CollatorAllowlist Allowlist (r:1 w:1) fn remove() -> Weight { - // Minimum execution time: 36_301 nanoseconds. - Weight::from_ref_time(37_001_000 as u64) + // Minimum execution time: 36_400 nanoseconds. + Weight::from_ref_time(37_101_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } diff --git a/runtime/centrifuge/src/weights/pallet_collator_selection.rs b/runtime/centrifuge/src/weights/pallet_collator_selection.rs new file mode 100644 index 0000000000..e0d661cd1a --- /dev/null +++ b/runtime/centrifuge/src/weights/pallet_collator_selection.rs @@ -0,0 +1,110 @@ + +//! Autogenerated weights for `pallet_collator_selection` +//! +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev +//! DATE: 2023-03-27, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` +//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("centrifuge-dev"), DB CACHE: 1024 + +// Executed Command: +// target/release/centrifuge-chain +// benchmark +// pallet +// --chain=centrifuge-dev +// --steps=50 +// --repeat=20 +// --pallet=pallet_collator_selection +// --extrinsic=* +// --execution=wasm +// --wasm-execution=compiled +// --heap-pages=4096 +// --output=/tmp/runtime/centrifuge/src/weights/pallet_collator_selection.rs + +#![cfg_attr(rustfmt, rustfmt_skip)] +#![allow(unused_parens)] +#![allow(unused_imports)] + +use frame_support::{traits::Get, weights::Weight}; +use sp_std::marker::PhantomData; + +/// Weight functions for `pallet_collator_selection`. +pub struct WeightInfo(PhantomData); +impl pallet_collator_selection::WeightInfo for WeightInfo { + // Storage: CollatorAllowlist Allowlist (r:1 w:0) + // Storage: Session NextKeys (r:1 w:0) + // Storage: CollatorSelection Invulnerables (r:0 w:1) + /// The range of component `b` is `[1, 100]`. + fn set_invulnerables(b: u32, ) -> Weight { + // Minimum execution time: 47_501 nanoseconds. + Weight::from_ref_time(49_205_356 as u64) + // Standard Error: 7_801 + .saturating_add(Weight::from_ref_time(6_486_742 as u64).saturating_mul(b as u64)) + .saturating_add(T::DbWeight::get().reads((2 as u64).saturating_mul(b as u64))) + .saturating_add(T::DbWeight::get().writes(1 as u64)) + } + // Storage: CollatorSelection DesiredCandidates (r:0 w:1) + fn set_desired_candidates() -> Weight { + // Minimum execution time: 30_800 nanoseconds. + Weight::from_ref_time(32_201_000 as u64) + .saturating_add(T::DbWeight::get().writes(1 as u64)) + } + // Storage: CollatorSelection CandidacyBond (r:0 w:1) + fn set_candidacy_bond() -> Weight { + // Minimum execution time: 26_801 nanoseconds. + Weight::from_ref_time(27_500_000 as u64) + .saturating_add(T::DbWeight::get().writes(1 as u64)) + } + // Storage: CollatorSelection Candidates (r:1 w:1) + // Storage: CollatorSelection DesiredCandidates (r:1 w:0) + // Storage: CollatorSelection Invulnerables (r:1 w:0) + // Storage: CollatorAllowlist Allowlist (r:1 w:0) + // Storage: Session NextKeys (r:1 w:0) + // Storage: CollatorSelection CandidacyBond (r:1 w:0) + // Storage: CollatorSelection LastAuthoredBlock (r:0 w:1) + /// The range of component `c` is `[1, 99]`. + fn register_as_candidate(c: u32, ) -> Weight { + // Minimum execution time: 92_502 nanoseconds. + Weight::from_ref_time(101_943_525 as u64) + // Standard Error: 3_754 + .saturating_add(Weight::from_ref_time(512_227 as u64).saturating_mul(c as u64)) + .saturating_add(T::DbWeight::get().reads(6 as u64)) + .saturating_add(T::DbWeight::get().writes(2 as u64)) + } + // Storage: CollatorSelection Candidates (r:1 w:1) + // Storage: CollatorSelection LastAuthoredBlock (r:0 w:1) + /// The range of component `c` is `[6, 100]`. + fn leave_intent(c: u32, ) -> Weight { + // Minimum execution time: 69_501 nanoseconds. + Weight::from_ref_time(71_101_392 as u64) + // Standard Error: 4_706 + .saturating_add(Weight::from_ref_time(451_804 as u64).saturating_mul(c as u64)) + .saturating_add(T::DbWeight::get().reads(1 as u64)) + .saturating_add(T::DbWeight::get().writes(2 as u64)) + } + // Storage: System Account (r:2 w:2) + // Storage: System BlockWeight (r:1 w:1) + // Storage: CollatorSelection LastAuthoredBlock (r:0 w:1) + fn note_author() -> Weight { + // Minimum execution time: 67_102 nanoseconds. + Weight::from_ref_time(67_901_000 as u64) + .saturating_add(T::DbWeight::get().reads(3 as u64)) + .saturating_add(T::DbWeight::get().writes(4 as u64)) + } + // Storage: CollatorSelection Candidates (r:1 w:1) + // Storage: CollatorSelection LastAuthoredBlock (r:100 w:1) + // Storage: System Account (r:1 w:1) + // Storage: CollatorSelection Invulnerables (r:1 w:0) + // Storage: System BlockWeight (r:1 w:1) + /// The range of component `r` is `[1, 100]`. + /// The range of component `c` is `[1, 100]`. + fn new_session(_r: u32, c: u32, ) -> Weight { + // Minimum execution time: 38_401 nanoseconds. + Weight::from_ref_time(39_101_000 as u64) + // Standard Error: 514_071 + .saturating_add(Weight::from_ref_time(19_273_271 as u64).saturating_mul(c as u64)) + .saturating_add(T::DbWeight::get().reads(4 as u64)) + .saturating_add(T::DbWeight::get().reads((1 as u64).saturating_mul(c as u64))) + .saturating_add(T::DbWeight::get().writes(1 as u64)) + .saturating_add(T::DbWeight::get().writes((1 as u64).saturating_mul(c as u64))) + } +} diff --git a/runtime/centrifuge/src/weights/pallet_collective.rs b/runtime/centrifuge/src/weights/pallet_collective.rs index 797c146cda..fcea773bf1 100644 --- a/runtime/centrifuge/src/weights/pallet_collective.rs +++ b/runtime/centrifuge/src/weights/pallet_collective.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_collective` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-03-22, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-03-27, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("centrifuge-dev"), DB CACHE: 1024 @@ -38,12 +38,12 @@ impl pallet_collective::WeightInfo for WeightInfo { /// The range of component `n` is `[0, 100]`. /// The range of component `p` is `[0, 100]`. fn set_members(m: u32, _n: u32, p: u32, ) -> Weight { - // Minimum execution time: 31_701 nanoseconds. - Weight::from_ref_time(32_201_000 as u64) - // Standard Error: 99_244 - .saturating_add(Weight::from_ref_time(7_380_754 as u64).saturating_mul(m as u64)) - // Standard Error: 99_244 - .saturating_add(Weight::from_ref_time(12_634_195 as u64).saturating_mul(p as u64)) + // Minimum execution time: 31_400 nanoseconds. + Weight::from_ref_time(31_500_000 as u64) + // Standard Error: 96_202 + .saturating_add(Weight::from_ref_time(7_397_697 as u64).saturating_mul(m as u64)) + // Standard Error: 96_202 + .saturating_add(Weight::from_ref_time(12_307_214 as u64).saturating_mul(p as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().reads((1 as u64).saturating_mul(p as u64))) .saturating_add(T::DbWeight::get().writes(2 as u64)) @@ -53,12 +53,12 @@ impl pallet_collective::WeightInfo for WeightInfo { /// The range of component `b` is `[1, 1024]`. /// The range of component `m` is `[1, 100]`. fn execute(b: u32, m: u32, ) -> Weight { - // Minimum execution time: 40_800 nanoseconds. - Weight::from_ref_time(40_541_285 as u64) - // Standard Error: 162 - .saturating_add(Weight::from_ref_time(2_434 as u64).saturating_mul(b as u64)) - // Standard Error: 1_676 - .saturating_add(Weight::from_ref_time(24_543 as u64).saturating_mul(m as u64)) + // Minimum execution time: 38_300 nanoseconds. + Weight::from_ref_time(41_758_120 as u64) + // Standard Error: 217 + .saturating_add(Weight::from_ref_time(1_706 as u64).saturating_mul(b as u64)) + // Standard Error: 2_247 + .saturating_add(Weight::from_ref_time(16_039 as u64).saturating_mul(m as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) } // Storage: Council Members (r:1 w:0) @@ -66,12 +66,12 @@ impl pallet_collective::WeightInfo for WeightInfo { /// The range of component `b` is `[1, 1024]`. /// The range of component `m` is `[1, 100]`. fn propose_execute(b: u32, m: u32, ) -> Weight { - // Minimum execution time: 44_501 nanoseconds. - Weight::from_ref_time(45_038_368 as u64) - // Standard Error: 217 - .saturating_add(Weight::from_ref_time(2_088 as u64).saturating_mul(b as u64)) - // Standard Error: 2_242 - .saturating_add(Weight::from_ref_time(34_125 as u64).saturating_mul(m as u64)) + // Minimum execution time: 42_400 nanoseconds. + Weight::from_ref_time(43_539_572 as u64) + // Standard Error: 311 + .saturating_add(Weight::from_ref_time(2_632 as u64).saturating_mul(b as u64)) + // Standard Error: 3_216 + .saturating_add(Weight::from_ref_time(49_699 as u64).saturating_mul(m as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) } // Storage: Council Members (r:1 w:0) @@ -83,14 +83,14 @@ impl pallet_collective::WeightInfo for WeightInfo { /// The range of component `m` is `[2, 100]`. /// The range of component `p` is `[1, 100]`. fn propose_proposed(b: u32, m: u32, p: u32, ) -> Weight { - // Minimum execution time: 57_700 nanoseconds. - Weight::from_ref_time(53_147_330 as u64) - // Standard Error: 273 - .saturating_add(Weight::from_ref_time(9_038 as u64).saturating_mul(b as u64)) - // Standard Error: 2_861 - .saturating_add(Weight::from_ref_time(45_225 as u64).saturating_mul(m as u64)) - // Standard Error: 2_824 - .saturating_add(Weight::from_ref_time(426_273 as u64).saturating_mul(p as u64)) + // Minimum execution time: 58_001 nanoseconds. + Weight::from_ref_time(55_068_586 as u64) + // Standard Error: 320 + .saturating_add(Weight::from_ref_time(7_209 as u64).saturating_mul(b as u64)) + // Standard Error: 3_344 + .saturating_add(Weight::from_ref_time(48_125 as u64).saturating_mul(m as u64)) + // Standard Error: 3_302 + .saturating_add(Weight::from_ref_time(402_833 as u64).saturating_mul(p as u64)) .saturating_add(T::DbWeight::get().reads(4 as u64)) .saturating_add(T::DbWeight::get().writes(4 as u64)) } @@ -98,10 +98,10 @@ impl pallet_collective::WeightInfo for WeightInfo { // Storage: Council Voting (r:1 w:1) /// The range of component `m` is `[5, 100]`. fn vote(m: u32, ) -> Weight { - // Minimum execution time: 62_400 nanoseconds. - Weight::from_ref_time(69_097_339 as u64) - // Standard Error: 4_424 - .saturating_add(Weight::from_ref_time(100_100 as u64).saturating_mul(m as u64)) + // Minimum execution time: 59_402 nanoseconds. + Weight::from_ref_time(68_986_571 as u64) + // Standard Error: 4_117 + .saturating_add(Weight::from_ref_time(80_265 as u64).saturating_mul(m as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } @@ -112,12 +112,12 @@ impl pallet_collective::WeightInfo for WeightInfo { /// The range of component `m` is `[4, 100]`. /// The range of component `p` is `[1, 100]`. fn close_early_disapproved(m: u32, p: u32, ) -> Weight { - // Minimum execution time: 61_600 nanoseconds. - Weight::from_ref_time(63_795_512 as u64) - // Standard Error: 2_361 - .saturating_add(Weight::from_ref_time(40_085 as u64).saturating_mul(m as u64)) - // Standard Error: 2_302 - .saturating_add(Weight::from_ref_time(379_929 as u64).saturating_mul(p as u64)) + // Minimum execution time: 60_501 nanoseconds. + Weight::from_ref_time(63_132_423 as u64) + // Standard Error: 2_858 + .saturating_add(Weight::from_ref_time(47_212 as u64).saturating_mul(m as u64)) + // Standard Error: 2_787 + .saturating_add(Weight::from_ref_time(361_086 as u64).saturating_mul(p as u64)) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -129,14 +129,14 @@ impl pallet_collective::WeightInfo for WeightInfo { /// The range of component `m` is `[4, 100]`. /// The range of component `p` is `[1, 100]`. fn close_early_approved(b: u32, m: u32, p: u32, ) -> Weight { - // Minimum execution time: 82_601 nanoseconds. - Weight::from_ref_time(78_304_032 as u64) - // Standard Error: 323 - .saturating_add(Weight::from_ref_time(5_974 as u64).saturating_mul(b as u64)) - // Standard Error: 3_426 - .saturating_add(Weight::from_ref_time(65_693 as u64).saturating_mul(m as u64)) - // Standard Error: 3_340 - .saturating_add(Weight::from_ref_time(424_371 as u64).saturating_mul(p as u64)) + // Minimum execution time: 83_202 nanoseconds. + Weight::from_ref_time(77_470_609 as u64) + // Standard Error: 278 + .saturating_add(Weight::from_ref_time(6_493 as u64).saturating_mul(b as u64)) + // Standard Error: 2_949 + .saturating_add(Weight::from_ref_time(75_717 as u64).saturating_mul(m as u64)) + // Standard Error: 2_875 + .saturating_add(Weight::from_ref_time(396_353 as u64).saturating_mul(p as u64)) .saturating_add(T::DbWeight::get().reads(4 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -148,12 +148,12 @@ impl pallet_collective::WeightInfo for WeightInfo { /// The range of component `m` is `[4, 100]`. /// The range of component `p` is `[1, 100]`. fn close_disapproved(m: u32, p: u32, ) -> Weight { - // Minimum execution time: 66_400 nanoseconds. - Weight::from_ref_time(66_445_151 as u64) - // Standard Error: 2_345 - .saturating_add(Weight::from_ref_time(63_290 as u64).saturating_mul(m as u64)) - // Standard Error: 2_287 - .saturating_add(Weight::from_ref_time(382_840 as u64).saturating_mul(p as u64)) + // Minimum execution time: 66_401 nanoseconds. + Weight::from_ref_time(68_021_907 as u64) + // Standard Error: 3_802 + .saturating_add(Weight::from_ref_time(59_743 as u64).saturating_mul(m as u64)) + // Standard Error: 3_708 + .saturating_add(Weight::from_ref_time(318_779 as u64).saturating_mul(p as u64)) .saturating_add(T::DbWeight::get().reads(4 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -166,14 +166,14 @@ impl pallet_collective::WeightInfo for WeightInfo { /// The range of component `m` is `[4, 100]`. /// The range of component `p` is `[1, 100]`. fn close_approved(b: u32, m: u32, p: u32, ) -> Weight { - // Minimum execution time: 87_601 nanoseconds. - Weight::from_ref_time(88_158_241 as u64) - // Standard Error: 301 - .saturating_add(Weight::from_ref_time(3_959 as u64).saturating_mul(b as u64)) - // Standard Error: 3_192 - .saturating_add(Weight::from_ref_time(31_046 as u64).saturating_mul(m as u64)) - // Standard Error: 3_112 - .saturating_add(Weight::from_ref_time(417_207 as u64).saturating_mul(p as u64)) + // Minimum execution time: 85_202 nanoseconds. + Weight::from_ref_time(81_799_386 as u64) + // Standard Error: 315 + .saturating_add(Weight::from_ref_time(7_595 as u64).saturating_mul(b as u64)) + // Standard Error: 3_333 + .saturating_add(Weight::from_ref_time(66_901 as u64).saturating_mul(m as u64)) + // Standard Error: 3_249 + .saturating_add(Weight::from_ref_time(389_683 as u64).saturating_mul(p as u64)) .saturating_add(T::DbWeight::get().reads(5 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -182,10 +182,10 @@ impl pallet_collective::WeightInfo for WeightInfo { // Storage: Council ProposalOf (r:0 w:1) /// The range of component `p` is `[1, 100]`. fn disapprove_proposal(p: u32, ) -> Weight { - // Minimum execution time: 39_801 nanoseconds. - Weight::from_ref_time(44_533_213 as u64) - // Standard Error: 3_329 - .saturating_add(Weight::from_ref_time(393_758 as u64).saturating_mul(p as u64)) + // Minimum execution time: 36_501 nanoseconds. + Weight::from_ref_time(44_786_338 as u64) + // Standard Error: 3_912 + .saturating_add(Weight::from_ref_time(371_438 as u64).saturating_mul(p as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } diff --git a/runtime/centrifuge/src/weights/pallet_crowdloan_claim.rs b/runtime/centrifuge/src/weights/pallet_crowdloan_claim.rs index d49d085313..17ab7e4560 100644 --- a/runtime/centrifuge/src/weights/pallet_crowdloan_claim.rs +++ b/runtime/centrifuge/src/weights/pallet_crowdloan_claim.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_crowdloan_claim` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-03-22, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-03-27, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("centrifuge-dev"), DB CACHE: 1024 @@ -42,8 +42,8 @@ impl pallet_crowdloan_claim::WeightInfo for WeightInfo< // Storage: System Account (r:2 w:2) // Storage: Balances Locks (r:1 w:1) fn claim_reward_ed25519() -> Weight { - // Minimum execution time: 274_202 nanoseconds. - Weight::from_ref_time(276_702_000 as u64) + // Minimum execution time: 270_505 nanoseconds. + Weight::from_ref_time(272_605_000 as u64) .saturating_add(T::DbWeight::get().reads(12 as u64)) .saturating_add(T::DbWeight::get().writes(5 as u64)) } @@ -59,8 +59,8 @@ impl pallet_crowdloan_claim::WeightInfo for WeightInfo< // Storage: System Account (r:2 w:2) // Storage: Balances Locks (r:1 w:1) fn claim_reward_sr25519() -> Weight { - // Minimum execution time: 280_202 nanoseconds. - Weight::from_ref_time(283_302_000 as u64) + // Minimum execution time: 269_405 nanoseconds. + Weight::from_ref_time(277_505_000 as u64) .saturating_add(T::DbWeight::get().reads(12 as u64)) .saturating_add(T::DbWeight::get().writes(5 as u64)) } @@ -76,8 +76,8 @@ impl pallet_crowdloan_claim::WeightInfo for WeightInfo< // Storage: System Account (r:2 w:2) // Storage: Balances Locks (r:1 w:1) fn claim_reward_ecdsa() -> Weight { - // Minimum execution time: 258_302 nanoseconds. - Weight::from_ref_time(259_902_000 as u64) + // Minimum execution time: 249_605 nanoseconds. + Weight::from_ref_time(255_005_000 as u64) .saturating_add(T::DbWeight::get().reads(12 as u64)) .saturating_add(T::DbWeight::get().writes(5 as u64)) } @@ -89,39 +89,39 @@ impl pallet_crowdloan_claim::WeightInfo for WeightInfo< // Storage: CrowdloanClaim CrowdloanTrieIndex (r:0 w:1) // Storage: CrowdloanClaim LockedAt (r:0 w:1) fn initialize() -> Weight { - // Minimum execution time: 42_900 nanoseconds. - Weight::from_ref_time(44_200_000 as u64) + // Minimum execution time: 55_901 nanoseconds. + Weight::from_ref_time(57_101_000 as u64) .saturating_add(T::DbWeight::get().reads(4 as u64)) .saturating_add(T::DbWeight::get().writes(6 as u64)) } // Storage: CrowdloanClaim LeaseStart (r:0 w:1) fn set_lease_start() -> Weight { - // Minimum execution time: 26_300 nanoseconds. - Weight::from_ref_time(26_900_000 as u64) + // Minimum execution time: 26_301 nanoseconds. + Weight::from_ref_time(27_000_000 as u64) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: CrowdloanClaim LeasePeriod (r:0 w:1) fn set_lease_period() -> Weight { // Minimum execution time: 26_000 nanoseconds. - Weight::from_ref_time(26_600_000 as u64) + Weight::from_ref_time(26_701_000 as u64) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: CrowdloanClaim Contributions (r:0 w:1) fn set_contributions_root() -> Weight { - // Minimum execution time: 27_900 nanoseconds. - Weight::from_ref_time(28_400_000 as u64) + // Minimum execution time: 27_800 nanoseconds. + Weight::from_ref_time(28_600_000 as u64) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: CrowdloanClaim LockedAt (r:0 w:1) fn set_locked_at() -> Weight { - // Minimum execution time: 26_300 nanoseconds. - Weight::from_ref_time(26_800_000 as u64) + // Minimum execution time: 26_001 nanoseconds. + Weight::from_ref_time(26_801_000 as u64) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: CrowdloanClaim CrowdloanTrieIndex (r:0 w:1) fn set_crowdloan_trie_index() -> Weight { - // Minimum execution time: 26_100 nanoseconds. - Weight::from_ref_time(26_800_000 as u64) + // Minimum execution time: 25_601 nanoseconds. + Weight::from_ref_time(26_701_000 as u64) .saturating_add(T::DbWeight::get().writes(1 as u64)) } } diff --git a/runtime/centrifuge/src/weights/pallet_crowdloan_reward.rs b/runtime/centrifuge/src/weights/pallet_crowdloan_reward.rs index d47d77e9ad..a82f45e710 100644 --- a/runtime/centrifuge/src/weights/pallet_crowdloan_reward.rs +++ b/runtime/centrifuge/src/weights/pallet_crowdloan_reward.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_crowdloan_reward` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-03-22, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-03-27, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("centrifuge-dev"), DB CACHE: 1024 @@ -34,26 +34,26 @@ impl pallet_crowdloan_reward::WeightInfo for WeightInfo // Storage: CrowdloanReward VestingPeriod (r:0 w:1) // Storage: CrowdloanReward DirectPayoutRatio (r:0 w:1) fn initialize() -> Weight { - // Minimum execution time: 29_200 nanoseconds. - Weight::from_ref_time(29_800_000 as u64) + // Minimum execution time: 29_600 nanoseconds. + Weight::from_ref_time(30_201_000 as u64) .saturating_add(T::DbWeight::get().writes(3 as u64)) } // Storage: CrowdloanReward VestingStart (r:0 w:1) fn set_vesting_start() -> Weight { - // Minimum execution time: 26_600 nanoseconds. - Weight::from_ref_time(27_100_000 as u64) + // Minimum execution time: 26_801 nanoseconds. + Weight::from_ref_time(27_301_000 as u64) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: CrowdloanReward VestingPeriod (r:0 w:1) fn set_vesting_period() -> Weight { - // Minimum execution time: 26_200 nanoseconds. - Weight::from_ref_time(26_600_000 as u64) + // Minimum execution time: 26_600 nanoseconds. + Weight::from_ref_time(27_100_000 as u64) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: CrowdloanReward DirectPayoutRatio (r:0 w:1) fn set_direct_payout_ratio() -> Weight { - // Minimum execution time: 26_200 nanoseconds. - Weight::from_ref_time(26_900_000 as u64) + // Minimum execution time: 26_900 nanoseconds. + Weight::from_ref_time(27_300_000 as u64) .saturating_add(T::DbWeight::get().writes(1 as u64)) } } diff --git a/runtime/centrifuge/src/weights/pallet_democracy.rs b/runtime/centrifuge/src/weights/pallet_democracy.rs index 32889bbad1..616f88019d 100644 --- a/runtime/centrifuge/src/weights/pallet_democracy.rs +++ b/runtime/centrifuge/src/weights/pallet_democracy.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_democracy` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-03-22, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-03-27, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("centrifuge-dev"), DB CACHE: 1024 @@ -35,15 +35,15 @@ impl pallet_democracy::WeightInfo for WeightInfo { // Storage: Democracy Blacklist (r:1 w:0) // Storage: Democracy DepositOf (r:0 w:1) fn propose() -> Weight { - // Minimum execution time: 96_101 nanoseconds. - Weight::from_ref_time(99_501_000 as u64) + // Minimum execution time: 95_102 nanoseconds. + Weight::from_ref_time(103_603_000 as u64) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } // Storage: Democracy DepositOf (r:1 w:1) fn second() -> Weight { - // Minimum execution time: 88_000 nanoseconds. - Weight::from_ref_time(91_701_000 as u64) + // Minimum execution time: 86_102 nanoseconds. + Weight::from_ref_time(89_102_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } @@ -51,8 +51,8 @@ impl pallet_democracy::WeightInfo for WeightInfo { // Storage: Democracy VotingOf (r:1 w:1) // Storage: Balances Locks (r:1 w:1) fn vote_new() -> Weight { - // Minimum execution time: 112_100 nanoseconds. - Weight::from_ref_time(115_201_000 as u64) + // Minimum execution time: 106_102 nanoseconds. + Weight::from_ref_time(109_702_000 as u64) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -60,16 +60,16 @@ impl pallet_democracy::WeightInfo for WeightInfo { // Storage: Democracy VotingOf (r:1 w:1) // Storage: Balances Locks (r:1 w:1) fn vote_existing() -> Weight { - // Minimum execution time: 110_601 nanoseconds. - Weight::from_ref_time(113_000_000 as u64) + // Minimum execution time: 101_902 nanoseconds. + Weight::from_ref_time(109_502_000 as u64) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } // Storage: Democracy ReferendumInfoOf (r:1 w:1) // Storage: Democracy Cancellations (r:1 w:1) fn emergency_cancel() -> Weight { - // Minimum execution time: 43_500 nanoseconds. - Weight::from_ref_time(44_001_000 as u64) + // Minimum execution time: 42_801 nanoseconds. + Weight::from_ref_time(43_501_000 as u64) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } @@ -80,45 +80,45 @@ impl pallet_democracy::WeightInfo for WeightInfo { // Storage: Democracy ReferendumInfoOf (r:1 w:1) // Storage: Democracy Blacklist (r:0 w:1) fn blacklist() -> Weight { - // Minimum execution time: 165_000 nanoseconds. - Weight::from_ref_time(171_001_000 as u64) + // Minimum execution time: 165_703 nanoseconds. + Weight::from_ref_time(170_204_000 as u64) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(7 as u64)) } // Storage: Democracy NextExternal (r:1 w:1) // Storage: Democracy Blacklist (r:1 w:0) fn external_propose() -> Weight { - // Minimum execution time: 32_901 nanoseconds. - Weight::from_ref_time(33_600_000 as u64) + // Minimum execution time: 30_800 nanoseconds. + Weight::from_ref_time(31_700_000 as u64) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Democracy NextExternal (r:0 w:1) fn external_propose_majority() -> Weight { - // Minimum execution time: 10_700 nanoseconds. - Weight::from_ref_time(11_000_000 as u64) + // Minimum execution time: 10_200 nanoseconds. + Weight::from_ref_time(10_500_000 as u64) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Democracy NextExternal (r:0 w:1) fn external_propose_default() -> Weight { - // Minimum execution time: 10_700 nanoseconds. - Weight::from_ref_time(10_900_000 as u64) + // Minimum execution time: 9_800 nanoseconds. + Weight::from_ref_time(10_201_000 as u64) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Democracy NextExternal (r:1 w:1) // Storage: Democracy ReferendumCount (r:1 w:1) // Storage: Democracy ReferendumInfoOf (r:0 w:1) fn fast_track() -> Weight { - // Minimum execution time: 43_100 nanoseconds. - Weight::from_ref_time(43_500_000 as u64) + // Minimum execution time: 39_701 nanoseconds. + Weight::from_ref_time(43_801_000 as u64) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } // Storage: Democracy NextExternal (r:1 w:1) // Storage: Democracy Blacklist (r:1 w:1) fn veto_external() -> Weight { - // Minimum execution time: 51_900 nanoseconds. - Weight::from_ref_time(52_601_000 as u64) + // Minimum execution time: 47_901 nanoseconds. + Weight::from_ref_time(52_401_000 as u64) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } @@ -126,15 +126,15 @@ impl pallet_democracy::WeightInfo for WeightInfo { // Storage: Democracy DepositOf (r:1 w:1) // Storage: System Account (r:2 w:2) fn cancel_proposal() -> Weight { - // Minimum execution time: 140_600 nanoseconds. - Weight::from_ref_time(152_601_000 as u64) + // Minimum execution time: 140_203 nanoseconds. + Weight::from_ref_time(146_603_000 as u64) .saturating_add(T::DbWeight::get().reads(4 as u64)) .saturating_add(T::DbWeight::get().writes(4 as u64)) } // Storage: Democracy ReferendumInfoOf (r:0 w:1) fn cancel_referendum() -> Weight { - // Minimum execution time: 28_600 nanoseconds. - Weight::from_ref_time(29_100_000 as u64) + // Minimum execution time: 27_801 nanoseconds. + Weight::from_ref_time(28_601_000 as u64) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Democracy LowestUnbaked (r:1 w:1) @@ -142,10 +142,10 @@ impl pallet_democracy::WeightInfo for WeightInfo { // Storage: Democracy ReferendumInfoOf (r:2 w:0) /// The range of component `r` is `[0, 99]`. fn on_initialize_base(r: u32, ) -> Weight { - // Minimum execution time: 12_600 nanoseconds. - Weight::from_ref_time(18_957_989 as u64) - // Standard Error: 5_746 - .saturating_add(Weight::from_ref_time(4_130_078 as u64).saturating_mul(r as u64)) + // Minimum execution time: 12_601 nanoseconds. + Weight::from_ref_time(19_125_902 as u64) + // Standard Error: 8_997 + .saturating_add(Weight::from_ref_time(4_067_788 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().reads((1 as u64).saturating_mul(r as u64))) .saturating_add(T::DbWeight::get().writes(1 as u64)) @@ -158,10 +158,10 @@ impl pallet_democracy::WeightInfo for WeightInfo { // Storage: Democracy ReferendumInfoOf (r:2 w:0) /// The range of component `r` is `[0, 99]`. fn on_initialize_base_with_launch_period(r: u32, ) -> Weight { - // Minimum execution time: 17_700 nanoseconds. - Weight::from_ref_time(24_911_416 as u64) - // Standard Error: 7_376 - .saturating_add(Weight::from_ref_time(4_117_291 as u64).saturating_mul(r as u64)) + // Minimum execution time: 17_600 nanoseconds. + Weight::from_ref_time(24_893_668 as u64) + // Standard Error: 9_430 + .saturating_add(Weight::from_ref_time(4_054_213 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(5 as u64)) .saturating_add(T::DbWeight::get().reads((1 as u64).saturating_mul(r as u64))) .saturating_add(T::DbWeight::get().writes(1 as u64)) @@ -171,10 +171,10 @@ impl pallet_democracy::WeightInfo for WeightInfo { // Storage: Democracy ReferendumInfoOf (r:2 w:2) /// The range of component `r` is `[0, 99]`. fn delegate(r: u32, ) -> Weight { - // Minimum execution time: 84_700 nanoseconds. - Weight::from_ref_time(90_654_379 as u64) - // Standard Error: 9_764 - .saturating_add(Weight::from_ref_time(6_314_017 as u64).saturating_mul(r as u64)) + // Minimum execution time: 83_901 nanoseconds. + Weight::from_ref_time(91_165_021 as u64) + // Standard Error: 9_818 + .saturating_add(Weight::from_ref_time(6_202_233 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(4 as u64)) .saturating_add(T::DbWeight::get().reads((1 as u64).saturating_mul(r as u64))) .saturating_add(T::DbWeight::get().writes(4 as u64)) @@ -184,10 +184,10 @@ impl pallet_democracy::WeightInfo for WeightInfo { // Storage: Democracy ReferendumInfoOf (r:2 w:2) /// The range of component `r` is `[0, 99]`. fn undelegate(r: u32, ) -> Weight { - // Minimum execution time: 50_300 nanoseconds. - Weight::from_ref_time(52_560_121 as u64) - // Standard Error: 9_337 - .saturating_add(Weight::from_ref_time(6_304_108 as u64).saturating_mul(r as u64)) + // Minimum execution time: 51_301 nanoseconds. + Weight::from_ref_time(55_202_350 as u64) + // Standard Error: 9_697 + .saturating_add(Weight::from_ref_time(6_102_441 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().reads((1 as u64).saturating_mul(r as u64))) .saturating_add(T::DbWeight::get().writes(2 as u64)) @@ -195,8 +195,8 @@ impl pallet_democracy::WeightInfo for WeightInfo { } // Storage: Democracy PublicProps (r:0 w:1) fn clear_public_proposals() -> Weight { - // Minimum execution time: 12_200 nanoseconds. - Weight::from_ref_time(12_700_000 as u64) + // Minimum execution time: 11_700 nanoseconds. + Weight::from_ref_time(12_200_000 as u64) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Democracy VotingOf (r:1 w:1) @@ -204,10 +204,10 @@ impl pallet_democracy::WeightInfo for WeightInfo { // Storage: System Account (r:1 w:1) /// The range of component `r` is `[0, 99]`. fn unlock_remove(r: u32, ) -> Weight { - // Minimum execution time: 51_000 nanoseconds. - Weight::from_ref_time(61_722_949 as u64) - // Standard Error: 3_046 - .saturating_add(Weight::from_ref_time(170_410 as u64).saturating_mul(r as u64)) + // Minimum execution time: 49_801 nanoseconds. + Weight::from_ref_time(60_491_330 as u64) + // Standard Error: 3_064 + .saturating_add(Weight::from_ref_time(145_194 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -216,10 +216,10 @@ impl pallet_democracy::WeightInfo for WeightInfo { // Storage: System Account (r:1 w:1) /// The range of component `r` is `[0, 99]`. fn unlock_set(r: u32, ) -> Weight { - // Minimum execution time: 59_000 nanoseconds. - Weight::from_ref_time(61_312_704 as u64) - // Standard Error: 2_161 - .saturating_add(Weight::from_ref_time(231_415 as u64).saturating_mul(r as u64)) + // Minimum execution time: 57_101 nanoseconds. + Weight::from_ref_time(59_152_639 as u64) + // Standard Error: 2_211 + .saturating_add(Weight::from_ref_time(218_465 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -227,10 +227,10 @@ impl pallet_democracy::WeightInfo for WeightInfo { // Storage: Democracy VotingOf (r:1 w:1) /// The range of component `r` is `[1, 100]`. fn remove_vote(r: u32, ) -> Weight { - // Minimum execution time: 33_500 nanoseconds. - Weight::from_ref_time(37_251_298 as u64) - // Standard Error: 3_036 - .saturating_add(Weight::from_ref_time(231_660 as u64).saturating_mul(r as u64)) + // Minimum execution time: 30_900 nanoseconds. + Weight::from_ref_time(35_886_616 as u64) + // Standard Error: 1_687 + .saturating_add(Weight::from_ref_time(224_177 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } @@ -238,10 +238,10 @@ impl pallet_democracy::WeightInfo for WeightInfo { // Storage: Democracy VotingOf (r:1 w:1) /// The range of component `r` is `[1, 100]`. fn remove_other_vote(r: u32, ) -> Weight { - // Minimum execution time: 33_100 nanoseconds. - Weight::from_ref_time(36_226_839 as u64) - // Standard Error: 1_864 - .saturating_add(Weight::from_ref_time(242_230 as u64).saturating_mul(r as u64)) + // Minimum execution time: 30_100 nanoseconds. + Weight::from_ref_time(35_429_670 as u64) + // Standard Error: 1_937 + .saturating_add(Weight::from_ref_time(227_094 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } diff --git a/runtime/centrifuge/src/weights/pallet_fees.rs b/runtime/centrifuge/src/weights/pallet_fees.rs index 1909c651bd..3a3e61a8b3 100644 --- a/runtime/centrifuge/src/weights/pallet_fees.rs +++ b/runtime/centrifuge/src/weights/pallet_fees.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_fees` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-03-22, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-03-27, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("centrifuge-dev"), DB CACHE: 1024 @@ -32,8 +32,8 @@ pub struct WeightInfo(PhantomData); impl pallet_fees::WeightInfo for WeightInfo { // Storage: Fees FeeBalances (r:0 w:1) fn set_fee() -> Weight { - // Minimum execution time: 28_201 nanoseconds. - Weight::from_ref_time(28_900_000 as u64) + // Minimum execution time: 28_200 nanoseconds. + Weight::from_ref_time(28_800_000 as u64) .saturating_add(T::DbWeight::get().writes(1 as u64)) } } diff --git a/runtime/centrifuge/src/weights/pallet_identity.rs b/runtime/centrifuge/src/weights/pallet_identity.rs index be56b64985..cf4d70a8ae 100644 --- a/runtime/centrifuge/src/weights/pallet_identity.rs +++ b/runtime/centrifuge/src/weights/pallet_identity.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_identity` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-03-22, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-03-27, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("centrifuge-dev"), DB CACHE: 1024 @@ -33,10 +33,10 @@ impl pallet_identity::WeightInfo for WeightInfo { // Storage: Identity Registrars (r:1 w:1) /// The range of component `r` is `[1, 19]`. fn add_registrar(r: u32, ) -> Weight { - // Minimum execution time: 35_401 nanoseconds. - Weight::from_ref_time(37_079_394 as u64) - // Standard Error: 5_246 - .saturating_add(Weight::from_ref_time(363_522 as u64).saturating_mul(r as u64)) + // Minimum execution time: 33_901 nanoseconds. + Weight::from_ref_time(36_565_115 as u64) + // Standard Error: 6_014 + .saturating_add(Weight::from_ref_time(355_051 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } @@ -44,12 +44,12 @@ impl pallet_identity::WeightInfo for WeightInfo { /// The range of component `r` is `[1, 20]`. /// The range of component `x` is `[0, 100]`. fn set_identity(r: u32, x: u32, ) -> Weight { - // Minimum execution time: 75_701 nanoseconds. - Weight::from_ref_time(71_718_053 as u64) - // Standard Error: 6_258 - .saturating_add(Weight::from_ref_time(345_307 as u64).saturating_mul(r as u64)) - // Standard Error: 1_221 - .saturating_add(Weight::from_ref_time(720_084 as u64).saturating_mul(x as u64)) + // Minimum execution time: 71_001 nanoseconds. + Weight::from_ref_time(71_971_184 as u64) + // Standard Error: 17_290 + .saturating_add(Weight::from_ref_time(212_597 as u64).saturating_mul(r as u64)) + // Standard Error: 3_373 + .saturating_add(Weight::from_ref_time(687_353 as u64).saturating_mul(x as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } @@ -58,10 +58,10 @@ impl pallet_identity::WeightInfo for WeightInfo { // Storage: Identity SuperOf (r:2 w:2) /// The range of component `s` is `[0, 100]`. fn set_subs_new(s: u32, ) -> Weight { - // Minimum execution time: 23_100 nanoseconds. - Weight::from_ref_time(60_266_376 as u64) - // Standard Error: 17_736 - .saturating_add(Weight::from_ref_time(5_159_463 as u64).saturating_mul(s as u64)) + // Minimum execution time: 21_701 nanoseconds. + Weight::from_ref_time(58_678_180 as u64) + // Standard Error: 17_227 + .saturating_add(Weight::from_ref_time(4_947_930 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().reads((1 as u64).saturating_mul(s as u64))) .saturating_add(T::DbWeight::get().writes(1 as u64)) @@ -72,10 +72,10 @@ impl pallet_identity::WeightInfo for WeightInfo { // Storage: Identity SuperOf (r:0 w:2) /// The range of component `p` is `[0, 100]`. fn set_subs_old(p: u32, ) -> Weight { - // Minimum execution time: 22_900 nanoseconds. - Weight::from_ref_time(58_841_562 as u64) - // Standard Error: 9_887 - .saturating_add(Weight::from_ref_time(2_217_884 as u64).saturating_mul(p as u64)) + // Minimum execution time: 21_600 nanoseconds. + Weight::from_ref_time(56_976_382 as u64) + // Standard Error: 9_475 + .saturating_add(Weight::from_ref_time(2_138_866 as u64).saturating_mul(p as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) .saturating_add(T::DbWeight::get().writes((1 as u64).saturating_mul(p as u64))) @@ -87,14 +87,14 @@ impl pallet_identity::WeightInfo for WeightInfo { /// The range of component `s` is `[0, 100]`. /// The range of component `x` is `[0, 100]`. fn clear_identity(r: u32, s: u32, x: u32, ) -> Weight { - // Minimum execution time: 102_201 nanoseconds. - Weight::from_ref_time(68_567_855 as u64) - // Standard Error: 13_883 - .saturating_add(Weight::from_ref_time(420_920 as u64).saturating_mul(r as u64)) - // Standard Error: 2_711 - .saturating_add(Weight::from_ref_time(2_202_259 as u64).saturating_mul(s as u64)) - // Standard Error: 2_711 - .saturating_add(Weight::from_ref_time(380_412 as u64).saturating_mul(x as u64)) + // Minimum execution time: 97_602 nanoseconds. + Weight::from_ref_time(67_749_322 as u64) + // Standard Error: 14_449 + .saturating_add(Weight::from_ref_time(327_577 as u64).saturating_mul(r as u64)) + // Standard Error: 2_821 + .saturating_add(Weight::from_ref_time(2_092_108 as u64).saturating_mul(s as u64)) + // Standard Error: 2_821 + .saturating_add(Weight::from_ref_time(373_695 as u64).saturating_mul(x as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) .saturating_add(T::DbWeight::get().writes((1 as u64).saturating_mul(s as u64))) @@ -104,12 +104,12 @@ impl pallet_identity::WeightInfo for WeightInfo { /// The range of component `r` is `[1, 20]`. /// The range of component `x` is `[0, 100]`. fn request_judgement(r: u32, x: u32, ) -> Weight { - // Minimum execution time: 76_512 nanoseconds. - Weight::from_ref_time(75_273_871 as u64) - // Standard Error: 7_566 - .saturating_add(Weight::from_ref_time(277_423 as u64).saturating_mul(r as u64)) - // Standard Error: 1_476 - .saturating_add(Weight::from_ref_time(741_498 as u64).saturating_mul(x as u64)) + // Minimum execution time: 70_402 nanoseconds. + Weight::from_ref_time(71_112_279 as u64) + // Standard Error: 16_853 + .saturating_add(Weight::from_ref_time(413_327 as u64).saturating_mul(r as u64)) + // Standard Error: 3_288 + .saturating_add(Weight::from_ref_time(711_853 as u64).saturating_mul(x as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } @@ -117,42 +117,42 @@ impl pallet_identity::WeightInfo for WeightInfo { /// The range of component `r` is `[1, 20]`. /// The range of component `x` is `[0, 100]`. fn cancel_request(r: u32, x: u32, ) -> Weight { - // Minimum execution time: 70_802 nanoseconds. - Weight::from_ref_time(68_976_038 as u64) - // Standard Error: 7_348 - .saturating_add(Weight::from_ref_time(281_328 as u64).saturating_mul(r as u64)) - // Standard Error: 1_433 - .saturating_add(Weight::from_ref_time(734_303 as u64).saturating_mul(x as u64)) + // Minimum execution time: 66_402 nanoseconds. + Weight::from_ref_time(66_553_026 as u64) + // Standard Error: 7_137 + .saturating_add(Weight::from_ref_time(306_576 as u64).saturating_mul(r as u64)) + // Standard Error: 1_392 + .saturating_add(Weight::from_ref_time(705_712 as u64).saturating_mul(x as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Identity Registrars (r:1 w:1) /// The range of component `r` is `[1, 19]`. fn set_fee(r: u32, ) -> Weight { - // Minimum execution time: 19_401 nanoseconds. - Weight::from_ref_time(20_412_791 as u64) - // Standard Error: 3_962 - .saturating_add(Weight::from_ref_time(288_594 as u64).saturating_mul(r as u64)) + // Minimum execution time: 17_800 nanoseconds. + Weight::from_ref_time(19_502_048 as u64) + // Standard Error: 4_244 + .saturating_add(Weight::from_ref_time(274_499 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Identity Registrars (r:1 w:1) /// The range of component `r` is `[1, 19]`. fn set_account_id(r: u32, ) -> Weight { - // Minimum execution time: 20_001 nanoseconds. - Weight::from_ref_time(20_943_860 as u64) - // Standard Error: 4_596 - .saturating_add(Weight::from_ref_time(258_487 as u64).saturating_mul(r as u64)) + // Minimum execution time: 18_500 nanoseconds. + Weight::from_ref_time(19_873_597 as u64) + // Standard Error: 3_337 + .saturating_add(Weight::from_ref_time(275_676 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Identity Registrars (r:1 w:1) /// The range of component `r` is `[1, 19]`. fn set_fields(r: u32, ) -> Weight { - // Minimum execution time: 19_501 nanoseconds. - Weight::from_ref_time(20_415_003 as u64) - // Standard Error: 6_271 - .saturating_add(Weight::from_ref_time(293_809 as u64).saturating_mul(r as u64)) + // Minimum execution time: 17_901 nanoseconds. + Weight::from_ref_time(19_739_614 as u64) + // Standard Error: 3_708 + .saturating_add(Weight::from_ref_time(283_260 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } @@ -161,12 +161,12 @@ impl pallet_identity::WeightInfo for WeightInfo { /// The range of component `r` is `[1, 19]`. /// The range of component `x` is `[0, 100]`. fn provide_judgement(r: u32, x: u32, ) -> Weight { - // Minimum execution time: 58_402 nanoseconds. - Weight::from_ref_time(55_989_832 as u64) - // Standard Error: 7_115 - .saturating_add(Weight::from_ref_time(316_865 as u64).saturating_mul(r as u64)) - // Standard Error: 1_316 - .saturating_add(Weight::from_ref_time(1_187_536 as u64).saturating_mul(x as u64)) + // Minimum execution time: 54_001 nanoseconds. + Weight::from_ref_time(53_284_974 as u64) + // Standard Error: 7_268 + .saturating_add(Weight::from_ref_time(372_905 as u64).saturating_mul(r as u64)) + // Standard Error: 1_344 + .saturating_add(Weight::from_ref_time(1_145_325 as u64).saturating_mul(x as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } @@ -178,14 +178,14 @@ impl pallet_identity::WeightInfo for WeightInfo { /// The range of component `s` is `[0, 100]`. /// The range of component `x` is `[0, 100]`. fn kill_identity(r: u32, s: u32, x: u32, ) -> Weight { - // Minimum execution time: 133_304 nanoseconds. - Weight::from_ref_time(92_739_819 as u64) - // Standard Error: 18_885 - .saturating_add(Weight::from_ref_time(404_821 as u64).saturating_mul(r as u64)) - // Standard Error: 3_688 - .saturating_add(Weight::from_ref_time(2_170_287 as u64).saturating_mul(s as u64)) - // Standard Error: 3_688 - .saturating_add(Weight::from_ref_time(419_284 as u64).saturating_mul(x as u64)) + // Minimum execution time: 119_502 nanoseconds. + Weight::from_ref_time(88_057_690 as u64) + // Standard Error: 16_781 + .saturating_add(Weight::from_ref_time(515_023 as u64).saturating_mul(r as u64)) + // Standard Error: 3_277 + .saturating_add(Weight::from_ref_time(2_085_492 as u64).saturating_mul(s as u64)) + // Standard Error: 3_277 + .saturating_add(Weight::from_ref_time(380_020 as u64).saturating_mul(x as u64)) .saturating_add(T::DbWeight::get().reads(4 as u64)) .saturating_add(T::DbWeight::get().writes(4 as u64)) .saturating_add(T::DbWeight::get().writes((1 as u64).saturating_mul(s as u64))) @@ -195,10 +195,10 @@ impl pallet_identity::WeightInfo for WeightInfo { // Storage: Identity SubsOf (r:1 w:1) /// The range of component `s` is `[0, 99]`. fn add_sub(s: u32, ) -> Weight { - // Minimum execution time: 68_303 nanoseconds. - Weight::from_ref_time(76_509_144 as u64) - // Standard Error: 3_640 - .saturating_add(Weight::from_ref_time(214_351 as u64).saturating_mul(s as u64)) + // Minimum execution time: 66_501 nanoseconds. + Weight::from_ref_time(76_420_433 as u64) + // Standard Error: 7_023 + .saturating_add(Weight::from_ref_time(198_860 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } @@ -206,10 +206,10 @@ impl pallet_identity::WeightInfo for WeightInfo { // Storage: Identity SuperOf (r:1 w:1) /// The range of component `s` is `[1, 100]`. fn rename_sub(s: u32, ) -> Weight { - // Minimum execution time: 29_301 nanoseconds. - Weight::from_ref_time(32_363_624 as u64) - // Standard Error: 1_999 - .saturating_add(Weight::from_ref_time(131_579 as u64).saturating_mul(s as u64)) + // Minimum execution time: 28_000 nanoseconds. + Weight::from_ref_time(31_341_109 as u64) + // Standard Error: 1_659 + .saturating_add(Weight::from_ref_time(126_133 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } @@ -218,10 +218,10 @@ impl pallet_identity::WeightInfo for WeightInfo { // Storage: Identity SubsOf (r:1 w:1) /// The range of component `s` is `[1, 100]`. fn remove_sub(s: u32, ) -> Weight { - // Minimum execution time: 73_603 nanoseconds. - Weight::from_ref_time(78_780_282 as u64) - // Standard Error: 3_889 - .saturating_add(Weight::from_ref_time(205_179 as u64).saturating_mul(s as u64)) + // Minimum execution time: 69_301 nanoseconds. + Weight::from_ref_time(76_520_242 as u64) + // Standard Error: 2_347 + .saturating_add(Weight::from_ref_time(202_555 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } @@ -229,10 +229,10 @@ impl pallet_identity::WeightInfo for WeightInfo { // Storage: Identity SubsOf (r:1 w:1) /// The range of component `s` is `[0, 99]`. fn quit_sub(s: u32, ) -> Weight { - // Minimum execution time: 51_402 nanoseconds. - Weight::from_ref_time(57_088_362 as u64) - // Standard Error: 3_913 - .saturating_add(Weight::from_ref_time(192_293 as u64).saturating_mul(s as u64)) + // Minimum execution time: 50_001 nanoseconds. + Weight::from_ref_time(56_016_262 as u64) + // Standard Error: 2_689 + .saturating_add(Weight::from_ref_time(187_217 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } diff --git a/runtime/centrifuge/src/weights/pallet_interest_accrual.rs b/runtime/centrifuge/src/weights/pallet_interest_accrual.rs index 810b46db61..866929708f 100644 --- a/runtime/centrifuge/src/weights/pallet_interest_accrual.rs +++ b/runtime/centrifuge/src/weights/pallet_interest_accrual.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_interest_accrual` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-03-22, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-03-27, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("centrifuge-dev"), DB CACHE: 1024 @@ -32,9 +32,9 @@ pub struct WeightInfo(PhantomData); impl pallet_interest_accrual::WeightInfo for WeightInfo { /// The range of component `n` is `[1, 25]`. fn calculate_accumulated_rate(n: u32, ) -> Weight { - // Minimum execution time: 900 nanoseconds. + // Minimum execution time: 800 nanoseconds. Weight::from_ref_time(900_000 as u64) - // Standard Error: 2_696 - .saturating_add(Weight::from_ref_time(987_963 as u64).saturating_mul(n as u64)) + // Standard Error: 2_663 + .saturating_add(Weight::from_ref_time(993_693 as u64).saturating_mul(n as u64)) } } diff --git a/runtime/centrifuge/src/weights/pallet_keystore.rs b/runtime/centrifuge/src/weights/pallet_keystore.rs index 8710125003..c8c941d36e 100644 --- a/runtime/centrifuge/src/weights/pallet_keystore.rs +++ b/runtime/centrifuge/src/weights/pallet_keystore.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_keystore` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-03-22, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-03-27, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("centrifuge-dev"), DB CACHE: 1024 @@ -36,10 +36,10 @@ impl pallet_keystore::WeightInfo for WeightInfo { // Storage: Keystore LastKeyByPurpose (r:0 w:1) /// The range of component `n` is `[1, 10]`. fn add_keys(n: u32, ) -> Weight { - // Minimum execution time: 59_803 nanoseconds. - Weight::from_ref_time(37_974_118 as u64) - // Standard Error: 36_800 - .saturating_add(Weight::from_ref_time(28_036_103 as u64).saturating_mul(n as u64)) + // Minimum execution time: 59_301 nanoseconds. + Weight::from_ref_time(38_695_384 as u64) + // Standard Error: 38_128 + .saturating_add(Weight::from_ref_time(26_742_823 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().reads((1 as u64).saturating_mul(n as u64))) .saturating_add(T::DbWeight::get().writes(2 as u64)) @@ -48,17 +48,17 @@ impl pallet_keystore::WeightInfo for WeightInfo { // Storage: Keystore Keys (r:1 w:1) /// The range of component `n` is `[1, 10]`. fn revoke_keys(n: u32, ) -> Weight { - // Minimum execution time: 40_102 nanoseconds. - Weight::from_ref_time(27_299_204 as u64) - // Standard Error: 35_114 - .saturating_add(Weight::from_ref_time(15_880_893 as u64).saturating_mul(n as u64)) + // Minimum execution time: 39_801 nanoseconds. + Weight::from_ref_time(26_934_593 as u64) + // Standard Error: 19_158 + .saturating_add(Weight::from_ref_time(15_472_918 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads((1 as u64).saturating_mul(n as u64))) .saturating_add(T::DbWeight::get().writes((1 as u64).saturating_mul(n as u64))) } // Storage: Keystore KeyDeposit (r:0 w:1) fn set_deposit() -> Weight { - // Minimum execution time: 27_501 nanoseconds. - Weight::from_ref_time(28_101_000 as u64) + // Minimum execution time: 36_000 nanoseconds. + Weight::from_ref_time(36_901_000 as u64) .saturating_add(T::DbWeight::get().writes(1 as u64)) } } diff --git a/runtime/centrifuge/src/weights/pallet_loans_ref.rs b/runtime/centrifuge/src/weights/pallet_loans_ref.rs index 062bc5c194..e40e8af2ea 100644 --- a/runtime/centrifuge/src/weights/pallet_loans_ref.rs +++ b/runtime/centrifuge/src/weights/pallet_loans_ref.rs @@ -2,19 +2,23 @@ //! Autogenerated weights for `pallet_loans_ref` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-03-09, STEPS: `2`, REPEAT: 1, LOW RANGE: `[]`, HIGH RANGE: `[]` -//! HOSTNAME: `MBP-de-Luis.home`, CPU: `` -//! EXECUTION: None, WASM-EXECUTION: Compiled, CHAIN: Some("centrifuge"), DB CACHE: 1024 +//! DATE: 2023-03-27, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` +//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("centrifuge-dev"), DB CACHE: 1024 // Executed Command: // target/release/centrifuge-chain // benchmark // pallet -// --pallet=pallet-loans -// --chain -// centrifuge +// --chain=centrifuge-dev +// --steps=50 +// --repeat=20 +// --pallet=pallet_loans_ref // --extrinsic=* -// --output=runtime/centrifuge/src/weights/pallet_loans_ref.rs +// --execution=wasm +// --wasm-execution=compiled +// --heap-pages=4096 +// --output=/tmp/runtime/centrifuge/src/weights/pallet_loans_ref.rs #![cfg_attr(rustfmt, rustfmt_skip)] #![allow(unused_parens)] @@ -26,57 +30,121 @@ use sp_std::marker::PhantomData; /// Weight functions for `pallet_loans_ref`. pub struct WeightInfo(PhantomData); impl pallet_loans_ref::WeightInfo for WeightInfo { - fn update_portfolio_valuation(n: u32) -> Weight { - Weight::from_ref_time(31_740_408) // Standard Error: 4_421 - .saturating_add(Weight::from_ref_time(5_889_944).saturating_mul(n as u64)) - .saturating_add(T::DbWeight::get().reads(4 as u64)) - .saturating_add(T::DbWeight::get().writes(1 as u64)) - } - + // Storage: Permissions Permission (r:1 w:0) + // Storage: Uniques Asset (r:1 w:1) + // Storage: PoolSystem Pool (r:1 w:0) + // Storage: Timestamp Now (r:1 w:0) + // Storage: Uniques Class (r:1 w:0) + // Storage: Loans LastLoanId (r:1 w:1) + // Storage: Loans CreatedLoan (r:0 w:1) + // Storage: Uniques Account (r:0 w:2) + // Storage: Uniques ItemPriceOf (r:0 w:1) fn create() -> Weight { - Weight::from_ref_time(55_000_000) + // Minimum execution time: 116_502 nanoseconds. + Weight::from_ref_time(119_203_000 as u64) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(6 as u64)) } - - fn borrow(n: u32) -> Weight { - Weight::from_ref_time(89_980_992) // Standard Error: 6_031 - .saturating_add(Weight::from_ref_time(339_355).saturating_mul(n as u64)) + // Storage: Loans CreatedLoan (r:1 w:1) + // Storage: Timestamp Now (r:1 w:0) + // Storage: InterestAccrual Rates (r:1 w:1) + // Storage: Loans PortfolioValuation (r:1 w:1) + // Storage: Loans ActiveLoans (r:1 w:1) + // Storage: PoolSystem Pool (r:1 w:1) + // Storage: OrmlTokens Accounts (r:2 w:2) + // Storage: System Account (r:1 w:0) + /// The range of component `n` is `[1, 999]`. + fn borrow(n: u32, ) -> Weight { + // Minimum execution time: 308_006 nanoseconds. + Weight::from_ref_time(316_993_186 as u64) + // Standard Error: 2_927 + .saturating_add(Weight::from_ref_time(633_288 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(9 as u64)) .saturating_add(T::DbWeight::get().writes(7 as u64)) } - - fn repay(n: u32) -> Weight { - Weight::from_ref_time(88_057_556) // Standard Error: 9_218 - .saturating_add(Weight::from_ref_time(296_755).saturating_mul(n as u64)) + // Storage: Loans PortfolioValuation (r:1 w:1) + // Storage: Loans ActiveLoans (r:1 w:1) + // Storage: Timestamp Now (r:1 w:0) + // Storage: InterestAccrual Rates (r:1 w:0) + // Storage: PoolSystem Pool (r:1 w:1) + // Storage: OrmlTokens Accounts (r:2 w:2) + // Storage: System Account (r:1 w:0) + /// The range of component `n` is `[1, 999]`. + fn repay(n: u32, ) -> Weight { + // Minimum execution time: 240_804 nanoseconds. + Weight::from_ref_time(244_230_368 as u64) + // Standard Error: 5_699 + .saturating_add(Weight::from_ref_time(730_962 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(8 as u64)) .saturating_add(T::DbWeight::get().writes(5 as u64)) } - - fn write_off(n: u32) -> Weight { - Weight::from_ref_time(50_179_983) // Standard Error: 1_760 - .saturating_add(Weight::from_ref_time(299_592).saturating_mul(n as u64)) + // Storage: Loans PortfolioValuation (r:1 w:1) + // Storage: Loans ActiveLoans (r:1 w:1) + // Storage: Timestamp Now (r:1 w:0) + // Storage: InterestAccrual Rates (r:1 w:1) + // Storage: Loans WriteOffPolicy (r:1 w:0) + /// The range of component `n` is `[1, 999]`. + fn write_off(n: u32, ) -> Weight { + // Minimum execution time: 268_205 nanoseconds. + Weight::from_ref_time(274_550_761 as u64) + // Standard Error: 4_802 + .saturating_add(Weight::from_ref_time(690_348 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(5 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } - - fn admin_write_off(n: u32) -> Weight { - Weight::from_ref_time(63_153_708) // Standard Error: 2_472 - .saturating_add(Weight::from_ref_time(325_868).saturating_mul(n as u64)) + // Storage: Permissions Permission (r:1 w:0) + // Storage: Loans PortfolioValuation (r:1 w:1) + // Storage: Loans ActiveLoans (r:1 w:1) + // Storage: Timestamp Now (r:1 w:0) + // Storage: InterestAccrual Rates (r:1 w:1) + // Storage: Loans WriteOffPolicy (r:1 w:0) + /// The range of component `n` is `[1, 999]`. + fn admin_write_off(n: u32, ) -> Weight { + // Minimum execution time: 282_105 nanoseconds. + Weight::from_ref_time(290_877_496 as u64) + // Standard Error: 3_721 + .saturating_add(Weight::from_ref_time(663_174 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } - - fn close(n: u32) -> Weight { - Weight::from_ref_time(55_882_678) // Standard Error: 7_625 - .saturating_add(Weight::from_ref_time(338_879).saturating_mul(n as u64)) + // Storage: Loans CreatedLoan (r:1 w:0) + // Storage: Loans ActiveLoans (r:1 w:1) + // Storage: InterestAccrual Rates (r:1 w:1) + // Storage: Uniques Class (r:1 w:0) + // Storage: Uniques Asset (r:1 w:1) + // Storage: Loans ClosedLoan (r:0 w:1) + // Storage: Uniques Account (r:0 w:2) + // Storage: Uniques ItemPriceOf (r:0 w:1) + /// The range of component `n` is `[1, 999]`. + fn close(n: u32, ) -> Weight { + // Minimum execution time: 158_403 nanoseconds. + Weight::from_ref_time(160_732_151 as u64) + // Standard Error: 4_195 + .saturating_add(Weight::from_ref_time(647_491 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(5 as u64)) .saturating_add(T::DbWeight::get().writes(7 as u64)) } - + // Storage: Permissions Permission (r:1 w:0) + // Storage: PoolSystem Pool (r:1 w:0) + // Storage: Loans WriteOffPolicy (r:0 w:1) fn update_write_off_policy() -> Weight { - Weight::from_ref_time(27_000_000) + // Minimum execution time: 108_302 nanoseconds. + Weight::from_ref_time(109_402_000 as u64) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } + // Storage: PoolSystem Pool (r:1 w:0) + // Storage: InterestAccrual Rates (r:1 w:0) + // Storage: Loans ActiveLoans (r:1 w:0) + // Storage: Timestamp Now (r:1 w:0) + // Storage: Loans PortfolioValuation (r:0 w:1) + /// The range of component `n` is `[1, 1000]`. + fn update_portfolio_valuation(n: u32, ) -> Weight { + // Minimum execution time: 119_102 nanoseconds. + Weight::from_ref_time(110_694_941 as u64) + // Standard Error: 3_065 + .saturating_add(Weight::from_ref_time(13_439_124 as u64).saturating_mul(n as u64)) + .saturating_add(T::DbWeight::get().reads(4 as u64)) + .saturating_add(T::DbWeight::get().writes(1 as u64)) + } } diff --git a/runtime/centrifuge/src/weights/pallet_migration_manager.rs b/runtime/centrifuge/src/weights/pallet_migration_manager.rs index a427a8351e..c5a9550b58 100644 --- a/runtime/centrifuge/src/weights/pallet_migration_manager.rs +++ b/runtime/centrifuge/src/weights/pallet_migration_manager.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_migration_manager` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-03-22, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-03-27, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("centrifuge-dev"), DB CACHE: 1024 @@ -32,8 +32,8 @@ pub struct WeightInfo(PhantomData); impl pallet_migration_manager::WeightInfo for WeightInfo { // Storage: Migration Status (r:1 w:1) fn finalize() -> Weight { - // Minimum execution time: 35_799 nanoseconds. - Weight::from_ref_time(36_500_000 as u64) + // Minimum execution time: 35_900 nanoseconds. + Weight::from_ref_time(36_800_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } @@ -41,18 +41,18 @@ impl pallet_migration_manager::WeightInfo for WeightInf // Storage: System Account (r:0 w:1) /// The range of component `n` is `[1, 100]`. fn migrate_system_account(n: u32, ) -> Weight { - // Minimum execution time: 38_000 nanoseconds. - Weight::from_ref_time(39_524_089 as u64) - // Standard Error: 7_234 - .saturating_add(Weight::from_ref_time(1_512_020 as u64).saturating_mul(n as u64)) + // Minimum execution time: 38_501 nanoseconds. + Weight::from_ref_time(40_227_441 as u64) + // Standard Error: 4_630 + .saturating_add(Weight::from_ref_time(1_440_647 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) .saturating_add(T::DbWeight::get().writes((1 as u64).saturating_mul(n as u64))) } // Storage: Migration Status (r:1 w:1) fn migrate_balances_issuance() -> Weight { - // Minimum execution time: 48_201 nanoseconds. - Weight::from_ref_time(49_201_000 as u64) + // Minimum execution time: 42_501 nanoseconds. + Weight::from_ref_time(43_200_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } @@ -62,10 +62,10 @@ impl pallet_migration_manager::WeightInfo for WeightInf // Storage: System Account (r:1 w:1) /// The range of component `n` is `[1, 10]`. fn migrate_vesting_vesting(n: u32, ) -> Weight { - // Minimum execution time: 237_602 nanoseconds. - Weight::from_ref_time(220_659_367 as u64) - // Standard Error: 137_812 - .saturating_add(Weight::from_ref_time(45_191_108 as u64).saturating_mul(n as u64)) + // Minimum execution time: 184_903 nanoseconds. + Weight::from_ref_time(166_771_787 as u64) + // Standard Error: 114_897 + .saturating_add(Weight::from_ref_time(42_758_513 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().reads((3 as u64).saturating_mul(n as u64))) .saturating_add(T::DbWeight::get().writes(1 as u64)) @@ -75,10 +75,10 @@ impl pallet_migration_manager::WeightInfo for WeightInf // Storage: Proxy Proxies (r:0 w:1) /// The range of component `n` is `[1, 10]`. fn migrate_proxy_proxies(n: u32, ) -> Weight { - // Minimum execution time: 175_001 nanoseconds. - Weight::from_ref_time(205_704_995 as u64) - // Standard Error: 119_696 - .saturating_add(Weight::from_ref_time(7_910_828 as u64).saturating_mul(n as u64)) + // Minimum execution time: 138_502 nanoseconds. + Weight::from_ref_time(144_494_493 as u64) + // Standard Error: 101_499 + .saturating_add(Weight::from_ref_time(8_449_470 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) .saturating_add(T::DbWeight::get().writes((1 as u64).saturating_mul(n as u64))) diff --git a/runtime/centrifuge/src/weights/pallet_multisig.rs b/runtime/centrifuge/src/weights/pallet_multisig.rs index 96703454ad..c3820a74c5 100644 --- a/runtime/centrifuge/src/weights/pallet_multisig.rs +++ b/runtime/centrifuge/src/weights/pallet_multisig.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_multisig` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-03-22, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-03-27, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("centrifuge-dev"), DB CACHE: 1024 @@ -32,22 +32,22 @@ pub struct WeightInfo(PhantomData); impl pallet_multisig::WeightInfo for WeightInfo { /// The range of component `z` is `[0, 10000]`. fn as_multi_threshold_1(z: u32, ) -> Weight { - // Minimum execution time: 36_500 nanoseconds. - Weight::from_ref_time(38_885_179 as u64) - // Standard Error: 11 - .saturating_add(Weight::from_ref_time(720 as u64).saturating_mul(z as u64)) + // Minimum execution time: 35_400 nanoseconds. + Weight::from_ref_time(37_542_343 as u64) + // Standard Error: 10 + .saturating_add(Weight::from_ref_time(514 as u64).saturating_mul(z as u64)) } // Storage: Multisig Multisigs (r:1 w:1) // Storage: unknown [0x3a65787472696e7369635f696e646578] (r:1 w:0) /// The range of component `s` is `[2, 100]`. /// The range of component `z` is `[0, 10000]`. fn as_multi_create(s: u32, z: u32, ) -> Weight { - // Minimum execution time: 88_900 nanoseconds. - Weight::from_ref_time(74_121_200 as u64) - // Standard Error: 4_049 - .saturating_add(Weight::from_ref_time(201_472 as u64).saturating_mul(s as u64)) - // Standard Error: 39 - .saturating_add(Weight::from_ref_time(2_022 as u64).saturating_mul(z as u64)) + // Minimum execution time: 85_501 nanoseconds. + Weight::from_ref_time(70_300_485 as u64) + // Standard Error: 3_335 + .saturating_add(Weight::from_ref_time(197_291 as u64).saturating_mul(s as u64)) + // Standard Error: 32 + .saturating_add(Weight::from_ref_time(2_147 as u64).saturating_mul(z as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } @@ -55,12 +55,12 @@ impl pallet_multisig::WeightInfo for WeightInfo { /// The range of component `s` is `[3, 100]`. /// The range of component `z` is `[0, 10000]`. fn as_multi_approve(s: u32, z: u32, ) -> Weight { - // Minimum execution time: 69_301 nanoseconds. - Weight::from_ref_time(51_326_096 as u64) - // Standard Error: 2_457 - .saturating_add(Weight::from_ref_time(221_776 as u64).saturating_mul(s as u64)) - // Standard Error: 24 - .saturating_add(Weight::from_ref_time(2_085 as u64).saturating_mul(z as u64)) + // Minimum execution time: 67_501 nanoseconds. + Weight::from_ref_time(49_100_770 as u64) + // Standard Error: 6_091 + .saturating_add(Weight::from_ref_time(212_852 as u64).saturating_mul(s as u64)) + // Standard Error: 59 + .saturating_add(Weight::from_ref_time(2_171 as u64).saturating_mul(z as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } @@ -69,12 +69,12 @@ impl pallet_multisig::WeightInfo for WeightInfo { /// The range of component `s` is `[2, 100]`. /// The range of component `z` is `[0, 10000]`. fn as_multi_complete(s: u32, z: u32, ) -> Weight { - // Minimum execution time: 93_101 nanoseconds. - Weight::from_ref_time(70_472_970 as u64) - // Standard Error: 2_702 - .saturating_add(Weight::from_ref_time(320_270 as u64).saturating_mul(s as u64)) - // Standard Error: 26 - .saturating_add(Weight::from_ref_time(2_499 as u64).saturating_mul(z as u64)) + // Minimum execution time: 92_401 nanoseconds. + Weight::from_ref_time(75_364_334 as u64) + // Standard Error: 1_554 + .saturating_add(Weight::from_ref_time(242_175 as u64).saturating_mul(s as u64)) + // Standard Error: 15 + .saturating_add(Weight::from_ref_time(2_076 as u64).saturating_mul(z as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } @@ -82,30 +82,30 @@ impl pallet_multisig::WeightInfo for WeightInfo { // Storage: unknown [0x3a65787472696e7369635f696e646578] (r:1 w:0) /// The range of component `s` is `[2, 100]`. fn approve_as_multi_create(s: u32, ) -> Weight { - // Minimum execution time: 66_500 nanoseconds. - Weight::from_ref_time(69_063_614 as u64) - // Standard Error: 2_804 - .saturating_add(Weight::from_ref_time(221_996 as u64).saturating_mul(s as u64)) + // Minimum execution time: 64_901 nanoseconds. + Weight::from_ref_time(68_371_584 as u64) + // Standard Error: 3_459 + .saturating_add(Weight::from_ref_time(195_491 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Multisig Multisigs (r:1 w:1) /// The range of component `s` is `[2, 100]`. fn approve_as_multi_approve(s: u32, ) -> Weight { - // Minimum execution time: 46_801 nanoseconds. - Weight::from_ref_time(48_758_188 as u64) - // Standard Error: 1_857 - .saturating_add(Weight::from_ref_time(217_168 as u64).saturating_mul(s as u64)) + // Minimum execution time: 45_701 nanoseconds. + Weight::from_ref_time(48_100_070 as u64) + // Standard Error: 2_287 + .saturating_add(Weight::from_ref_time(203_019 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Multisig Multisigs (r:1 w:1) /// The range of component `s` is `[2, 100]`. fn cancel_as_multi(s: u32, ) -> Weight { - // Minimum execution time: 66_001 nanoseconds. - Weight::from_ref_time(69_037_727 as u64) - // Standard Error: 3_988 - .saturating_add(Weight::from_ref_time(208_119 as u64).saturating_mul(s as u64)) + // Minimum execution time: 64_401 nanoseconds. + Weight::from_ref_time(68_283_025 as u64) + // Standard Error: 1_666 + .saturating_add(Weight::from_ref_time(199_581 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } diff --git a/runtime/centrifuge/src/weights/pallet_permissions.rs b/runtime/centrifuge/src/weights/pallet_permissions.rs index 2031f15ec7..b9b65608d9 100644 --- a/runtime/centrifuge/src/weights/pallet_permissions.rs +++ b/runtime/centrifuge/src/weights/pallet_permissions.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_permissions` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-03-22, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-03-27, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("centrifuge-dev"), DB CACHE: 1024 @@ -33,46 +33,46 @@ impl pallet_permissions::WeightInfo for WeightInfo { // Storage: Permissions PermissionCount (r:1 w:1) // Storage: Permissions Permission (r:1 w:1) fn add_as_admin() -> Weight { - // Minimum execution time: 40_900 nanoseconds. - Weight::from_ref_time(41_501_000 as u64) + // Minimum execution time: 39_601 nanoseconds. + Weight::from_ref_time(41_001_000 as u64) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } // Storage: Permissions Permission (r:2 w:1) // Storage: Permissions PermissionCount (r:1 w:1) fn add_as_editor() -> Weight { - // Minimum execution time: 51_000 nanoseconds. - Weight::from_ref_time(51_701_000 as u64) + // Minimum execution time: 50_601 nanoseconds. + Weight::from_ref_time(51_601_000 as u64) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } // Storage: Permissions PermissionCount (r:1 w:1) // Storage: Permissions Permission (r:1 w:1) fn remove_as_admin() -> Weight { - // Minimum execution time: 44_700 nanoseconds. - Weight::from_ref_time(45_700_000 as u64) + // Minimum execution time: 44_400 nanoseconds. + Weight::from_ref_time(47_500_000 as u64) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } // Storage: Permissions Permission (r:2 w:1) // Storage: Permissions PermissionCount (r:1 w:1) fn remove_as_editor() -> Weight { - // Minimum execution time: 54_101 nanoseconds. - Weight::from_ref_time(55_001_000 as u64) + // Minimum execution time: 53_301 nanoseconds. + Weight::from_ref_time(54_101_000 as u64) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } // Storage: Permissions Permission (r:1 w:1) fn purge() -> Weight { - // Minimum execution time: 40_600 nanoseconds. - Weight::from_ref_time(41_500_000 as u64) + // Minimum execution time: 40_200 nanoseconds. + Weight::from_ref_time(41_001_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Permissions Permission (r:1 w:1) fn admin_purge() -> Weight { - // Minimum execution time: 41_100 nanoseconds. - Weight::from_ref_time(41_700_000 as u64) + // Minimum execution time: 40_301 nanoseconds. + Weight::from_ref_time(41_601_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } diff --git a/runtime/centrifuge/src/weights/pallet_pool_registry.rs b/runtime/centrifuge/src/weights/pallet_pool_registry.rs index 7c1af53c4f..fe82c8c2f4 100644 --- a/runtime/centrifuge/src/weights/pallet_pool_registry.rs +++ b/runtime/centrifuge/src/weights/pallet_pool_registry.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_pool_registry` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-03-22, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-03-27, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("centrifuge-dev"), DB CACHE: 1024 @@ -43,10 +43,10 @@ impl pallet_pool_registry::WeightInfo for WeightInfo // Storage: PoolSystem PoolDeposit (r:0 w:1) /// The range of component `n` is `[1, 5]`. fn register(n: u32, ) -> Weight { - // Minimum execution time: 153_701 nanoseconds. - Weight::from_ref_time(130_621_961 as u64) - // Standard Error: 47_463 - .saturating_add(Weight::from_ref_time(27_412_623 as u64).saturating_mul(n as u64)) + // Minimum execution time: 147_003 nanoseconds. + Weight::from_ref_time(126_507_641 as u64) + // Standard Error: 53_902 + .saturating_add(Weight::from_ref_time(27_441_361 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(9 as u64)) .saturating_add(T::DbWeight::get().reads((2 as u64).saturating_mul(n as u64))) .saturating_add(T::DbWeight::get().writes(7 as u64)) @@ -60,10 +60,10 @@ impl pallet_pool_registry::WeightInfo for WeightInfo // Storage: PoolSystem ScheduledUpdate (r:0 w:1) /// The range of component `n` is `[1, 5]`. fn update_no_execution(n: u32, ) -> Weight { - // Minimum execution time: 80_700 nanoseconds. - Weight::from_ref_time(79_392_700 as u64) - // Standard Error: 19_932 - .saturating_add(Weight::from_ref_time(3_055_725 as u64).saturating_mul(n as u64)) + // Minimum execution time: 77_602 nanoseconds. + Weight::from_ref_time(78_517_069 as u64) + // Standard Error: 23_582 + .saturating_add(Weight::from_ref_time(3_041_958 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(4 as u64)) .saturating_add(T::DbWeight::get().reads((1 as u64).saturating_mul(n as u64))) .saturating_add(T::DbWeight::get().writes(1 as u64)) @@ -77,10 +77,10 @@ impl pallet_pool_registry::WeightInfo for WeightInfo // Storage: PoolSystem ScheduledUpdate (r:0 w:1) /// The range of component `n` is `[1, 5]`. fn update_and_execute(n: u32, ) -> Weight { - // Minimum execution time: 120_600 nanoseconds. - Weight::from_ref_time(114_181_198 as u64) - // Standard Error: 41_942 - .saturating_add(Weight::from_ref_time(9_471_671 as u64).saturating_mul(n as u64)) + // Minimum execution time: 116_102 nanoseconds. + Weight::from_ref_time(112_049_966 as u64) + // Standard Error: 59_704 + .saturating_add(Weight::from_ref_time(9_384_025 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().reads((1 as u64).saturating_mul(n as u64))) .saturating_add(T::DbWeight::get().writes(3 as u64)) @@ -93,10 +93,10 @@ impl pallet_pool_registry::WeightInfo for WeightInfo // Storage: OrmlAssetRegistry Metadata (r:2 w:1) /// The range of component `n` is `[1, 5]`. fn execute_update(n: u32, ) -> Weight { - // Minimum execution time: 108_001 nanoseconds. - Weight::from_ref_time(100_506_669 as u64) - // Standard Error: 37_522 - .saturating_add(Weight::from_ref_time(9_769_407 as u64).saturating_mul(n as u64)) + // Minimum execution time: 102_802 nanoseconds. + Weight::from_ref_time(98_871_774 as u64) + // Standard Error: 68_633 + .saturating_add(Weight::from_ref_time(9_818_786 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().reads((1 as u64).saturating_mul(n as u64))) .saturating_add(T::DbWeight::get().writes(3 as u64)) @@ -105,10 +105,10 @@ impl pallet_pool_registry::WeightInfo for WeightInfo // Storage: PoolRegistry PoolMetadata (r:0 w:1) /// The range of component `n` is `[0, 46]`. fn set_metadata(n: u32, ) -> Weight { - // Minimum execution time: 44_700 nanoseconds. - Weight::from_ref_time(46_564_432 as u64) - // Standard Error: 7_447 - .saturating_add(Weight::from_ref_time(12_968 as u64).saturating_mul(n as u64)) + // Minimum execution time: 42_701 nanoseconds. + Weight::from_ref_time(45_371_985 as u64) + // Standard Error: 9_407 + .saturating_add(Weight::from_ref_time(38_760 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } diff --git a/runtime/centrifuge/src/weights/pallet_pool_system.rs b/runtime/centrifuge/src/weights/pallet_pool_system.rs index 7a960c5ac3..e552e2d32f 100644 --- a/runtime/centrifuge/src/weights/pallet_pool_system.rs +++ b/runtime/centrifuge/src/weights/pallet_pool_system.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_pool_system` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-03-22, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-03-27, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("centrifuge-dev"), DB CACHE: 1024 @@ -33,15 +33,15 @@ impl pallet_pool_system::WeightInfo for WeightInfo { // Storage: Permissions Permission (r:1 w:0) // Storage: PoolSystem Pool (r:1 w:1) fn set_max_reserve() -> Weight { - // Minimum execution time: 56_200 nanoseconds. - Weight::from_ref_time(56_900_000 as u64) + // Minimum execution time: 55_901 nanoseconds. + Weight::from_ref_time(56_801_000 as u64) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: PoolSystem Pool (r:1 w:1) // Storage: PoolSystem EpochExecution (r:1 w:0) // Storage: Timestamp Now (r:1 w:0) - // Storage: Loans PoolNAV (r:1 w:0) + // Storage: Loans PortfolioValuation (r:1 w:0) // Storage: OrmlTokens TotalIssuance (r:1 w:0) // Storage: Investments ActiveInvestOrders (r:1 w:1) // Storage: Investments InProcessingInvestOrders (r:1 w:1) @@ -54,10 +54,10 @@ impl pallet_pool_system::WeightInfo for WeightInfo { // Storage: Investments ClearedRedeemOrders (r:0 w:1) /// The range of component `n` is `[1, 5]`. fn close_epoch_no_orders(n: u32, ) -> Weight { - // Minimum execution time: 182_601 nanoseconds. - Weight::from_ref_time(85_167_982 as u64) - // Standard Error: 140_693 - .saturating_add(Weight::from_ref_time(101_639_110 as u64).saturating_mul(n as u64)) + // Minimum execution time: 168_703 nanoseconds. + Weight::from_ref_time(80_971_132 as u64) + // Standard Error: 84_302 + .saturating_add(Weight::from_ref_time(95_860_498 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(4 as u64)) .saturating_add(T::DbWeight::get().reads((8 as u64).saturating_mul(n as u64))) .saturating_add(T::DbWeight::get().writes(1 as u64)) @@ -66,7 +66,7 @@ impl pallet_pool_system::WeightInfo for WeightInfo { // Storage: PoolSystem Pool (r:1 w:1) // Storage: PoolSystem EpochExecution (r:1 w:1) // Storage: Timestamp Now (r:1 w:0) - // Storage: Loans PoolNAV (r:1 w:0) + // Storage: Loans PortfolioValuation (r:1 w:0) // Storage: OrmlTokens TotalIssuance (r:1 w:0) // Storage: Investments ActiveInvestOrders (r:1 w:1) // Storage: Investments InProcessingInvestOrders (r:1 w:1) @@ -76,10 +76,10 @@ impl pallet_pool_system::WeightInfo for WeightInfo { // Storage: Investments RedeemOrderId (r:1 w:1) /// The range of component `n` is `[1, 5]`. fn close_epoch_no_execution(n: u32, ) -> Weight { - // Minimum execution time: 130_101 nanoseconds. - Weight::from_ref_time(89_571_176 as u64) - // Standard Error: 45_773 - .saturating_add(Weight::from_ref_time(43_623_255 as u64).saturating_mul(n as u64)) + // Minimum execution time: 121_102 nanoseconds. + Weight::from_ref_time(85_663_946 as u64) + // Standard Error: 58_487 + .saturating_add(Weight::from_ref_time(41_017_688 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(4 as u64)) .saturating_add(T::DbWeight::get().reads((7 as u64).saturating_mul(n as u64))) .saturating_add(T::DbWeight::get().writes(2 as u64)) @@ -88,7 +88,7 @@ impl pallet_pool_system::WeightInfo for WeightInfo { // Storage: PoolSystem Pool (r:1 w:1) // Storage: PoolSystem EpochExecution (r:1 w:0) // Storage: Timestamp Now (r:1 w:0) - // Storage: Loans PoolNAV (r:1 w:0) + // Storage: Loans PortfolioValuation (r:1 w:0) // Storage: OrmlTokens TotalIssuance (r:1 w:1) // Storage: Investments ActiveInvestOrders (r:1 w:1) // Storage: Investments InProcessingInvestOrders (r:1 w:1) @@ -102,10 +102,10 @@ impl pallet_pool_system::WeightInfo for WeightInfo { // Storage: Investments ClearedRedeemOrders (r:0 w:1) /// The range of component `n` is `[1, 5]`. fn close_epoch_execute(n: u32, ) -> Weight { - // Minimum execution time: 293_902 nanoseconds. - Weight::from_ref_time(200_363_518 as u64) - // Standard Error: 79_791 - .saturating_add(Weight::from_ref_time(103_612_030 as u64).saturating_mul(n as u64)) + // Minimum execution time: 276_605 nanoseconds. + Weight::from_ref_time(190_507_310 as u64) + // Standard Error: 115_318 + .saturating_add(Weight::from_ref_time(98_009_530 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(8 as u64)) .saturating_add(T::DbWeight::get().reads((8 as u64).saturating_mul(n as u64))) .saturating_add(T::DbWeight::get().writes(7 as u64)) @@ -115,10 +115,10 @@ impl pallet_pool_system::WeightInfo for WeightInfo { // Storage: PoolSystem Pool (r:1 w:0) /// The range of component `n` is `[1, 5]`. fn submit_solution(n: u32, ) -> Weight { - // Minimum execution time: 58_000 nanoseconds. - Weight::from_ref_time(57_087_548 as u64) - // Standard Error: 21_709 - .saturating_add(Weight::from_ref_time(2_821_394 as u64).saturating_mul(n as u64)) + // Minimum execution time: 55_201 nanoseconds. + Weight::from_ref_time(55_890_543 as u64) + // Standard Error: 16_826 + .saturating_add(Weight::from_ref_time(2_594_854 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } @@ -138,10 +138,10 @@ impl pallet_pool_system::WeightInfo for WeightInfo { // Storage: Investments ClearedRedeemOrders (r:0 w:1) /// The range of component `n` is `[1, 5]`. fn execute_epoch(n: u32, ) -> Weight { - // Minimum execution time: 250_901 nanoseconds. - Weight::from_ref_time(178_608_862 as u64) - // Standard Error: 133_102 - .saturating_add(Weight::from_ref_time(75_793_573 as u64).saturating_mul(n as u64)) + // Minimum execution time: 240_905 nanoseconds. + Weight::from_ref_time(174_747_251 as u64) + // Standard Error: 82_683 + .saturating_add(Weight::from_ref_time(70_884_880 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(8 as u64)) .saturating_add(T::DbWeight::get().reads((7 as u64).saturating_mul(n as u64))) .saturating_add(T::DbWeight::get().writes(8 as u64)) diff --git a/runtime/centrifuge/src/weights/pallet_preimage.rs b/runtime/centrifuge/src/weights/pallet_preimage.rs index 4f82c3792a..7772be1522 100644 --- a/runtime/centrifuge/src/weights/pallet_preimage.rs +++ b/runtime/centrifuge/src/weights/pallet_preimage.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_preimage` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-03-22, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-03-27, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("centrifuge-dev"), DB CACHE: 1024 @@ -34,10 +34,10 @@ impl pallet_preimage::WeightInfo for WeightInfo { // Storage: Preimage PreimageFor (r:0 w:1) /// The range of component `s` is `[0, 4194304]`. fn note_preimage(s: u32, ) -> Weight { - // Minimum execution time: 61_800 nanoseconds. - Weight::from_ref_time(62_501_000 as u64) - // Standard Error: 3 - .saturating_add(Weight::from_ref_time(2_507 as u64).saturating_mul(s as u64)) + // Minimum execution time: 60_801 nanoseconds. + Weight::from_ref_time(61_001_000 as u64) + // Standard Error: 2 + .saturating_add(Weight::from_ref_time(2_326 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } @@ -45,10 +45,10 @@ impl pallet_preimage::WeightInfo for WeightInfo { // Storage: Preimage PreimageFor (r:0 w:1) /// The range of component `s` is `[0, 4194304]`. fn note_requested_preimage(s: u32, ) -> Weight { - // Minimum execution time: 42_700 nanoseconds. - Weight::from_ref_time(43_000_000 as u64) + // Minimum execution time: 42_001 nanoseconds. + Weight::from_ref_time(42_401_000 as u64) // Standard Error: 2 - .saturating_add(Weight::from_ref_time(2_448 as u64).saturating_mul(s as u64)) + .saturating_add(Weight::from_ref_time(2_318 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } @@ -56,76 +56,76 @@ impl pallet_preimage::WeightInfo for WeightInfo { // Storage: Preimage PreimageFor (r:0 w:1) /// The range of component `s` is `[0, 4194304]`. fn note_no_deposit_preimage(s: u32, ) -> Weight { - // Minimum execution time: 40_200 nanoseconds. - Weight::from_ref_time(40_401_000 as u64) - // Standard Error: 2 - .saturating_add(Weight::from_ref_time(2_440 as u64).saturating_mul(s as u64)) + // Minimum execution time: 39_701 nanoseconds. + Weight::from_ref_time(39_901_000 as u64) + // Standard Error: 1 + .saturating_add(Weight::from_ref_time(2_275 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } // Storage: Preimage StatusFor (r:1 w:1) // Storage: Preimage PreimageFor (r:0 w:1) fn unnote_preimage() -> Weight { - // Minimum execution time: 101_400 nanoseconds. - Weight::from_ref_time(111_301_000 as u64) + // Minimum execution time: 83_302 nanoseconds. + Weight::from_ref_time(90_001_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } // Storage: Preimage StatusFor (r:1 w:1) // Storage: Preimage PreimageFor (r:0 w:1) fn unnote_no_deposit_preimage() -> Weight { - // Minimum execution time: 82_601 nanoseconds. - Weight::from_ref_time(95_601_000 as u64) + // Minimum execution time: 62_101 nanoseconds. + Weight::from_ref_time(69_001_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } // Storage: Preimage StatusFor (r:1 w:1) fn request_preimage() -> Weight { - // Minimum execution time: 89_801 nanoseconds. - Weight::from_ref_time(95_201_000 as u64) + // Minimum execution time: 63_701 nanoseconds. + Weight::from_ref_time(74_401_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Preimage StatusFor (r:1 w:1) fn request_no_deposit_preimage() -> Weight { - // Minimum execution time: 53_100 nanoseconds. - Weight::from_ref_time(59_300_000 as u64) + // Minimum execution time: 38_201 nanoseconds. + Weight::from_ref_time(45_801_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Preimage StatusFor (r:1 w:1) fn request_unnoted_preimage() -> Weight { - // Minimum execution time: 52_000 nanoseconds. - Weight::from_ref_time(57_000_000 as u64) + // Minimum execution time: 37_000 nanoseconds. + Weight::from_ref_time(39_201_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Preimage StatusFor (r:1 w:1) fn request_requested_preimage() -> Weight { - // Minimum execution time: 20_900 nanoseconds. - Weight::from_ref_time(21_800_000 as u64) + // Minimum execution time: 18_500 nanoseconds. + Weight::from_ref_time(19_201_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Preimage StatusFor (r:1 w:1) // Storage: Preimage PreimageFor (r:0 w:1) fn unrequest_preimage() -> Weight { - // Minimum execution time: 76_001 nanoseconds. - Weight::from_ref_time(87_501_000 as u64) + // Minimum execution time: 56_801 nanoseconds. + Weight::from_ref_time(61_401_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } // Storage: Preimage StatusFor (r:1 w:1) fn unrequest_unnoted_preimage() -> Weight { - // Minimum execution time: 19_700 nanoseconds. - Weight::from_ref_time(20_600_000 as u64) + // Minimum execution time: 17_600 nanoseconds. + Weight::from_ref_time(18_700_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Preimage StatusFor (r:1 w:1) fn unrequest_multi_referenced_preimage() -> Weight { - // Minimum execution time: 20_100 nanoseconds. - Weight::from_ref_time(21_200_000 as u64) + // Minimum execution time: 18_400 nanoseconds. + Weight::from_ref_time(18_901_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } diff --git a/runtime/centrifuge/src/weights/pallet_proxy.rs b/runtime/centrifuge/src/weights/pallet_proxy.rs index 068dd6485e..2dcc5ef4b8 100644 --- a/runtime/centrifuge/src/weights/pallet_proxy.rs +++ b/runtime/centrifuge/src/weights/pallet_proxy.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_proxy` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-03-22, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-03-27, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("centrifuge-dev"), DB CACHE: 1024 @@ -33,10 +33,10 @@ impl pallet_proxy::WeightInfo for WeightInfo { // Storage: Proxy Proxies (r:1 w:0) /// The range of component `p` is `[1, 31]`. fn proxy(p: u32, ) -> Weight { - // Minimum execution time: 42_400 nanoseconds. - Weight::from_ref_time(43_926_662 as u64) - // Standard Error: 3_093 - .saturating_add(Weight::from_ref_time(74_366 as u64).saturating_mul(p as u64)) + // Minimum execution time: 41_201 nanoseconds. + Weight::from_ref_time(44_102_408 as u64) + // Standard Error: 9_675 + .saturating_add(Weight::from_ref_time(50_853 as u64).saturating_mul(p as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) } // Storage: Proxy Proxies (r:1 w:0) @@ -45,12 +45,12 @@ impl pallet_proxy::WeightInfo for WeightInfo { /// The range of component `a` is `[0, 31]`. /// The range of component `p` is `[1, 31]`. fn proxy_announced(a: u32, p: u32, ) -> Weight { - // Minimum execution time: 79_000 nanoseconds. - Weight::from_ref_time(79_691_053 as u64) - // Standard Error: 4_663 - .saturating_add(Weight::from_ref_time(258_288 as u64).saturating_mul(a as u64)) - // Standard Error: 4_818 - .saturating_add(Weight::from_ref_time(71_358 as u64).saturating_mul(p as u64)) + // Minimum execution time: 74_801 nanoseconds. + Weight::from_ref_time(78_072_257 as u64) + // Standard Error: 3_917 + .saturating_add(Weight::from_ref_time(251_140 as u64).saturating_mul(a as u64)) + // Standard Error: 4_048 + .saturating_add(Weight::from_ref_time(75_347 as u64).saturating_mul(p as u64)) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } @@ -59,12 +59,12 @@ impl pallet_proxy::WeightInfo for WeightInfo { /// The range of component `a` is `[0, 31]`. /// The range of component `p` is `[1, 31]`. fn remove_announcement(a: u32, p: u32, ) -> Weight { - // Minimum execution time: 53_100 nanoseconds. - Weight::from_ref_time(55_559_154 as u64) - // Standard Error: 4_627 - .saturating_add(Weight::from_ref_time(263_035 as u64).saturating_mul(a as u64)) - // Standard Error: 4_780 - .saturating_add(Weight::from_ref_time(14_790 as u64).saturating_mul(p as u64)) + // Minimum execution time: 52_101 nanoseconds. + Weight::from_ref_time(55_135_786 as u64) + // Standard Error: 11_361 + .saturating_add(Weight::from_ref_time(285_562 as u64).saturating_mul(a as u64)) + // Standard Error: 11_738 + .saturating_add(Weight::from_ref_time(11_912 as u64).saturating_mul(p as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } @@ -73,12 +73,12 @@ impl pallet_proxy::WeightInfo for WeightInfo { /// The range of component `a` is `[0, 31]`. /// The range of component `p` is `[1, 31]`. fn reject_announcement(a: u32, p: u32, ) -> Weight { - // Minimum execution time: 52_400 nanoseconds. - Weight::from_ref_time(54_486_188 as u64) - // Standard Error: 5_056 - .saturating_add(Weight::from_ref_time(285_431 as u64).saturating_mul(a as u64)) - // Standard Error: 5_224 - .saturating_add(Weight::from_ref_time(40_751 as u64).saturating_mul(p as u64)) + // Minimum execution time: 53_301 nanoseconds. + Weight::from_ref_time(55_285_482 as u64) + // Standard Error: 3_332 + .saturating_add(Weight::from_ref_time(258_517 as u64).saturating_mul(a as u64)) + // Standard Error: 3_443 + .saturating_add(Weight::from_ref_time(19_307 as u64).saturating_mul(p as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } @@ -88,42 +88,42 @@ impl pallet_proxy::WeightInfo for WeightInfo { /// The range of component `a` is `[0, 31]`. /// The range of component `p` is `[1, 31]`. fn announce(a: u32, p: u32, ) -> Weight { - // Minimum execution time: 69_900 nanoseconds. - Weight::from_ref_time(74_953_492 as u64) - // Standard Error: 14_621 - .saturating_add(Weight::from_ref_time(161_849 as u64).saturating_mul(a as u64)) - // Standard Error: 15_106 - .saturating_add(Weight::from_ref_time(40_496 as u64).saturating_mul(p as u64)) + // Minimum execution time: 69_002 nanoseconds. + Weight::from_ref_time(69_889_425 as u64) + // Standard Error: 5_302 + .saturating_add(Weight::from_ref_time(264_850 as u64).saturating_mul(a as u64)) + // Standard Error: 5_478 + .saturating_add(Weight::from_ref_time(73_912 as u64).saturating_mul(p as u64)) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } // Storage: Proxy Proxies (r:1 w:1) /// The range of component `p` is `[1, 31]`. fn add_proxy(p: u32, ) -> Weight { - // Minimum execution time: 59_001 nanoseconds. - Weight::from_ref_time(60_103_703 as u64) - // Standard Error: 5_775 - .saturating_add(Weight::from_ref_time(131_225 as u64).saturating_mul(p as u64)) + // Minimum execution time: 58_401 nanoseconds. + Weight::from_ref_time(60_507_759 as u64) + // Standard Error: 11_610 + .saturating_add(Weight::from_ref_time(153_853 as u64).saturating_mul(p as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Proxy Proxies (r:1 w:1) /// The range of component `p` is `[1, 31]`. fn remove_proxy(p: u32, ) -> Weight { - // Minimum execution time: 58_201 nanoseconds. - Weight::from_ref_time(62_360_424 as u64) - // Standard Error: 10_934 - .saturating_add(Weight::from_ref_time(52_492 as u64).saturating_mul(p as u64)) + // Minimum execution time: 57_001 nanoseconds. + Weight::from_ref_time(59_786_610 as u64) + // Standard Error: 3_540 + .saturating_add(Weight::from_ref_time(158_927 as u64).saturating_mul(p as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Proxy Proxies (r:1 w:1) /// The range of component `p` is `[1, 31]`. fn remove_proxies(p: u32, ) -> Weight { - // Minimum execution time: 49_700 nanoseconds. - Weight::from_ref_time(51_609_645 as u64) - // Standard Error: 1_983 - .saturating_add(Weight::from_ref_time(86_869 as u64).saturating_mul(p as u64)) + // Minimum execution time: 49_701 nanoseconds. + Weight::from_ref_time(51_564_928 as u64) + // Standard Error: 10_444 + .saturating_add(Weight::from_ref_time(123_007 as u64).saturating_mul(p as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } @@ -131,20 +131,20 @@ impl pallet_proxy::WeightInfo for WeightInfo { // Storage: Proxy Proxies (r:1 w:1) /// The range of component `p` is `[1, 31]`. fn create_pure(p: u32, ) -> Weight { - // Minimum execution time: 60_800 nanoseconds. - Weight::from_ref_time(64_937_851 as u64) - // Standard Error: 8_139 - .saturating_add(Weight::from_ref_time(67_749 as u64).saturating_mul(p as u64)) + // Minimum execution time: 62_002 nanoseconds. + Weight::from_ref_time(65_312_895 as u64) + // Standard Error: 16_159 + .saturating_add(Weight::from_ref_time(27_972 as u64).saturating_mul(p as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Proxy Proxies (r:1 w:1) /// The range of component `p` is `[0, 30]`. fn kill_pure(p: u32, ) -> Weight { - // Minimum execution time: 51_500 nanoseconds. - Weight::from_ref_time(53_565_592 as u64) - // Standard Error: 3_139 - .saturating_add(Weight::from_ref_time(89_977 as u64).saturating_mul(p as u64)) + // Minimum execution time: 52_001 nanoseconds. + Weight::from_ref_time(54_907_508 as u64) + // Standard Error: 14_726 + .saturating_add(Weight::from_ref_time(62_805 as u64).saturating_mul(p as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } diff --git a/runtime/centrifuge/src/weights/pallet_restricted_tokens.rs b/runtime/centrifuge/src/weights/pallet_restricted_tokens.rs new file mode 100644 index 0000000000..f9c3f32bcd --- /dev/null +++ b/runtime/centrifuge/src/weights/pallet_restricted_tokens.rs @@ -0,0 +1,109 @@ + +//! Autogenerated weights for `pallet_restricted_tokens` +//! +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev +//! DATE: 2023-03-27, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` +//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("centrifuge-dev"), DB CACHE: 1024 + +// Executed Command: +// target/release/centrifuge-chain +// benchmark +// pallet +// --chain=centrifuge-dev +// --steps=50 +// --repeat=20 +// --pallet=pallet_restricted_tokens +// --extrinsic=* +// --execution=wasm +// --wasm-execution=compiled +// --heap-pages=4096 +// --output=/tmp/runtime/centrifuge/src/weights/pallet_restricted_tokens.rs + +#![cfg_attr(rustfmt, rustfmt_skip)] +#![allow(unused_parens)] +#![allow(unused_imports)] + +use frame_support::{traits::Get, weights::Weight}; +use sp_std::marker::PhantomData; + +/// Weight functions for `pallet_restricted_tokens`. +pub struct WeightInfo(PhantomData); +impl pallet_restricted_tokens::WeightInfo for WeightInfo { + // Storage: System Account (r:1 w:1) + fn transfer_native() -> Weight { + // Minimum execution time: 81_501 nanoseconds. + Weight::from_ref_time(82_401_000 as u64) + .saturating_add(T::DbWeight::get().reads(1 as u64)) + .saturating_add(T::DbWeight::get().writes(1 as u64)) + } + // Storage: OrmlTokens Accounts (r:2 w:2) + // Storage: System Account (r:1 w:1) + fn transfer_other() -> Weight { + // Minimum execution time: 85_802 nanoseconds. + Weight::from_ref_time(87_601_000 as u64) + .saturating_add(T::DbWeight::get().reads(3 as u64)) + .saturating_add(T::DbWeight::get().writes(3 as u64)) + } + // Storage: System Account (r:1 w:1) + fn transfer_keep_alive_native() -> Weight { + // Minimum execution time: 73_801 nanoseconds. + Weight::from_ref_time(74_902_000 as u64) + .saturating_add(T::DbWeight::get().reads(1 as u64)) + .saturating_add(T::DbWeight::get().writes(1 as u64)) + } + // Storage: OrmlTokens Accounts (r:2 w:2) + // Storage: System Account (r:1 w:1) + fn transfer_keep_alive_other() -> Weight { + // Minimum execution time: 80_902 nanoseconds. + Weight::from_ref_time(82_101_000 as u64) + .saturating_add(T::DbWeight::get().reads(3 as u64)) + .saturating_add(T::DbWeight::get().writes(3 as u64)) + } + // Storage: System Account (r:1 w:1) + fn transfer_all_native() -> Weight { + // Minimum execution time: 86_302 nanoseconds. + Weight::from_ref_time(86_901_000 as u64) + .saturating_add(T::DbWeight::get().reads(1 as u64)) + .saturating_add(T::DbWeight::get().writes(1 as u64)) + } + // Storage: OrmlTokens Accounts (r:2 w:2) + // Storage: System Account (r:1 w:1) + fn transfer_all_other() -> Weight { + // Minimum execution time: 91_201 nanoseconds. + Weight::from_ref_time(92_501_000 as u64) + .saturating_add(T::DbWeight::get().reads(3 as u64)) + .saturating_add(T::DbWeight::get().writes(3 as u64)) + } + // Storage: System Account (r:1 w:1) + fn force_transfer_native() -> Weight { + // Minimum execution time: 81_802 nanoseconds. + Weight::from_ref_time(83_101_000 as u64) + .saturating_add(T::DbWeight::get().reads(1 as u64)) + .saturating_add(T::DbWeight::get().writes(1 as u64)) + } + // Storage: OrmlTokens Accounts (r:2 w:2) + // Storage: System Account (r:1 w:1) + fn force_transfer_other() -> Weight { + // Minimum execution time: 84_501 nanoseconds. + Weight::from_ref_time(87_201_000 as u64) + .saturating_add(T::DbWeight::get().reads(3 as u64)) + .saturating_add(T::DbWeight::get().writes(3 as u64)) + } + // Storage: System Account (r:1 w:1) + fn set_balance_native() -> Weight { + // Minimum execution time: 84_202 nanoseconds. + Weight::from_ref_time(86_101_000 as u64) + .saturating_add(T::DbWeight::get().reads(1 as u64)) + .saturating_add(T::DbWeight::get().writes(1 as u64)) + } + // Storage: OrmlTokens Accounts (r:1 w:1) + // Storage: OrmlTokens TotalIssuance (r:1 w:1) + // Storage: System Account (r:1 w:1) + fn set_balance_other() -> Weight { + // Minimum execution time: 95_301 nanoseconds. + Weight::from_ref_time(98_502_000 as u64) + .saturating_add(T::DbWeight::get().reads(3 as u64)) + .saturating_add(T::DbWeight::get().writes(3 as u64)) + } +} diff --git a/runtime/centrifuge/src/weights/pallet_scheduler.rs b/runtime/centrifuge/src/weights/pallet_scheduler.rs index 792d2623fe..13467756a1 100644 --- a/runtime/centrifuge/src/weights/pallet_scheduler.rs +++ b/runtime/centrifuge/src/weights/pallet_scheduler.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_scheduler` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-03-22, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-03-27, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("centrifuge-dev"), DB CACHE: 1024 @@ -33,60 +33,60 @@ impl pallet_scheduler::WeightInfo for WeightInfo { // Storage: Scheduler IncompleteSince (r:1 w:1) fn service_agendas_base() -> Weight { // Minimum execution time: 8_900 nanoseconds. - Weight::from_ref_time(9_300_000 as u64) + Weight::from_ref_time(9_000_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Scheduler Agenda (r:1 w:1) /// The range of component `s` is `[0, 50]`. fn service_agenda_base(s: u32, ) -> Weight { - // Minimum execution time: 8_200 nanoseconds. - Weight::from_ref_time(15_762_428 as u64) - // Standard Error: 4_574 - .saturating_add(Weight::from_ref_time(1_048_040 as u64).saturating_mul(s as u64)) + // Minimum execution time: 7_800 nanoseconds. + Weight::from_ref_time(15_543_177 as u64) + // Standard Error: 7_503 + .saturating_add(Weight::from_ref_time(1_044_127 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } fn service_task_base() -> Weight { - // Minimum execution time: 19_100 nanoseconds. - Weight::from_ref_time(19_400_000 as u64) + // Minimum execution time: 25_700 nanoseconds. + Weight::from_ref_time(26_900_000 as u64) } // Storage: Preimage PreimageFor (r:1 w:1) // Storage: Preimage StatusFor (r:1 w:1) /// The range of component `s` is `[128, 4194304]`. fn service_task_fetched(s: u32, ) -> Weight { - // Minimum execution time: 44_200 nanoseconds. - Weight::from_ref_time(44_500_000 as u64) - // Standard Error: 4 - .saturating_add(Weight::from_ref_time(1_697 as u64).saturating_mul(s as u64)) + // Minimum execution time: 44_001 nanoseconds. + Weight::from_ref_time(44_600_000 as u64) + // Standard Error: 2 + .saturating_add(Weight::from_ref_time(1_628 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } // Storage: Scheduler Lookup (r:0 w:1) fn service_task_named() -> Weight { - // Minimum execution time: 21_600 nanoseconds. - Weight::from_ref_time(22_700_000 as u64) + // Minimum execution time: 22_501 nanoseconds. + Weight::from_ref_time(23_001_000 as u64) .saturating_add(T::DbWeight::get().writes(1 as u64)) } fn service_task_periodic() -> Weight { - // Minimum execution time: 17_600 nanoseconds. - Weight::from_ref_time(19_400_000 as u64) + // Minimum execution time: 19_500 nanoseconds. + Weight::from_ref_time(20_101_000 as u64) } fn execute_dispatch_signed() -> Weight { - // Minimum execution time: 8_700 nanoseconds. - Weight::from_ref_time(9_300_000 as u64) + // Minimum execution time: 8_600 nanoseconds. + Weight::from_ref_time(9_200_000 as u64) } fn execute_dispatch_unsigned() -> Weight { - // Minimum execution time: 9_400 nanoseconds. - Weight::from_ref_time(9_700_000 as u64) + // Minimum execution time: 8_900 nanoseconds. + Weight::from_ref_time(9_200_000 as u64) } // Storage: Scheduler Agenda (r:1 w:1) /// The range of component `s` is `[0, 49]`. fn schedule(s: u32, ) -> Weight { - // Minimum execution time: 32_600 nanoseconds. - Weight::from_ref_time(49_825_420 as u64) - // Standard Error: 23_539 - .saturating_add(Weight::from_ref_time(902_679 as u64).saturating_mul(s as u64)) + // Minimum execution time: 36_201 nanoseconds. + Weight::from_ref_time(42_419_519 as u64) + // Standard Error: 7_915 + .saturating_add(Weight::from_ref_time(1_111_884 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } @@ -94,10 +94,10 @@ impl pallet_scheduler::WeightInfo for WeightInfo { // Storage: Scheduler Lookup (r:0 w:1) /// The range of component `s` is `[1, 50]`. fn cancel(s: u32, ) -> Weight { - // Minimum execution time: 40_000 nanoseconds. - Weight::from_ref_time(43_216_468 as u64) - // Standard Error: 4_672 - .saturating_add(Weight::from_ref_time(1_064_635 as u64).saturating_mul(s as u64)) + // Minimum execution time: 38_300 nanoseconds. + Weight::from_ref_time(42_970_519 as u64) + // Standard Error: 7_718 + .saturating_add(Weight::from_ref_time(1_045_685 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } @@ -105,10 +105,10 @@ impl pallet_scheduler::WeightInfo for WeightInfo { // Storage: Scheduler Agenda (r:1 w:1) /// The range of component `s` is `[0, 49]`. fn schedule_named(s: u32, ) -> Weight { - // Minimum execution time: 41_400 nanoseconds. - Weight::from_ref_time(50_423_549 as u64) - // Standard Error: 8_770 - .saturating_add(Weight::from_ref_time(1_138_627 as u64).saturating_mul(s as u64)) + // Minimum execution time: 41_701 nanoseconds. + Weight::from_ref_time(49_540_867 as u64) + // Standard Error: 8_349 + .saturating_add(Weight::from_ref_time(1_126_183 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } @@ -116,10 +116,10 @@ impl pallet_scheduler::WeightInfo for WeightInfo { // Storage: Scheduler Agenda (r:1 w:1) /// The range of component `s` is `[1, 50]`. fn cancel_named(s: u32, ) -> Weight { - // Minimum execution time: 42_100 nanoseconds. - Weight::from_ref_time(45_976_767 as u64) - // Standard Error: 4_769 - .saturating_add(Weight::from_ref_time(1_116_536 as u64).saturating_mul(s as u64)) + // Minimum execution time: 41_500 nanoseconds. + Weight::from_ref_time(45_237_657 as u64) + // Standard Error: 4_528 + .saturating_add(Weight::from_ref_time(1_107_767 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } diff --git a/runtime/centrifuge/src/weights/pallet_timestamp.rs b/runtime/centrifuge/src/weights/pallet_timestamp.rs index 124e09e19f..2c287975e8 100644 --- a/runtime/centrifuge/src/weights/pallet_timestamp.rs +++ b/runtime/centrifuge/src/weights/pallet_timestamp.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_timestamp` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-03-22, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-03-27, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("centrifuge-dev"), DB CACHE: 1024 @@ -33,13 +33,13 @@ impl pallet_timestamp::WeightInfo for WeightInfo { // Storage: Timestamp Now (r:1 w:1) // Storage: Aura CurrentSlot (r:1 w:0) fn set() -> Weight { - // Minimum execution time: 26_801 nanoseconds. - Weight::from_ref_time(27_500_000 as u64) + // Minimum execution time: 19_600 nanoseconds. + Weight::from_ref_time(20_001_000 as u64) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } fn on_finalize() -> Weight { - // Minimum execution time: 9_100 nanoseconds. - Weight::from_ref_time(9_201_000 as u64) + // Minimum execution time: 8_800 nanoseconds. + Weight::from_ref_time(9_001_000 as u64) } } diff --git a/runtime/centrifuge/src/weights/pallet_treasury.rs b/runtime/centrifuge/src/weights/pallet_treasury.rs index 23b40b05d3..31875d6065 100644 --- a/runtime/centrifuge/src/weights/pallet_treasury.rs +++ b/runtime/centrifuge/src/weights/pallet_treasury.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_treasury` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-03-22, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-03-27, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("centrifuge-dev"), DB CACHE: 1024 @@ -32,21 +32,21 @@ pub struct WeightInfo(PhantomData); impl pallet_treasury::WeightInfo for WeightInfo { fn spend() -> Weight { // Minimum execution time: 400 nanoseconds. - Weight::from_ref_time(400_000 as u64) + Weight::from_ref_time(401_000 as u64) } // Storage: Treasury ProposalCount (r:1 w:1) // Storage: Treasury Proposals (r:0 w:1) fn propose_spend() -> Weight { - // Minimum execution time: 57_200 nanoseconds. - Weight::from_ref_time(58_500_000 as u64) + // Minimum execution time: 58_201 nanoseconds. + Weight::from_ref_time(59_101_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } // Storage: Treasury Proposals (r:1 w:1) // Storage: System Account (r:2 w:2) fn reject_proposal() -> Weight { - // Minimum execution time: 81_301 nanoseconds. - Weight::from_ref_time(82_600_000 as u64) + // Minimum execution time: 80_402 nanoseconds. + Weight::from_ref_time(83_402_000 as u64) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -54,17 +54,17 @@ impl pallet_treasury::WeightInfo for WeightInfo { // Storage: Treasury Approvals (r:1 w:1) /// The range of component `p` is `[0, 99]`. fn approve_proposal(p: u32, ) -> Weight { - // Minimum execution time: 22_900 nanoseconds. - Weight::from_ref_time(30_793_836 as u64) - // Standard Error: 4_582 - .saturating_add(Weight::from_ref_time(210_204 as u64).saturating_mul(p as u64)) + // Minimum execution time: 22_301 nanoseconds. + Weight::from_ref_time(29_165_216 as u64) + // Standard Error: 3_059 + .saturating_add(Weight::from_ref_time(231_989 as u64).saturating_mul(p as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Treasury Approvals (r:1 w:1) fn remove_approval() -> Weight { - // Minimum execution time: 19_199 nanoseconds. - Weight::from_ref_time(19_600_000 as u64) + // Minimum execution time: 18_101 nanoseconds. + Weight::from_ref_time(18_801_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } @@ -73,10 +73,10 @@ impl pallet_treasury::WeightInfo for WeightInfo { // Storage: Treasury Proposals (r:2 w:0) /// The range of component `p` is `[0, 100]`. fn on_initialize_proposals(p: u32, ) -> Weight { - // Minimum execution time: 49_000 nanoseconds. - Weight::from_ref_time(48_851_589 as u64) - // Standard Error: 6_408 - .saturating_add(Weight::from_ref_time(4_139_638 as u64).saturating_mul(p as u64)) + // Minimum execution time: 51_501 nanoseconds. + Weight::from_ref_time(46_011_480 as u64) + // Standard Error: 6_091 + .saturating_add(Weight::from_ref_time(4_072_340 as u64).saturating_mul(p as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().reads((1 as u64).saturating_mul(p as u64))) .saturating_add(T::DbWeight::get().writes(1 as u64)) diff --git a/runtime/centrifuge/src/weights/pallet_uniques.rs b/runtime/centrifuge/src/weights/pallet_uniques.rs index 6d6077faf6..f1cb9cd037 100644 --- a/runtime/centrifuge/src/weights/pallet_uniques.rs +++ b/runtime/centrifuge/src/weights/pallet_uniques.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_uniques` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-03-22, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-03-27, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("centrifuge-dev"), DB CACHE: 1024 @@ -33,16 +33,16 @@ impl pallet_uniques::WeightInfo for WeightInfo { // Storage: Uniques Class (r:1 w:1) // Storage: Uniques ClassAccount (r:0 w:1) fn create() -> Weight { - // Minimum execution time: 60_400 nanoseconds. - Weight::from_ref_time(61_000_000 as u64) + // Minimum execution time: 61_501 nanoseconds. + Weight::from_ref_time(62_701_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } // Storage: Uniques Class (r:1 w:1) // Storage: Uniques ClassAccount (r:0 w:1) fn force_create() -> Weight { - // Minimum execution time: 37_900 nanoseconds. - Weight::from_ref_time(38_800_000 as u64) + // Minimum execution time: 38_501 nanoseconds. + Weight::from_ref_time(39_101_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } @@ -58,14 +58,14 @@ impl pallet_uniques::WeightInfo for WeightInfo { /// The range of component `m` is `[0, 1000]`. /// The range of component `a` is `[0, 1000]`. fn destroy(n: u32, m: u32, a: u32, ) -> Weight { - // Minimum execution time: 4_248_015 nanoseconds. - Weight::from_ref_time(4_313_915_000 as u64) - // Standard Error: 59_146 - .saturating_add(Weight::from_ref_time(17_747_711 as u64).saturating_mul(n as u64)) - // Standard Error: 59_146 - .saturating_add(Weight::from_ref_time(581_513 as u64).saturating_mul(m as u64)) - // Standard Error: 59_146 - .saturating_add(Weight::from_ref_time(809_617 as u64).saturating_mul(a as u64)) + // Minimum execution time: 3_887_472 nanoseconds. + Weight::from_ref_time(3_965_373_000 as u64) + // Standard Error: 45_917 + .saturating_add(Weight::from_ref_time(16_223_970 as u64).saturating_mul(n as u64)) + // Standard Error: 45_917 + .saturating_add(Weight::from_ref_time(481_083 as u64).saturating_mul(m as u64)) + // Standard Error: 45_917 + .saturating_add(Weight::from_ref_time(482_437 as u64).saturating_mul(a as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().reads((1 as u64).saturating_mul(n as u64))) .saturating_add(T::DbWeight::get().writes(4 as u64)) @@ -78,8 +78,8 @@ impl pallet_uniques::WeightInfo for WeightInfo { // Storage: Uniques CollectionMaxSupply (r:1 w:0) // Storage: Uniques Account (r:0 w:1) fn mint() -> Weight { - // Minimum execution time: 74_400 nanoseconds. - Weight::from_ref_time(75_500_000 as u64) + // Minimum execution time: 76_102 nanoseconds. + Weight::from_ref_time(77_202_000 as u64) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -88,8 +88,8 @@ impl pallet_uniques::WeightInfo for WeightInfo { // Storage: Uniques Account (r:0 w:1) // Storage: Uniques ItemPriceOf (r:0 w:1) fn burn() -> Weight { - // Minimum execution time: 78_000 nanoseconds. - Weight::from_ref_time(79_001_000 as u64) + // Minimum execution time: 78_201 nanoseconds. + Weight::from_ref_time(80_502_000 as u64) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(4 as u64)) } @@ -98,8 +98,8 @@ impl pallet_uniques::WeightInfo for WeightInfo { // Storage: Uniques Account (r:0 w:2) // Storage: Uniques ItemPriceOf (r:0 w:1) fn transfer() -> Weight { - // Minimum execution time: 61_100 nanoseconds. - Weight::from_ref_time(61_700_000 as u64) + // Minimum execution time: 62_201 nanoseconds. + Weight::from_ref_time(81_102_000 as u64) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(4 as u64)) } @@ -108,9 +108,9 @@ impl pallet_uniques::WeightInfo for WeightInfo { /// The range of component `i` is `[0, 5000]`. fn redeposit(i: u32, ) -> Weight { // Minimum execution time: 39_101 nanoseconds. - Weight::from_ref_time(39_501_000 as u64) - // Standard Error: 18_907 - .saturating_add(Weight::from_ref_time(23_594_077 as u64).saturating_mul(i as u64)) + Weight::from_ref_time(40_501_000 as u64) + // Standard Error: 14_203 + .saturating_add(Weight::from_ref_time(23_090_650 as u64).saturating_mul(i as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().reads((1 as u64).saturating_mul(i as u64))) .saturating_add(T::DbWeight::get().writes(1 as u64)) @@ -119,30 +119,30 @@ impl pallet_uniques::WeightInfo for WeightInfo { // Storage: Uniques Asset (r:1 w:1) // Storage: Uniques Class (r:1 w:0) fn freeze() -> Weight { - // Minimum execution time: 46_101 nanoseconds. - Weight::from_ref_time(46_701_000 as u64) + // Minimum execution time: 45_901 nanoseconds. + Weight::from_ref_time(47_801_000 as u64) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Uniques Asset (r:1 w:1) // Storage: Uniques Class (r:1 w:0) fn thaw() -> Weight { - // Minimum execution time: 46_001 nanoseconds. - Weight::from_ref_time(46_501_000 as u64) + // Minimum execution time: 48_201 nanoseconds. + Weight::from_ref_time(52_801_000 as u64) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Uniques Class (r:1 w:1) fn freeze_collection() -> Weight { - // Minimum execution time: 37_101 nanoseconds. - Weight::from_ref_time(37_800_000 as u64) + // Minimum execution time: 37_900 nanoseconds. + Weight::from_ref_time(38_701_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Uniques Class (r:1 w:1) fn thaw_collection() -> Weight { - // Minimum execution time: 37_300 nanoseconds. - Weight::from_ref_time(37_800_000 as u64) + // Minimum execution time: 37_901 nanoseconds. + Weight::from_ref_time(38_501_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } @@ -150,23 +150,23 @@ impl pallet_uniques::WeightInfo for WeightInfo { // Storage: Uniques Class (r:1 w:1) // Storage: Uniques ClassAccount (r:0 w:2) fn transfer_ownership() -> Weight { - // Minimum execution time: 51_900 nanoseconds. - Weight::from_ref_time(52_401_000 as u64) + // Minimum execution time: 53_001 nanoseconds. + Weight::from_ref_time(53_501_000 as u64) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(4 as u64)) } // Storage: Uniques Class (r:1 w:1) fn set_team() -> Weight { - // Minimum execution time: 38_301 nanoseconds. - Weight::from_ref_time(39_101_000 as u64) + // Minimum execution time: 39_301 nanoseconds. + Weight::from_ref_time(39_901_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Uniques Class (r:1 w:1) // Storage: Uniques ClassAccount (r:0 w:1) fn force_item_status() -> Weight { - // Minimum execution time: 42_700 nanoseconds. - Weight::from_ref_time(43_401_000 as u64) + // Minimum execution time: 43_701 nanoseconds. + Weight::from_ref_time(44_201_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } @@ -174,8 +174,8 @@ impl pallet_uniques::WeightInfo for WeightInfo { // Storage: Uniques InstanceMetadataOf (r:1 w:0) // Storage: Uniques Attribute (r:1 w:1) fn set_attribute() -> Weight { - // Minimum execution time: 88_301 nanoseconds. - Weight::from_ref_time(89_601_000 as u64) + // Minimum execution time: 89_701 nanoseconds. + Weight::from_ref_time(91_101_000 as u64) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } @@ -183,79 +183,79 @@ impl pallet_uniques::WeightInfo for WeightInfo { // Storage: Uniques InstanceMetadataOf (r:1 w:0) // Storage: Uniques Attribute (r:1 w:1) fn clear_attribute() -> Weight { - // Minimum execution time: 87_102 nanoseconds. - Weight::from_ref_time(88_401_000 as u64) + // Minimum execution time: 89_201 nanoseconds. + Weight::from_ref_time(90_302_000 as u64) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } // Storage: Uniques Class (r:1 w:1) // Storage: Uniques InstanceMetadataOf (r:1 w:1) fn set_metadata() -> Weight { - // Minimum execution time: 68_401 nanoseconds. - Weight::from_ref_time(69_401_000 as u64) + // Minimum execution time: 70_402 nanoseconds. + Weight::from_ref_time(71_601_000 as u64) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } // Storage: Uniques Class (r:1 w:1) // Storage: Uniques InstanceMetadataOf (r:1 w:1) fn clear_metadata() -> Weight { - // Minimum execution time: 70_501 nanoseconds. - Weight::from_ref_time(71_301_000 as u64) + // Minimum execution time: 71_802 nanoseconds. + Weight::from_ref_time(72_601_000 as u64) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } // Storage: Uniques Class (r:1 w:1) // Storage: Uniques ClassMetadataOf (r:1 w:1) fn set_collection_metadata() -> Weight { - // Minimum execution time: 66_801 nanoseconds. - Weight::from_ref_time(67_601_000 as u64) + // Minimum execution time: 87_402 nanoseconds. + Weight::from_ref_time(89_001_000 as u64) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } // Storage: Uniques Class (r:1 w:0) // Storage: Uniques ClassMetadataOf (r:1 w:1) fn clear_collection_metadata() -> Weight { - // Minimum execution time: 64_902 nanoseconds. - Weight::from_ref_time(65_801_000 as u64) + // Minimum execution time: 66_202 nanoseconds. + Weight::from_ref_time(67_301_000 as u64) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Uniques Class (r:1 w:0) // Storage: Uniques Asset (r:1 w:1) fn approve_transfer() -> Weight { - // Minimum execution time: 47_901 nanoseconds. - Weight::from_ref_time(48_601_000 as u64) + // Minimum execution time: 48_401 nanoseconds. + Weight::from_ref_time(49_401_000 as u64) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Uniques Class (r:1 w:0) // Storage: Uniques Asset (r:1 w:1) fn cancel_approval() -> Weight { - // Minimum execution time: 47_900 nanoseconds. - Weight::from_ref_time(48_400_000 as u64) + // Minimum execution time: 48_601 nanoseconds. + Weight::from_ref_time(49_101_000 as u64) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Uniques OwnershipAcceptance (r:1 w:1) fn set_accept_ownership() -> Weight { - // Minimum execution time: 43_700 nanoseconds. - Weight::from_ref_time(44_401_000 as u64) + // Minimum execution time: 45_200 nanoseconds. + Weight::from_ref_time(45_801_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Uniques CollectionMaxSupply (r:1 w:1) // Storage: Uniques Class (r:1 w:0) fn set_collection_max_supply() -> Weight { - // Minimum execution time: 41_701 nanoseconds. - Weight::from_ref_time(42_201_000 as u64) + // Minimum execution time: 41_801 nanoseconds. + Weight::from_ref_time(42_601_000 as u64) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Uniques Asset (r:1 w:0) // Storage: Uniques ItemPriceOf (r:0 w:1) fn set_price() -> Weight { - // Minimum execution time: 42_301 nanoseconds. - Weight::from_ref_time(42_901_000 as u64) + // Minimum execution time: 43_401 nanoseconds. + Weight::from_ref_time(44_001_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } @@ -264,8 +264,8 @@ impl pallet_uniques::WeightInfo for WeightInfo { // Storage: Uniques Class (r:1 w:0) // Storage: Uniques Account (r:0 w:2) fn buy_item() -> Weight { - // Minimum execution time: 79_901 nanoseconds. - Weight::from_ref_time(80_901_000 as u64) + // Minimum execution time: 80_901 nanoseconds. + Weight::from_ref_time(83_602_000 as u64) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(4 as u64)) } diff --git a/runtime/centrifuge/src/weights/pallet_utility.rs b/runtime/centrifuge/src/weights/pallet_utility.rs index ff89c1264a..9e9859815f 100644 --- a/runtime/centrifuge/src/weights/pallet_utility.rs +++ b/runtime/centrifuge/src/weights/pallet_utility.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_utility` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-03-22, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-03-27, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("centrifuge-dev"), DB CACHE: 1024 @@ -32,31 +32,31 @@ pub struct WeightInfo(PhantomData); impl pallet_utility::WeightInfo for WeightInfo { /// The range of component `c` is `[0, 1000]`. fn batch(c: u32, ) -> Weight { - // Minimum execution time: 25_300 nanoseconds. - Weight::from_ref_time(43_984_599 as u64) - // Standard Error: 3_528 - .saturating_add(Weight::from_ref_time(8_946_930 as u64).saturating_mul(c as u64)) + // Minimum execution time: 24_500 nanoseconds. + Weight::from_ref_time(43_489_908 as u64) + // Standard Error: 3_492 + .saturating_add(Weight::from_ref_time(8_266_513 as u64).saturating_mul(c as u64)) } fn as_derivative() -> Weight { - // Minimum execution time: 19_700 nanoseconds. - Weight::from_ref_time(20_100_000 as u64) + // Minimum execution time: 13_900 nanoseconds. + Weight::from_ref_time(14_300_000 as u64) } /// The range of component `c` is `[0, 1000]`. fn batch_all(c: u32, ) -> Weight { - // Minimum execution time: 24_801 nanoseconds. - Weight::from_ref_time(38_543_565 as u64) - // Standard Error: 3_463 - .saturating_add(Weight::from_ref_time(9_410_755 as u64).saturating_mul(c as u64)) + // Minimum execution time: 24_700 nanoseconds. + Weight::from_ref_time(37_264_511 as u64) + // Standard Error: 3_193 + .saturating_add(Weight::from_ref_time(8_694_898 as u64).saturating_mul(c as u64)) } fn dispatch_as() -> Weight { - // Minimum execution time: 30_600 nanoseconds. - Weight::from_ref_time(31_601_000 as u64) + // Minimum execution time: 29_601 nanoseconds. + Weight::from_ref_time(30_301_000 as u64) } /// The range of component `c` is `[0, 1000]`. fn force_batch(c: u32, ) -> Weight { - // Minimum execution time: 25_200 nanoseconds. - Weight::from_ref_time(39_005_739 as u64) - // Standard Error: 3_181 - .saturating_add(Weight::from_ref_time(8_978_664 as u64).saturating_mul(c as u64)) + // Minimum execution time: 24_800 nanoseconds. + Weight::from_ref_time(42_619_495 as u64) + // Standard Error: 3_435 + .saturating_add(Weight::from_ref_time(8_240_228 as u64).saturating_mul(c as u64)) } } diff --git a/runtime/centrifuge/src/weights/pallet_vesting.rs b/runtime/centrifuge/src/weights/pallet_vesting.rs index 2e21e44b78..8ca1d1fd37 100644 --- a/runtime/centrifuge/src/weights/pallet_vesting.rs +++ b/runtime/centrifuge/src/weights/pallet_vesting.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_vesting` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-03-22, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-03-27, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("centrifuge-dev"), DB CACHE: 1024 @@ -35,12 +35,12 @@ impl pallet_vesting::WeightInfo for WeightInfo { /// The range of component `l` is `[0, 49]`. /// The range of component `s` is `[1, 3]`. fn vest_locked(l: u32, s: u32, ) -> Weight { - // Minimum execution time: 72_401 nanoseconds. - Weight::from_ref_time(73_754_374 as u64) - // Standard Error: 6_074 - .saturating_add(Weight::from_ref_time(96_059 as u64).saturating_mul(l as u64)) - // Standard Error: 116_395 - .saturating_add(Weight::from_ref_time(489_512 as u64).saturating_mul(s as u64)) + // Minimum execution time: 69_902 nanoseconds. + Weight::from_ref_time(75_652_784 as u64) + // Standard Error: 8_138 + .saturating_add(Weight::from_ref_time(24_046 as u64).saturating_mul(l as u64)) + // Standard Error: 155_929 + .saturating_add(Weight::from_ref_time(6_565 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } @@ -49,12 +49,12 @@ impl pallet_vesting::WeightInfo for WeightInfo { /// The range of component `l` is `[0, 49]`. /// The range of component `s` is `[1, 3]`. fn vest_unlocked(l: u32, s: u32, ) -> Weight { - // Minimum execution time: 72_101 nanoseconds. - Weight::from_ref_time(73_063_601 as u64) - // Standard Error: 4_860 - .saturating_add(Weight::from_ref_time(82_669 as u64).saturating_mul(l as u64)) - // Standard Error: 93_134 - .saturating_add(Weight::from_ref_time(369_768 as u64).saturating_mul(s as u64)) + // Minimum execution time: 70_101 nanoseconds. + Weight::from_ref_time(72_176_978 as u64) + // Standard Error: 5_519 + .saturating_add(Weight::from_ref_time(64_027 as u64).saturating_mul(l as u64)) + // Standard Error: 105_750 + .saturating_add(Weight::from_ref_time(344_739 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } @@ -64,12 +64,12 @@ impl pallet_vesting::WeightInfo for WeightInfo { /// The range of component `l` is `[0, 49]`. /// The range of component `s` is `[1, 3]`. fn vest_other_locked(l: u32, s: u32, ) -> Weight { - // Minimum execution time: 72_200 nanoseconds. - Weight::from_ref_time(72_411_361 as u64) - // Standard Error: 3_395 - .saturating_add(Weight::from_ref_time(101_124 as u64).saturating_mul(l as u64)) - // Standard Error: 65_055 - .saturating_add(Weight::from_ref_time(504_635 as u64).saturating_mul(s as u64)) + // Minimum execution time: 69_401 nanoseconds. + Weight::from_ref_time(74_016_121 as u64) + // Standard Error: 16_171 + .saturating_add(Weight::from_ref_time(25_187 as u64).saturating_mul(l as u64)) + // Standard Error: 309_849 + .saturating_add(Weight::from_ref_time(598_970 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -78,13 +78,11 @@ impl pallet_vesting::WeightInfo for WeightInfo { // Storage: System Account (r:1 w:1) /// The range of component `l` is `[0, 49]`. /// The range of component `s` is `[1, 3]`. - fn vest_other_unlocked(l: u32, s: u32, ) -> Weight { - // Minimum execution time: 71_101 nanoseconds. - Weight::from_ref_time(75_115_899 as u64) - // Standard Error: 12_065 - .saturating_add(Weight::from_ref_time(40_630 as u64).saturating_mul(l as u64)) - // Standard Error: 231_182 - .saturating_add(Weight::from_ref_time(217_014 as u64).saturating_mul(s as u64)) + fn vest_other_unlocked(l: u32, _s: u32, ) -> Weight { + // Minimum execution time: 67_301 nanoseconds. + Weight::from_ref_time(73_529_174 as u64) + // Standard Error: 9_866 + .saturating_add(Weight::from_ref_time(33_360 as u64).saturating_mul(l as u64)) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -94,8 +92,8 @@ impl pallet_vesting::WeightInfo for WeightInfo { /// The range of component `l` is `[0, 49]`. /// The range of component `s` is `[0, 2]`. fn vested_transfer(_l: u32, _s: u32, ) -> Weight { - // Minimum execution time: 101_201 nanoseconds. - Weight::from_ref_time(121_350_657 as u64) + // Minimum execution time: 97_602 nanoseconds. + Weight::from_ref_time(119_805_609 as u64) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -105,8 +103,8 @@ impl pallet_vesting::WeightInfo for WeightInfo { /// The range of component `l` is `[0, 49]`. /// The range of component `s` is `[0, 2]`. fn force_vested_transfer(_l: u32, _s: u32, ) -> Weight { - // Minimum execution time: 100_401 nanoseconds. - Weight::from_ref_time(120_143_883 as u64) + // Minimum execution time: 95_002 nanoseconds. + Weight::from_ref_time(116_072_549 as u64) .saturating_add(T::DbWeight::get().reads(4 as u64)) .saturating_add(T::DbWeight::get().writes(4 as u64)) } @@ -116,12 +114,12 @@ impl pallet_vesting::WeightInfo for WeightInfo { /// The range of component `l` is `[0, 49]`. /// The range of component `s` is `[2, 3]`. fn not_unlocking_merge_schedules(l: u32, s: u32, ) -> Weight { - // Minimum execution time: 73_800 nanoseconds. - Weight::from_ref_time(77_773_276 as u64) - // Standard Error: 9_836 - .saturating_add(Weight::from_ref_time(56_071 as u64).saturating_mul(l as u64)) - // Standard Error: 313_726 - .saturating_add(Weight::from_ref_time(20_199 as u64).saturating_mul(s as u64)) + // Minimum execution time: 70_601 nanoseconds. + Weight::from_ref_time(70_269_553 as u64) + // Standard Error: 9_184 + .saturating_add(Weight::from_ref_time(103_885 as u64).saturating_mul(l as u64)) + // Standard Error: 292_906 + .saturating_add(Weight::from_ref_time(1_413_467 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -131,12 +129,12 @@ impl pallet_vesting::WeightInfo for WeightInfo { /// The range of component `l` is `[0, 49]`. /// The range of component `s` is `[2, 3]`. fn unlocking_merge_schedules(l: u32, s: u32, ) -> Weight { - // Minimum execution time: 73_801 nanoseconds. - Weight::from_ref_time(73_311_367 as u64) - // Standard Error: 7_146 - .saturating_add(Weight::from_ref_time(109_182 as u64).saturating_mul(l as u64)) - // Standard Error: 227_925 - .saturating_add(Weight::from_ref_time(1_018_378 as u64).saturating_mul(s as u64)) + // Minimum execution time: 69_701 nanoseconds. + Weight::from_ref_time(73_302_702 as u64) + // Standard Error: 4_632 + .saturating_add(Weight::from_ref_time(93_834 as u64).saturating_mul(l as u64)) + // Standard Error: 147_736 + .saturating_add(Weight::from_ref_time(218_659 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } From 351abec3d009a0aaf65873833d86c06791c96b97 Mon Sep 17 00:00:00 2001 From: mustermeiszer Date: Tue, 28 Mar 2023 08:48:44 +0200 Subject: [PATCH 44/55] feat: Update weights altair --- runtime/altair/src/weights/frame_system.rs | 44 ++--- runtime/altair/src/weights/pallet_anchors.rs | 18 +- runtime/altair/src/weights/pallet_balances.rs | 30 +-- .../src/weights/pallet_collator_allowlist.rs | 10 +- .../altair/src/weights/pallet_collective.rs | 126 ++++++------ .../src/weights/pallet_crowdloan_claim.rs | 38 ++-- .../src/weights/pallet_crowdloan_reward.rs | 16 +- .../altair/src/weights/pallet_democracy.rs | 122 ++++++------ runtime/altair/src/weights/pallet_fees.rs | 6 +- runtime/altair/src/weights/pallet_identity.rs | 160 +++++++-------- .../src/weights/pallet_interest_accrual.rs | 8 +- runtime/altair/src/weights/pallet_loans.rs | 184 +++++++++--------- .../src/weights/pallet_migration_manager.rs | 34 ++-- runtime/altair/src/weights/pallet_multisig.rs | 70 +++---- .../altair/src/weights/pallet_nft_sales.rs | 14 +- .../altair/src/weights/pallet_permissions.rs | 26 +-- .../src/weights/pallet_pool_registry.rs | 44 ++--- .../altair/src/weights/pallet_pool_system.rs | 46 ++--- runtime/altair/src/weights/pallet_preimage.rs | 58 +++--- runtime/altair/src/weights/pallet_proxy.rs | 98 +++++----- .../src/weights/pallet_restricted_tokens.rs | 42 ++-- .../altair/src/weights/pallet_scheduler.rs | 72 +++---- .../altair/src/weights/pallet_timestamp.rs | 6 +- runtime/altair/src/weights/pallet_treasury.rs | 30 +-- runtime/altair/src/weights/pallet_uniques.rs | 122 ++++++------ runtime/altair/src/weights/pallet_utility.rs | 34 ++-- runtime/altair/src/weights/pallet_vesting.rs | 98 +++++----- 27 files changed, 778 insertions(+), 778 deletions(-) diff --git a/runtime/altair/src/weights/frame_system.rs b/runtime/altair/src/weights/frame_system.rs index eb35daf926..815e1e802f 100644 --- a/runtime/altair/src/weights/frame_system.rs +++ b/runtime/altair/src/weights/frame_system.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `frame_system` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-01-12, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-03-25, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("altair-dev"), DB CACHE: 1024 @@ -32,51 +32,51 @@ pub struct WeightInfo(PhantomData); impl frame_system::WeightInfo for WeightInfo { /// The range of component `b` is `[0, 3932160]`. fn remark(b: u32, ) -> Weight { - // Minimum execution time: 8_001 nanoseconds. - Weight::from_ref_time(11_535_975 as u64) + // Minimum execution time: 8_300 nanoseconds. + Weight::from_ref_time(11_674_648 as u64) // Standard Error: 0 - .saturating_add(Weight::from_ref_time(533 as u64).saturating_mul(b as u64)) + .saturating_add(Weight::from_ref_time(531 as u64).saturating_mul(b as u64)) } /// The range of component `b` is `[0, 3932160]`. fn remark_with_event(b: u32, ) -> Weight { - // Minimum execution time: 26_100 nanoseconds. - Weight::from_ref_time(12_616_396 as u64) - // Standard Error: 0 - .saturating_add(Weight::from_ref_time(1_890 as u64).saturating_mul(b as u64)) + // Minimum execution time: 25_200 nanoseconds. + Weight::from_ref_time(37_255_034 as u64) + // Standard Error: 1 + .saturating_add(Weight::from_ref_time(1_879 as u64).saturating_mul(b as u64)) } // Storage: System Digest (r:1 w:1) // Storage: unknown [0x3a686561707061676573] (r:0 w:1) fn set_heap_pages() -> Weight { - // Minimum execution time: 16_900 nanoseconds. - Weight::from_ref_time(17_300_000 as u64) + // Minimum execution time: 16_800 nanoseconds. + Weight::from_ref_time(17_401_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } // Storage: Skipped Metadata (r:0 w:0) /// The range of component `i` is `[0, 1000]`. fn set_storage(i: u32, ) -> Weight { - // Minimum execution time: 8_100 nanoseconds. - Weight::from_ref_time(89_306 as u64) - // Standard Error: 1_702 - .saturating_add(Weight::from_ref_time(1_148_953 as u64).saturating_mul(i as u64)) + // Minimum execution time: 7_700 nanoseconds. + Weight::from_ref_time(2_101_462 as u64) + // Standard Error: 1_717 + .saturating_add(Weight::from_ref_time(1_132_906 as u64).saturating_mul(i as u64)) .saturating_add(T::DbWeight::get().writes((1 as u64).saturating_mul(i as u64))) } // Storage: Skipped Metadata (r:0 w:0) /// The range of component `i` is `[0, 1000]`. fn kill_storage(i: u32, ) -> Weight { - // Minimum execution time: 8_000 nanoseconds. - Weight::from_ref_time(3_259_984 as u64) - // Standard Error: 1_635 - .saturating_add(Weight::from_ref_time(901_614 as u64).saturating_mul(i as u64)) + // Minimum execution time: 7_400 nanoseconds. + Weight::from_ref_time(3_993_264 as u64) + // Standard Error: 1_689 + .saturating_add(Weight::from_ref_time(883_945 as u64).saturating_mul(i as u64)) .saturating_add(T::DbWeight::get().writes((1 as u64).saturating_mul(i as u64))) } // Storage: Skipped Metadata (r:0 w:0) /// The range of component `p` is `[0, 1000]`. fn kill_prefix(p: u32, ) -> Weight { - // Minimum execution time: 11_600 nanoseconds. - Weight::from_ref_time(11_700_000 as u64) - // Standard Error: 1_579 - .saturating_add(Weight::from_ref_time(1_663_730 as u64).saturating_mul(p as u64)) + // Minimum execution time: 11_400 nanoseconds. + Weight::from_ref_time(1_846_148 as u64) + // Standard Error: 2_709 + .saturating_add(Weight::from_ref_time(1_627_406 as u64).saturating_mul(p as u64)) .saturating_add(T::DbWeight::get().writes((1 as u64).saturating_mul(p as u64))) } } diff --git a/runtime/altair/src/weights/pallet_anchors.rs b/runtime/altair/src/weights/pallet_anchors.rs index 39efeb030d..0da22b8c5b 100644 --- a/runtime/altair/src/weights/pallet_anchors.rs +++ b/runtime/altair/src/weights/pallet_anchors.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_anchors` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-01-12, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-03-25, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("altair-dev"), DB CACHE: 1024 @@ -34,8 +34,8 @@ impl pallet_anchors::WeightInfo for WeightInfo { // Storage: Anchor PreCommits (r:1 w:1) // Storage: Fees FeeBalances (r:1 w:0) fn pre_commit() -> Weight { - // Minimum execution time: 62_801 nanoseconds. - Weight::from_ref_time(63_801_000 as u64) + // Minimum execution time: 60_701 nanoseconds. + Weight::from_ref_time(62_802_000 as u64) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } @@ -49,15 +49,15 @@ impl pallet_anchors::WeightInfo for WeightInfo { // Storage: Anchor AnchorIndexes (r:0 w:1) // Storage: unknown [0xdb4faa73ca6d2016e53c7156087c176b79b169c409b8a0063a07964f3187f9e9] (r:0 w:1) fn commit() -> Weight { - // Minimum execution time: 95_601 nanoseconds. - Weight::from_ref_time(96_501_000 as u64) + // Minimum execution time: 88_701 nanoseconds. + Weight::from_ref_time(97_402_000 as u64) .saturating_add(T::DbWeight::get().reads(7 as u64)) .saturating_add(T::DbWeight::get().writes(5 as u64)) } // Storage: Anchor PreCommits (r:100 w:100) fn evict_pre_commits() -> Weight { - // Minimum execution time: 2_018_428 nanoseconds. - Weight::from_ref_time(2_033_028_000 as u64) + // Minimum execution time: 2_014_538 nanoseconds. + Weight::from_ref_time(2_045_039_000 as u64) .saturating_add(T::DbWeight::get().reads(100 as u64)) .saturating_add(T::DbWeight::get().writes(100 as u64)) } @@ -269,8 +269,8 @@ impl pallet_anchors::WeightInfo for WeightInfo { // Storage: unknown [0xee60c64e1e32117f948ee71d391f978e8ac98c2bd869322fc25164502e3f7a9b] (r:0 w:1) // Storage: unknown [0xf7e4b8a5415405a940e730546df85583c8c23956d99a3be18e09eebf3639d312] (r:0 w:1) fn evict_anchors() -> Weight { - // Minimum execution time: 2_229_631 nanoseconds. - Weight::from_ref_time(2_257_632_000 as u64) + // Minimum execution time: 2_228_842 nanoseconds. + Weight::from_ref_time(2_267_943_000 as u64) .saturating_add(T::DbWeight::get().reads(404 as u64)) .saturating_add(T::DbWeight::get().writes(402 as u64)) } diff --git a/runtime/altair/src/weights/pallet_balances.rs b/runtime/altair/src/weights/pallet_balances.rs index ba0f39fb11..a259c10b6c 100644 --- a/runtime/altair/src/weights/pallet_balances.rs +++ b/runtime/altair/src/weights/pallet_balances.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_balances` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-01-12, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-03-25, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("altair-dev"), DB CACHE: 1024 @@ -32,50 +32,50 @@ pub struct WeightInfo(PhantomData); impl pallet_balances::WeightInfo for WeightInfo { // Storage: System Account (r:1 w:1) fn transfer() -> Weight { - // Minimum execution time: 87_501 nanoseconds. - Weight::from_ref_time(88_701_000 as u64) + // Minimum execution time: 88_101 nanoseconds. + Weight::from_ref_time(89_101_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: System Account (r:1 w:1) fn transfer_keep_alive() -> Weight { - // Minimum execution time: 64_201 nanoseconds. - Weight::from_ref_time(65_301_000 as u64) + // Minimum execution time: 64_701 nanoseconds. + Weight::from_ref_time(65_401_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: System Account (r:1 w:1) fn set_balance_creating() -> Weight { - // Minimum execution time: 47_701 nanoseconds. - Weight::from_ref_time(48_700_000 as u64) + // Minimum execution time: 47_101 nanoseconds. + Weight::from_ref_time(48_001_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: System Account (r:1 w:1) fn set_balance_killing() -> Weight { - // Minimum execution time: 53_100 nanoseconds. - Weight::from_ref_time(54_001_000 as u64) + // Minimum execution time: 53_801 nanoseconds. + Weight::from_ref_time(54_401_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: System Account (r:2 w:2) fn force_transfer() -> Weight { - // Minimum execution time: 86_201 nanoseconds. - Weight::from_ref_time(87_202_000 as u64) + // Minimum execution time: 86_801 nanoseconds. + Weight::from_ref_time(88_002_000 as u64) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } // Storage: System Account (r:1 w:1) fn transfer_all() -> Weight { - // Minimum execution time: 74_801 nanoseconds. - Weight::from_ref_time(76_201_000 as u64) + // Minimum execution time: 75_801 nanoseconds. + Weight::from_ref_time(76_801_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: System Account (r:1 w:1) fn force_unreserve() -> Weight { - // Minimum execution time: 40_401 nanoseconds. - Weight::from_ref_time(41_400_000 as u64) + // Minimum execution time: 40_701 nanoseconds. + Weight::from_ref_time(41_300_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } diff --git a/runtime/altair/src/weights/pallet_collator_allowlist.rs b/runtime/altair/src/weights/pallet_collator_allowlist.rs index b102d8be6f..9fde08b3a6 100644 --- a/runtime/altair/src/weights/pallet_collator_allowlist.rs +++ b/runtime/altair/src/weights/pallet_collator_allowlist.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_collator_allowlist` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-01-12, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-03-25, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("altair-dev"), DB CACHE: 1024 @@ -33,15 +33,15 @@ impl pallet_collator_allowlist::WeightInfo for WeightIn // Storage: Session NextKeys (r:1 w:0) // Storage: CollatorAllowlist Allowlist (r:1 w:1) fn add() -> Weight { - // Minimum execution time: 41_501 nanoseconds. - Weight::from_ref_time(42_201_000 as u64) + // Minimum execution time: 39_801 nanoseconds. + Weight::from_ref_time(43_501_000 as u64) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: CollatorAllowlist Allowlist (r:1 w:1) fn remove() -> Weight { - // Minimum execution time: 35_100 nanoseconds. - Weight::from_ref_time(35_601_000 as u64) + // Minimum execution time: 34_600 nanoseconds. + Weight::from_ref_time(36_101_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } diff --git a/runtime/altair/src/weights/pallet_collective.rs b/runtime/altair/src/weights/pallet_collective.rs index e818ee28e6..8e00278613 100644 --- a/runtime/altair/src/weights/pallet_collective.rs +++ b/runtime/altair/src/weights/pallet_collective.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_collective` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-01-12, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-03-25, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("altair-dev"), DB CACHE: 1024 @@ -38,12 +38,12 @@ impl pallet_collective::WeightInfo for WeightInfo { /// The range of component `n` is `[0, 100]`. /// The range of component `p` is `[0, 100]`. fn set_members(m: u32, _n: u32, p: u32, ) -> Weight { - // Minimum execution time: 31_201 nanoseconds. - Weight::from_ref_time(31_701_000 as u64) - // Standard Error: 97_225 - .saturating_add(Weight::from_ref_time(7_459_011 as u64).saturating_mul(m as u64)) - // Standard Error: 97_225 - .saturating_add(Weight::from_ref_time(12_388_486 as u64).saturating_mul(p as u64)) + // Minimum execution time: 29_200 nanoseconds. + Weight::from_ref_time(31_201_000 as u64) + // Standard Error: 96_114 + .saturating_add(Weight::from_ref_time(7_276_642 as u64).saturating_mul(m as u64)) + // Standard Error: 96_114 + .saturating_add(Weight::from_ref_time(12_330_162 as u64).saturating_mul(p as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().reads((1 as u64).saturating_mul(p as u64))) .saturating_add(T::DbWeight::get().writes(2 as u64)) @@ -53,12 +53,12 @@ impl pallet_collective::WeightInfo for WeightInfo { /// The range of component `b` is `[1, 1024]`. /// The range of component `m` is `[1, 100]`. fn execute(b: u32, m: u32, ) -> Weight { - // Minimum execution time: 40_700 nanoseconds. - Weight::from_ref_time(39_351_559 as u64) - // Standard Error: 146 - .saturating_add(Weight::from_ref_time(2_124 as u64).saturating_mul(b as u64)) - // Standard Error: 1_511 - .saturating_add(Weight::from_ref_time(29_692 as u64).saturating_mul(m as u64)) + // Minimum execution time: 39_100 nanoseconds. + Weight::from_ref_time(42_065_006 as u64) + // Standard Error: 342 + .saturating_add(Weight::from_ref_time(851 as u64).saturating_mul(b as u64)) + // Standard Error: 3_533 + .saturating_add(Weight::from_ref_time(25_594 as u64).saturating_mul(m as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) } // Storage: Council Members (r:1 w:0) @@ -66,12 +66,12 @@ impl pallet_collective::WeightInfo for WeightInfo { /// The range of component `b` is `[1, 1024]`. /// The range of component `m` is `[1, 100]`. fn propose_execute(b: u32, m: u32, ) -> Weight { - // Minimum execution time: 44_500 nanoseconds. - Weight::from_ref_time(45_516_160 as u64) - // Standard Error: 536 - .saturating_add(Weight::from_ref_time(258 as u64).saturating_mul(b as u64)) - // Standard Error: 5_530 - .saturating_add(Weight::from_ref_time(40_016 as u64).saturating_mul(m as u64)) + // Minimum execution time: 42_200 nanoseconds. + Weight::from_ref_time(44_088_614 as u64) + // Standard Error: 289 + .saturating_add(Weight::from_ref_time(1_670 as u64).saturating_mul(b as u64)) + // Standard Error: 2_983 + .saturating_add(Weight::from_ref_time(52_077 as u64).saturating_mul(m as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) } // Storage: Council Members (r:1 w:0) @@ -83,14 +83,14 @@ impl pallet_collective::WeightInfo for WeightInfo { /// The range of component `m` is `[2, 100]`. /// The range of component `p` is `[1, 100]`. fn propose_proposed(b: u32, m: u32, p: u32, ) -> Weight { - // Minimum execution time: 56_701 nanoseconds. - Weight::from_ref_time(51_381_102 as u64) - // Standard Error: 309 - .saturating_add(Weight::from_ref_time(8_875 as u64).saturating_mul(b as u64)) - // Standard Error: 3_231 - .saturating_add(Weight::from_ref_time(58_683 as u64).saturating_mul(m as u64)) - // Standard Error: 3_190 - .saturating_add(Weight::from_ref_time(404_877 as u64).saturating_mul(p as u64)) + // Minimum execution time: 57_800 nanoseconds. + Weight::from_ref_time(52_075_230 as u64) + // Standard Error: 332 + .saturating_add(Weight::from_ref_time(9_350 as u64).saturating_mul(b as u64)) + // Standard Error: 3_470 + .saturating_add(Weight::from_ref_time(51_949 as u64).saturating_mul(m as u64)) + // Standard Error: 3_426 + .saturating_add(Weight::from_ref_time(399_824 as u64).saturating_mul(p as u64)) .saturating_add(T::DbWeight::get().reads(4 as u64)) .saturating_add(T::DbWeight::get().writes(4 as u64)) } @@ -98,10 +98,10 @@ impl pallet_collective::WeightInfo for WeightInfo { // Storage: Council Voting (r:1 w:1) /// The range of component `m` is `[5, 100]`. fn vote(m: u32, ) -> Weight { - // Minimum execution time: 61_401 nanoseconds. - Weight::from_ref_time(67_249_387 as u64) - // Standard Error: 3_459 - .saturating_add(Weight::from_ref_time(96_256 as u64).saturating_mul(m as u64)) + // Minimum execution time: 56_700 nanoseconds. + Weight::from_ref_time(67_880_741 as u64) + // Standard Error: 4_361 + .saturating_add(Weight::from_ref_time(69_110 as u64).saturating_mul(m as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } @@ -112,12 +112,12 @@ impl pallet_collective::WeightInfo for WeightInfo { /// The range of component `m` is `[4, 100]`. /// The range of component `p` is `[1, 100]`. fn close_early_disapproved(m: u32, p: u32, ) -> Weight { - // Minimum execution time: 59_901 nanoseconds. - Weight::from_ref_time(62_531_840 as u64) - // Standard Error: 1_997 - .saturating_add(Weight::from_ref_time(40_352 as u64).saturating_mul(m as u64)) - // Standard Error: 1_948 - .saturating_add(Weight::from_ref_time(376_902 as u64).saturating_mul(p as u64)) + // Minimum execution time: 60_500 nanoseconds. + Weight::from_ref_time(66_091_886 as u64) + // Standard Error: 3_158 + .saturating_add(Weight::from_ref_time(18_251 as u64).saturating_mul(m as u64)) + // Standard Error: 3_079 + .saturating_add(Weight::from_ref_time(334_931 as u64).saturating_mul(p as u64)) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -129,14 +129,14 @@ impl pallet_collective::WeightInfo for WeightInfo { /// The range of component `m` is `[4, 100]`. /// The range of component `p` is `[1, 100]`. fn close_early_approved(b: u32, m: u32, p: u32, ) -> Weight { - // Minimum execution time: 82_001 nanoseconds. - Weight::from_ref_time(77_244_228 as u64) - // Standard Error: 270 - .saturating_add(Weight::from_ref_time(5_365 as u64).saturating_mul(b as u64)) - // Standard Error: 2_859 - .saturating_add(Weight::from_ref_time(72_623 as u64).saturating_mul(m as u64)) - // Standard Error: 2_787 - .saturating_add(Weight::from_ref_time(404_097 as u64).saturating_mul(p as u64)) + // Minimum execution time: 84_401 nanoseconds. + Weight::from_ref_time(77_785_627 as u64) + // Standard Error: 332 + .saturating_add(Weight::from_ref_time(7_102 as u64).saturating_mul(b as u64)) + // Standard Error: 3_520 + .saturating_add(Weight::from_ref_time(72_087 as u64).saturating_mul(m as u64)) + // Standard Error: 3_431 + .saturating_add(Weight::from_ref_time(377_282 as u64).saturating_mul(p as u64)) .saturating_add(T::DbWeight::get().reads(4 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -148,12 +148,12 @@ impl pallet_collective::WeightInfo for WeightInfo { /// The range of component `m` is `[4, 100]`. /// The range of component `p` is `[1, 100]`. fn close_disapproved(m: u32, p: u32, ) -> Weight { - // Minimum execution time: 66_101 nanoseconds. - Weight::from_ref_time(64_697_794 as u64) - // Standard Error: 2_851 - .saturating_add(Weight::from_ref_time(69_767 as u64).saturating_mul(m as u64)) - // Standard Error: 2_780 - .saturating_add(Weight::from_ref_time(383_436 as u64).saturating_mul(p as u64)) + // Minimum execution time: 62_001 nanoseconds. + Weight::from_ref_time(68_902_501 as u64) + // Standard Error: 2_761 + .saturating_add(Weight::from_ref_time(34_960 as u64).saturating_mul(m as u64)) + // Standard Error: 2_692 + .saturating_add(Weight::from_ref_time(341_244 as u64).saturating_mul(p as u64)) .saturating_add(T::DbWeight::get().reads(4 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -166,14 +166,14 @@ impl pallet_collective::WeightInfo for WeightInfo { /// The range of component `m` is `[4, 100]`. /// The range of component `p` is `[1, 100]`. fn close_approved(b: u32, m: u32, p: u32, ) -> Weight { - // Minimum execution time: 86_201 nanoseconds. - Weight::from_ref_time(79_549_812 as u64) - // Standard Error: 283 - .saturating_add(Weight::from_ref_time(6_470 as u64).saturating_mul(b as u64)) - // Standard Error: 2_996 - .saturating_add(Weight::from_ref_time(89_296 as u64).saturating_mul(m as u64)) - // Standard Error: 2_920 - .saturating_add(Weight::from_ref_time(412_087 as u64).saturating_mul(p as u64)) + // Minimum execution time: 84_901 nanoseconds. + Weight::from_ref_time(83_483_301 as u64) + // Standard Error: 337 + .saturating_add(Weight::from_ref_time(7_041 as u64).saturating_mul(b as u64)) + // Standard Error: 3_566 + .saturating_add(Weight::from_ref_time(62_803 as u64).saturating_mul(m as u64)) + // Standard Error: 3_476 + .saturating_add(Weight::from_ref_time(372_634 as u64).saturating_mul(p as u64)) .saturating_add(T::DbWeight::get().reads(5 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -182,10 +182,10 @@ impl pallet_collective::WeightInfo for WeightInfo { // Storage: Council ProposalOf (r:0 w:1) /// The range of component `p` is `[1, 100]`. fn disapprove_proposal(p: u32, ) -> Weight { - // Minimum execution time: 38_900 nanoseconds. - Weight::from_ref_time(43_718_970 as u64) - // Standard Error: 3_308 - .saturating_add(Weight::from_ref_time(376_115 as u64).saturating_mul(p as u64)) + // Minimum execution time: 37_600 nanoseconds. + Weight::from_ref_time(44_263_570 as u64) + // Standard Error: 3_155 + .saturating_add(Weight::from_ref_time(371_841 as u64).saturating_mul(p as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } diff --git a/runtime/altair/src/weights/pallet_crowdloan_claim.rs b/runtime/altair/src/weights/pallet_crowdloan_claim.rs index a7b2610684..90855414a9 100644 --- a/runtime/altair/src/weights/pallet_crowdloan_claim.rs +++ b/runtime/altair/src/weights/pallet_crowdloan_claim.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_crowdloan_claim` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-01-12, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-03-25, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("altair-dev"), DB CACHE: 1024 @@ -42,8 +42,8 @@ impl pallet_crowdloan_claim::WeightInfo for WeightInfo< // Storage: System Account (r:2 w:2) // Storage: Balances Locks (r:1 w:1) fn claim_reward_ed25519() -> Weight { - // Minimum execution time: 267_804 nanoseconds. - Weight::from_ref_time(268_904_000 as u64) + // Minimum execution time: 263_403 nanoseconds. + Weight::from_ref_time(278_603_000 as u64) .saturating_add(T::DbWeight::get().reads(12 as u64)) .saturating_add(T::DbWeight::get().writes(5 as u64)) } @@ -59,8 +59,8 @@ impl pallet_crowdloan_claim::WeightInfo for WeightInfo< // Storage: System Account (r:2 w:2) // Storage: Balances Locks (r:1 w:1) fn claim_reward_sr25519() -> Weight { - // Minimum execution time: 270_304 nanoseconds. - Weight::from_ref_time(271_904_000 as u64) + // Minimum execution time: 253_303 nanoseconds. + Weight::from_ref_time(275_803_000 as u64) .saturating_add(T::DbWeight::get().reads(12 as u64)) .saturating_add(T::DbWeight::get().writes(5 as u64)) } @@ -76,8 +76,8 @@ impl pallet_crowdloan_claim::WeightInfo for WeightInfo< // Storage: System Account (r:2 w:2) // Storage: Balances Locks (r:1 w:1) fn claim_reward_ecdsa() -> Weight { - // Minimum execution time: 249_603 nanoseconds. - Weight::from_ref_time(251_104_000 as u64) + // Minimum execution time: 234_503 nanoseconds. + Weight::from_ref_time(268_303_000 as u64) .saturating_add(T::DbWeight::get().reads(12 as u64)) .saturating_add(T::DbWeight::get().writes(5 as u64)) } @@ -89,39 +89,39 @@ impl pallet_crowdloan_claim::WeightInfo for WeightInfo< // Storage: CrowdloanClaim CrowdloanTrieIndex (r:0 w:1) // Storage: CrowdloanClaim LockedAt (r:0 w:1) fn initialize() -> Weight { - // Minimum execution time: 42_201 nanoseconds. - Weight::from_ref_time(42_901_000 as u64) + // Minimum execution time: 42_101 nanoseconds. + Weight::from_ref_time(57_200_000 as u64) .saturating_add(T::DbWeight::get().reads(4 as u64)) .saturating_add(T::DbWeight::get().writes(6 as u64)) } // Storage: CrowdloanClaim LeaseStart (r:0 w:1) fn set_lease_start() -> Weight { - // Minimum execution time: 25_301 nanoseconds. - Weight::from_ref_time(26_200_000 as u64) + // Minimum execution time: 25_501 nanoseconds. + Weight::from_ref_time(26_600_000 as u64) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: CrowdloanClaim LeasePeriod (r:0 w:1) fn set_lease_period() -> Weight { - // Minimum execution time: 25_500 nanoseconds. - Weight::from_ref_time(26_100_000 as u64) + // Minimum execution time: 23_900 nanoseconds. + Weight::from_ref_time(26_700_000 as u64) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: CrowdloanClaim Contributions (r:0 w:1) fn set_contributions_root() -> Weight { - // Minimum execution time: 27_100 nanoseconds. - Weight::from_ref_time(27_600_000 as u64) + // Minimum execution time: 25_900 nanoseconds. + Weight::from_ref_time(27_901_000 as u64) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: CrowdloanClaim LockedAt (r:0 w:1) fn set_locked_at() -> Weight { - // Minimum execution time: 25_600 nanoseconds. - Weight::from_ref_time(26_300_000 as u64) + // Minimum execution time: 24_001 nanoseconds. + Weight::from_ref_time(26_500_000 as u64) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: CrowdloanClaim CrowdloanTrieIndex (r:0 w:1) fn set_crowdloan_trie_index() -> Weight { - // Minimum execution time: 25_700 nanoseconds. - Weight::from_ref_time(26_101_000 as u64) + // Minimum execution time: 24_300 nanoseconds. + Weight::from_ref_time(25_000_000 as u64) .saturating_add(T::DbWeight::get().writes(1 as u64)) } } diff --git a/runtime/altair/src/weights/pallet_crowdloan_reward.rs b/runtime/altair/src/weights/pallet_crowdloan_reward.rs index eda9b5806d..4e50fa7813 100644 --- a/runtime/altair/src/weights/pallet_crowdloan_reward.rs +++ b/runtime/altair/src/weights/pallet_crowdloan_reward.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_crowdloan_reward` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-01-12, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-03-25, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("altair-dev"), DB CACHE: 1024 @@ -34,26 +34,26 @@ impl pallet_crowdloan_reward::WeightInfo for WeightInfo // Storage: CrowdloanReward VestingPeriod (r:0 w:1) // Storage: CrowdloanReward DirectPayoutRatio (r:0 w:1) fn initialize() -> Weight { - // Minimum execution time: 28_400 nanoseconds. - Weight::from_ref_time(29_201_000 as u64) + // Minimum execution time: 28_200 nanoseconds. + Weight::from_ref_time(29_600_000 as u64) .saturating_add(T::DbWeight::get().writes(3 as u64)) } // Storage: CrowdloanReward VestingStart (r:0 w:1) fn set_vesting_start() -> Weight { // Minimum execution time: 25_701 nanoseconds. - Weight::from_ref_time(26_300_000 as u64) + Weight::from_ref_time(26_600_000 as u64) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: CrowdloanReward VestingPeriod (r:0 w:1) fn set_vesting_period() -> Weight { - // Minimum execution time: 25_400 nanoseconds. - Weight::from_ref_time(25_900_000 as u64) + // Minimum execution time: 24_400 nanoseconds. + Weight::from_ref_time(26_801_000 as u64) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: CrowdloanReward DirectPayoutRatio (r:0 w:1) fn set_direct_payout_ratio() -> Weight { - // Minimum execution time: 25_501 nanoseconds. - Weight::from_ref_time(26_000_000 as u64) + // Minimum execution time: 25_601 nanoseconds. + Weight::from_ref_time(26_801_000 as u64) .saturating_add(T::DbWeight::get().writes(1 as u64)) } } diff --git a/runtime/altair/src/weights/pallet_democracy.rs b/runtime/altair/src/weights/pallet_democracy.rs index 8b71b8bf35..5145604d24 100644 --- a/runtime/altair/src/weights/pallet_democracy.rs +++ b/runtime/altair/src/weights/pallet_democracy.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_democracy` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-01-12, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-03-25, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("altair-dev"), DB CACHE: 1024 @@ -35,15 +35,15 @@ impl pallet_democracy::WeightInfo for WeightInfo { // Storage: Democracy Blacklist (r:1 w:0) // Storage: Democracy DepositOf (r:0 w:1) fn propose() -> Weight { - // Minimum execution time: 101_101 nanoseconds. - Weight::from_ref_time(103_101_000 as u64) + // Minimum execution time: 100_501 nanoseconds. + Weight::from_ref_time(104_301_000 as u64) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } // Storage: Democracy DepositOf (r:1 w:1) fn second() -> Weight { - // Minimum execution time: 86_001 nanoseconds. - Weight::from_ref_time(89_401_000 as u64) + // Minimum execution time: 86_801 nanoseconds. + Weight::from_ref_time(88_201_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } @@ -51,8 +51,8 @@ impl pallet_democracy::WeightInfo for WeightInfo { // Storage: Democracy VotingOf (r:1 w:1) // Storage: Balances Locks (r:1 w:1) fn vote_new() -> Weight { - // Minimum execution time: 107_902 nanoseconds. - Weight::from_ref_time(109_402_000 as u64) + // Minimum execution time: 104_701 nanoseconds. + Weight::from_ref_time(108_601_000 as u64) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -60,16 +60,16 @@ impl pallet_democracy::WeightInfo for WeightInfo { // Storage: Democracy VotingOf (r:1 w:1) // Storage: Balances Locks (r:1 w:1) fn vote_existing() -> Weight { - // Minimum execution time: 107_302 nanoseconds. - Weight::from_ref_time(109_001_000 as u64) + // Minimum execution time: 102_701 nanoseconds. + Weight::from_ref_time(111_902_000 as u64) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } // Storage: Democracy ReferendumInfoOf (r:1 w:1) // Storage: Democracy Cancellations (r:1 w:1) fn emergency_cancel() -> Weight { - // Minimum execution time: 42_101 nanoseconds. - Weight::from_ref_time(43_101_000 as u64) + // Minimum execution time: 39_300 nanoseconds. + Weight::from_ref_time(42_801_000 as u64) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } @@ -80,45 +80,45 @@ impl pallet_democracy::WeightInfo for WeightInfo { // Storage: Democracy ReferendumInfoOf (r:1 w:1) // Storage: Democracy Blacklist (r:0 w:1) fn blacklist() -> Weight { - // Minimum execution time: 167_103 nanoseconds. - Weight::from_ref_time(171_202_000 as u64) + // Minimum execution time: 156_501 nanoseconds. + Weight::from_ref_time(170_202_000 as u64) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(7 as u64)) } // Storage: Democracy NextExternal (r:1 w:1) // Storage: Democracy Blacklist (r:1 w:0) fn external_propose() -> Weight { - // Minimum execution time: 32_100 nanoseconds. - Weight::from_ref_time(32_601_000 as u64) + // Minimum execution time: 29_901 nanoseconds. + Weight::from_ref_time(32_400_000 as u64) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Democracy NextExternal (r:0 w:1) fn external_propose_majority() -> Weight { - // Minimum execution time: 10_400 nanoseconds. - Weight::from_ref_time(10_800_000 as u64) + // Minimum execution time: 10_200 nanoseconds. + Weight::from_ref_time(10_601_000 as u64) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Democracy NextExternal (r:0 w:1) fn external_propose_default() -> Weight { - // Minimum execution time: 10_500 nanoseconds. - Weight::from_ref_time(10_800_000 as u64) + // Minimum execution time: 10_400 nanoseconds. + Weight::from_ref_time(10_900_000 as u64) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Democracy NextExternal (r:1 w:1) // Storage: Democracy ReferendumCount (r:1 w:1) // Storage: Democracy ReferendumInfoOf (r:0 w:1) fn fast_track() -> Weight { - // Minimum execution time: 42_200 nanoseconds. - Weight::from_ref_time(42_801_000 as u64) + // Minimum execution time: 39_501 nanoseconds. + Weight::from_ref_time(43_101_000 as u64) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } // Storage: Democracy NextExternal (r:1 w:1) // Storage: Democracy Blacklist (r:1 w:1) fn veto_external() -> Weight { - // Minimum execution time: 51_001 nanoseconds. - Weight::from_ref_time(51_801_000 as u64) + // Minimum execution time: 50_200 nanoseconds. + Weight::from_ref_time(52_200_000 as u64) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } @@ -126,15 +126,15 @@ impl pallet_democracy::WeightInfo for WeightInfo { // Storage: Democracy DepositOf (r:1 w:1) // Storage: System Account (r:2 w:2) fn cancel_proposal() -> Weight { - // Minimum execution time: 143_602 nanoseconds. - Weight::from_ref_time(146_702_000 as u64) + // Minimum execution time: 136_301 nanoseconds. + Weight::from_ref_time(146_301_000 as u64) .saturating_add(T::DbWeight::get().reads(4 as u64)) .saturating_add(T::DbWeight::get().writes(4 as u64)) } // Storage: Democracy ReferendumInfoOf (r:0 w:1) fn cancel_referendum() -> Weight { - // Minimum execution time: 27_501 nanoseconds. - Weight::from_ref_time(27_900_000 as u64) + // Minimum execution time: 27_800 nanoseconds. + Weight::from_ref_time(28_301_000 as u64) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Democracy LowestUnbaked (r:1 w:1) @@ -142,10 +142,10 @@ impl pallet_democracy::WeightInfo for WeightInfo { // Storage: Democracy ReferendumInfoOf (r:2 w:0) /// The range of component `r` is `[0, 99]`. fn on_initialize_base(r: u32, ) -> Weight { - // Minimum execution time: 12_500 nanoseconds. - Weight::from_ref_time(18_497_435 as u64) - // Standard Error: 6_117 - .saturating_add(Weight::from_ref_time(4_063_798 as u64).saturating_mul(r as u64)) + // Minimum execution time: 12_901 nanoseconds. + Weight::from_ref_time(19_113_552 as u64) + // Standard Error: 9_713 + .saturating_add(Weight::from_ref_time(4_033_738 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().reads((1 as u64).saturating_mul(r as u64))) .saturating_add(T::DbWeight::get().writes(1 as u64)) @@ -158,10 +158,10 @@ impl pallet_democracy::WeightInfo for WeightInfo { // Storage: Democracy ReferendumInfoOf (r:2 w:0) /// The range of component `r` is `[0, 99]`. fn on_initialize_base_with_launch_period(r: u32, ) -> Weight { - // Minimum execution time: 17_300 nanoseconds. - Weight::from_ref_time(23_334_817 as u64) - // Standard Error: 21_985 - .saturating_add(Weight::from_ref_time(4_101_140 as u64).saturating_mul(r as u64)) + // Minimum execution time: 16_200 nanoseconds. + Weight::from_ref_time(32_496_283 as u64) + // Standard Error: 15_156 + .saturating_add(Weight::from_ref_time(3_910_652 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(5 as u64)) .saturating_add(T::DbWeight::get().reads((1 as u64).saturating_mul(r as u64))) .saturating_add(T::DbWeight::get().writes(1 as u64)) @@ -171,10 +171,10 @@ impl pallet_democracy::WeightInfo for WeightInfo { // Storage: Democracy ReferendumInfoOf (r:2 w:2) /// The range of component `r` is `[0, 99]`. fn delegate(r: u32, ) -> Weight { - // Minimum execution time: 82_601 nanoseconds. - Weight::from_ref_time(90_001_289 as u64) - // Standard Error: 13_974 - .saturating_add(Weight::from_ref_time(6_137_967 as u64).saturating_mul(r as u64)) + // Minimum execution time: 78_001 nanoseconds. + Weight::from_ref_time(89_370_608 as u64) + // Standard Error: 10_203 + .saturating_add(Weight::from_ref_time(6_160_910 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(4 as u64)) .saturating_add(T::DbWeight::get().reads((1 as u64).saturating_mul(r as u64))) .saturating_add(T::DbWeight::get().writes(4 as u64)) @@ -184,10 +184,10 @@ impl pallet_democracy::WeightInfo for WeightInfo { // Storage: Democracy ReferendumInfoOf (r:2 w:2) /// The range of component `r` is `[0, 99]`. fn undelegate(r: u32, ) -> Weight { - // Minimum execution time: 49_200 nanoseconds. - Weight::from_ref_time(52_647_740 as u64) - // Standard Error: 8_097 - .saturating_add(Weight::from_ref_time(6_077_621 as u64).saturating_mul(r as u64)) + // Minimum execution time: 45_400 nanoseconds. + Weight::from_ref_time(53_261_536 as u64) + // Standard Error: 11_169 + .saturating_add(Weight::from_ref_time(6_083_687 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().reads((1 as u64).saturating_mul(r as u64))) .saturating_add(T::DbWeight::get().writes(2 as u64)) @@ -195,8 +195,8 @@ impl pallet_democracy::WeightInfo for WeightInfo { } // Storage: Democracy PublicProps (r:0 w:1) fn clear_public_proposals() -> Weight { - // Minimum execution time: 12_600 nanoseconds. - Weight::from_ref_time(12_901_000 as u64) + // Minimum execution time: 12_700 nanoseconds. + Weight::from_ref_time(15_800_000 as u64) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Democracy VotingOf (r:1 w:1) @@ -204,10 +204,10 @@ impl pallet_democracy::WeightInfo for WeightInfo { // Storage: System Account (r:1 w:1) /// The range of component `r` is `[0, 99]`. fn unlock_remove(r: u32, ) -> Weight { - // Minimum execution time: 49_201 nanoseconds. - Weight::from_ref_time(60_697_710 as u64) - // Standard Error: 2_874 - .saturating_add(Weight::from_ref_time(154_619 as u64).saturating_mul(r as u64)) + // Minimum execution time: 48_801 nanoseconds. + Weight::from_ref_time(61_124_217 as u64) + // Standard Error: 3_505 + .saturating_add(Weight::from_ref_time(141_241 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -216,10 +216,10 @@ impl pallet_democracy::WeightInfo for WeightInfo { // Storage: System Account (r:1 w:1) /// The range of component `r` is `[0, 99]`. fn unlock_set(r: u32, ) -> Weight { - // Minimum execution time: 57_601 nanoseconds. - Weight::from_ref_time(58_844_285 as u64) - // Standard Error: 2_080 - .saturating_add(Weight::from_ref_time(253_584 as u64).saturating_mul(r as u64)) + // Minimum execution time: 54_100 nanoseconds. + Weight::from_ref_time(59_804_241 as u64) + // Standard Error: 2_767 + .saturating_add(Weight::from_ref_time(226_327 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -227,10 +227,10 @@ impl pallet_democracy::WeightInfo for WeightInfo { // Storage: Democracy VotingOf (r:1 w:1) /// The range of component `r` is `[1, 100]`. fn remove_vote(r: u32, ) -> Weight { - // Minimum execution time: 32_201 nanoseconds. - Weight::from_ref_time(35_765_615 as u64) - // Standard Error: 2_718 - .saturating_add(Weight::from_ref_time(238_589 as u64).saturating_mul(r as u64)) + // Minimum execution time: 33_101 nanoseconds. + Weight::from_ref_time(36_320_014 as u64) + // Standard Error: 2_210 + .saturating_add(Weight::from_ref_time(225_652 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } @@ -238,10 +238,10 @@ impl pallet_democracy::WeightInfo for WeightInfo { // Storage: Democracy VotingOf (r:1 w:1) /// The range of component `r` is `[1, 100]`. fn remove_other_vote(r: u32, ) -> Weight { - // Minimum execution time: 32_300 nanoseconds. - Weight::from_ref_time(35_398_002 as u64) - // Standard Error: 2_237 - .saturating_add(Weight::from_ref_time(243_764 as u64).saturating_mul(r as u64)) + // Minimum execution time: 32_001 nanoseconds. + Weight::from_ref_time(35_847_410 as u64) + // Standard Error: 2_398 + .saturating_add(Weight::from_ref_time(232_463 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } diff --git a/runtime/altair/src/weights/pallet_fees.rs b/runtime/altair/src/weights/pallet_fees.rs index ee642f61a9..c9c049f2ea 100644 --- a/runtime/altair/src/weights/pallet_fees.rs +++ b/runtime/altair/src/weights/pallet_fees.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_fees` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-01-12, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-03-25, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("altair-dev"), DB CACHE: 1024 @@ -32,8 +32,8 @@ pub struct WeightInfo(PhantomData); impl pallet_fees::WeightInfo for WeightInfo { // Storage: Fees FeeBalances (r:0 w:1) fn set_fee() -> Weight { - // Minimum execution time: 27_600 nanoseconds. - Weight::from_ref_time(27_900_000 as u64) + // Minimum execution time: 28_101 nanoseconds. + Weight::from_ref_time(29_001_000 as u64) .saturating_add(T::DbWeight::get().writes(1 as u64)) } } diff --git a/runtime/altair/src/weights/pallet_identity.rs b/runtime/altair/src/weights/pallet_identity.rs index 28aa98cbde..19fdb18676 100644 --- a/runtime/altair/src/weights/pallet_identity.rs +++ b/runtime/altair/src/weights/pallet_identity.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_identity` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-01-12, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-03-25, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("altair-dev"), DB CACHE: 1024 @@ -33,10 +33,10 @@ impl pallet_identity::WeightInfo for WeightInfo { // Storage: Identity Registrars (r:1 w:1) /// The range of component `r` is `[1, 19]`. fn add_registrar(r: u32, ) -> Weight { - // Minimum execution time: 34_300 nanoseconds. - Weight::from_ref_time(36_405_130 as u64) - // Standard Error: 5_627 - .saturating_add(Weight::from_ref_time(338_132 as u64).saturating_mul(r as u64)) + // Minimum execution time: 34_501 nanoseconds. + Weight::from_ref_time(37_061_534 as u64) + // Standard Error: 8_719 + .saturating_add(Weight::from_ref_time(331_059 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } @@ -44,12 +44,12 @@ impl pallet_identity::WeightInfo for WeightInfo { /// The range of component `r` is `[1, 20]`. /// The range of component `x` is `[0, 100]`. fn set_identity(r: u32, x: u32, ) -> Weight { - // Minimum execution time: 72_701 nanoseconds. - Weight::from_ref_time(68_281_173 as u64) - // Standard Error: 5_153 - .saturating_add(Weight::from_ref_time(335_993 as u64).saturating_mul(r as u64)) - // Standard Error: 1_005 - .saturating_add(Weight::from_ref_time(708_516 as u64).saturating_mul(x as u64)) + // Minimum execution time: 68_503 nanoseconds. + Weight::from_ref_time(70_424_478 as u64) + // Standard Error: 12_046 + .saturating_add(Weight::from_ref_time(302_164 as u64).saturating_mul(r as u64)) + // Standard Error: 2_350 + .saturating_add(Weight::from_ref_time(690_939 as u64).saturating_mul(x as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } @@ -58,10 +58,10 @@ impl pallet_identity::WeightInfo for WeightInfo { // Storage: Identity SuperOf (r:2 w:2) /// The range of component `s` is `[0, 100]`. fn set_subs_new(s: u32, ) -> Weight { - // Minimum execution time: 22_301 nanoseconds. - Weight::from_ref_time(57_500_642 as u64) - // Standard Error: 18_595 - .saturating_add(Weight::from_ref_time(4_953_310 as u64).saturating_mul(s as u64)) + // Minimum execution time: 20_601 nanoseconds. + Weight::from_ref_time(59_507_358 as u64) + // Standard Error: 18_728 + .saturating_add(Weight::from_ref_time(5_015_079 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().reads((1 as u64).saturating_mul(s as u64))) .saturating_add(T::DbWeight::get().writes(1 as u64)) @@ -73,9 +73,9 @@ impl pallet_identity::WeightInfo for WeightInfo { /// The range of component `p` is `[0, 100]`. fn set_subs_old(p: u32, ) -> Weight { // Minimum execution time: 22_001 nanoseconds. - Weight::from_ref_time(55_742_942 as u64) - // Standard Error: 8_496 - .saturating_add(Weight::from_ref_time(2_131_957 as u64).saturating_mul(p as u64)) + Weight::from_ref_time(54_590_107 as u64) + // Standard Error: 8_561 + .saturating_add(Weight::from_ref_time(2_196_780 as u64).saturating_mul(p as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) .saturating_add(T::DbWeight::get().writes((1 as u64).saturating_mul(p as u64))) @@ -87,14 +87,14 @@ impl pallet_identity::WeightInfo for WeightInfo { /// The range of component `s` is `[0, 100]`. /// The range of component `x` is `[0, 100]`. fn clear_identity(r: u32, s: u32, x: u32, ) -> Weight { - // Minimum execution time: 105_102 nanoseconds. - Weight::from_ref_time(67_703_451 as u64) - // Standard Error: 9_264 - .saturating_add(Weight::from_ref_time(345_507 as u64).saturating_mul(r as u64)) - // Standard Error: 1_809 - .saturating_add(Weight::from_ref_time(2_086_115 as u64).saturating_mul(s as u64)) - // Standard Error: 1_809 - .saturating_add(Weight::from_ref_time(360_251 as u64).saturating_mul(x as u64)) + // Minimum execution time: 98_404 nanoseconds. + Weight::from_ref_time(69_759_484 as u64) + // Standard Error: 21_125 + .saturating_add(Weight::from_ref_time(317_250 as u64).saturating_mul(r as u64)) + // Standard Error: 4_125 + .saturating_add(Weight::from_ref_time(2_131_550 as u64).saturating_mul(s as u64)) + // Standard Error: 4_125 + .saturating_add(Weight::from_ref_time(353_720 as u64).saturating_mul(x as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) .saturating_add(T::DbWeight::get().writes((1 as u64).saturating_mul(s as u64))) @@ -104,12 +104,12 @@ impl pallet_identity::WeightInfo for WeightInfo { /// The range of component `r` is `[1, 20]`. /// The range of component `x` is `[0, 100]`. fn request_judgement(r: u32, x: u32, ) -> Weight { - // Minimum execution time: 76_001 nanoseconds. - Weight::from_ref_time(72_908_005 as u64) - // Standard Error: 15_298 - .saturating_add(Weight::from_ref_time(313_413 as u64).saturating_mul(r as u64)) - // Standard Error: 2_985 - .saturating_add(Weight::from_ref_time(714_087 as u64).saturating_mul(x as u64)) + // Minimum execution time: 71_702 nanoseconds. + Weight::from_ref_time(74_001_974 as u64) + // Standard Error: 23_825 + .saturating_add(Weight::from_ref_time(301_911 as u64).saturating_mul(r as u64)) + // Standard Error: 4_648 + .saturating_add(Weight::from_ref_time(708_137 as u64).saturating_mul(x as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } @@ -117,42 +117,42 @@ impl pallet_identity::WeightInfo for WeightInfo { /// The range of component `r` is `[1, 20]`. /// The range of component `x` is `[0, 100]`. fn cancel_request(r: u32, x: u32, ) -> Weight { - // Minimum execution time: 69_301 nanoseconds. - Weight::from_ref_time(67_139_794 as u64) - // Standard Error: 15_366 - .saturating_add(Weight::from_ref_time(282_235 as u64).saturating_mul(r as u64)) - // Standard Error: 2_998 - .saturating_add(Weight::from_ref_time(712_579 as u64).saturating_mul(x as u64)) + // Minimum execution time: 69_801 nanoseconds. + Weight::from_ref_time(66_486_985 as u64) + // Standard Error: 9_499 + .saturating_add(Weight::from_ref_time(299_341 as u64).saturating_mul(r as u64)) + // Standard Error: 1_853 + .saturating_add(Weight::from_ref_time(719_331 as u64).saturating_mul(x as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Identity Registrars (r:1 w:1) /// The range of component `r` is `[1, 19]`. fn set_fee(r: u32, ) -> Weight { - // Minimum execution time: 19_000 nanoseconds. - Weight::from_ref_time(19_840_192 as u64) - // Standard Error: 2_788 - .saturating_add(Weight::from_ref_time(271_588 as u64).saturating_mul(r as u64)) + // Minimum execution time: 17_800 nanoseconds. + Weight::from_ref_time(19_919_300 as u64) + // Standard Error: 3_560 + .saturating_add(Weight::from_ref_time(268_364 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Identity Registrars (r:1 w:1) /// The range of component `r` is `[1, 19]`. fn set_account_id(r: u32, ) -> Weight { - // Minimum execution time: 19_200 nanoseconds. - Weight::from_ref_time(20_026_790 as u64) - // Standard Error: 4_145 - .saturating_add(Weight::from_ref_time(293_352 as u64).saturating_mul(r as u64)) + // Minimum execution time: 18_301 nanoseconds. + Weight::from_ref_time(20_323_743 as u64) + // Standard Error: 5_759 + .saturating_add(Weight::from_ref_time(251_554 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Identity Registrars (r:1 w:1) /// The range of component `r` is `[1, 19]`. fn set_fields(r: u32, ) -> Weight { - // Minimum execution time: 19_300 nanoseconds. - Weight::from_ref_time(20_059_907 as u64) - // Standard Error: 3_041 - .saturating_add(Weight::from_ref_time(268_973 as u64).saturating_mul(r as u64)) + // Minimum execution time: 18_101 nanoseconds. + Weight::from_ref_time(19_964_552 as u64) + // Standard Error: 3_906 + .saturating_add(Weight::from_ref_time(272_495 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } @@ -161,12 +161,12 @@ impl pallet_identity::WeightInfo for WeightInfo { /// The range of component `r` is `[1, 19]`. /// The range of component `x` is `[0, 100]`. fn provide_judgement(r: u32, x: u32, ) -> Weight { - // Minimum execution time: 56_801 nanoseconds. - Weight::from_ref_time(54_755_634 as u64) - // Standard Error: 12_939 - .saturating_add(Weight::from_ref_time(306_023 as u64).saturating_mul(r as u64)) - // Standard Error: 2_394 - .saturating_add(Weight::from_ref_time(1_162_078 as u64).saturating_mul(x as u64)) + // Minimum execution time: 56_502 nanoseconds. + Weight::from_ref_time(54_217_613 as u64) + // Standard Error: 15_946 + .saturating_add(Weight::from_ref_time(318_719 as u64).saturating_mul(r as u64)) + // Standard Error: 2_950 + .saturating_add(Weight::from_ref_time(1_161_992 as u64).saturating_mul(x as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } @@ -178,14 +178,14 @@ impl pallet_identity::WeightInfo for WeightInfo { /// The range of component `s` is `[0, 100]`. /// The range of component `x` is `[0, 100]`. fn kill_identity(r: u32, s: u32, x: u32, ) -> Weight { - // Minimum execution time: 128_102 nanoseconds. - Weight::from_ref_time(93_638_078 as u64) - // Standard Error: 10_206 - .saturating_add(Weight::from_ref_time(311_145 as u64).saturating_mul(r as u64)) - // Standard Error: 1_993 - .saturating_add(Weight::from_ref_time(2_059_183 as u64).saturating_mul(s as u64)) - // Standard Error: 1_993 - .saturating_add(Weight::from_ref_time(351_832 as u64).saturating_mul(x as u64)) + // Minimum execution time: 121_503 nanoseconds. + Weight::from_ref_time(89_861_539 as u64) + // Standard Error: 21_971 + .saturating_add(Weight::from_ref_time(458_618 as u64).saturating_mul(r as u64)) + // Standard Error: 4_290 + .saturating_add(Weight::from_ref_time(2_119_477 as u64).saturating_mul(s as u64)) + // Standard Error: 4_290 + .saturating_add(Weight::from_ref_time(386_519 as u64).saturating_mul(x as u64)) .saturating_add(T::DbWeight::get().reads(4 as u64)) .saturating_add(T::DbWeight::get().writes(4 as u64)) .saturating_add(T::DbWeight::get().writes((1 as u64).saturating_mul(s as u64))) @@ -195,10 +195,10 @@ impl pallet_identity::WeightInfo for WeightInfo { // Storage: Identity SubsOf (r:1 w:1) /// The range of component `s` is `[0, 99]`. fn add_sub(s: u32, ) -> Weight { - // Minimum execution time: 64_501 nanoseconds. - Weight::from_ref_time(75_384_711 as u64) - // Standard Error: 6_070 - .saturating_add(Weight::from_ref_time(188_046 as u64).saturating_mul(s as u64)) + // Minimum execution time: 61_002 nanoseconds. + Weight::from_ref_time(74_280_879 as u64) + // Standard Error: 5_540 + .saturating_add(Weight::from_ref_time(231_776 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } @@ -206,10 +206,10 @@ impl pallet_identity::WeightInfo for WeightInfo { // Storage: Identity SuperOf (r:1 w:1) /// The range of component `s` is `[1, 100]`. fn rename_sub(s: u32, ) -> Weight { - // Minimum execution time: 28_400 nanoseconds. - Weight::from_ref_time(32_049_870 as u64) - // Standard Error: 3_239 - .saturating_add(Weight::from_ref_time(124_763 as u64).saturating_mul(s as u64)) + // Minimum execution time: 27_700 nanoseconds. + Weight::from_ref_time(32_508_628 as u64) + // Standard Error: 3_265 + .saturating_add(Weight::from_ref_time(119_027 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } @@ -218,10 +218,10 @@ impl pallet_identity::WeightInfo for WeightInfo { // Storage: Identity SubsOf (r:1 w:1) /// The range of component `s` is `[1, 100]`. fn remove_sub(s: u32, ) -> Weight { - // Minimum execution time: 71_201 nanoseconds. - Weight::from_ref_time(75_705_499 as u64) - // Standard Error: 2_899 - .saturating_add(Weight::from_ref_time(195_115 as u64).saturating_mul(s as u64)) + // Minimum execution time: 67_202 nanoseconds. + Weight::from_ref_time(75_513_186 as u64) + // Standard Error: 5_252 + .saturating_add(Weight::from_ref_time(231_593 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } @@ -229,10 +229,10 @@ impl pallet_identity::WeightInfo for WeightInfo { // Storage: Identity SubsOf (r:1 w:1) /// The range of component `s` is `[0, 99]`. fn quit_sub(s: u32, ) -> Weight { - // Minimum execution time: 49_600 nanoseconds. - Weight::from_ref_time(54_218_039 as u64) - // Standard Error: 2_079 - .saturating_add(Weight::from_ref_time(205_492 as u64).saturating_mul(s as u64)) + // Minimum execution time: 46_601 nanoseconds. + Weight::from_ref_time(54_885_965 as u64) + // Standard Error: 4_066 + .saturating_add(Weight::from_ref_time(202_677 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } diff --git a/runtime/altair/src/weights/pallet_interest_accrual.rs b/runtime/altair/src/weights/pallet_interest_accrual.rs index 706f198b81..c20af04bcd 100644 --- a/runtime/altair/src/weights/pallet_interest_accrual.rs +++ b/runtime/altair/src/weights/pallet_interest_accrual.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_interest_accrual` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-01-12, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-03-25, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("altair-dev"), DB CACHE: 1024 @@ -33,8 +33,8 @@ impl pallet_interest_accrual::WeightInfo for WeightInfo /// The range of component `n` is `[1, 25]`. fn calculate_accumulated_rate(n: u32, ) -> Weight { // Minimum execution time: 800 nanoseconds. - Weight::from_ref_time(801_000 as u64) - // Standard Error: 1_919 - .saturating_add(Weight::from_ref_time(924_319 as u64).saturating_mul(n as u64)) + Weight::from_ref_time(900_000 as u64) + // Standard Error: 2_151 + .saturating_add(Weight::from_ref_time(923_545 as u64).saturating_mul(n as u64)) } } diff --git a/runtime/altair/src/weights/pallet_loans.rs b/runtime/altair/src/weights/pallet_loans.rs index 17eff82586..f9d5cf9f43 100644 --- a/runtime/altair/src/weights/pallet_loans.rs +++ b/runtime/altair/src/weights/pallet_loans.rs @@ -2,15 +2,15 @@ //! Autogenerated weights for `pallet_loans` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-01-04, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` -//! HOSTNAME: `branan-laptop`, CPU: `Intel(R) Core(TM) i7-10875H CPU @ 2.30GHz` -//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("development-local"), DB CACHE: 1024 +//! DATE: 2023-03-25, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` +//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("altair-dev"), DB CACHE: 1024 // Executed Command: // target/release/centrifuge-chain // benchmark // pallet -// --chain=development-local +// --chain=altair-dev // --steps=50 // --repeat=20 // --pallet=pallet_loans @@ -18,7 +18,7 @@ // --execution=wasm // --wasm-execution=compiled // --heap-pages=4096 -// --output=./runtime/development/src/weights/pallet_loans.rs +// --output=/tmp/runtime/altair/src/weights/pallet_loans.rs #![cfg_attr(rustfmt, rustfmt_skip)] #![allow(unused_parens)] @@ -37,8 +37,8 @@ impl pallet_loans::WeightInfo for WeightInfo { // Storage: Loans PoolNAV (r:0 w:1) // Storage: Loans LoanNftClassToPool (r:0 w:1) fn initialise_pool() -> Weight { - // Minimum execution time: 59_033 nanoseconds. - Weight::from_ref_time(60_700_000 as u64) + // Minimum execution time: 75_202 nanoseconds. + Weight::from_ref_time(76_302_000 as u64) .saturating_add(T::DbWeight::get().reads(4 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -53,37 +53,37 @@ impl pallet_loans::WeightInfo for WeightInfo { // Storage: Uniques Account (r:0 w:3) // Storage: Uniques ItemPriceOf (r:0 w:1) fn create() -> Weight { - // Minimum execution time: 128_627 nanoseconds. - Weight::from_ref_time(129_199_000 as u64) + // Minimum execution time: 170_605 nanoseconds. + Weight::from_ref_time(174_504_000 as u64) .saturating_add(T::DbWeight::get().reads(9 as u64)) .saturating_add(T::DbWeight::get().writes(9 as u64)) } // Storage: Loans Loan (r:1 w:1) // Storage: Permissions Permission (r:1 w:0) // Storage: Timestamp Now (r:1 w:0) - // Storage: InterestAccrual Rates (r:1 w:0) + // Storage: InterestAccrual Rates (r:1 w:1) // Storage: Loans ActiveLoans (r:1 w:1) // Storage: InterestAccrual LastUpdated (r:1 w:0) // Storage: Loans PoolWriteOffGroups (r:1 w:0) // Storage: Loans PoolNAV (r:1 w:1) - /// The range of component `n` is `[1, 50]`. - /// The range of component `m` is `[1, 50]`. + /// The range of component `n` is `[1, 300]`. + /// The range of component `m` is `[1, 300]`. fn price(n: u32, m: u32, ) -> Weight { - // Minimum execution time: 98_935 nanoseconds. - Weight::from_ref_time(96_676_390 as u64) - // Standard Error: 15_520 - .saturating_add(Weight::from_ref_time(1_044_085 as u64).saturating_mul(n as u64)) - // Standard Error: 15_520 - .saturating_add(Weight::from_ref_time(237_179 as u64).saturating_mul(m as u64)) + // Minimum execution time: 181_205 nanoseconds. + Weight::from_ref_time(133_843_894 as u64) + // Standard Error: 4_353 + .saturating_add(Weight::from_ref_time(856_065 as u64).saturating_mul(n as u64)) + // Standard Error: 4_353 + .saturating_add(Weight::from_ref_time(206_868 as u64).saturating_mul(m as u64)) .saturating_add(T::DbWeight::get().reads(8 as u64)) - .saturating_add(T::DbWeight::get().writes(3 as u64)) + .saturating_add(T::DbWeight::get().writes(4 as u64)) } // Storage: Permissions Permission (r:1 w:0) // Storage: Loans PoolToLoanNftClass (r:1 w:0) // Storage: Loans PoolWriteOffGroups (r:1 w:1) fn add_write_off_group() -> Weight { - // Minimum execution time: 62_246 nanoseconds. - Weight::from_ref_time(63_880_000 as u64) + // Minimum execution time: 70_901 nanoseconds. + Weight::from_ref_time(73_601_000 as u64) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } @@ -98,15 +98,15 @@ impl pallet_loans::WeightInfo for WeightInfo { // Storage: PoolSystem Pool (r:1 w:1) // Storage: OrmlTokens Accounts (r:2 w:2) // Storage: System Account (r:1 w:0) - /// The range of component `n` is `[1, 50]`. - /// The range of component `m` is `[1, 50]`. + /// The range of component `n` is `[1, 300]`. + /// The range of component `m` is `[1, 300]`. fn initial_borrow(n: u32, m: u32, ) -> Weight { - // Minimum execution time: 188_637 nanoseconds. - Weight::from_ref_time(195_983_686 as u64) - // Standard Error: 16_012 - .saturating_add(Weight::from_ref_time(520_917 as u64).saturating_mul(n as u64)) - // Standard Error: 16_012 - .saturating_add(Weight::from_ref_time(196_531 as u64).saturating_mul(m as u64)) + // Minimum execution time: 264_205 nanoseconds. + Weight::from_ref_time(263_526_813 as u64) + // Standard Error: 4_961 + .saturating_add(Weight::from_ref_time(620_301 as u64).saturating_mul(n as u64)) + // Standard Error: 4_961 + .saturating_add(Weight::from_ref_time(81_381 as u64).saturating_mul(m as u64)) .saturating_add(T::DbWeight::get().reads(12 as u64)) .saturating_add(T::DbWeight::get().writes(5 as u64)) } @@ -121,15 +121,15 @@ impl pallet_loans::WeightInfo for WeightInfo { // Storage: PoolSystem Pool (r:1 w:1) // Storage: OrmlTokens Accounts (r:2 w:2) // Storage: System Account (r:1 w:0) - /// The range of component `n` is `[1, 50]`. - /// The range of component `m` is `[1, 50]`. + /// The range of component `n` is `[1, 300]`. + /// The range of component `m` is `[1, 300]`. fn further_borrows(n: u32, m: u32, ) -> Weight { - // Minimum execution time: 234_810 nanoseconds. - Weight::from_ref_time(253_208_678 as u64) - // Standard Error: 21_738 - .saturating_add(Weight::from_ref_time(703_225 as u64).saturating_mul(n as u64)) - // Standard Error: 21_738 - .saturating_add(Weight::from_ref_time(49_932 as u64).saturating_mul(m as u64)) + // Minimum execution time: 343_505 nanoseconds. + Weight::from_ref_time(357_499_319 as u64) + // Standard Error: 4_397 + .saturating_add(Weight::from_ref_time(499_480 as u64).saturating_mul(n as u64)) + // Standard Error: 4_397 + .saturating_add(Weight::from_ref_time(97_489 as u64).saturating_mul(m as u64)) .saturating_add(T::DbWeight::get().reads(12 as u64)) .saturating_add(T::DbWeight::get().writes(5 as u64)) } @@ -144,15 +144,15 @@ impl pallet_loans::WeightInfo for WeightInfo { // Storage: Loans PoolNAV (r:1 w:1) // Storage: PoolSystem Pool (r:1 w:1) // Storage: OrmlTokens Accounts (r:2 w:2) - /// The range of component `n` is `[1, 50]`. - /// The range of component `m` is `[1, 50]`. + /// The range of component `n` is `[1, 300]`. + /// The range of component `m` is `[1, 300]`. fn repay(n: u32, m: u32, ) -> Weight { - // Minimum execution time: 211_910 nanoseconds. - Weight::from_ref_time(226_022_608 as u64) - // Standard Error: 16_677 - .saturating_add(Weight::from_ref_time(618_506 as u64).saturating_mul(n as u64)) - // Standard Error: 16_677 - .saturating_add(Weight::from_ref_time(27_635 as u64).saturating_mul(m as u64)) + // Minimum execution time: 285_103 nanoseconds. + Weight::from_ref_time(306_345_697 as u64) + // Standard Error: 4_283 + .saturating_add(Weight::from_ref_time(556_486 as u64).saturating_mul(n as u64)) + // Standard Error: 4_283 + .saturating_add(Weight::from_ref_time(78_363 as u64).saturating_mul(m as u64)) .saturating_add(T::DbWeight::get().reads(12 as u64)) .saturating_add(T::DbWeight::get().writes(5 as u64)) } @@ -163,16 +163,18 @@ impl pallet_loans::WeightInfo for WeightInfo { // Storage: InterestAccrual Rates (r:1 w:1) // Storage: InterestAccrual LastUpdated (r:1 w:0) // Storage: Loans PoolNAV (r:1 w:1) - /// The range of component `n` is `[1, 50]`. - /// The range of component `m` is `[1, 10]`. - /// The range of component `o` is `[1, 49]`. - fn write_off(n: u32, _m: u32, o: u32, ) -> Weight { - // Minimum execution time: 133_276 nanoseconds. - Weight::from_ref_time(142_405_252 as u64) - // Standard Error: 16_720 - .saturating_add(Weight::from_ref_time(851_262 as u64).saturating_mul(n as u64)) - // Standard Error: 16_743 - .saturating_add(Weight::from_ref_time(207_991 as u64).saturating_mul(o as u64)) + /// The range of component `n` is `[1, 300]`. + /// The range of component `m` is `[1, 100]`. + /// The range of component `o` is `[1, 299]`. + fn write_off(n: u32, m: u32, o: u32, ) -> Weight { + // Minimum execution time: 220_505 nanoseconds. + Weight::from_ref_time(200_365_098 as u64) + // Standard Error: 3_341 + .saturating_add(Weight::from_ref_time(536_364 as u64).saturating_mul(n as u64)) + // Standard Error: 10_084 + .saturating_add(Weight::from_ref_time(10_275 as u64).saturating_mul(m as u64)) + // Standard Error: 3_352 + .saturating_add(Weight::from_ref_time(170_046 as u64).saturating_mul(o as u64)) .saturating_add(T::DbWeight::get().reads(7 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -184,15 +186,15 @@ impl pallet_loans::WeightInfo for WeightInfo { // Storage: InterestAccrual LastUpdated (r:1 w:0) // Storage: Timestamp Now (r:1 w:0) // Storage: Loans PoolNAV (r:1 w:1) - /// The range of component `n` is `[1, 50]`. - /// The range of component `m` is `[1, 49]`. + /// The range of component `n` is `[1, 300]`. + /// The range of component `m` is `[1, 299]`. fn admin_write_off(n: u32, m: u32, ) -> Weight { - // Minimum execution time: 155_899 nanoseconds. - Weight::from_ref_time(161_281_536 as u64) - // Standard Error: 14_046 - .saturating_add(Weight::from_ref_time(683_305 as u64).saturating_mul(n as u64)) - // Standard Error: 14_066 - .saturating_add(Weight::from_ref_time(187_296 as u64).saturating_mul(m as u64)) + // Minimum execution time: 237_204 nanoseconds. + Weight::from_ref_time(205_809_125 as u64) + // Standard Error: 3_801 + .saturating_add(Weight::from_ref_time(558_355 as u64).saturating_mul(n as u64)) + // Standard Error: 3_814 + .saturating_add(Weight::from_ref_time(186_042 as u64).saturating_mul(m as u64)) .saturating_add(T::DbWeight::get().reads(8 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -202,21 +204,21 @@ impl pallet_loans::WeightInfo for WeightInfo { // Storage: Loans ActiveLoans (r:1 w:1) // Storage: Loans PoolWriteOffGroups (r:1 w:0) // Storage: Uniques Class (r:2 w:1) - // Storage: InterestAccrual Rates (r:1 w:0) + // Storage: InterestAccrual Rates (r:1 w:1) // Storage: Loans ClosedLoans (r:0 w:1) // Storage: Uniques Account (r:0 w:3) // Storage: Uniques ItemPriceOf (r:0 w:2) - /// The range of component `n` is `[1, 50]`. - /// The range of component `m` is `[1, 50]`. + /// The range of component `n` is `[1, 300]`. + /// The range of component `m` is `[1, 300]`. fn repay_and_close(n: u32, m: u32, ) -> Weight { - // Minimum execution time: 153_745 nanoseconds. - Weight::from_ref_time(164_503_805 as u64) - // Standard Error: 24_522 - .saturating_add(Weight::from_ref_time(970_414 as u64).saturating_mul(n as u64)) - // Standard Error: 24_522 - .saturating_add(Weight::from_ref_time(90_209 as u64).saturating_mul(m as u64)) + // Minimum execution time: 194_302 nanoseconds. + Weight::from_ref_time(202_465_463 as u64) + // Standard Error: 3_113 + .saturating_add(Weight::from_ref_time(549_075 as u64).saturating_mul(n as u64)) + // Standard Error: 3_113 + .saturating_add(Weight::from_ref_time(62_411 as u64).saturating_mul(m as u64)) .saturating_add(T::DbWeight::get().reads(9 as u64)) - .saturating_add(T::DbWeight::get().writes(11 as u64)) + .saturating_add(T::DbWeight::get().writes(12 as u64)) } // Storage: Loans PoolToLoanNftClass (r:1 w:0) // Storage: Uniques Asset (r:2 w:2) @@ -224,36 +226,36 @@ impl pallet_loans::WeightInfo for WeightInfo { // Storage: Loans ActiveLoans (r:1 w:1) // Storage: Loans PoolWriteOffGroups (r:1 w:0) // Storage: Uniques Class (r:2 w:1) - // Storage: InterestAccrual Rates (r:1 w:0) + // Storage: InterestAccrual Rates (r:1 w:1) // Storage: Loans ClosedLoans (r:0 w:1) // Storage: Uniques Account (r:0 w:3) // Storage: Uniques ItemPriceOf (r:0 w:2) - /// The range of component `n` is `[1, 50]`. - /// The range of component `m` is `[1, 49]`. + /// The range of component `n` is `[1, 300]`. + /// The range of component `m` is `[1, 299]`. fn write_off_and_close(n: u32, m: u32, ) -> Weight { - // Minimum execution time: 152_854 nanoseconds. - Weight::from_ref_time(157_491_219 as u64) - // Standard Error: 19_952 - .saturating_add(Weight::from_ref_time(923_707 as u64).saturating_mul(n as u64)) - // Standard Error: 19_981 - .saturating_add(Weight::from_ref_time(287_155 as u64).saturating_mul(m as u64)) + // Minimum execution time: 200_607 nanoseconds. + Weight::from_ref_time(194_229_515 as u64) + // Standard Error: 7_328 + .saturating_add(Weight::from_ref_time(692_305 as u64).saturating_mul(n as u64)) + // Standard Error: 7_353 + .saturating_add(Weight::from_ref_time(77_160 as u64).saturating_mul(m as u64)) .saturating_add(T::DbWeight::get().reads(9 as u64)) - .saturating_add(T::DbWeight::get().writes(11 as u64)) + .saturating_add(T::DbWeight::get().writes(12 as u64)) } // Storage: Loans PoolWriteOffGroups (r:1 w:0) // Storage: InterestAccrual Rates (r:1 w:0) // Storage: Loans ActiveLoans (r:1 w:1) // Storage: Timestamp Now (r:1 w:0) // Storage: Loans PoolNAV (r:0 w:1) - /// The range of component `n` is `[1, 50]`. - /// The range of component `m` is `[1, 50]`. + /// The range of component `n` is `[1, 300]`. + /// The range of component `m` is `[1, 300]`. fn update_nav(n: u32, m: u32, ) -> Weight { - // Minimum execution time: 102_400 nanoseconds. - Weight::from_ref_time(68_707_198 as u64) - // Standard Error: 72_609 - .saturating_add(Weight::from_ref_time(29_997_518 as u64).saturating_mul(n as u64)) - // Standard Error: 72_609 - .saturating_add(Weight::from_ref_time(540_170 as u64).saturating_mul(m as u64)) + // Minimum execution time: 144_603 nanoseconds. + Weight::from_ref_time(34_939_729 as u64) + // Standard Error: 18_055 + .saturating_add(Weight::from_ref_time(42_045_542 as u64).saturating_mul(n as u64)) + // Standard Error: 18_055 + .saturating_add(Weight::from_ref_time(411_388 as u64).saturating_mul(m as u64)) .saturating_add(T::DbWeight::get().reads(4 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } diff --git a/runtime/altair/src/weights/pallet_migration_manager.rs b/runtime/altair/src/weights/pallet_migration_manager.rs index e385f987e0..3aaecdffaf 100644 --- a/runtime/altair/src/weights/pallet_migration_manager.rs +++ b/runtime/altair/src/weights/pallet_migration_manager.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_migration_manager` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-01-12, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-03-25, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("altair-dev"), DB CACHE: 1024 @@ -32,8 +32,8 @@ pub struct WeightInfo(PhantomData); impl pallet_migration_manager::WeightInfo for WeightInfo { // Storage: Migration Status (r:1 w:1) fn finalize() -> Weight { - // Minimum execution time: 34_700 nanoseconds. - Weight::from_ref_time(35_300_000 as u64) + // Minimum execution time: 35_300 nanoseconds. + Weight::from_ref_time(36_001_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } @@ -41,18 +41,18 @@ impl pallet_migration_manager::WeightInfo for WeightInf // Storage: System Account (r:0 w:1) /// The range of component `n` is `[1, 100]`. fn migrate_system_account(n: u32, ) -> Weight { - // Minimum execution time: 37_301 nanoseconds. - Weight::from_ref_time(38_064_508 as u64) - // Standard Error: 9_915 - .saturating_add(Weight::from_ref_time(1_497_066 as u64).saturating_mul(n as u64)) + // Minimum execution time: 37_900 nanoseconds. + Weight::from_ref_time(40_469_173 as u64) + // Standard Error: 6_508 + .saturating_add(Weight::from_ref_time(1_449_587 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) .saturating_add(T::DbWeight::get().writes((1 as u64).saturating_mul(n as u64))) } // Storage: Migration Status (r:1 w:1) fn migrate_balances_issuance() -> Weight { - // Minimum execution time: 41_101 nanoseconds. - Weight::from_ref_time(41_700_000 as u64) + // Minimum execution time: 41_400 nanoseconds. + Weight::from_ref_time(42_200_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } @@ -62,10 +62,10 @@ impl pallet_migration_manager::WeightInfo for WeightInf // Storage: System Account (r:1 w:1) /// The range of component `n` is `[1, 10]`. fn migrate_vesting_vesting(n: u32, ) -> Weight { - // Minimum execution time: 209_403 nanoseconds. - Weight::from_ref_time(186_190_557 as u64) - // Standard Error: 173_109 - .saturating_add(Weight::from_ref_time(42_823_095 as u64).saturating_mul(n as u64)) + // Minimum execution time: 226_403 nanoseconds. + Weight::from_ref_time(206_948_721 as u64) + // Standard Error: 87_565 + .saturating_add(Weight::from_ref_time(43_548_286 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().reads((3 as u64).saturating_mul(n as u64))) .saturating_add(T::DbWeight::get().writes(1 as u64)) @@ -75,10 +75,10 @@ impl pallet_migration_manager::WeightInfo for WeightInf // Storage: Proxy Proxies (r:0 w:1) /// The range of component `n` is `[1, 10]`. fn migrate_proxy_proxies(n: u32, ) -> Weight { - // Minimum execution time: 154_603 nanoseconds. - Weight::from_ref_time(175_139_074 as u64) - // Standard Error: 126_925 - .saturating_add(Weight::from_ref_time(8_433_197 as u64).saturating_mul(n as u64)) + // Minimum execution time: 166_602 nanoseconds. + Weight::from_ref_time(186_865_726 as u64) + // Standard Error: 78_341 + .saturating_add(Weight::from_ref_time(11_037_238 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) .saturating_add(T::DbWeight::get().writes((1 as u64).saturating_mul(n as u64))) diff --git a/runtime/altair/src/weights/pallet_multisig.rs b/runtime/altair/src/weights/pallet_multisig.rs index e3673c5c43..fcfca6ca43 100644 --- a/runtime/altair/src/weights/pallet_multisig.rs +++ b/runtime/altair/src/weights/pallet_multisig.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_multisig` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-01-12, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-03-25, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("altair-dev"), DB CACHE: 1024 @@ -32,22 +32,22 @@ pub struct WeightInfo(PhantomData); impl pallet_multisig::WeightInfo for WeightInfo { /// The range of component `z` is `[0, 10000]`. fn as_multi_threshold_1(z: u32, ) -> Weight { - // Minimum execution time: 37_001 nanoseconds. - Weight::from_ref_time(37_825_046 as u64) - // Standard Error: 13 - .saturating_add(Weight::from_ref_time(798 as u64).saturating_mul(z as u64)) + // Minimum execution time: 35_200 nanoseconds. + Weight::from_ref_time(37_732_001 as u64) + // Standard Error: 12 + .saturating_add(Weight::from_ref_time(698 as u64).saturating_mul(z as u64)) } // Storage: Multisig Multisigs (r:1 w:1) // Storage: unknown [0x3a65787472696e7369635f696e646578] (r:1 w:0) /// The range of component `s` is `[2, 100]`. /// The range of component `z` is `[0, 10000]`. fn as_multi_create(s: u32, z: u32, ) -> Weight { - // Minimum execution time: 86_501 nanoseconds. - Weight::from_ref_time(69_328_003 as u64) - // Standard Error: 2_239 - .saturating_add(Weight::from_ref_time(237_157 as u64).saturating_mul(s as u64)) - // Standard Error: 21 - .saturating_add(Weight::from_ref_time(2_122 as u64).saturating_mul(z as u64)) + // Minimum execution time: 86_101 nanoseconds. + Weight::from_ref_time(68_358_819 as u64) + // Standard Error: 2_571 + .saturating_add(Weight::from_ref_time(246_384 as u64).saturating_mul(s as u64)) + // Standard Error: 25 + .saturating_add(Weight::from_ref_time(2_140 as u64).saturating_mul(z as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } @@ -55,12 +55,12 @@ impl pallet_multisig::WeightInfo for WeightInfo { /// The range of component `s` is `[3, 100]`. /// The range of component `z` is `[0, 10000]`. fn as_multi_approve(s: u32, z: u32, ) -> Weight { - // Minimum execution time: 68_701 nanoseconds. - Weight::from_ref_time(51_097_315 as u64) - // Standard Error: 1_921 - .saturating_add(Weight::from_ref_time(223_898 as u64).saturating_mul(s as u64)) - // Standard Error: 18 - .saturating_add(Weight::from_ref_time(2_015 as u64).saturating_mul(z as u64)) + // Minimum execution time: 68_801 nanoseconds. + Weight::from_ref_time(51_266_463 as u64) + // Standard Error: 2_374 + .saturating_add(Weight::from_ref_time(221_662 as u64).saturating_mul(s as u64)) + // Standard Error: 23 + .saturating_add(Weight::from_ref_time(2_034 as u64).saturating_mul(z as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } @@ -69,12 +69,12 @@ impl pallet_multisig::WeightInfo for WeightInfo { /// The range of component `s` is `[2, 100]`. /// The range of component `z` is `[0, 10000]`. fn as_multi_complete(s: u32, z: u32, ) -> Weight { - // Minimum execution time: 91_301 nanoseconds. - Weight::from_ref_time(74_950_044 as u64) - // Standard Error: 3_462 - .saturating_add(Weight::from_ref_time(245_705 as u64).saturating_mul(s as u64)) - // Standard Error: 33 - .saturating_add(Weight::from_ref_time(2_120 as u64).saturating_mul(z as u64)) + // Minimum execution time: 90_601 nanoseconds. + Weight::from_ref_time(70_247_868 as u64) + // Standard Error: 2_200 + .saturating_add(Weight::from_ref_time(309_687 as u64).saturating_mul(s as u64)) + // Standard Error: 21 + .saturating_add(Weight::from_ref_time(2_312 as u64).saturating_mul(z as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } @@ -82,30 +82,30 @@ impl pallet_multisig::WeightInfo for WeightInfo { // Storage: unknown [0x3a65787472696e7369635f696e646578] (r:1 w:0) /// The range of component `s` is `[2, 100]`. fn approve_as_multi_create(s: u32, ) -> Weight { - // Minimum execution time: 63_701 nanoseconds. - Weight::from_ref_time(66_646_362 as u64) - // Standard Error: 2_241 - .saturating_add(Weight::from_ref_time(227_841 as u64).saturating_mul(s as u64)) + // Minimum execution time: 63_500 nanoseconds. + Weight::from_ref_time(66_394_187 as u64) + // Standard Error: 2_869 + .saturating_add(Weight::from_ref_time(239_362 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Multisig Multisigs (r:1 w:1) /// The range of component `s` is `[2, 100]`. fn approve_as_multi_approve(s: u32, ) -> Weight { - // Minimum execution time: 45_400 nanoseconds. - Weight::from_ref_time(47_628_571 as u64) - // Standard Error: 2_007 - .saturating_add(Weight::from_ref_time(225_722 as u64).saturating_mul(s as u64)) + // Minimum execution time: 45_101 nanoseconds. + Weight::from_ref_time(47_330_931 as u64) + // Standard Error: 1_880 + .saturating_add(Weight::from_ref_time(223_532 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Multisig Multisigs (r:1 w:1) /// The range of component `s` is `[2, 100]`. fn cancel_as_multi(s: u32, ) -> Weight { - // Minimum execution time: 63_301 nanoseconds. - Weight::from_ref_time(65_701_580 as u64) - // Standard Error: 1_653 - .saturating_add(Weight::from_ref_time(231_532 as u64).saturating_mul(s as u64)) + // Minimum execution time: 63_800 nanoseconds. + Weight::from_ref_time(66_200_761 as u64) + // Standard Error: 2_003 + .saturating_add(Weight::from_ref_time(229_523 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } diff --git a/runtime/altair/src/weights/pallet_nft_sales.rs b/runtime/altair/src/weights/pallet_nft_sales.rs index 2747542f34..a0107f2e08 100644 --- a/runtime/altair/src/weights/pallet_nft_sales.rs +++ b/runtime/altair/src/weights/pallet_nft_sales.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_nft_sales` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-01-12, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-03-25, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("altair-dev"), DB CACHE: 1024 @@ -37,8 +37,8 @@ impl pallet_nft_sales::WeightInfo for WeightInfo { // Storage: Uniques ItemPriceOf (r:0 w:1) // Storage: NftSales NftsBySeller (r:0 w:1) fn add() -> Weight { - // Minimum execution time: 86_502 nanoseconds. - Weight::from_ref_time(87_301_000 as u64) + // Minimum execution time: 90_501 nanoseconds. + Weight::from_ref_time(91_501_000 as u64) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(6 as u64)) } @@ -49,8 +49,8 @@ impl pallet_nft_sales::WeightInfo for WeightInfo { // Storage: Uniques ItemPriceOf (r:0 w:1) // Storage: NftSales NftsBySeller (r:0 w:1) fn remove() -> Weight { - // Minimum execution time: 86_101 nanoseconds. - Weight::from_ref_time(87_201_000 as u64) + // Minimum execution time: 88_501 nanoseconds. + Weight::from_ref_time(90_002_000 as u64) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(5 as u64)) } @@ -63,8 +63,8 @@ impl pallet_nft_sales::WeightInfo for WeightInfo { // Storage: Uniques ItemPriceOf (r:0 w:1) // Storage: NftSales NftsBySeller (r:0 w:1) fn buy() -> Weight { - // Minimum execution time: 138_602 nanoseconds. - Weight::from_ref_time(139_602_000 as u64) + // Minimum execution time: 144_202 nanoseconds. + Weight::from_ref_time(145_702_000 as u64) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(9 as u64)) } diff --git a/runtime/altair/src/weights/pallet_permissions.rs b/runtime/altair/src/weights/pallet_permissions.rs index 45500cff48..3315ec64d8 100644 --- a/runtime/altair/src/weights/pallet_permissions.rs +++ b/runtime/altair/src/weights/pallet_permissions.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_permissions` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-01-12, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-03-25, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("altair-dev"), DB CACHE: 1024 @@ -33,46 +33,46 @@ impl pallet_permissions::WeightInfo for WeightInfo { // Storage: Permissions PermissionCount (r:1 w:1) // Storage: Permissions Permission (r:1 w:1) fn add_as_admin() -> Weight { - // Minimum execution time: 39_600 nanoseconds. - Weight::from_ref_time(40_600_000 as u64) + // Minimum execution time: 53_001 nanoseconds. + Weight::from_ref_time(54_401_000 as u64) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } // Storage: Permissions Permission (r:2 w:1) // Storage: Permissions PermissionCount (r:1 w:1) fn add_as_editor() -> Weight { - // Minimum execution time: 49_201 nanoseconds. - Weight::from_ref_time(50_301_000 as u64) + // Minimum execution time: 50_701 nanoseconds. + Weight::from_ref_time(51_202_000 as u64) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } // Storage: Permissions PermissionCount (r:1 w:1) // Storage: Permissions Permission (r:1 w:1) fn remove_as_admin() -> Weight { - // Minimum execution time: 43_401 nanoseconds. - Weight::from_ref_time(44_500_000 as u64) + // Minimum execution time: 44_302 nanoseconds. + Weight::from_ref_time(45_201_000 as u64) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } // Storage: Permissions Permission (r:2 w:1) // Storage: Permissions PermissionCount (r:1 w:1) fn remove_as_editor() -> Weight { - // Minimum execution time: 52_000 nanoseconds. - Weight::from_ref_time(52_500_000 as u64) + // Minimum execution time: 51_902 nanoseconds. + Weight::from_ref_time(53_802_000 as u64) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } // Storage: Permissions Permission (r:1 w:1) fn purge() -> Weight { - // Minimum execution time: 39_300 nanoseconds. - Weight::from_ref_time(40_000_000 as u64) + // Minimum execution time: 39_001 nanoseconds. + Weight::from_ref_time(40_601_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Permissions Permission (r:1 w:1) fn admin_purge() -> Weight { - // Minimum execution time: 43_801 nanoseconds. - Weight::from_ref_time(44_500_000 as u64) + // Minimum execution time: 40_301 nanoseconds. + Weight::from_ref_time(41_101_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } diff --git a/runtime/altair/src/weights/pallet_pool_registry.rs b/runtime/altair/src/weights/pallet_pool_registry.rs index 316c4e6869..8470ff7bf0 100644 --- a/runtime/altair/src/weights/pallet_pool_registry.rs +++ b/runtime/altair/src/weights/pallet_pool_registry.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_pool_registry` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-01-12, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-03-25, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("altair-dev"), DB CACHE: 1024 @@ -42,10 +42,10 @@ impl pallet_pool_registry::WeightInfo for WeightInfo // Storage: PoolSystem PoolDeposit (r:0 w:1) /// The range of component `n` is `[1, 5]`. fn register(n: u32, ) -> Weight { - // Minimum execution time: 128_802 nanoseconds. - Weight::from_ref_time(103_871_751 as u64) - // Standard Error: 39_502 - .saturating_add(Weight::from_ref_time(27_702_342 as u64).saturating_mul(n as u64)) + // Minimum execution time: 125_602 nanoseconds. + Weight::from_ref_time(105_161_788 as u64) + // Standard Error: 64_886 + .saturating_add(Weight::from_ref_time(27_699_491 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(8 as u64)) .saturating_add(T::DbWeight::get().reads((2 as u64).saturating_mul(n as u64))) .saturating_add(T::DbWeight::get().writes(6 as u64)) @@ -59,10 +59,10 @@ impl pallet_pool_registry::WeightInfo for WeightInfo // Storage: PoolSystem ScheduledUpdate (r:0 w:1) /// The range of component `n` is `[1, 5]`. fn update_no_execution(n: u32, ) -> Weight { - // Minimum execution time: 79_301 nanoseconds. - Weight::from_ref_time(75_328_653 as u64) - // Standard Error: 207_902 - .saturating_add(Weight::from_ref_time(4_606_499 as u64).saturating_mul(n as u64)) + // Minimum execution time: 79_101 nanoseconds. + Weight::from_ref_time(77_505_876 as u64) + // Standard Error: 30_406 + .saturating_add(Weight::from_ref_time(3_377_367 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(4 as u64)) .saturating_add(T::DbWeight::get().reads((1 as u64).saturating_mul(n as u64))) .saturating_add(T::DbWeight::get().writes(1 as u64)) @@ -76,26 +76,26 @@ impl pallet_pool_registry::WeightInfo for WeightInfo // Storage: PoolSystem ScheduledUpdate (r:0 w:1) /// The range of component `n` is `[1, 5]`. fn update_and_execute(n: u32, ) -> Weight { - // Minimum execution time: 116_502 nanoseconds. - Weight::from_ref_time(117_001_349 as u64) - // Standard Error: 545_607 - .saturating_add(Weight::from_ref_time(7_810_548 as u64).saturating_mul(n as u64)) + // Minimum execution time: 115_801 nanoseconds. + Weight::from_ref_time(110_771_359 as u64) + // Standard Error: 43_039 + .saturating_add(Weight::from_ref_time(9_655_092 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().reads((1 as u64).saturating_mul(n as u64))) .saturating_add(T::DbWeight::get().writes(3 as u64)) } + // Storage: PoolSystem Pool (r:1 w:1) // Storage: PoolSystem EpochExecution (r:1 w:0) // Storage: PoolSystem ScheduledUpdate (r:1 w:1) // Storage: Timestamp Now (r:1 w:0) - // Storage: PoolSystem Pool (r:1 w:1) // Storage: Investments ActiveRedeemOrders (r:1 w:0) // Storage: OrmlAssetRegistry Metadata (r:2 w:1) /// The range of component `n` is `[1, 5]`. fn execute_update(n: u32, ) -> Weight { - // Minimum execution time: 106_201 nanoseconds. - Weight::from_ref_time(98_682_425 as u64) - // Standard Error: 46_698 - .saturating_add(Weight::from_ref_time(10_009_727 as u64).saturating_mul(n as u64)) + // Minimum execution time: 106_101 nanoseconds. + Weight::from_ref_time(98_749_888 as u64) + // Standard Error: 38_482 + .saturating_add(Weight::from_ref_time(9_677_614 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().reads((1 as u64).saturating_mul(n as u64))) .saturating_add(T::DbWeight::get().writes(3 as u64)) @@ -104,10 +104,10 @@ impl pallet_pool_registry::WeightInfo for WeightInfo // Storage: PoolRegistry PoolMetadata (r:0 w:1) /// The range of component `n` is `[0, 46]`. fn set_metadata(n: u32, ) -> Weight { - // Minimum execution time: 42_800 nanoseconds. - Weight::from_ref_time(45_664_145 as u64) - // Standard Error: 12_243 - .saturating_add(Weight::from_ref_time(23_548 as u64).saturating_mul(n as u64)) + // Minimum execution time: 42_801 nanoseconds. + Weight::from_ref_time(45_650_721 as u64) + // Standard Error: 9_681 + .saturating_add(Weight::from_ref_time(170 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } diff --git a/runtime/altair/src/weights/pallet_pool_system.rs b/runtime/altair/src/weights/pallet_pool_system.rs index f37f7b2938..77fe0a9d34 100644 --- a/runtime/altair/src/weights/pallet_pool_system.rs +++ b/runtime/altair/src/weights/pallet_pool_system.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_pool_system` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-01-12, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-03-25, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("altair-dev"), DB CACHE: 1024 @@ -33,8 +33,8 @@ impl pallet_pool_system::WeightInfo for WeightInfo { // Storage: Permissions Permission (r:1 w:0) // Storage: PoolSystem Pool (r:1 w:1) fn set_max_reserve() -> Weight { - // Minimum execution time: 52_101 nanoseconds. - Weight::from_ref_time(52_901_000 as u64) + // Minimum execution time: 53_701 nanoseconds. + Weight::from_ref_time(54_301_000 as u64) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } @@ -54,10 +54,10 @@ impl pallet_pool_system::WeightInfo for WeightInfo { // Storage: Investments ClearedRedeemOrders (r:0 w:1) /// The range of component `n` is `[1, 5]`. fn close_epoch_no_orders(n: u32, ) -> Weight { - // Minimum execution time: 169_202 nanoseconds. - Weight::from_ref_time(81_363_379 as u64) - // Standard Error: 67_367 - .saturating_add(Weight::from_ref_time(91_546_687 as u64).saturating_mul(n as u64)) + // Minimum execution time: 173_102 nanoseconds. + Weight::from_ref_time(81_170_515 as u64) + // Standard Error: 78_938 + .saturating_add(Weight::from_ref_time(94_712_307 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(4 as u64)) .saturating_add(T::DbWeight::get().reads((8 as u64).saturating_mul(n as u64))) .saturating_add(T::DbWeight::get().writes(1 as u64)) @@ -76,10 +76,10 @@ impl pallet_pool_system::WeightInfo for WeightInfo { // Storage: Investments RedeemOrderId (r:1 w:1) /// The range of component `n` is `[1, 5]`. fn close_epoch_no_execution(n: u32, ) -> Weight { - // Minimum execution time: 125_602 nanoseconds. - Weight::from_ref_time(89_349_021 as u64) - // Standard Error: 37_016 - .saturating_add(Weight::from_ref_time(39_093_988 as u64).saturating_mul(n as u64)) + // Minimum execution time: 124_701 nanoseconds. + Weight::from_ref_time(87_142_693 as u64) + // Standard Error: 39_277 + .saturating_add(Weight::from_ref_time(40_555_404 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(4 as u64)) .saturating_add(T::DbWeight::get().reads((7 as u64).saturating_mul(n as u64))) .saturating_add(T::DbWeight::get().writes(2 as u64)) @@ -102,10 +102,10 @@ impl pallet_pool_system::WeightInfo for WeightInfo { // Storage: Investments ClearedRedeemOrders (r:0 w:1) /// The range of component `n` is `[1, 5]`. fn close_epoch_execute(n: u32, ) -> Weight { - // Minimum execution time: 279_404 nanoseconds. - Weight::from_ref_time(190_021_094 as u64) - // Standard Error: 83_327 - .saturating_add(Weight::from_ref_time(93_952_832 as u64).saturating_mul(n as u64)) + // Minimum execution time: 282_904 nanoseconds. + Weight::from_ref_time(190_532_648 as u64) + // Standard Error: 79_070 + .saturating_add(Weight::from_ref_time(97_072_971 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(8 as u64)) .saturating_add(T::DbWeight::get().reads((8 as u64).saturating_mul(n as u64))) .saturating_add(T::DbWeight::get().writes(7 as u64)) @@ -115,10 +115,10 @@ impl pallet_pool_system::WeightInfo for WeightInfo { // Storage: PoolSystem Pool (r:1 w:0) /// The range of component `n` is `[1, 5]`. fn submit_solution(n: u32, ) -> Weight { - // Minimum execution time: 54_901 nanoseconds. - Weight::from_ref_time(53_779_317 as u64) - // Standard Error: 15_443 - .saturating_add(Weight::from_ref_time(2_701_951 as u64).saturating_mul(n as u64)) + // Minimum execution time: 56_301 nanoseconds. + Weight::from_ref_time(55_936_163 as u64) + // Standard Error: 26_049 + .saturating_add(Weight::from_ref_time(2_453_954 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } @@ -138,10 +138,10 @@ impl pallet_pool_system::WeightInfo for WeightInfo { // Storage: Investments ClearedRedeemOrders (r:0 w:1) /// The range of component `n` is `[1, 5]`. fn execute_epoch(n: u32, ) -> Weight { - // Minimum execution time: 237_403 nanoseconds. - Weight::from_ref_time(172_163_224 as u64) - // Standard Error: 43_466 - .saturating_add(Weight::from_ref_time(68_504_560 as u64).saturating_mul(n as u64)) + // Minimum execution time: 239_803 nanoseconds. + Weight::from_ref_time(171_793_686 as u64) + // Standard Error: 55_109 + .saturating_add(Weight::from_ref_time(71_255_896 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(8 as u64)) .saturating_add(T::DbWeight::get().reads((7 as u64).saturating_mul(n as u64))) .saturating_add(T::DbWeight::get().writes(8 as u64)) diff --git a/runtime/altair/src/weights/pallet_preimage.rs b/runtime/altair/src/weights/pallet_preimage.rs index 56228228c9..bb93100163 100644 --- a/runtime/altair/src/weights/pallet_preimage.rs +++ b/runtime/altair/src/weights/pallet_preimage.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_preimage` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-01-12, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-03-25, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("altair-dev"), DB CACHE: 1024 @@ -34,10 +34,10 @@ impl pallet_preimage::WeightInfo for WeightInfo { // Storage: Preimage PreimageFor (r:0 w:1) /// The range of component `s` is `[0, 4194304]`. fn note_preimage(s: u32, ) -> Weight { - // Minimum execution time: 59_401 nanoseconds. - Weight::from_ref_time(60_101_000 as u64) - // Standard Error: 3 - .saturating_add(Weight::from_ref_time(2_344 as u64).saturating_mul(s as u64)) + // Minimum execution time: 60_200 nanoseconds. + Weight::from_ref_time(61_101_000 as u64) + // Standard Error: 2 + .saturating_add(Weight::from_ref_time(2_459 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } @@ -45,10 +45,10 @@ impl pallet_preimage::WeightInfo for WeightInfo { // Storage: Preimage PreimageFor (r:0 w:1) /// The range of component `s` is `[0, 4194304]`. fn note_requested_preimage(s: u32, ) -> Weight { - // Minimum execution time: 41_800 nanoseconds. - Weight::from_ref_time(42_100_000 as u64) + // Minimum execution time: 42_301 nanoseconds. + Weight::from_ref_time(42_602_000 as u64) // Standard Error: 2 - .saturating_add(Weight::from_ref_time(2_345 as u64).saturating_mul(s as u64)) + .saturating_add(Weight::from_ref_time(2_453 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } @@ -56,76 +56,76 @@ impl pallet_preimage::WeightInfo for WeightInfo { // Storage: Preimage PreimageFor (r:0 w:1) /// The range of component `s` is `[0, 4194304]`. fn note_no_deposit_preimage(s: u32, ) -> Weight { - // Minimum execution time: 50_701 nanoseconds. - Weight::from_ref_time(51_500_000 as u64) + // Minimum execution time: 39_501 nanoseconds. + Weight::from_ref_time(40_001_000 as u64) // Standard Error: 2 - .saturating_add(Weight::from_ref_time(2_332 as u64).saturating_mul(s as u64)) + .saturating_add(Weight::from_ref_time(2_464 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } // Storage: Preimage StatusFor (r:1 w:1) // Storage: Preimage PreimageFor (r:0 w:1) fn unnote_preimage() -> Weight { - // Minimum execution time: 88_600 nanoseconds. - Weight::from_ref_time(93_599_000 as u64) + // Minimum execution time: 99_903 nanoseconds. + Weight::from_ref_time(113_304_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } // Storage: Preimage StatusFor (r:1 w:1) // Storage: Preimage PreimageFor (r:0 w:1) fn unnote_no_deposit_preimage() -> Weight { - // Minimum execution time: 63_300 nanoseconds. - Weight::from_ref_time(68_800_000 as u64) + // Minimum execution time: 80_603 nanoseconds. + Weight::from_ref_time(85_603_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } // Storage: Preimage StatusFor (r:1 w:1) fn request_preimage() -> Weight { - // Minimum execution time: 61_901 nanoseconds. - Weight::from_ref_time(64_101_000 as u64) + // Minimum execution time: 70_303 nanoseconds. + Weight::from_ref_time(83_303_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Preimage StatusFor (r:1 w:1) fn request_no_deposit_preimage() -> Weight { - // Minimum execution time: 34_900 nanoseconds. - Weight::from_ref_time(42_001_000 as u64) + // Minimum execution time: 49_501 nanoseconds. + Weight::from_ref_time(54_502_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Preimage StatusFor (r:1 w:1) fn request_unnoted_preimage() -> Weight { - // Minimum execution time: 39_000 nanoseconds. - Weight::from_ref_time(40_101_000 as u64) + // Minimum execution time: 49_301 nanoseconds. + Weight::from_ref_time(52_702_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Preimage StatusFor (r:1 w:1) fn request_requested_preimage() -> Weight { - // Minimum execution time: 19_600 nanoseconds. - Weight::from_ref_time(20_000_000 as u64) + // Minimum execution time: 20_501 nanoseconds. + Weight::from_ref_time(21_900_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Preimage StatusFor (r:1 w:1) // Storage: Preimage PreimageFor (r:0 w:1) fn unrequest_preimage() -> Weight { - // Minimum execution time: 58_801 nanoseconds. - Weight::from_ref_time(65_201_000 as u64) + // Minimum execution time: 68_802 nanoseconds. + Weight::from_ref_time(79_003_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } // Storage: Preimage StatusFor (r:1 w:1) fn unrequest_unnoted_preimage() -> Weight { - // Minimum execution time: 19_100 nanoseconds. - Weight::from_ref_time(19_601_000 as u64) + // Minimum execution time: 20_600 nanoseconds. + Weight::from_ref_time(21_401_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Preimage StatusFor (r:1 w:1) fn unrequest_multi_referenced_preimage() -> Weight { - // Minimum execution time: 18_800 nanoseconds. - Weight::from_ref_time(19_500_000 as u64) + // Minimum execution time: 20_301 nanoseconds. + Weight::from_ref_time(21_900_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } diff --git a/runtime/altair/src/weights/pallet_proxy.rs b/runtime/altair/src/weights/pallet_proxy.rs index e92150b581..c20a707d61 100644 --- a/runtime/altair/src/weights/pallet_proxy.rs +++ b/runtime/altair/src/weights/pallet_proxy.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_proxy` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-01-12, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-03-25, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("altair-dev"), DB CACHE: 1024 @@ -33,10 +33,10 @@ impl pallet_proxy::WeightInfo for WeightInfo { // Storage: Proxy Proxies (r:1 w:0) /// The range of component `p` is `[1, 31]`. fn proxy(p: u32, ) -> Weight { - // Minimum execution time: 42_400 nanoseconds. - Weight::from_ref_time(43_721_324 as u64) - // Standard Error: 3_448 - .saturating_add(Weight::from_ref_time(72_419 as u64).saturating_mul(p as u64)) + // Minimum execution time: 41_401 nanoseconds. + Weight::from_ref_time(42_601_938 as u64) + // Standard Error: 7_915 + .saturating_add(Weight::from_ref_time(100_756 as u64).saturating_mul(p as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) } // Storage: Proxy Proxies (r:1 w:0) @@ -45,12 +45,12 @@ impl pallet_proxy::WeightInfo for WeightInfo { /// The range of component `a` is `[0, 31]`. /// The range of component `p` is `[1, 31]`. fn proxy_announced(a: u32, p: u32, ) -> Weight { - // Minimum execution time: 77_801 nanoseconds. - Weight::from_ref_time(78_174_593 as u64) - // Standard Error: 3_646 - .saturating_add(Weight::from_ref_time(270_963 as u64).saturating_mul(a as u64)) - // Standard Error: 3_767 - .saturating_add(Weight::from_ref_time(87_863 as u64).saturating_mul(p as u64)) + // Minimum execution time: 76_503 nanoseconds. + Weight::from_ref_time(78_164_800 as u64) + // Standard Error: 5_054 + .saturating_add(Weight::from_ref_time(261_392 as u64).saturating_mul(a as u64)) + // Standard Error: 5_222 + .saturating_add(Weight::from_ref_time(60_586 as u64).saturating_mul(p as u64)) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } @@ -59,12 +59,12 @@ impl pallet_proxy::WeightInfo for WeightInfo { /// The range of component `a` is `[0, 31]`. /// The range of component `p` is `[1, 31]`. fn remove_announcement(a: u32, p: u32, ) -> Weight { - // Minimum execution time: 52_800 nanoseconds. - Weight::from_ref_time(55_107_492 as u64) - // Standard Error: 10_312 - .saturating_add(Weight::from_ref_time(274_732 as u64).saturating_mul(a as u64)) - // Standard Error: 10_654 - .saturating_add(Weight::from_ref_time(16_863 as u64).saturating_mul(p as u64)) + // Minimum execution time: 51_602 nanoseconds. + Weight::from_ref_time(53_388_576 as u64) + // Standard Error: 4_130 + .saturating_add(Weight::from_ref_time(281_901 as u64).saturating_mul(a as u64)) + // Standard Error: 4_267 + .saturating_add(Weight::from_ref_time(26_446 as u64).saturating_mul(p as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } @@ -73,12 +73,12 @@ impl pallet_proxy::WeightInfo for WeightInfo { /// The range of component `a` is `[0, 31]`. /// The range of component `p` is `[1, 31]`. fn reject_announcement(a: u32, p: u32, ) -> Weight { - // Minimum execution time: 52_601 nanoseconds. - Weight::from_ref_time(54_048_939 as u64) - // Standard Error: 2_918 - .saturating_add(Weight::from_ref_time(284_450 as u64).saturating_mul(a as u64)) - // Standard Error: 3_015 - .saturating_add(Weight::from_ref_time(27_368 as u64).saturating_mul(p as u64)) + // Minimum execution time: 51_601 nanoseconds. + Weight::from_ref_time(53_013_300 as u64) + // Standard Error: 10_477 + .saturating_add(Weight::from_ref_time(291_732 as u64).saturating_mul(a as u64)) + // Standard Error: 10_824 + .saturating_add(Weight::from_ref_time(42_146 as u64).saturating_mul(p as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } @@ -88,63 +88,61 @@ impl pallet_proxy::WeightInfo for WeightInfo { /// The range of component `a` is `[0, 31]`. /// The range of component `p` is `[1, 31]`. fn announce(a: u32, p: u32, ) -> Weight { - // Minimum execution time: 69_001 nanoseconds. - Weight::from_ref_time(70_557_565 as u64) - // Standard Error: 3_793 - .saturating_add(Weight::from_ref_time(249_612 as u64).saturating_mul(a as u64)) - // Standard Error: 3_919 - .saturating_add(Weight::from_ref_time(73_744 as u64).saturating_mul(p as u64)) + // Minimum execution time: 68_002 nanoseconds. + Weight::from_ref_time(70_002_897 as u64) + // Standard Error: 3_658 + .saturating_add(Weight::from_ref_time(255_039 as u64).saturating_mul(a as u64)) + // Standard Error: 3_780 + .saturating_add(Weight::from_ref_time(73_250 as u64).saturating_mul(p as u64)) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } // Storage: Proxy Proxies (r:1 w:1) /// The range of component `p` is `[1, 31]`. fn add_proxy(p: u32, ) -> Weight { - // Minimum execution time: 58_000 nanoseconds. - Weight::from_ref_time(59_221_202 as u64) - // Standard Error: 12_921 - .saturating_add(Weight::from_ref_time(154_890 as u64).saturating_mul(p as u64)) + // Minimum execution time: 57_602 nanoseconds. + Weight::from_ref_time(59_339_480 as u64) + // Standard Error: 11_556 + .saturating_add(Weight::from_ref_time(109_447 as u64).saturating_mul(p as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Proxy Proxies (r:1 w:1) /// The range of component `p` is `[1, 31]`. fn remove_proxy(p: u32, ) -> Weight { - // Minimum execution time: 57_100 nanoseconds. - Weight::from_ref_time(61_254_704 as u64) - // Standard Error: 18_676 - .saturating_add(Weight::from_ref_time(77_615 as u64).saturating_mul(p as u64)) + // Minimum execution time: 56_701 nanoseconds. + Weight::from_ref_time(59_620_172 as u64) + // Standard Error: 10_557 + .saturating_add(Weight::from_ref_time(95_565 as u64).saturating_mul(p as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Proxy Proxies (r:1 w:1) /// The range of component `p` is `[1, 31]`. fn remove_proxies(p: u32, ) -> Weight { - // Minimum execution time: 49_601 nanoseconds. - Weight::from_ref_time(52_599_797 as u64) - // Standard Error: 12_409 - .saturating_add(Weight::from_ref_time(14_418 as u64).saturating_mul(p as u64)) + // Minimum execution time: 49_001 nanoseconds. + Weight::from_ref_time(52_127_518 as u64) + // Standard Error: 14_853 + .saturating_add(Weight::from_ref_time(17_527 as u64).saturating_mul(p as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: unknown [0x3a65787472696e7369635f696e646578] (r:1 w:0) // Storage: Proxy Proxies (r:1 w:1) /// The range of component `p` is `[1, 31]`. - fn create_pure(p: u32, ) -> Weight { - // Minimum execution time: 62_801 nanoseconds. - Weight::from_ref_time(64_461_301 as u64) - // Standard Error: 3_149 - .saturating_add(Weight::from_ref_time(48_532 as u64).saturating_mul(p as u64)) + fn create_pure(_p: u32, ) -> Weight { + // Minimum execution time: 62_501 nanoseconds. + Weight::from_ref_time(65_840_792 as u64) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Proxy Proxies (r:1 w:1) /// The range of component `p` is `[0, 30]`. fn kill_pure(p: u32, ) -> Weight { - // Minimum execution time: 51_200 nanoseconds. - Weight::from_ref_time(53_223_536 as u64) - // Standard Error: 13_356 - .saturating_add(Weight::from_ref_time(94_754 as u64).saturating_mul(p as u64)) + // Minimum execution time: 51_102 nanoseconds. + Weight::from_ref_time(52_437_729 as u64) + // Standard Error: 2_138 + .saturating_add(Weight::from_ref_time(75_096 as u64).saturating_mul(p as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } diff --git a/runtime/altair/src/weights/pallet_restricted_tokens.rs b/runtime/altair/src/weights/pallet_restricted_tokens.rs index 5c6ddeef00..ddbeb359f5 100644 --- a/runtime/altair/src/weights/pallet_restricted_tokens.rs +++ b/runtime/altair/src/weights/pallet_restricted_tokens.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_restricted_tokens` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-01-12, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-03-25, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("altair-dev"), DB CACHE: 1024 @@ -32,68 +32,68 @@ pub struct WeightInfo(PhantomData); impl pallet_restricted_tokens::WeightInfo for WeightInfo { // Storage: System Account (r:1 w:1) fn transfer_native() -> Weight { - // Minimum execution time: 80_301 nanoseconds. - Weight::from_ref_time(81_201_000 as u64) + // Minimum execution time: 80_802 nanoseconds. + Weight::from_ref_time(81_602_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: OrmlTokens Accounts (r:2 w:2) // Storage: System Account (r:1 w:1) fn transfer_other() -> Weight { - // Minimum execution time: 83_801 nanoseconds. - Weight::from_ref_time(84_702_000 as u64) + // Minimum execution time: 84_202 nanoseconds. + Weight::from_ref_time(86_102_000 as u64) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } // Storage: System Account (r:1 w:1) fn transfer_keep_alive_native() -> Weight { - // Minimum execution time: 72_701 nanoseconds. - Weight::from_ref_time(73_601_000 as u64) + // Minimum execution time: 73_102 nanoseconds. + Weight::from_ref_time(73_902_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: OrmlTokens Accounts (r:2 w:2) // Storage: System Account (r:1 w:1) fn transfer_keep_alive_other() -> Weight { - // Minimum execution time: 78_001 nanoseconds. - Weight::from_ref_time(78_802_000 as u64) + // Minimum execution time: 78_502 nanoseconds. + Weight::from_ref_time(79_502_000 as u64) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } // Storage: System Account (r:1 w:1) fn transfer_all_native() -> Weight { - // Minimum execution time: 83_901 nanoseconds. - Weight::from_ref_time(85_301_000 as u64) + // Minimum execution time: 85_402 nanoseconds. + Weight::from_ref_time(86_102_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: OrmlTokens Accounts (r:2 w:2) // Storage: System Account (r:1 w:1) fn transfer_all_other() -> Weight { - // Minimum execution time: 88_401 nanoseconds. - Weight::from_ref_time(89_401_000 as u64) + // Minimum execution time: 90_302 nanoseconds. + Weight::from_ref_time(91_302_000 as u64) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } // Storage: System Account (r:1 w:1) fn force_transfer_native() -> Weight { - // Minimum execution time: 80_501 nanoseconds. - Weight::from_ref_time(81_402_000 as u64) + // Minimum execution time: 80_702 nanoseconds. + Weight::from_ref_time(82_502_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: OrmlTokens Accounts (r:2 w:2) // Storage: System Account (r:1 w:1) fn force_transfer_other() -> Weight { - // Minimum execution time: 84_001 nanoseconds. - Weight::from_ref_time(85_302_000 as u64) + // Minimum execution time: 85_402 nanoseconds. + Weight::from_ref_time(86_602_000 as u64) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } // Storage: System Account (r:1 w:1) fn set_balance_native() -> Weight { - // Minimum execution time: 82_701 nanoseconds. - Weight::from_ref_time(83_801_000 as u64) + // Minimum execution time: 83_602 nanoseconds. + Weight::from_ref_time(84_802_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } @@ -101,8 +101,8 @@ impl pallet_restricted_tokens::WeightInfo for WeightInf // Storage: OrmlTokens TotalIssuance (r:1 w:1) // Storage: System Account (r:1 w:1) fn set_balance_other() -> Weight { - // Minimum execution time: 94_102 nanoseconds. - Weight::from_ref_time(95_601_000 as u64) + // Minimum execution time: 96_203 nanoseconds. + Weight::from_ref_time(97_503_000 as u64) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } diff --git a/runtime/altair/src/weights/pallet_scheduler.rs b/runtime/altair/src/weights/pallet_scheduler.rs index de2cc0cd4d..a3b0be8992 100644 --- a/runtime/altair/src/weights/pallet_scheduler.rs +++ b/runtime/altair/src/weights/pallet_scheduler.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_scheduler` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-01-12, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-03-25, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("altair-dev"), DB CACHE: 1024 @@ -32,61 +32,61 @@ pub struct WeightInfo(PhantomData); impl pallet_scheduler::WeightInfo for WeightInfo { // Storage: Scheduler IncompleteSince (r:1 w:1) fn service_agendas_base() -> Weight { - // Minimum execution time: 8_700 nanoseconds. - Weight::from_ref_time(9_100_000 as u64) + // Minimum execution time: 8_900 nanoseconds. + Weight::from_ref_time(9_200_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Scheduler Agenda (r:1 w:1) /// The range of component `s` is `[0, 50]`. fn service_agenda_base(s: u32, ) -> Weight { - // Minimum execution time: 7_900 nanoseconds. - Weight::from_ref_time(15_416_320 as u64) - // Standard Error: 5_739 - .saturating_add(Weight::from_ref_time(1_066_497 as u64).saturating_mul(s as u64)) + // Minimum execution time: 8_100 nanoseconds. + Weight::from_ref_time(15_249_469 as u64) + // Standard Error: 4_436 + .saturating_add(Weight::from_ref_time(1_048_024 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } fn service_task_base() -> Weight { - // Minimum execution time: 18_801 nanoseconds. + // Minimum execution time: 19_200 nanoseconds. Weight::from_ref_time(19_501_000 as u64) } // Storage: Preimage PreimageFor (r:1 w:1) // Storage: Preimage StatusFor (r:1 w:1) /// The range of component `s` is `[128, 4194304]`. fn service_task_fetched(s: u32, ) -> Weight { - // Minimum execution time: 43_001 nanoseconds. - Weight::from_ref_time(43_601_000 as u64) - // Standard Error: 3 - .saturating_add(Weight::from_ref_time(1_653 as u64).saturating_mul(s as u64)) + // Minimum execution time: 43_901 nanoseconds. + Weight::from_ref_time(44_301_000 as u64) + // Standard Error: 4 + .saturating_add(Weight::from_ref_time(1_784 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } // Storage: Scheduler Lookup (r:0 w:1) fn service_task_named() -> Weight { - // Minimum execution time: 22_201 nanoseconds. - Weight::from_ref_time(22_600_000 as u64) + // Minimum execution time: 22_301 nanoseconds. + Weight::from_ref_time(22_701_000 as u64) .saturating_add(T::DbWeight::get().writes(1 as u64)) } fn service_task_periodic() -> Weight { - // Minimum execution time: 19_000 nanoseconds. - Weight::from_ref_time(19_600_000 as u64) + // Minimum execution time: 19_101 nanoseconds. + Weight::from_ref_time(19_601_000 as u64) } fn execute_dispatch_signed() -> Weight { - // Minimum execution time: 9_000 nanoseconds. - Weight::from_ref_time(9_500_000 as u64) + // Minimum execution time: 9_100 nanoseconds. + Weight::from_ref_time(9_300_000 as u64) } fn execute_dispatch_unsigned() -> Weight { - // Minimum execution time: 9_200 nanoseconds. - Weight::from_ref_time(12_500_000 as u64) + // Minimum execution time: 9_000 nanoseconds. + Weight::from_ref_time(9_201_000 as u64) } // Storage: Scheduler Agenda (r:1 w:1) /// The range of component `s` is `[0, 49]`. fn schedule(s: u32, ) -> Weight { - // Minimum execution time: 34_800 nanoseconds. - Weight::from_ref_time(44_075_716 as u64) - // Standard Error: 11_436 - .saturating_add(Weight::from_ref_time(1_063_194 as u64).saturating_mul(s as u64)) + // Minimum execution time: 35_101 nanoseconds. + Weight::from_ref_time(42_573_735 as u64) + // Standard Error: 7_228 + .saturating_add(Weight::from_ref_time(1_117_293 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } @@ -94,10 +94,10 @@ impl pallet_scheduler::WeightInfo for WeightInfo { // Storage: Scheduler Lookup (r:0 w:1) /// The range of component `s` is `[1, 50]`. fn cancel(s: u32, ) -> Weight { - // Minimum execution time: 39_400 nanoseconds. - Weight::from_ref_time(42_137_322 as u64) - // Standard Error: 7_277 - .saturating_add(Weight::from_ref_time(1_081_656 as u64).saturating_mul(s as u64)) + // Minimum execution time: 39_301 nanoseconds. + Weight::from_ref_time(42_269_884 as u64) + // Standard Error: 4_907 + .saturating_add(Weight::from_ref_time(1_089_577 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } @@ -105,10 +105,10 @@ impl pallet_scheduler::WeightInfo for WeightInfo { // Storage: Scheduler Agenda (r:1 w:1) /// The range of component `s` is `[0, 49]`. fn schedule_named(s: u32, ) -> Weight { - // Minimum execution time: 40_601 nanoseconds. - Weight::from_ref_time(49_338_917 as u64) - // Standard Error: 5_728 - .saturating_add(Weight::from_ref_time(1_141_599 as u64).saturating_mul(s as u64)) + // Minimum execution time: 41_101 nanoseconds. + Weight::from_ref_time(50_013_329 as u64) + // Standard Error: 7_601 + .saturating_add(Weight::from_ref_time(1_144_290 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } @@ -116,10 +116,10 @@ impl pallet_scheduler::WeightInfo for WeightInfo { // Storage: Scheduler Agenda (r:1 w:1) /// The range of component `s` is `[1, 50]`. fn cancel_named(s: u32, ) -> Weight { - // Minimum execution time: 41_901 nanoseconds. - Weight::from_ref_time(46_372_365 as u64) - // Standard Error: 8_636 - .saturating_add(Weight::from_ref_time(1_085_713 as u64).saturating_mul(s as u64)) + // Minimum execution time: 41_701 nanoseconds. + Weight::from_ref_time(45_862_629 as u64) + // Standard Error: 4_615 + .saturating_add(Weight::from_ref_time(1_109_979 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } diff --git a/runtime/altair/src/weights/pallet_timestamp.rs b/runtime/altair/src/weights/pallet_timestamp.rs index aaa6b072a1..65e16d2634 100644 --- a/runtime/altair/src/weights/pallet_timestamp.rs +++ b/runtime/altair/src/weights/pallet_timestamp.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_timestamp` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-01-12, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-03-25, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("altair-dev"), DB CACHE: 1024 @@ -33,8 +33,8 @@ impl pallet_timestamp::WeightInfo for WeightInfo { // Storage: Timestamp Now (r:1 w:1) // Storage: Aura CurrentSlot (r:1 w:0) fn set() -> Weight { - // Minimum execution time: 19_901 nanoseconds. - Weight::from_ref_time(20_601_000 as u64) + // Minimum execution time: 19_801 nanoseconds. + Weight::from_ref_time(20_401_000 as u64) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } diff --git a/runtime/altair/src/weights/pallet_treasury.rs b/runtime/altair/src/weights/pallet_treasury.rs index 9a00b634e9..10e161ed4e 100644 --- a/runtime/altair/src/weights/pallet_treasury.rs +++ b/runtime/altair/src/weights/pallet_treasury.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_treasury` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-01-12, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-03-25, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("altair-dev"), DB CACHE: 1024 @@ -37,16 +37,16 @@ impl pallet_treasury::WeightInfo for WeightInfo { // Storage: Treasury ProposalCount (r:1 w:1) // Storage: Treasury Proposals (r:0 w:1) fn propose_spend() -> Weight { - // Minimum execution time: 55_901 nanoseconds. - Weight::from_ref_time(56_601_000 as u64) + // Minimum execution time: 58_101 nanoseconds. + Weight::from_ref_time(58_702_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } // Storage: Treasury Proposals (r:1 w:1) // Storage: System Account (r:2 w:2) fn reject_proposal() -> Weight { - // Minimum execution time: 79_601 nanoseconds. - Weight::from_ref_time(80_402_000 as u64) + // Minimum execution time: 82_302 nanoseconds. + Weight::from_ref_time(83_002_000 as u64) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -54,17 +54,17 @@ impl pallet_treasury::WeightInfo for WeightInfo { // Storage: Treasury Approvals (r:1 w:1) /// The range of component `p` is `[0, 99]`. fn approve_proposal(p: u32, ) -> Weight { - // Minimum execution time: 22_300 nanoseconds. - Weight::from_ref_time(28_205_014 as u64) - // Standard Error: 2_772 - .saturating_add(Weight::from_ref_time(272_663 as u64).saturating_mul(p as u64)) + // Minimum execution time: 22_901 nanoseconds. + Weight::from_ref_time(29_503_189 as u64) + // Standard Error: 2_905 + .saturating_add(Weight::from_ref_time(272_683 as u64).saturating_mul(p as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Treasury Approvals (r:1 w:1) fn remove_approval() -> Weight { - // Minimum execution time: 18_400 nanoseconds. - Weight::from_ref_time(19_000_000 as u64) + // Minimum execution time: 19_200 nanoseconds. + Weight::from_ref_time(19_701_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } @@ -73,10 +73,10 @@ impl pallet_treasury::WeightInfo for WeightInfo { // Storage: Treasury Proposals (r:2 w:0) /// The range of component `p` is `[0, 100]`. fn on_initialize_proposals(p: u32, ) -> Weight { - // Minimum execution time: 51_600 nanoseconds. - Weight::from_ref_time(45_380_794 as u64) - // Standard Error: 7_202 - .saturating_add(Weight::from_ref_time(4_081_466 as u64).saturating_mul(p as u64)) + // Minimum execution time: 53_102 nanoseconds. + Weight::from_ref_time(47_642_425 as u64) + // Standard Error: 6_816 + .saturating_add(Weight::from_ref_time(4_184_504 as u64).saturating_mul(p as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().reads((1 as u64).saturating_mul(p as u64))) .saturating_add(T::DbWeight::get().writes(1 as u64)) diff --git a/runtime/altair/src/weights/pallet_uniques.rs b/runtime/altair/src/weights/pallet_uniques.rs index a67b5b4e3c..4c229bff74 100644 --- a/runtime/altair/src/weights/pallet_uniques.rs +++ b/runtime/altair/src/weights/pallet_uniques.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_uniques` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-01-12, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-03-25, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("altair-dev"), DB CACHE: 1024 @@ -33,16 +33,16 @@ impl pallet_uniques::WeightInfo for WeightInfo { // Storage: Uniques Class (r:1 w:1) // Storage: Uniques ClassAccount (r:0 w:1) fn create() -> Weight { - // Minimum execution time: 60_400 nanoseconds. - Weight::from_ref_time(79_801_000 as u64) + // Minimum execution time: 60_801 nanoseconds. + Weight::from_ref_time(61_701_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } // Storage: Uniques Class (r:1 w:1) // Storage: Uniques ClassAccount (r:0 w:1) fn force_create() -> Weight { - // Minimum execution time: 38_100 nanoseconds. - Weight::from_ref_time(38_600_000 as u64) + // Minimum execution time: 38_201 nanoseconds. + Weight::from_ref_time(39_000_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } @@ -58,14 +58,14 @@ impl pallet_uniques::WeightInfo for WeightInfo { /// The range of component `m` is `[0, 1000]`. /// The range of component `a` is `[0, 1000]`. fn destroy(n: u32, m: u32, a: u32, ) -> Weight { - // Minimum execution time: 4_160_259 nanoseconds. - Weight::from_ref_time(4_212_360_000 as u64) - // Standard Error: 48_841 - .saturating_add(Weight::from_ref_time(15_673_983 as u64).saturating_mul(n as u64)) - // Standard Error: 48_841 - .saturating_add(Weight::from_ref_time(449_762 as u64).saturating_mul(m as u64)) - // Standard Error: 48_841 - .saturating_add(Weight::from_ref_time(918_850 as u64).saturating_mul(a as u64)) + // Minimum execution time: 4_093_316 nanoseconds. + Weight::from_ref_time(4_170_418_000 as u64) + // Standard Error: 43_705 + .saturating_add(Weight::from_ref_time(15_285_586 as u64).saturating_mul(n as u64)) + // Standard Error: 43_705 + .saturating_add(Weight::from_ref_time(661_122 as u64).saturating_mul(m as u64)) + // Standard Error: 43_705 + .saturating_add(Weight::from_ref_time(802_145 as u64).saturating_mul(a as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().reads((1 as u64).saturating_mul(n as u64))) .saturating_add(T::DbWeight::get().writes(4 as u64)) @@ -78,8 +78,8 @@ impl pallet_uniques::WeightInfo for WeightInfo { // Storage: Uniques CollectionMaxSupply (r:1 w:0) // Storage: Uniques Account (r:0 w:1) fn mint() -> Weight { - // Minimum execution time: 73_701 nanoseconds. - Weight::from_ref_time(74_501_000 as u64) + // Minimum execution time: 68_602 nanoseconds. + Weight::from_ref_time(75_403_000 as u64) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -88,8 +88,8 @@ impl pallet_uniques::WeightInfo for WeightInfo { // Storage: Uniques Account (r:0 w:1) // Storage: Uniques ItemPriceOf (r:0 w:1) fn burn() -> Weight { - // Minimum execution time: 77_401 nanoseconds. - Weight::from_ref_time(78_301_000 as u64) + // Minimum execution time: 71_803 nanoseconds. + Weight::from_ref_time(78_503_000 as u64) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(4 as u64)) } @@ -98,8 +98,8 @@ impl pallet_uniques::WeightInfo for WeightInfo { // Storage: Uniques Account (r:0 w:2) // Storage: Uniques ItemPriceOf (r:0 w:1) fn transfer() -> Weight { - // Minimum execution time: 60_201 nanoseconds. - Weight::from_ref_time(61_100_000 as u64) + // Minimum execution time: 56_902 nanoseconds. + Weight::from_ref_time(61_403_000 as u64) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(4 as u64)) } @@ -107,10 +107,10 @@ impl pallet_uniques::WeightInfo for WeightInfo { // Storage: Uniques Asset (r:102 w:102) /// The range of component `i` is `[0, 5000]`. fn redeposit(i: u32, ) -> Weight { - // Minimum execution time: 38_900 nanoseconds. - Weight::from_ref_time(39_101_000 as u64) - // Standard Error: 16_293 - .saturating_add(Weight::from_ref_time(22_586_340 as u64).saturating_mul(i as u64)) + // Minimum execution time: 40_101 nanoseconds. + Weight::from_ref_time(40_901_000 as u64) + // Standard Error: 13_528 + .saturating_add(Weight::from_ref_time(22_150_632 as u64).saturating_mul(i as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().reads((1 as u64).saturating_mul(i as u64))) .saturating_add(T::DbWeight::get().writes(1 as u64)) @@ -119,30 +119,30 @@ impl pallet_uniques::WeightInfo for WeightInfo { // Storage: Uniques Asset (r:1 w:1) // Storage: Uniques Class (r:1 w:0) fn freeze() -> Weight { - // Minimum execution time: 45_901 nanoseconds. - Weight::from_ref_time(46_701_000 as u64) + // Minimum execution time: 45_800 nanoseconds. + Weight::from_ref_time(46_901_000 as u64) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Uniques Asset (r:1 w:1) // Storage: Uniques Class (r:1 w:0) fn thaw() -> Weight { - // Minimum execution time: 46_301 nanoseconds. - Weight::from_ref_time(46_900_000 as u64) + // Minimum execution time: 44_600 nanoseconds. + Weight::from_ref_time(46_400_000 as u64) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Uniques Class (r:1 w:1) fn freeze_collection() -> Weight { - // Minimum execution time: 37_600 nanoseconds. - Weight::from_ref_time(38_200_000 as u64) + // Minimum execution time: 34_600 nanoseconds. + Weight::from_ref_time(37_400_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Uniques Class (r:1 w:1) fn thaw_collection() -> Weight { - // Minimum execution time: 37_600 nanoseconds. - Weight::from_ref_time(38_400_000 as u64) + // Minimum execution time: 34_200 nanoseconds. + Weight::from_ref_time(37_001_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } @@ -150,23 +150,23 @@ impl pallet_uniques::WeightInfo for WeightInfo { // Storage: Uniques Class (r:1 w:1) // Storage: Uniques ClassAccount (r:0 w:2) fn transfer_ownership() -> Weight { - // Minimum execution time: 51_901 nanoseconds. - Weight::from_ref_time(52_501_000 as u64) + // Minimum execution time: 52_101 nanoseconds. + Weight::from_ref_time(53_101_000 as u64) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(4 as u64)) } // Storage: Uniques Class (r:1 w:1) fn set_team() -> Weight { - // Minimum execution time: 38_901 nanoseconds. - Weight::from_ref_time(39_201_000 as u64) + // Minimum execution time: 37_901 nanoseconds. + Weight::from_ref_time(39_500_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Uniques Class (r:1 w:1) // Storage: Uniques ClassAccount (r:0 w:1) fn force_item_status() -> Weight { - // Minimum execution time: 43_400 nanoseconds. - Weight::from_ref_time(43_901_000 as u64) + // Minimum execution time: 42_301 nanoseconds. + Weight::from_ref_time(43_701_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } @@ -174,8 +174,8 @@ impl pallet_uniques::WeightInfo for WeightInfo { // Storage: Uniques InstanceMetadataOf (r:1 w:0) // Storage: Uniques Attribute (r:1 w:1) fn set_attribute() -> Weight { - // Minimum execution time: 88_801 nanoseconds. - Weight::from_ref_time(89_301_000 as u64) + // Minimum execution time: 81_201 nanoseconds. + Weight::from_ref_time(88_701_000 as u64) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } @@ -183,79 +183,79 @@ impl pallet_uniques::WeightInfo for WeightInfo { // Storage: Uniques InstanceMetadataOf (r:1 w:0) // Storage: Uniques Attribute (r:1 w:1) fn clear_attribute() -> Weight { - // Minimum execution time: 87_101 nanoseconds. - Weight::from_ref_time(87_901_000 as u64) + // Minimum execution time: 80_702 nanoseconds. + Weight::from_ref_time(88_201_000 as u64) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } // Storage: Uniques Class (r:1 w:1) // Storage: Uniques InstanceMetadataOf (r:1 w:1) fn set_metadata() -> Weight { - // Minimum execution time: 69_000 nanoseconds. - Weight::from_ref_time(70_001_000 as u64) + // Minimum execution time: 62_901 nanoseconds. + Weight::from_ref_time(68_101_000 as u64) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } // Storage: Uniques Class (r:1 w:1) // Storage: Uniques InstanceMetadataOf (r:1 w:1) fn clear_metadata() -> Weight { - // Minimum execution time: 70_401 nanoseconds. - Weight::from_ref_time(71_700_000 as u64) + // Minimum execution time: 64_801 nanoseconds. + Weight::from_ref_time(70_701_000 as u64) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } // Storage: Uniques Class (r:1 w:1) // Storage: Uniques ClassMetadataOf (r:1 w:1) fn set_collection_metadata() -> Weight { - // Minimum execution time: 67_400 nanoseconds. - Weight::from_ref_time(68_001_000 as u64) + // Minimum execution time: 61_201 nanoseconds. + Weight::from_ref_time(67_401_000 as u64) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } // Storage: Uniques Class (r:1 w:0) // Storage: Uniques ClassMetadataOf (r:1 w:1) fn clear_collection_metadata() -> Weight { - // Minimum execution time: 65_601 nanoseconds. - Weight::from_ref_time(66_401_000 as u64) + // Minimum execution time: 59_601 nanoseconds. + Weight::from_ref_time(65_201_000 as u64) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Uniques Class (r:1 w:0) // Storage: Uniques Asset (r:1 w:1) fn approve_transfer() -> Weight { - // Minimum execution time: 47_801 nanoseconds. - Weight::from_ref_time(48_401_000 as u64) + // Minimum execution time: 44_701 nanoseconds. + Weight::from_ref_time(47_801_000 as u64) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Uniques Class (r:1 w:0) // Storage: Uniques Asset (r:1 w:1) fn cancel_approval() -> Weight { - // Minimum execution time: 47_500 nanoseconds. - Weight::from_ref_time(48_201_000 as u64) + // Minimum execution time: 44_400 nanoseconds. + Weight::from_ref_time(48_401_000 as u64) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Uniques OwnershipAcceptance (r:1 w:1) fn set_accept_ownership() -> Weight { - // Minimum execution time: 43_901 nanoseconds. - Weight::from_ref_time(44_701_000 as u64) + // Minimum execution time: 44_001 nanoseconds. + Weight::from_ref_time(44_401_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Uniques CollectionMaxSupply (r:1 w:1) // Storage: Uniques Class (r:1 w:0) fn set_collection_max_supply() -> Weight { - // Minimum execution time: 41_901 nanoseconds. - Weight::from_ref_time(44_700_000 as u64) + // Minimum execution time: 38_301 nanoseconds. + Weight::from_ref_time(40_701_000 as u64) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Uniques Asset (r:1 w:0) // Storage: Uniques ItemPriceOf (r:0 w:1) fn set_price() -> Weight { - // Minimum execution time: 42_600 nanoseconds. - Weight::from_ref_time(43_300_000 as u64) + // Minimum execution time: 42_000 nanoseconds. + Weight::from_ref_time(42_701_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } @@ -264,8 +264,8 @@ impl pallet_uniques::WeightInfo for WeightInfo { // Storage: Uniques Class (r:1 w:0) // Storage: Uniques Account (r:0 w:2) fn buy_item() -> Weight { - // Minimum execution time: 80_401 nanoseconds. - Weight::from_ref_time(81_401_000 as u64) + // Minimum execution time: 75_001 nanoseconds. + Weight::from_ref_time(81_701_000 as u64) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(4 as u64)) } diff --git a/runtime/altair/src/weights/pallet_utility.rs b/runtime/altair/src/weights/pallet_utility.rs index bf6abd1407..eec4a970c6 100644 --- a/runtime/altair/src/weights/pallet_utility.rs +++ b/runtime/altair/src/weights/pallet_utility.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_utility` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-01-12, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-03-25, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("altair-dev"), DB CACHE: 1024 @@ -32,31 +32,31 @@ pub struct WeightInfo(PhantomData); impl pallet_utility::WeightInfo for WeightInfo { /// The range of component `c` is `[0, 1000]`. fn batch(c: u32, ) -> Weight { - // Minimum execution time: 24_400 nanoseconds. - Weight::from_ref_time(33_647_204 as u64) - // Standard Error: 3_603 - .saturating_add(Weight::from_ref_time(8_521_381 as u64).saturating_mul(c as u64)) + // Minimum execution time: 24_500 nanoseconds. + Weight::from_ref_time(31_790_295 as u64) + // Standard Error: 4_714 + .saturating_add(Weight::from_ref_time(8_393_577 as u64).saturating_mul(c as u64)) } fn as_derivative() -> Weight { - // Minimum execution time: 14_000 nanoseconds. - Weight::from_ref_time(14_400_000 as u64) + // Minimum execution time: 13_600 nanoseconds. + Weight::from_ref_time(14_200_000 as u64) } /// The range of component `c` is `[0, 1000]`. fn batch_all(c: u32, ) -> Weight { - // Minimum execution time: 24_000 nanoseconds. - Weight::from_ref_time(38_979_775 as u64) - // Standard Error: 3_428 - .saturating_add(Weight::from_ref_time(8_826_788 as u64).saturating_mul(c as u64)) + // Minimum execution time: 24_200 nanoseconds. + Weight::from_ref_time(48_838_111 as u64) + // Standard Error: 5_234 + .saturating_add(Weight::from_ref_time(8_685_737 as u64).saturating_mul(c as u64)) } fn dispatch_as() -> Weight { - // Minimum execution time: 28_700 nanoseconds. - Weight::from_ref_time(29_600_000 as u64) + // Minimum execution time: 38_800 nanoseconds. + Weight::from_ref_time(39_500_000 as u64) } /// The range of component `c` is `[0, 1000]`. fn force_batch(c: u32, ) -> Weight { - // Minimum execution time: 23_901 nanoseconds. - Weight::from_ref_time(38_721_193 as u64) - // Standard Error: 3_414 - .saturating_add(Weight::from_ref_time(8_480_455 as u64).saturating_mul(c as u64)) + // Minimum execution time: 24_800 nanoseconds. + Weight::from_ref_time(60_768_278 as u64) + // Standard Error: 6_273 + .saturating_add(Weight::from_ref_time(8_305_554 as u64).saturating_mul(c as u64)) } } diff --git a/runtime/altair/src/weights/pallet_vesting.rs b/runtime/altair/src/weights/pallet_vesting.rs index 7dd2212944..3ec3982c50 100644 --- a/runtime/altair/src/weights/pallet_vesting.rs +++ b/runtime/altair/src/weights/pallet_vesting.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_vesting` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-01-12, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-03-25, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("altair-dev"), DB CACHE: 1024 @@ -35,12 +35,12 @@ impl pallet_vesting::WeightInfo for WeightInfo { /// The range of component `l` is `[0, 49]`. /// The range of component `s` is `[1, 28]`. fn vest_locked(l: u32, s: u32, ) -> Weight { - // Minimum execution time: 74_601 nanoseconds. - Weight::from_ref_time(73_195_140 as u64) - // Standard Error: 2_462 - .saturating_add(Weight::from_ref_time(96_479 as u64).saturating_mul(l as u64)) - // Standard Error: 4_380 - .saturating_add(Weight::from_ref_time(106_962 as u64).saturating_mul(s as u64)) + // Minimum execution time: 70_002 nanoseconds. + Weight::from_ref_time(73_148_294 as u64) + // Standard Error: 3_376 + .saturating_add(Weight::from_ref_time(104_831 as u64).saturating_mul(l as u64)) + // Standard Error: 6_006 + .saturating_add(Weight::from_ref_time(143_955 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } @@ -49,12 +49,12 @@ impl pallet_vesting::WeightInfo for WeightInfo { /// The range of component `l` is `[0, 49]`. /// The range of component `s` is `[1, 28]`. fn vest_unlocked(l: u32, s: u32, ) -> Weight { - // Minimum execution time: 72_901 nanoseconds. - Weight::from_ref_time(72_852_219 as u64) - // Standard Error: 3_108 - .saturating_add(Weight::from_ref_time(73_341 as u64).saturating_mul(l as u64)) - // Standard Error: 5_530 - .saturating_add(Weight::from_ref_time(80_398 as u64).saturating_mul(s as u64)) + // Minimum execution time: 68_001 nanoseconds. + Weight::from_ref_time(73_811_676 as u64) + // Standard Error: 3_910 + .saturating_add(Weight::from_ref_time(78_301 as u64).saturating_mul(l as u64)) + // Standard Error: 6_958 + .saturating_add(Weight::from_ref_time(56_165 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } @@ -64,12 +64,12 @@ impl pallet_vesting::WeightInfo for WeightInfo { /// The range of component `l` is `[0, 49]`. /// The range of component `s` is `[1, 28]`. fn vest_other_locked(l: u32, s: u32, ) -> Weight { - // Minimum execution time: 72_301 nanoseconds. - Weight::from_ref_time(71_799_715 as u64) - // Standard Error: 7_519 - .saturating_add(Weight::from_ref_time(118_280 as u64).saturating_mul(l as u64)) - // Standard Error: 13_378 - .saturating_add(Weight::from_ref_time(112_520 as u64).saturating_mul(s as u64)) + // Minimum execution time: 69_601 nanoseconds. + Weight::from_ref_time(73_111_484 as u64) + // Standard Error: 3_124 + .saturating_add(Weight::from_ref_time(90_194 as u64).saturating_mul(l as u64)) + // Standard Error: 5_558 + .saturating_add(Weight::from_ref_time(121_007 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -79,12 +79,12 @@ impl pallet_vesting::WeightInfo for WeightInfo { /// The range of component `l` is `[0, 49]`. /// The range of component `s` is `[1, 28]`. fn vest_other_unlocked(l: u32, s: u32, ) -> Weight { - // Minimum execution time: 71_701 nanoseconds. - Weight::from_ref_time(71_864_532 as u64) - // Standard Error: 2_377 - .saturating_add(Weight::from_ref_time(78_878 as u64).saturating_mul(l as u64)) - // Standard Error: 4_230 - .saturating_add(Weight::from_ref_time(70_103 as u64).saturating_mul(s as u64)) + // Minimum execution time: 69_101 nanoseconds. + Weight::from_ref_time(72_731_407 as u64) + // Standard Error: 2_968 + .saturating_add(Weight::from_ref_time(77_466 as u64).saturating_mul(l as u64)) + // Standard Error: 5_281 + .saturating_add(Weight::from_ref_time(71_742 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -94,12 +94,12 @@ impl pallet_vesting::WeightInfo for WeightInfo { /// The range of component `l` is `[0, 49]`. /// The range of component `s` is `[0, 27]`. fn vested_transfer(l: u32, s: u32, ) -> Weight { - // Minimum execution time: 103_301 nanoseconds. - Weight::from_ref_time(104_808_264 as u64) - // Standard Error: 4_841 - .saturating_add(Weight::from_ref_time(80_808 as u64).saturating_mul(l as u64)) - // Standard Error: 8_614 - .saturating_add(Weight::from_ref_time(43_341 as u64).saturating_mul(s as u64)) + // Minimum execution time: 96_201 nanoseconds. + Weight::from_ref_time(106_121_673 as u64) + // Standard Error: 6_336 + .saturating_add(Weight::from_ref_time(86_143 as u64).saturating_mul(l as u64)) + // Standard Error: 11_274 + .saturating_add(Weight::from_ref_time(41_741 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -109,12 +109,12 @@ impl pallet_vesting::WeightInfo for WeightInfo { /// The range of component `l` is `[0, 49]`. /// The range of component `s` is `[0, 27]`. fn force_vested_transfer(l: u32, s: u32, ) -> Weight { - // Minimum execution time: 101_702 nanoseconds. - Weight::from_ref_time(103_240_863 as u64) - // Standard Error: 4_656 - .saturating_add(Weight::from_ref_time(74_105 as u64).saturating_mul(l as u64)) - // Standard Error: 8_284 - .saturating_add(Weight::from_ref_time(53_710 as u64).saturating_mul(s as u64)) + // Minimum execution time: 96_002 nanoseconds. + Weight::from_ref_time(104_211_765 as u64) + // Standard Error: 13_747 + .saturating_add(Weight::from_ref_time(108_418 as u64).saturating_mul(l as u64)) + // Standard Error: 24_459 + .saturating_add(Weight::from_ref_time(68_043 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(4 as u64)) .saturating_add(T::DbWeight::get().writes(4 as u64)) } @@ -124,12 +124,12 @@ impl pallet_vesting::WeightInfo for WeightInfo { /// The range of component `l` is `[0, 49]`. /// The range of component `s` is `[2, 28]`. fn not_unlocking_merge_schedules(l: u32, s: u32, ) -> Weight { - // Minimum execution time: 76_201 nanoseconds. - Weight::from_ref_time(75_182_142 as u64) - // Standard Error: 3_901 - .saturating_add(Weight::from_ref_time(89_328 as u64).saturating_mul(l as u64)) - // Standard Error: 7_204 - .saturating_add(Weight::from_ref_time(105_564 as u64).saturating_mul(s as u64)) + // Minimum execution time: 72_201 nanoseconds. + Weight::from_ref_time(76_321_122 as u64) + // Standard Error: 2_965 + .saturating_add(Weight::from_ref_time(85_708 as u64).saturating_mul(l as u64)) + // Standard Error: 5_475 + .saturating_add(Weight::from_ref_time(94_325 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -139,12 +139,12 @@ impl pallet_vesting::WeightInfo for WeightInfo { /// The range of component `l` is `[0, 49]`. /// The range of component `s` is `[2, 28]`. fn unlocking_merge_schedules(l: u32, s: u32, ) -> Weight { - // Minimum execution time: 74_901 nanoseconds. - Weight::from_ref_time(74_190_043 as u64) - // Standard Error: 1_789 - .saturating_add(Weight::from_ref_time(102_421 as u64).saturating_mul(l as u64)) - // Standard Error: 3_304 - .saturating_add(Weight::from_ref_time(115_837 as u64).saturating_mul(s as u64)) + // Minimum execution time: 70_601 nanoseconds. + Weight::from_ref_time(75_329_870 as u64) + // Standard Error: 2_816 + .saturating_add(Weight::from_ref_time(92_803 as u64).saturating_mul(l as u64)) + // Standard Error: 5_200 + .saturating_add(Weight::from_ref_time(122_179 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } From 093c9c47c1d6bec4e9e5947fbb88cb2e21e35126 Mon Sep 17 00:00:00 2001 From: mustermeiszer Date: Tue, 28 Mar 2023 09:04:50 +0200 Subject: [PATCH 45/55] fix: use weights, adapt comments --- runtime/centrifuge/src/lib.rs | 25 ++++++++++++++++++++----- 1 file changed, 20 insertions(+), 5 deletions(-) diff --git a/runtime/centrifuge/src/lib.rs b/runtime/centrifuge/src/lib.rs index 84113657c6..8f06515c4e 100644 --- a/runtime/centrifuge/src/lib.rs +++ b/runtime/centrifuge/src/lib.rs @@ -311,7 +311,7 @@ impl pallet_restricted_tokens::Config for Runtime { type PreFungiblesTransfer = cfg_traits::Always; type PreReservableCurrency = cfg_traits::Always; type RuntimeEvent = RuntimeEvent; - type WeightInfo = (); + type WeightInfo = weights::pallet_restricted_tokens::WeightInfo; } pub struct RestrictedTokens

(PhantomData

); @@ -778,7 +778,6 @@ parameter_types! { // Make sure that there are no more than `MAX_MEMBERS` members elected via elections-phragmen. const_assert!(DesiredMembers::get() <= CouncilMaxMembers::get()); -// TODO: Can we remove phragmen? impl pallet_elections_phragmen::Config for Runtime { /// How much should be locked up in order to submit one's candidacy. type CandidacyBond = CandidacyBond; @@ -1008,6 +1007,9 @@ impl pallet_nft::Config for Runtime { type NftProofValidationFeeKey = NftProofValidationFeeKey; type ResourceHashId = ResourceHashId; type RuntimeEvent = RuntimeEvent; + // NOTE: No benchmarks available. + // BUT will be deprecated once Tinlake + // is wind down. type WeightInfo = (); } @@ -1024,6 +1026,10 @@ impl pallet_bridge::Config for Runtime { type NativeTokenId = NativeTokenId; type NativeTokenTransferFeeKey = NativeTokenTransferFeeKey; type RuntimeEvent = RuntimeEvent; + // NOTE: No benchmarks available. + // Might need to do that if we + // extend the bridge usage + // For not fine. type WeightInfo = (); } @@ -1044,7 +1050,10 @@ impl chainbridge::Config for Runtime { type ProposalLifetime = ProposalLifetime; type RelayerVoteThreshold = RelayerVoteThreshold; type RuntimeEvent = RuntimeEvent; - // TODO: Fix benchmarks + // NOTE: No benchmarks available. + // External pallet, we use a fork of. + // If we extend using this bridge + // we need to write appropriate benches. type WeightInfo = (); } @@ -1061,6 +1070,9 @@ impl pallet_claims::Config for Runtime { type MinimalPayoutAmount = MinimalPayoutAmount; type PalletId = ClaimsPalletId; type RuntimeEvent = RuntimeEvent; + // NOTE: No benchmarks available. + // BUT will be deprecated once Tinlake + // is wind down. type WeightInfo = (); } @@ -1451,6 +1463,10 @@ impl pallet_investments::Config for Runtime { type PreConditions = IsTrancheInvestor; type RuntimeEvent = RuntimeEvent; type Tokens = Tokens; + // TODO: Fix benchmarks + // + // NOTE: Fixed weights are really high and + // cover worst case, but are inefficient. type WeightInfo = (); } @@ -1607,10 +1623,9 @@ construct_runtime!( OrmlXcm: orml_xcm::{Pallet, Storage, Call, Event} = 153, // Synced pallets across all runtimes - Range: 180-240 - // WHY: * integrations liek fireblocks will need to know the index in the enum + // WHY: * integrations like fireblocks will need to know the index in the enum // * makes it easier, without parsing complete metadata // * makes it in-sync for XCM integrations -- same enum variant again - // TODO: Research how to change this in Altair... PoolRegistry: pallet_pool_registry::{Pallet, Call, Storage, Event} = 180, PoolSystem: pallet_pool_system::{Pallet, Call, Storage, Event} = 181, Permissions: pallet_permissions::{Pallet, Call, Storage, Event} = 182, From 5b5493439e853233bd9affe315f010891932dc0a Mon Sep 17 00:00:00 2001 From: mustermeiszer Date: Tue, 28 Mar 2023 09:55:20 +0200 Subject: [PATCH 46/55] fix: only signed origin in registry benches --- pallets/pool-registry/src/benchmarking.rs | 6 +++++- runtime/altair/src/lib.rs | 11 ++--------- runtime/centrifuge/src/lib.rs | 15 ++++----------- 3 files changed, 11 insertions(+), 21 deletions(-) diff --git a/pallets/pool-registry/src/benchmarking.rs b/pallets/pool-registry/src/benchmarking.rs index 4284b1fb75..f660d484cf 100644 --- a/pallets/pool-registry/src/benchmarking.rs +++ b/pallets/pool-registry/src/benchmarking.rs @@ -88,7 +88,11 @@ benchmarks! { let n in 1..::MaxTranches::get(); let caller: ::AccountId = create_admin::(0); let tranches = build_bench_input_tranches::(n); - let origin = RawOrigin::Signed(caller.clone()); + let origin = if let Ok(_) = ::PoolCreateOrigin::try_origin(RawOrigin::Signed(caller.clone()).into()) { + RawOrigin::Signed(caller.clone()) + } else { + RawOrigin::Root + }; prepare_asset_registry::(); }: register(origin, caller, POOL, tranches.clone(), CurrencyId::AUSD, MAX_RESERVE, None) verify { diff --git a/runtime/altair/src/lib.rs b/runtime/altair/src/lib.rs index 4578feda97..28e868914f 100644 --- a/runtime/altair/src/lib.rs +++ b/runtime/altair/src/lib.rs @@ -1166,13 +1166,6 @@ parameter_types! { pub const PoolDeposit: Balance = 0; } -// The pool benchmarks can't handle a required root origin (yet). -// TODO: Fix those benchmarks and remove this -#[cfg(not(feature = "runtime-benchmarks"))] -type PoolCreateOrigin = EnsureRoot; -#[cfg(feature = "runtime-benchmarks")] -type PoolCreateOrigin = EnsureSigned; - impl pallet_pool_system::Config for Runtime { type AssetRegistry = OrmlAssetRegistry; type Balance = Balance; @@ -1196,7 +1189,7 @@ impl pallet_pool_system::Config for Runtime { type PalletIndex = PoolPalletIndex; type ParachainId = ParachainInfo; type Permission = Permissions; - type PoolCreateOrigin = PoolCreateOrigin; + type PoolCreateOrigin = EnsureRoot; type PoolCurrency = PoolCurrency; type PoolDeposit = PoolDeposit; type PoolId = PoolId; @@ -1221,7 +1214,7 @@ impl pallet_pool_registry::Config for Runtime { type MaxTranches = MaxTranches; type ModifyPool = pallet_pool_system::Pallet; type Permission = Permissions; - type PoolCreateOrigin = PoolCreateOrigin; + type PoolCreateOrigin = EnsureRoot; type PoolId = PoolId; type Rate = Rate; type RuntimeEvent = RuntimeEvent; diff --git a/runtime/centrifuge/src/lib.rs b/runtime/centrifuge/src/lib.rs index 8f06515c4e..6258f5db8a 100644 --- a/runtime/centrifuge/src/lib.rs +++ b/runtime/centrifuge/src/lib.rs @@ -803,7 +803,9 @@ impl pallet_elections_phragmen::Config for Runtime { type VotingBondBase = VotingBondBase; /// How much should be locked up in order to be able to submit votes. type VotingBondFactor = VotingBond; - type WeightInfo = pallet_elections_phragmen::weights::SubstrateWeight; + // NOTE: Benchmarks are failing with + // "Error: Input("failed to submit candidacy")" + type WeightInfo = (); } parameter_types! { @@ -1268,13 +1270,6 @@ impl PoolUpdateGuard for UpdateGuard { } } -// The pool benchmarks can't handle a required root origin (yet). -// TODO: Fix those benchmarks and remove this -#[cfg(not(feature = "runtime-benchmarks"))] -type PoolCreateOrigin = EnsureRoot; -#[cfg(feature = "runtime-benchmarks")] -type PoolCreateOrigin = EnsureSigned; - impl pallet_pool_registry::Config for Runtime { type Balance = Balance; type CurrencyId = CurrencyId; @@ -1285,7 +1280,7 @@ impl pallet_pool_registry::Config for Runtime { type MaxTranches = MaxTranches; type ModifyPool = pallet_pool_system::Pallet; type Permission = Permissions; - type PoolCreateOrigin = PoolCreateOrigin; + type PoolCreateOrigin = EnsureRoot; type PoolId = PoolId; type Rate = Rate; type RuntimeEvent = RuntimeEvent; @@ -1312,7 +1307,6 @@ impl pallet_pool_system::Config for Runtime { type MinEpochTimeUpperBound = MinEpochTimeUpperBound; type MinUpdateDelay = MinUpdateDelay; type NAV = Loans; - // TODO: Add actual pallet-loans, after https://github.com/centrifuge/centrifuge-chain/pull/1180 is merged type PalletId = PoolPalletId; type PalletIndex = PoolPalletIndex; type ParachainId = ParachainInfo; @@ -1481,7 +1475,6 @@ impl pallet_interest_accrual::Config for Runtime { } parameter_types! { - pub const LoansPalletId: PalletId = cfg_types::ids::LOANS_PALLET_ID; pub const MaxActiveLoansPerPool: u32 = 1000; pub const MaxWriteOffPolicySize: u32 = 100; } From a862e54e0ce0127db4121ba87d5abd21f5de1a13 Mon Sep 17 00:00:00 2001 From: mustermeiszer Date: Tue, 28 Mar 2023 09:57:11 +0200 Subject: [PATCH 47/55] feat: Pump version number Centrifuge --- runtime/centrifuge/src/lib.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/runtime/centrifuge/src/lib.rs b/runtime/centrifuge/src/lib.rs index 6258f5db8a..949c9e11e2 100644 --- a/runtime/centrifuge/src/lib.rs +++ b/runtime/centrifuge/src/lib.rs @@ -117,7 +117,7 @@ pub const VERSION: RuntimeVersion = RuntimeVersion { spec_name: create_runtime_str!("centrifuge_1018_v1"), impl_name: create_runtime_str!("centrifuge"), authoring_version: 1, - spec_version: 1017, + spec_version: 1018, impl_version: 1, #[cfg(not(feature = "disable-runtime-api"))] apis: RUNTIME_API_VERSIONS, From 94a38f4e3b4eca3b3328e1f87f961cbb745dfd23 Mon Sep 17 00:00:00 2001 From: mustermeiszer Date: Tue, 28 Mar 2023 11:22:51 +0200 Subject: [PATCH 48/55] Update Cargo.toml centrifuge --- runtime/centrifuge/Cargo.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/runtime/centrifuge/Cargo.toml b/runtime/centrifuge/Cargo.toml index de49f4b477..ba5be35aa7 100644 --- a/runtime/centrifuge/Cargo.toml +++ b/runtime/centrifuge/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "centrifuge-runtime" -version = "0.10.17" +version = "0.10.18" authors = ["Centrifuge "] edition = "2021" build = "build.rs" From 5663eb6488dc26802e8b3d487cf6d2e96b47f414 Mon Sep 17 00:00:00 2001 From: William Freudenberger Date: Tue, 28 Mar 2023 17:12:11 +0200 Subject: [PATCH 49/55] fix: remarks from review --- Cargo.lock | 2 +- pallets/interest-accrual/src/migrations.rs | 17 +++++++++++++++++ runtime/altair/src/lib.rs | 2 +- runtime/centrifuge/src/lib.rs | 11 ++++++----- runtime/development/src/lib.rs | 2 +- 5 files changed, 26 insertions(+), 8 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 3249eada4b..dcd68d3d32 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -961,7 +961,7 @@ dependencies = [ [[package]] name = "centrifuge-runtime" -version = "0.10.17" +version = "0.10.18" dependencies = [ "cfg-primitives", "cfg-traits", diff --git a/pallets/interest-accrual/src/migrations.rs b/pallets/interest-accrual/src/migrations.rs index f18bbea142..c076379e6e 100644 --- a/pallets/interest-accrual/src/migrations.rs +++ b/pallets/interest-accrual/src/migrations.rs @@ -110,6 +110,23 @@ pub mod v2 { } } +pub mod centrifuge { + use super::*; + + pub struct SetStorageVersionToV2(sp_std::marker::PhantomData); + + impl OnRuntimeUpgrade for SetStorageVersionToV2 { + fn on_runtime_upgrade() -> Weight { + if StorageVersion::::get() != Release::V2 { + StorageVersion::::set(Release::V2); + T::DbWeight::get().reads_writes(1, 1) + } else { + T::DbWeight::get().reads(1) + } + } + } +} + #[cfg(test)] mod test { use super::*; diff --git a/runtime/altair/src/lib.rs b/runtime/altair/src/lib.rs index 28e868914f..50e5c62952 100644 --- a/runtime/altair/src/lib.rs +++ b/runtime/altair/src/lib.rs @@ -1330,7 +1330,7 @@ impl pallet_investments::Config for Runtime { } /// Checks whether the given `who` has the role -/// of a `TrancehInvestor` for the given pool. +/// of a `TrancheInvestor` for the given pool. pub struct IsTrancheInvestor(PhantomData<(P, T)>); impl< P: PermissionsT, Role = Role>, diff --git a/runtime/centrifuge/src/lib.rs b/runtime/centrifuge/src/lib.rs index 949c9e11e2..e4bfc4721d 100644 --- a/runtime/centrifuge/src/lib.rs +++ b/runtime/centrifuge/src/lib.rs @@ -114,7 +114,7 @@ impl_opaque_keys! { /// Runtime version. #[sp_version::runtime_version] pub const VERSION: RuntimeVersion = RuntimeVersion { - spec_name: create_runtime_str!("centrifuge_1018_v1"), + spec_name: create_runtime_str!("centrifuge"), impl_name: create_runtime_str!("centrifuge"), authoring_version: 1, spec_version: 1018, @@ -1399,7 +1399,7 @@ parameter_types! { } /// Checks whether the given `who` has the role -/// of a `TrancehInvestor` for the given pool. +/// of a `TrancheInvestor` for the given pool. pub struct IsTrancheInvestor(PhantomData<(P, T)>); impl< P: PermissionsT, Role = Role>, @@ -1516,13 +1516,13 @@ parameter_types! { // per byte deposit is 0.01 CFG pub const DepositPerByte: Balance = 1 * CENTI_CFG; // Base deposit to add attribute is 0.1 CFG - pub const AttributeDepositBase: Balance = 1 * CENTI_CFG; + pub const AttributeDepositBase: Balance = 10 * CENTI_CFG; // Base deposit to add metadata is 0.1 CFG - pub const MetadataDepositBase: Balance = 1 * CENTI_CFG; + pub const MetadataDepositBase: Balance = 10 * CENTI_CFG; // Deposit to create a class is 100 CFG pub const CollectionDeposit: Balance = 100 * CFG; // Deposit to create a class is 0.1 CFG - pub const ItemDeposit: Balance = 1 * CENTI_CFG; + pub const ItemDeposit: Balance = 10 * CENTI_CFG; // Maximum limit of bytes for Metadata, Attribute key and Value pub const Limit: u32 = 256; } @@ -1665,6 +1665,7 @@ pub type Executive = frame_executive::Executive< pallet_preimage::migration::v1::Migration, pallet_democracy::migrations::v1::Migration, pallet_scheduler::migration::v3::MigrateToV4, + pallet_interest_accrual::migrations::centrifuge::SetStorageVersionToV2, ), >; diff --git a/runtime/development/src/lib.rs b/runtime/development/src/lib.rs index a54f316c87..1e7a3028b0 100644 --- a/runtime/development/src/lib.rs +++ b/runtime/development/src/lib.rs @@ -1567,7 +1567,7 @@ impl pallet_investments::Config for Runtime { } /// Checks whether the given `who` has the role -/// of a `TrancehInvestor` for the given pool. +/// of a `TrancheInvestor` for the given pool. pub struct IsTrancheInvestor(PhantomData<(P, T)>); impl< P: PermissionsT, Role = Role>, From ff1f281c18ac1490be4bb27a631303b565da8aac Mon Sep 17 00:00:00 2001 From: William Freudenberger Date: Tue, 28 Mar 2023 17:17:22 +0200 Subject: [PATCH 50/55] chore: bump nix --- flake.nix | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/flake.nix b/flake.nix index 86fbad0bd6..080bf0a0cb 100644 --- a/flake.nix +++ b/flake.nix @@ -93,7 +93,7 @@ }; # This is a hash of all the Cargo dependencies, for reproducibility. - cargoSha256 = "sha256-Q29cYuepnB3LxOSSwzxhnn+yxm+hLxOH5t8N645J0f4="; + cargoSha256 = "sha256-DQcJ7D7n4qzE2Xy3a322x/sSKrbRtS+Bw6h0k5SomC8=="; nativeBuildInputs = with pkgs; [ clang git-mock pkg-config ]; buildInputs = with pkgs; [ openssl ] ++ ( From c02892fe318acb9d5e0a17d365baf8a3ed280bd2 Mon Sep 17 00:00:00 2001 From: William Freudenberger Date: Tue, 28 Mar 2023 17:23:11 +0200 Subject: [PATCH 51/55] fix: enable phrag elec benches in cfg runtime --- runtime/centrifuge/src/lib.rs | 2 ++ 1 file changed, 2 insertions(+) diff --git a/runtime/centrifuge/src/lib.rs b/runtime/centrifuge/src/lib.rs index e4bfc4721d..16cce7ca1d 100644 --- a/runtime/centrifuge/src/lib.rs +++ b/runtime/centrifuge/src/lib.rs @@ -1856,6 +1856,7 @@ impl_runtime_apis! { list_benchmark!(list, extra, pallet_scheduler, Scheduler); list_benchmark!(list, extra, pallet_collective, Council); list_benchmark!(list, extra, pallet_democracy, Democracy); + list_benchmark!(list, extra, pallet_elections_phragmen, Elections); list_benchmark!(list, extra, pallet_identity, Identity); list_benchmark!(list, extra, pallet_vesting, Vesting); list_benchmark!(list, extra, pallet_treasury, Treasury); @@ -1919,6 +1920,7 @@ impl_runtime_apis! { add_benchmark!(params, batches, pallet_scheduler, Scheduler); add_benchmark!(params, batches, pallet_collective, Council); add_benchmark!(params, batches, pallet_democracy, Democracy); + add_benchmark!(params, batches, pallet_elections_phragmen, Elections); add_benchmark!(params, batches, pallet_identity, Identity); add_benchmark!(params, batches, pallet_vesting, Vesting); add_benchmark!(params, batches, pallet_treasury, Treasury); From d761ad4f5d8dfdb05b58915ae58eacdc638956ad Mon Sep 17 00:00:00 2001 From: mustermeiszer Date: Tue, 4 Apr 2023 09:17:49 +0200 Subject: [PATCH 52/55] fix: remove old migrations, default to V2 interest accrual --- pallets/interest-accrual/src/lib.rs | 2 +- runtime/centrifuge/src/lib.rs | 7 ------- 2 files changed, 1 insertion(+), 8 deletions(-) diff --git a/pallets/interest-accrual/src/lib.rs b/pallets/interest-accrual/src/lib.rs index a5907c9626..50aa589b98 100644 --- a/pallets/interest-accrual/src/lib.rs +++ b/pallets/interest-accrual/src/lib.rs @@ -182,7 +182,7 @@ pub enum Release { impl Default for Release { fn default() -> Self { - Self::V0 + Self::V2 } } diff --git a/runtime/centrifuge/src/lib.rs b/runtime/centrifuge/src/lib.rs index 16cce7ca1d..31786303c4 100644 --- a/runtime/centrifuge/src/lib.rs +++ b/runtime/centrifuge/src/lib.rs @@ -1660,13 +1660,6 @@ pub type Executive = frame_executive::Executive< frame_system::ChainContext, Runtime, AllPalletsWithSystem, - ( - pallet_multisig::migrations::v1::MigrateToV1, - pallet_preimage::migration::v1::Migration, - pallet_democracy::migrations::v1::Migration, - pallet_scheduler::migration::v3::MigrateToV4, - pallet_interest_accrual::migrations::centrifuge::SetStorageVersionToV2, - ), >; #[cfg(not(feature = "disable-runtime-api"))] From 02d3334f70bbe063207b1bacccf5a6dd0a27a3c5 Mon Sep 17 00:00:00 2001 From: mustermeiszer Date: Tue, 4 Apr 2023 09:29:42 +0200 Subject: [PATCH 53/55] fix: typos, use dummy weight phragmen, prepare for bench --- runtime/centrifuge/src/lib.rs | 6 +- runtime/centrifuge/src/weights/mod.rs | 1 + .../src/weights/pallet_elections_phragmen.rs | 141 ++++++++++++++++++ 3 files changed, 145 insertions(+), 3 deletions(-) create mode 100644 runtime/centrifuge/src/weights/pallet_elections_phragmen.rs diff --git a/runtime/centrifuge/src/lib.rs b/runtime/centrifuge/src/lib.rs index 31786303c4..257eb5d9e7 100644 --- a/runtime/centrifuge/src/lib.rs +++ b/runtime/centrifuge/src/lib.rs @@ -395,7 +395,7 @@ impl orml_asset_registry::Config for Runtime { type CustomMetadata = CustomMetadata; type RuntimeEvent = RuntimeEvent; // NOTE: Need no weights as spamming is not possible as the - // calls are only callable by `AuthorityOrigin`. In out + // calls are only callable by `AuthorityOrigin`. In our // case, pallet-pools and democracy type WeightInfo = (); } @@ -805,7 +805,7 @@ impl pallet_elections_phragmen::Config for Runtime { type VotingBondFactor = VotingBond; // NOTE: Benchmarks are failing with // "Error: Input("failed to submit candidacy")" - type WeightInfo = (); + type WeightInfo = weights::pallet_elections_phragmen::WeightInfo; } parameter_types! { @@ -1031,7 +1031,7 @@ impl pallet_bridge::Config for Runtime { // NOTE: No benchmarks available. // Might need to do that if we // extend the bridge usage - // For not fine. + // For now fine. type WeightInfo = (); } diff --git a/runtime/centrifuge/src/weights/mod.rs b/runtime/centrifuge/src/weights/mod.rs index b755e9c78a..702a509ec9 100644 --- a/runtime/centrifuge/src/weights/mod.rs +++ b/runtime/centrifuge/src/weights/mod.rs @@ -19,6 +19,7 @@ pub mod pallet_collective; pub mod pallet_crowdloan_claim; pub mod pallet_crowdloan_reward; pub mod pallet_democracy; +pub mod pallet_elections_phragmen; pub mod pallet_fees; pub mod pallet_identity; pub mod pallet_interest_accrual; diff --git a/runtime/centrifuge/src/weights/pallet_elections_phragmen.rs b/runtime/centrifuge/src/weights/pallet_elections_phragmen.rs new file mode 100644 index 0000000000..6d9e34cdbb --- /dev/null +++ b/runtime/centrifuge/src/weights/pallet_elections_phragmen.rs @@ -0,0 +1,141 @@ +#![cfg_attr(rustfmt, rustfmt_skip)] +#![allow(unused_parens)] +#![allow(unused_imports)] + +use frame_support::{traits::Get, weights::Weight}; +use sp_std::marker::PhantomData; + +/// Weight functions for `pallet_crowdloan_reward`. +pub struct WeightInfo(PhantomData); +impl pallet_elections_phragmen::WeightInfo for WeightInfo { + fn vote_equal(v: u32, ) -> Weight { + Weight::from_ref_time(27_011_000 as u64) + // Standard Error: 3_000 + .saturating_add(Weight::from_ref_time(214_000 as u64).saturating_mul(v as u64)) + .saturating_add(T::DbWeight::get().reads(5 as u64)) + .saturating_add(T::DbWeight::get().writes(2 as u64)) + } + // Storage: Elections Candidates (r:1 w:0) + // Storage: Elections Members (r:1 w:0) + // Storage: Elections RunnersUp (r:1 w:0) + // Storage: Elections Voting (r:1 w:1) + // Storage: Balances Locks (r:1 w:1) + /// The range of component `v` is `[2, 16]`. + fn vote_more(v: u32, ) -> Weight { + Weight::from_ref_time(40_240_000 as u64) + // Standard Error: 5_000 + .saturating_add(Weight::from_ref_time(244_000 as u64).saturating_mul(v as u64)) + .saturating_add(T::DbWeight::get().reads(5 as u64)) + .saturating_add(T::DbWeight::get().writes(2 as u64)) + } + // Storage: Elections Candidates (r:1 w:0) + // Storage: Elections Members (r:1 w:0) + // Storage: Elections RunnersUp (r:1 w:0) + // Storage: Elections Voting (r:1 w:1) + // Storage: Balances Locks (r:1 w:1) + /// The range of component `v` is `[2, 16]`. + fn vote_less(v: u32, ) -> Weight { + Weight::from_ref_time(40_394_000 as u64) + // Standard Error: 5_000 + .saturating_add(Weight::from_ref_time(217_000 as u64).saturating_mul(v as u64)) + .saturating_add(T::DbWeight::get().reads(5 as u64)) + .saturating_add(T::DbWeight::get().writes(2 as u64)) + } + // Storage: Elections Voting (r:1 w:1) + // Storage: Balances Locks (r:1 w:1) + fn remove_voter() -> Weight { + Weight::from_ref_time(37_651_000 as u64) + .saturating_add(T::DbWeight::get().reads(2 as u64)) + .saturating_add(T::DbWeight::get().writes(2 as u64)) + } + // Storage: Elections Candidates (r:1 w:1) + // Storage: Elections Members (r:1 w:0) + // Storage: Elections RunnersUp (r:1 w:0) + /// The range of component `c` is `[1, 1000]`. + fn submit_candidacy(c: u32, ) -> Weight { + Weight::from_ref_time(42_217_000 as u64) + // Standard Error: 0 + .saturating_add(Weight::from_ref_time(50_000 as u64).saturating_mul(c as u64)) + .saturating_add(T::DbWeight::get().reads(3 as u64)) + .saturating_add(T::DbWeight::get().writes(1 as u64)) + } + // Storage: Elections Candidates (r:1 w:1) + /// The range of component `c` is `[1, 1000]`. + fn renounce_candidacy_candidate(c: u32, ) -> Weight { + Weight::from_ref_time(46_459_000 as u64) + // Standard Error: 0 + .saturating_add(Weight::from_ref_time(26_000 as u64).saturating_mul(c as u64)) + .saturating_add(T::DbWeight::get().reads(1 as u64)) + .saturating_add(T::DbWeight::get().writes(1 as u64)) + } + // Storage: Elections Members (r:1 w:1) + // Storage: Elections RunnersUp (r:1 w:1) + // Storage: Council Prime (r:1 w:1) + // Storage: Council Proposals (r:1 w:0) + // Storage: Council Members (r:0 w:1) + fn renounce_candidacy_members() -> Weight { + Weight::from_ref_time(45_189_000 as u64) + .saturating_add(T::DbWeight::get().reads(4 as u64)) + .saturating_add(T::DbWeight::get().writes(4 as u64)) + } + // Storage: Elections RunnersUp (r:1 w:1) + fn renounce_candidacy_runners_up() -> Weight { + Weight::from_ref_time(34_516_000 as u64) + .saturating_add(T::DbWeight::get().reads(1 as u64)) + .saturating_add(T::DbWeight::get().writes(1 as u64)) + } + // Storage: Benchmark Override (r:0 w:0) + fn remove_member_without_replacement() -> Weight { + Weight::from_ref_time(2_000_000_000_000 as u64) + } + // Storage: Elections Members (r:1 w:1) + // Storage: System Account (r:1 w:1) + // Storage: Elections RunnersUp (r:1 w:1) + // Storage: Council Prime (r:1 w:1) + // Storage: Council Proposals (r:1 w:0) + // Storage: Council Members (r:0 w:1) + fn remove_member_with_replacement() -> Weight { + Weight::from_ref_time(51_838_000 as u64) + .saturating_add(T::DbWeight::get().reads(5 as u64)) + .saturating_add(T::DbWeight::get().writes(5 as u64)) + } + // Storage: Elections Voting (r:5001 w:5000) + // Storage: Elections Members (r:1 w:0) + // Storage: Elections RunnersUp (r:1 w:0) + // Storage: Elections Candidates (r:1 w:0) + // Storage: Balances Locks (r:5000 w:5000) + // Storage: System Account (r:5000 w:5000) + /// The range of component `v` is `[5000, 10000]`. + /// The range of component `d` is `[1, 5000]`. + fn clean_defunct_voters(v: u32, _d: u32, ) -> Weight { + Weight::from_ref_time(0 as u64) + // Standard Error: 76_000 + .saturating_add(Weight::from_ref_time(63_721_000 as u64).saturating_mul(v as u64)) + .saturating_add(T::DbWeight::get().reads(4 as u64)) + .saturating_add(T::DbWeight::get().reads((3 as u64).saturating_mul(v as u64))) + .saturating_add(T::DbWeight::get().writes((3 as u64).saturating_mul(v as u64))) + } + // Storage: Elections Candidates (r:1 w:1) + // Storage: Elections Members (r:1 w:1) + // Storage: Elections RunnersUp (r:1 w:1) + // Storage: Elections Voting (r:10001 w:0) + // Storage: Council Proposals (r:1 w:0) + // Storage: Elections ElectionRounds (r:1 w:1) + // Storage: Council Members (r:0 w:1) + // Storage: Council Prime (r:0 w:1) + // Storage: System Account (r:1 w:1) + /// The range of component `c` is `[1, 1000]`. + /// The range of component `v` is `[1, 10000]`. + /// The range of component `e` is `[10000, 160000]`. + fn election_phragmen(c: u32, v: u32, e: u32, ) -> Weight { + Weight::from_ref_time(0 as u64) + // Standard Error: 773_000 + .saturating_add(Weight::from_ref_time(81_534_000 as u64).saturating_mul(v as u64)) + // Standard Error: 51_000 + .saturating_add(Weight::from_ref_time(4_453_000 as u64).saturating_mul(e as u64)) + .saturating_add(T::DbWeight::get().reads(280 as u64)) + .saturating_add(T::DbWeight::get().reads((1 as u64).saturating_mul(c as u64))) + .saturating_add(T::DbWeight::get().reads((1 as u64).saturating_mul(v as u64))) + .saturating_add(T::DbWeight::get().writes((1 as u64).saturating_mul(c as u64))) + } +} From 2b66f184715ef56c801cc34d3d9a0f05b5fd28ff Mon Sep 17 00:00:00 2001 From: mustermeiszer Date: Tue, 4 Apr 2023 10:10:16 +0200 Subject: [PATCH 54/55] fix: adapt nix hash --- flake.nix | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/flake.nix b/flake.nix index 080bf0a0cb..3967320ee0 100644 --- a/flake.nix +++ b/flake.nix @@ -93,7 +93,7 @@ }; # This is a hash of all the Cargo dependencies, for reproducibility. - cargoSha256 = "sha256-DQcJ7D7n4qzE2Xy3a322x/sSKrbRtS+Bw6h0k5SomC8=="; + cargoSha256 = "sha256-B44+vaseMmcmEAn0qhGime0a1geVofH0Qtbd9Epo5KI="; nativeBuildInputs = with pkgs; [ clang git-mock pkg-config ]; buildInputs = with pkgs; [ openssl ] ++ ( From 4915a4700c5b2791dd382c557459e9e4ddb1fbf2 Mon Sep 17 00:00:00 2001 From: mustermeiszer Date: Tue, 4 Apr 2023 13:58:00 +0200 Subject: [PATCH 55/55] chore: update weights centrifuge --- .../src/weights/cumulus_pallet_xcmp_queue.rs | 10 +- .../centrifuge/src/weights/frame_system.rs | 42 +-- .../centrifuge/src/weights/pallet_anchors.rs | 18 +- .../centrifuge/src/weights/pallet_balances.rs | 30 +- .../src/weights/pallet_collator_allowlist.rs | 10 +- .../src/weights/pallet_collator_selection.rs | 46 +-- .../src/weights/pallet_collective.rs | 124 +++---- .../src/weights/pallet_crowdloan_claim.rs | 36 +-- .../src/weights/pallet_crowdloan_reward.rs | 18 +- .../src/weights/pallet_democracy.rs | 122 +++---- .../src/weights/pallet_elections_phragmen.rs | 306 ++++++++++-------- runtime/centrifuge/src/weights/pallet_fees.rs | 6 +- .../centrifuge/src/weights/pallet_identity.rs | 162 +++++----- .../src/weights/pallet_interest_accrual.rs | 10 +- .../centrifuge/src/weights/pallet_keystore.rs | 22 +- .../src/weights/pallet_loans_ref.rs | 76 ++--- .../src/weights/pallet_migration_manager.rs | 34 +- .../centrifuge/src/weights/pallet_multisig.rs | 68 ++-- .../src/weights/pallet_permissions.rs | 24 +- .../src/weights/pallet_pool_registry.rs | 42 +-- .../src/weights/pallet_pool_system.rs | 46 +-- .../centrifuge/src/weights/pallet_preimage.rs | 60 ++-- .../centrifuge/src/weights/pallet_proxy.rs | 98 +++--- .../src/weights/pallet_restricted_tokens.rs | 42 +-- .../src/weights/pallet_scheduler.rs | 72 ++--- .../src/weights/pallet_timestamp.rs | 10 +- .../centrifuge/src/weights/pallet_treasury.rs | 34 +- .../centrifuge/src/weights/pallet_uniques.rs | 114 ++++--- .../centrifuge/src/weights/pallet_utility.rs | 34 +- .../centrifuge/src/weights/pallet_vesting.rs | 78 +++-- 30 files changed, 918 insertions(+), 876 deletions(-) diff --git a/runtime/centrifuge/src/weights/cumulus_pallet_xcmp_queue.rs b/runtime/centrifuge/src/weights/cumulus_pallet_xcmp_queue.rs index ccb7df2f53..201bddd434 100644 --- a/runtime/centrifuge/src/weights/cumulus_pallet_xcmp_queue.rs +++ b/runtime/centrifuge/src/weights/cumulus_pallet_xcmp_queue.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `cumulus_pallet_xcmp_queue` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-03-27, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-04-04, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("centrifuge-dev"), DB CACHE: 1024 @@ -32,15 +32,15 @@ pub struct WeightInfo(PhantomData); impl cumulus_pallet_xcmp_queue::WeightInfo for WeightInfo { // Storage: XcmpQueue QueueConfig (r:1 w:1) fn set_config_with_u32() -> Weight { - // Minimum execution time: 13_901 nanoseconds. - Weight::from_ref_time(14_200_000 as u64) + // Minimum execution time: 14_300 nanoseconds. + Weight::from_ref_time(14_900_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: XcmpQueue QueueConfig (r:1 w:1) fn set_config_with_weight() -> Weight { - // Minimum execution time: 14_000 nanoseconds. - Weight::from_ref_time(14_301_000 as u64) + // Minimum execution time: 14_100 nanoseconds. + Weight::from_ref_time(14_400_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } diff --git a/runtime/centrifuge/src/weights/frame_system.rs b/runtime/centrifuge/src/weights/frame_system.rs index 30fdd41aaf..31463eda06 100644 --- a/runtime/centrifuge/src/weights/frame_system.rs +++ b/runtime/centrifuge/src/weights/frame_system.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `frame_system` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-03-27, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-04-04, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("centrifuge-dev"), DB CACHE: 1024 @@ -32,51 +32,51 @@ pub struct WeightInfo(PhantomData); impl frame_system::WeightInfo for WeightInfo { /// The range of component `b` is `[0, 3932160]`. fn remark(b: u32, ) -> Weight { - // Minimum execution time: 10_700 nanoseconds. - Weight::from_ref_time(7_898_599 as u64) + // Minimum execution time: 8_200 nanoseconds. + Weight::from_ref_time(11_262_776 as u64) // Standard Error: 0 - .saturating_add(Weight::from_ref_time(534 as u64).saturating_mul(b as u64)) + .saturating_add(Weight::from_ref_time(670 as u64).saturating_mul(b as u64)) } /// The range of component `b` is `[0, 3932160]`. fn remark_with_event(b: u32, ) -> Weight { - // Minimum execution time: 26_600 nanoseconds. - Weight::from_ref_time(2_721_110 as u64) + // Minimum execution time: 26_100 nanoseconds. + Weight::from_ref_time(8_711_470 as u64) // Standard Error: 1 - .saturating_add(Weight::from_ref_time(1_904 as u64).saturating_mul(b as u64)) + .saturating_add(Weight::from_ref_time(2_045 as u64).saturating_mul(b as u64)) } // Storage: System Digest (r:1 w:1) // Storage: unknown [0x3a686561707061676573] (r:0 w:1) fn set_heap_pages() -> Weight { - // Minimum execution time: 16_600 nanoseconds. - Weight::from_ref_time(17_200_000 as u64) + // Minimum execution time: 16_900 nanoseconds. + Weight::from_ref_time(17_501_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } // Storage: Skipped Metadata (r:0 w:0) /// The range of component `i` is `[0, 1000]`. fn set_storage(i: u32, ) -> Weight { - // Minimum execution time: 8_101 nanoseconds. - Weight::from_ref_time(8_300_000 as u64) - // Standard Error: 919 - .saturating_add(Weight::from_ref_time(1_135_971 as u64).saturating_mul(i as u64)) + // Minimum execution time: 8_200 nanoseconds. + Weight::from_ref_time(1_131_500 as u64) + // Standard Error: 1_733 + .saturating_add(Weight::from_ref_time(1_137_655 as u64).saturating_mul(i as u64)) .saturating_add(T::DbWeight::get().writes((1 as u64).saturating_mul(i as u64))) } // Storage: Skipped Metadata (r:0 w:0) /// The range of component `i` is `[0, 1000]`. fn kill_storage(i: u32, ) -> Weight { - // Minimum execution time: 10_400 nanoseconds. - Weight::from_ref_time(2_798_133 as u64) - // Standard Error: 1_547 - .saturating_add(Weight::from_ref_time(899_039 as u64).saturating_mul(i as u64)) + // Minimum execution time: 7_901 nanoseconds. + Weight::from_ref_time(4_703_774 as u64) + // Standard Error: 1_725 + .saturating_add(Weight::from_ref_time(869_789 as u64).saturating_mul(i as u64)) .saturating_add(T::DbWeight::get().writes((1 as u64).saturating_mul(i as u64))) } // Storage: Skipped Metadata (r:0 w:0) /// The range of component `p` is `[0, 1000]`. fn kill_prefix(p: u32, ) -> Weight { - // Minimum execution time: 11_600 nanoseconds. - Weight::from_ref_time(591_927 as u64) - // Standard Error: 2_410 - .saturating_add(Weight::from_ref_time(1_672_410 as u64).saturating_mul(p as u64)) + // Minimum execution time: 11_500 nanoseconds. + Weight::from_ref_time(11_601_000 as u64) + // Standard Error: 1_850 + .saturating_add(Weight::from_ref_time(1_617_212 as u64).saturating_mul(p as u64)) .saturating_add(T::DbWeight::get().writes((1 as u64).saturating_mul(p as u64))) } } diff --git a/runtime/centrifuge/src/weights/pallet_anchors.rs b/runtime/centrifuge/src/weights/pallet_anchors.rs index 4c52924fab..b1939ff76d 100644 --- a/runtime/centrifuge/src/weights/pallet_anchors.rs +++ b/runtime/centrifuge/src/weights/pallet_anchors.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_anchors` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-03-27, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-04-04, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("centrifuge-dev"), DB CACHE: 1024 @@ -34,8 +34,8 @@ impl pallet_anchors::WeightInfo for WeightInfo { // Storage: Anchor PreCommits (r:1 w:1) // Storage: Fees FeeBalances (r:1 w:0) fn pre_commit() -> Weight { - // Minimum execution time: 62_201 nanoseconds. - Weight::from_ref_time(64_401_000 as u64) + // Minimum execution time: 62_502 nanoseconds. + Weight::from_ref_time(63_402_000 as u64) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } @@ -49,15 +49,15 @@ impl pallet_anchors::WeightInfo for WeightInfo { // Storage: Anchor AnchorIndexes (r:0 w:1) // Storage: unknown [0xdb4faa73ca6d2016e53c7156087c176b79b169c409b8a0063a07964f3187f9e9] (r:0 w:1) fn commit() -> Weight { - // Minimum execution time: 97_201 nanoseconds. - Weight::from_ref_time(98_102_000 as u64) + // Minimum execution time: 94_902 nanoseconds. + Weight::from_ref_time(96_202_000 as u64) .saturating_add(T::DbWeight::get().reads(7 as u64)) .saturating_add(T::DbWeight::get().writes(5 as u64)) } // Storage: Anchor PreCommits (r:100 w:100) fn evict_pre_commits() -> Weight { - // Minimum execution time: 2_020_237 nanoseconds. - Weight::from_ref_time(2_044_239_000 as u64) + // Minimum execution time: 2_050_546 nanoseconds. + Weight::from_ref_time(2_081_046_000 as u64) .saturating_add(T::DbWeight::get().reads(100 as u64)) .saturating_add(T::DbWeight::get().writes(100 as u64)) } @@ -269,8 +269,8 @@ impl pallet_anchors::WeightInfo for WeightInfo { // Storage: unknown [0xee60c64e1e32117f948ee71d391f978e8ac98c2bd869322fc25164502e3f7a9b] (r:0 w:1) // Storage: unknown [0xf7e4b8a5415405a940e730546df85583c8c23956d99a3be18e09eebf3639d312] (r:0 w:1) fn evict_anchors() -> Weight { - // Minimum execution time: 2_266_743 nanoseconds. - Weight::from_ref_time(2_287_843_000 as u64) + // Minimum execution time: 2_247_951 nanoseconds. + Weight::from_ref_time(2_279_251_000 as u64) .saturating_add(T::DbWeight::get().reads(404 as u64)) .saturating_add(T::DbWeight::get().writes(402 as u64)) } diff --git a/runtime/centrifuge/src/weights/pallet_balances.rs b/runtime/centrifuge/src/weights/pallet_balances.rs index 65fdf2c1b5..19bfc81c40 100644 --- a/runtime/centrifuge/src/weights/pallet_balances.rs +++ b/runtime/centrifuge/src/weights/pallet_balances.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_balances` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-03-27, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-04-04, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("centrifuge-dev"), DB CACHE: 1024 @@ -32,50 +32,50 @@ pub struct WeightInfo(PhantomData); impl pallet_balances::WeightInfo for WeightInfo { // Storage: System Account (r:1 w:1) fn transfer() -> Weight { - // Minimum execution time: 87_101 nanoseconds. - Weight::from_ref_time(90_501_000 as u64) + // Minimum execution time: 82_602 nanoseconds. + Weight::from_ref_time(90_702_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: System Account (r:1 w:1) fn transfer_keep_alive() -> Weight { - // Minimum execution time: 64_801 nanoseconds. - Weight::from_ref_time(66_001_000 as u64) + // Minimum execution time: 66_601 nanoseconds. + Weight::from_ref_time(67_201_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: System Account (r:1 w:1) fn set_balance_creating() -> Weight { - // Minimum execution time: 48_501 nanoseconds. - Weight::from_ref_time(49_501_000 as u64) + // Minimum execution time: 47_301 nanoseconds. + Weight::from_ref_time(48_401_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: System Account (r:1 w:1) fn set_balance_killing() -> Weight { - // Minimum execution time: 55_001 nanoseconds. - Weight::from_ref_time(55_701_000 as u64) + // Minimum execution time: 52_701 nanoseconds. + Weight::from_ref_time(54_701_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: System Account (r:2 w:2) fn force_transfer() -> Weight { - // Minimum execution time: 84_301 nanoseconds. - Weight::from_ref_time(87_602_000 as u64) + // Minimum execution time: 88_902 nanoseconds. + Weight::from_ref_time(89_802_000 as u64) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } // Storage: System Account (r:1 w:1) fn transfer_all() -> Weight { - // Minimum execution time: 75_702 nanoseconds. - Weight::from_ref_time(77_002_000 as u64) + // Minimum execution time: 77_401 nanoseconds. + Weight::from_ref_time(78_302_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: System Account (r:1 w:1) fn force_unreserve() -> Weight { - // Minimum execution time: 40_901 nanoseconds. - Weight::from_ref_time(54_201_000 as u64) + // Minimum execution time: 39_601 nanoseconds. + Weight::from_ref_time(41_701_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } diff --git a/runtime/centrifuge/src/weights/pallet_collator_allowlist.rs b/runtime/centrifuge/src/weights/pallet_collator_allowlist.rs index 54a663a9c9..f1e85f472f 100644 --- a/runtime/centrifuge/src/weights/pallet_collator_allowlist.rs +++ b/runtime/centrifuge/src/weights/pallet_collator_allowlist.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_collator_allowlist` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-03-27, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-04-04, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("centrifuge-dev"), DB CACHE: 1024 @@ -33,15 +33,15 @@ impl pallet_collator_allowlist::WeightInfo for WeightIn // Storage: Session NextKeys (r:1 w:0) // Storage: CollatorAllowlist Allowlist (r:1 w:1) fn add() -> Weight { - // Minimum execution time: 58_701 nanoseconds. - Weight::from_ref_time(60_601_000 as u64) + // Minimum execution time: 43_001 nanoseconds. + Weight::from_ref_time(43_601_000 as u64) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: CollatorAllowlist Allowlist (r:1 w:1) fn remove() -> Weight { - // Minimum execution time: 36_400 nanoseconds. - Weight::from_ref_time(37_101_000 as u64) + // Minimum execution time: 35_501 nanoseconds. + Weight::from_ref_time(36_201_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } diff --git a/runtime/centrifuge/src/weights/pallet_collator_selection.rs b/runtime/centrifuge/src/weights/pallet_collator_selection.rs index e0d661cd1a..46c5597cde 100644 --- a/runtime/centrifuge/src/weights/pallet_collator_selection.rs +++ b/runtime/centrifuge/src/weights/pallet_collator_selection.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_collator_selection` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-03-27, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-04-04, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("centrifuge-dev"), DB CACHE: 1024 @@ -35,23 +35,23 @@ impl pallet_collator_selection::WeightInfo for WeightIn // Storage: CollatorSelection Invulnerables (r:0 w:1) /// The range of component `b` is `[1, 100]`. fn set_invulnerables(b: u32, ) -> Weight { - // Minimum execution time: 47_501 nanoseconds. - Weight::from_ref_time(49_205_356 as u64) - // Standard Error: 7_801 - .saturating_add(Weight::from_ref_time(6_486_742 as u64).saturating_mul(b as u64)) + // Minimum execution time: 46_901 nanoseconds. + Weight::from_ref_time(47_249_193 as u64) + // Standard Error: 6_772 + .saturating_add(Weight::from_ref_time(6_514_376 as u64).saturating_mul(b as u64)) .saturating_add(T::DbWeight::get().reads((2 as u64).saturating_mul(b as u64))) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: CollatorSelection DesiredCandidates (r:0 w:1) fn set_desired_candidates() -> Weight { - // Minimum execution time: 30_800 nanoseconds. - Weight::from_ref_time(32_201_000 as u64) + // Minimum execution time: 38_201 nanoseconds. + Weight::from_ref_time(39_101_000 as u64) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: CollatorSelection CandidacyBond (r:0 w:1) fn set_candidacy_bond() -> Weight { - // Minimum execution time: 26_801 nanoseconds. - Weight::from_ref_time(27_500_000 as u64) + // Minimum execution time: 26_000 nanoseconds. + Weight::from_ref_time(26_301_000 as u64) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: CollatorSelection Candidates (r:1 w:1) @@ -63,10 +63,10 @@ impl pallet_collator_selection::WeightInfo for WeightIn // Storage: CollatorSelection LastAuthoredBlock (r:0 w:1) /// The range of component `c` is `[1, 99]`. fn register_as_candidate(c: u32, ) -> Weight { - // Minimum execution time: 92_502 nanoseconds. - Weight::from_ref_time(101_943_525 as u64) - // Standard Error: 3_754 - .saturating_add(Weight::from_ref_time(512_227 as u64).saturating_mul(c as u64)) + // Minimum execution time: 92_302 nanoseconds. + Weight::from_ref_time(98_271_990 as u64) + // Standard Error: 3_788 + .saturating_add(Weight::from_ref_time(547_963 as u64).saturating_mul(c as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } @@ -74,10 +74,10 @@ impl pallet_collator_selection::WeightInfo for WeightIn // Storage: CollatorSelection LastAuthoredBlock (r:0 w:1) /// The range of component `c` is `[6, 100]`. fn leave_intent(c: u32, ) -> Weight { - // Minimum execution time: 69_501 nanoseconds. - Weight::from_ref_time(71_101_392 as u64) - // Standard Error: 4_706 - .saturating_add(Weight::from_ref_time(451_804 as u64).saturating_mul(c as u64)) + // Minimum execution time: 68_402 nanoseconds. + Weight::from_ref_time(69_940_200 as u64) + // Standard Error: 5_268 + .saturating_add(Weight::from_ref_time(451_489 as u64).saturating_mul(c as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } @@ -85,8 +85,8 @@ impl pallet_collator_selection::WeightInfo for WeightIn // Storage: System BlockWeight (r:1 w:1) // Storage: CollatorSelection LastAuthoredBlock (r:0 w:1) fn note_author() -> Weight { - // Minimum execution time: 67_102 nanoseconds. - Weight::from_ref_time(67_901_000 as u64) + // Minimum execution time: 67_201 nanoseconds. + Weight::from_ref_time(67_802_000 as u64) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(4 as u64)) } @@ -98,10 +98,10 @@ impl pallet_collator_selection::WeightInfo for WeightIn /// The range of component `r` is `[1, 100]`. /// The range of component `c` is `[1, 100]`. fn new_session(_r: u32, c: u32, ) -> Weight { - // Minimum execution time: 38_401 nanoseconds. - Weight::from_ref_time(39_101_000 as u64) - // Standard Error: 514_071 - .saturating_add(Weight::from_ref_time(19_273_271 as u64).saturating_mul(c as u64)) + // Minimum execution time: 39_201 nanoseconds. + Weight::from_ref_time(39_801_000 as u64) + // Standard Error: 520_982 + .saturating_add(Weight::from_ref_time(19_558_771 as u64).saturating_mul(c as u64)) .saturating_add(T::DbWeight::get().reads(4 as u64)) .saturating_add(T::DbWeight::get().reads((1 as u64).saturating_mul(c as u64))) .saturating_add(T::DbWeight::get().writes(1 as u64)) diff --git a/runtime/centrifuge/src/weights/pallet_collective.rs b/runtime/centrifuge/src/weights/pallet_collective.rs index fcea773bf1..1128d401af 100644 --- a/runtime/centrifuge/src/weights/pallet_collective.rs +++ b/runtime/centrifuge/src/weights/pallet_collective.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_collective` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-03-27, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-04-04, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("centrifuge-dev"), DB CACHE: 1024 @@ -38,12 +38,12 @@ impl pallet_collective::WeightInfo for WeightInfo { /// The range of component `n` is `[0, 100]`. /// The range of component `p` is `[0, 100]`. fn set_members(m: u32, _n: u32, p: u32, ) -> Weight { - // Minimum execution time: 31_400 nanoseconds. - Weight::from_ref_time(31_500_000 as u64) - // Standard Error: 96_202 - .saturating_add(Weight::from_ref_time(7_397_697 as u64).saturating_mul(m as u64)) - // Standard Error: 96_202 - .saturating_add(Weight::from_ref_time(12_307_214 as u64).saturating_mul(p as u64)) + // Minimum execution time: 40_401 nanoseconds. + Weight::from_ref_time(40_901_000 as u64) + // Standard Error: 98_194 + .saturating_add(Weight::from_ref_time(7_390_161 as u64).saturating_mul(m as u64)) + // Standard Error: 98_194 + .saturating_add(Weight::from_ref_time(12_416_850 as u64).saturating_mul(p as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().reads((1 as u64).saturating_mul(p as u64))) .saturating_add(T::DbWeight::get().writes(2 as u64)) @@ -53,12 +53,12 @@ impl pallet_collective::WeightInfo for WeightInfo { /// The range of component `b` is `[1, 1024]`. /// The range of component `m` is `[1, 100]`. fn execute(b: u32, m: u32, ) -> Weight { - // Minimum execution time: 38_300 nanoseconds. - Weight::from_ref_time(41_758_120 as u64) - // Standard Error: 217 - .saturating_add(Weight::from_ref_time(1_706 as u64).saturating_mul(b as u64)) - // Standard Error: 2_247 - .saturating_add(Weight::from_ref_time(16_039 as u64).saturating_mul(m as u64)) + // Minimum execution time: 41_201 nanoseconds. + Weight::from_ref_time(39_842_386 as u64) + // Standard Error: 146 + .saturating_add(Weight::from_ref_time(2_534 as u64).saturating_mul(b as u64)) + // Standard Error: 1_514 + .saturating_add(Weight::from_ref_time(30_183 as u64).saturating_mul(m as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) } // Storage: Council Members (r:1 w:0) @@ -66,12 +66,12 @@ impl pallet_collective::WeightInfo for WeightInfo { /// The range of component `b` is `[1, 1024]`. /// The range of component `m` is `[1, 100]`. fn propose_execute(b: u32, m: u32, ) -> Weight { - // Minimum execution time: 42_400 nanoseconds. - Weight::from_ref_time(43_539_572 as u64) - // Standard Error: 311 - .saturating_add(Weight::from_ref_time(2_632 as u64).saturating_mul(b as u64)) - // Standard Error: 3_216 - .saturating_add(Weight::from_ref_time(49_699 as u64).saturating_mul(m as u64)) + // Minimum execution time: 44_601 nanoseconds. + Weight::from_ref_time(43_848_537 as u64) + // Standard Error: 113 + .saturating_add(Weight::from_ref_time(2_761 as u64).saturating_mul(b as u64)) + // Standard Error: 1_168 + .saturating_add(Weight::from_ref_time(40_713 as u64).saturating_mul(m as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) } // Storage: Council Members (r:1 w:0) @@ -83,14 +83,14 @@ impl pallet_collective::WeightInfo for WeightInfo { /// The range of component `m` is `[2, 100]`. /// The range of component `p` is `[1, 100]`. fn propose_proposed(b: u32, m: u32, p: u32, ) -> Weight { - // Minimum execution time: 58_001 nanoseconds. - Weight::from_ref_time(55_068_586 as u64) - // Standard Error: 320 - .saturating_add(Weight::from_ref_time(7_209 as u64).saturating_mul(b as u64)) - // Standard Error: 3_344 - .saturating_add(Weight::from_ref_time(48_125 as u64).saturating_mul(m as u64)) - // Standard Error: 3_302 - .saturating_add(Weight::from_ref_time(402_833 as u64).saturating_mul(p as u64)) + // Minimum execution time: 56_801 nanoseconds. + Weight::from_ref_time(53_186_869 as u64) + // Standard Error: 265 + .saturating_add(Weight::from_ref_time(8_983 as u64).saturating_mul(b as u64)) + // Standard Error: 2_769 + .saturating_add(Weight::from_ref_time(38_464 as u64).saturating_mul(m as u64)) + // Standard Error: 2_734 + .saturating_add(Weight::from_ref_time(421_056 as u64).saturating_mul(p as u64)) .saturating_add(T::DbWeight::get().reads(4 as u64)) .saturating_add(T::DbWeight::get().writes(4 as u64)) } @@ -98,10 +98,10 @@ impl pallet_collective::WeightInfo for WeightInfo { // Storage: Council Voting (r:1 w:1) /// The range of component `m` is `[5, 100]`. fn vote(m: u32, ) -> Weight { - // Minimum execution time: 59_402 nanoseconds. - Weight::from_ref_time(68_986_571 as u64) - // Standard Error: 4_117 - .saturating_add(Weight::from_ref_time(80_265 as u64).saturating_mul(m as u64)) + // Minimum execution time: 61_501 nanoseconds. + Weight::from_ref_time(66_361_854 as u64) + // Standard Error: 3_519 + .saturating_add(Weight::from_ref_time(115_684 as u64).saturating_mul(m as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } @@ -112,12 +112,12 @@ impl pallet_collective::WeightInfo for WeightInfo { /// The range of component `m` is `[4, 100]`. /// The range of component `p` is `[1, 100]`. fn close_early_disapproved(m: u32, p: u32, ) -> Weight { - // Minimum execution time: 60_501 nanoseconds. - Weight::from_ref_time(63_132_423 as u64) - // Standard Error: 2_858 - .saturating_add(Weight::from_ref_time(47_212 as u64).saturating_mul(m as u64)) - // Standard Error: 2_787 - .saturating_add(Weight::from_ref_time(361_086 as u64).saturating_mul(p as u64)) + // Minimum execution time: 60_802 nanoseconds. + Weight::from_ref_time(61_433_638 as u64) + // Standard Error: 2_456 + .saturating_add(Weight::from_ref_time(58_466 as u64).saturating_mul(m as u64)) + // Standard Error: 2_395 + .saturating_add(Weight::from_ref_time(382_905 as u64).saturating_mul(p as u64)) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -129,14 +129,14 @@ impl pallet_collective::WeightInfo for WeightInfo { /// The range of component `m` is `[4, 100]`. /// The range of component `p` is `[1, 100]`. fn close_early_approved(b: u32, m: u32, p: u32, ) -> Weight { - // Minimum execution time: 83_202 nanoseconds. - Weight::from_ref_time(77_470_609 as u64) + // Minimum execution time: 83_902 nanoseconds. + Weight::from_ref_time(78_304_356 as u64) // Standard Error: 278 - .saturating_add(Weight::from_ref_time(6_493 as u64).saturating_mul(b as u64)) - // Standard Error: 2_949 - .saturating_add(Weight::from_ref_time(75_717 as u64).saturating_mul(m as u64)) - // Standard Error: 2_875 - .saturating_add(Weight::from_ref_time(396_353 as u64).saturating_mul(p as u64)) + .saturating_add(Weight::from_ref_time(5_790 as u64).saturating_mul(b as u64)) + // Standard Error: 2_941 + .saturating_add(Weight::from_ref_time(73_146 as u64).saturating_mul(m as u64)) + // Standard Error: 2_867 + .saturating_add(Weight::from_ref_time(424_666 as u64).saturating_mul(p as u64)) .saturating_add(T::DbWeight::get().reads(4 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -148,12 +148,12 @@ impl pallet_collective::WeightInfo for WeightInfo { /// The range of component `m` is `[4, 100]`. /// The range of component `p` is `[1, 100]`. fn close_disapproved(m: u32, p: u32, ) -> Weight { - // Minimum execution time: 66_401 nanoseconds. - Weight::from_ref_time(68_021_907 as u64) - // Standard Error: 3_802 - .saturating_add(Weight::from_ref_time(59_743 as u64).saturating_mul(m as u64)) - // Standard Error: 3_708 - .saturating_add(Weight::from_ref_time(318_779 as u64).saturating_mul(p as u64)) + // Minimum execution time: 66_002 nanoseconds. + Weight::from_ref_time(66_223_900 as u64) + // Standard Error: 2_106 + .saturating_add(Weight::from_ref_time(54_107 as u64).saturating_mul(m as u64)) + // Standard Error: 2_053 + .saturating_add(Weight::from_ref_time(375_237 as u64).saturating_mul(p as u64)) .saturating_add(T::DbWeight::get().reads(4 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -166,14 +166,14 @@ impl pallet_collective::WeightInfo for WeightInfo { /// The range of component `m` is `[4, 100]`. /// The range of component `p` is `[1, 100]`. fn close_approved(b: u32, m: u32, p: u32, ) -> Weight { - // Minimum execution time: 85_202 nanoseconds. - Weight::from_ref_time(81_799_386 as u64) - // Standard Error: 315 - .saturating_add(Weight::from_ref_time(7_595 as u64).saturating_mul(b as u64)) - // Standard Error: 3_333 - .saturating_add(Weight::from_ref_time(66_901 as u64).saturating_mul(m as u64)) - // Standard Error: 3_249 - .saturating_add(Weight::from_ref_time(389_683 as u64).saturating_mul(p as u64)) + // Minimum execution time: 88_102 nanoseconds. + Weight::from_ref_time(77_792_845 as u64) + // Standard Error: 325 + .saturating_add(Weight::from_ref_time(8_445 as u64).saturating_mul(b as u64)) + // Standard Error: 3_447 + .saturating_add(Weight::from_ref_time(99_781 as u64).saturating_mul(m as u64)) + // Standard Error: 3_360 + .saturating_add(Weight::from_ref_time(428_616 as u64).saturating_mul(p as u64)) .saturating_add(T::DbWeight::get().reads(5 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -182,10 +182,10 @@ impl pallet_collective::WeightInfo for WeightInfo { // Storage: Council ProposalOf (r:0 w:1) /// The range of component `p` is `[1, 100]`. fn disapprove_proposal(p: u32, ) -> Weight { - // Minimum execution time: 36_501 nanoseconds. - Weight::from_ref_time(44_786_338 as u64) - // Standard Error: 3_912 - .saturating_add(Weight::from_ref_time(371_438 as u64).saturating_mul(p as u64)) + // Minimum execution time: 39_700 nanoseconds. + Weight::from_ref_time(43_867_506 as u64) + // Standard Error: 3_124 + .saturating_add(Weight::from_ref_time(399_208 as u64).saturating_mul(p as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } diff --git a/runtime/centrifuge/src/weights/pallet_crowdloan_claim.rs b/runtime/centrifuge/src/weights/pallet_crowdloan_claim.rs index 17ab7e4560..874c9e233f 100644 --- a/runtime/centrifuge/src/weights/pallet_crowdloan_claim.rs +++ b/runtime/centrifuge/src/weights/pallet_crowdloan_claim.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_crowdloan_claim` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-03-27, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-04-04, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("centrifuge-dev"), DB CACHE: 1024 @@ -42,8 +42,8 @@ impl pallet_crowdloan_claim::WeightInfo for WeightInfo< // Storage: System Account (r:2 w:2) // Storage: Balances Locks (r:1 w:1) fn claim_reward_ed25519() -> Weight { - // Minimum execution time: 270_505 nanoseconds. - Weight::from_ref_time(272_605_000 as u64) + // Minimum execution time: 269_906 nanoseconds. + Weight::from_ref_time(271_806_000 as u64) .saturating_add(T::DbWeight::get().reads(12 as u64)) .saturating_add(T::DbWeight::get().writes(5 as u64)) } @@ -59,8 +59,8 @@ impl pallet_crowdloan_claim::WeightInfo for WeightInfo< // Storage: System Account (r:2 w:2) // Storage: Balances Locks (r:1 w:1) fn claim_reward_sr25519() -> Weight { - // Minimum execution time: 269_405 nanoseconds. - Weight::from_ref_time(277_505_000 as u64) + // Minimum execution time: 274_907 nanoseconds. + Weight::from_ref_time(276_106_000 as u64) .saturating_add(T::DbWeight::get().reads(12 as u64)) .saturating_add(T::DbWeight::get().writes(5 as u64)) } @@ -76,8 +76,8 @@ impl pallet_crowdloan_claim::WeightInfo for WeightInfo< // Storage: System Account (r:2 w:2) // Storage: Balances Locks (r:1 w:1) fn claim_reward_ecdsa() -> Weight { - // Minimum execution time: 249_605 nanoseconds. - Weight::from_ref_time(255_005_000 as u64) + // Minimum execution time: 252_506 nanoseconds. + Weight::from_ref_time(254_006_000 as u64) .saturating_add(T::DbWeight::get().reads(12 as u64)) .saturating_add(T::DbWeight::get().writes(5 as u64)) } @@ -89,39 +89,39 @@ impl pallet_crowdloan_claim::WeightInfo for WeightInfo< // Storage: CrowdloanClaim CrowdloanTrieIndex (r:0 w:1) // Storage: CrowdloanClaim LockedAt (r:0 w:1) fn initialize() -> Weight { - // Minimum execution time: 55_901 nanoseconds. - Weight::from_ref_time(57_101_000 as u64) + // Minimum execution time: 43_001 nanoseconds. + Weight::from_ref_time(43_801_000 as u64) .saturating_add(T::DbWeight::get().reads(4 as u64)) .saturating_add(T::DbWeight::get().writes(6 as u64)) } // Storage: CrowdloanClaim LeaseStart (r:0 w:1) fn set_lease_start() -> Weight { - // Minimum execution time: 26_301 nanoseconds. - Weight::from_ref_time(27_000_000 as u64) + // Minimum execution time: 26_001 nanoseconds. + Weight::from_ref_time(26_601_000 as u64) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: CrowdloanClaim LeasePeriod (r:0 w:1) fn set_lease_period() -> Weight { - // Minimum execution time: 26_000 nanoseconds. - Weight::from_ref_time(26_701_000 as u64) + // Minimum execution time: 26_001 nanoseconds. + Weight::from_ref_time(26_700_000 as u64) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: CrowdloanClaim Contributions (r:0 w:1) fn set_contributions_root() -> Weight { - // Minimum execution time: 27_800 nanoseconds. - Weight::from_ref_time(28_600_000 as u64) + // Minimum execution time: 27_500 nanoseconds. + Weight::from_ref_time(28_001_000 as u64) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: CrowdloanClaim LockedAt (r:0 w:1) fn set_locked_at() -> Weight { // Minimum execution time: 26_001 nanoseconds. - Weight::from_ref_time(26_801_000 as u64) + Weight::from_ref_time(26_600_000 as u64) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: CrowdloanClaim CrowdloanTrieIndex (r:0 w:1) fn set_crowdloan_trie_index() -> Weight { - // Minimum execution time: 25_601 nanoseconds. - Weight::from_ref_time(26_701_000 as u64) + // Minimum execution time: 26_101 nanoseconds. + Weight::from_ref_time(26_700_000 as u64) .saturating_add(T::DbWeight::get().writes(1 as u64)) } } diff --git a/runtime/centrifuge/src/weights/pallet_crowdloan_reward.rs b/runtime/centrifuge/src/weights/pallet_crowdloan_reward.rs index a82f45e710..e4abc2e60d 100644 --- a/runtime/centrifuge/src/weights/pallet_crowdloan_reward.rs +++ b/runtime/centrifuge/src/weights/pallet_crowdloan_reward.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_crowdloan_reward` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-03-27, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-04-04, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("centrifuge-dev"), DB CACHE: 1024 @@ -34,26 +34,26 @@ impl pallet_crowdloan_reward::WeightInfo for WeightInfo // Storage: CrowdloanReward VestingPeriod (r:0 w:1) // Storage: CrowdloanReward DirectPayoutRatio (r:0 w:1) fn initialize() -> Weight { - // Minimum execution time: 29_600 nanoseconds. - Weight::from_ref_time(30_201_000 as u64) + // Minimum execution time: 29_401 nanoseconds. + Weight::from_ref_time(30_000_000 as u64) .saturating_add(T::DbWeight::get().writes(3 as u64)) } // Storage: CrowdloanReward VestingStart (r:0 w:1) fn set_vesting_start() -> Weight { - // Minimum execution time: 26_801 nanoseconds. - Weight::from_ref_time(27_301_000 as u64) + // Minimum execution time: 26_500 nanoseconds. + Weight::from_ref_time(27_101_000 as u64) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: CrowdloanReward VestingPeriod (r:0 w:1) fn set_vesting_period() -> Weight { - // Minimum execution time: 26_600 nanoseconds. - Weight::from_ref_time(27_100_000 as u64) + // Minimum execution time: 26_301 nanoseconds. + Weight::from_ref_time(27_000_000 as u64) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: CrowdloanReward DirectPayoutRatio (r:0 w:1) fn set_direct_payout_ratio() -> Weight { - // Minimum execution time: 26_900 nanoseconds. - Weight::from_ref_time(27_300_000 as u64) + // Minimum execution time: 26_600 nanoseconds. + Weight::from_ref_time(26_701_000 as u64) .saturating_add(T::DbWeight::get().writes(1 as u64)) } } diff --git a/runtime/centrifuge/src/weights/pallet_democracy.rs b/runtime/centrifuge/src/weights/pallet_democracy.rs index 616f88019d..e7076b4a89 100644 --- a/runtime/centrifuge/src/weights/pallet_democracy.rs +++ b/runtime/centrifuge/src/weights/pallet_democracy.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_democracy` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-03-27, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-04-04, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("centrifuge-dev"), DB CACHE: 1024 @@ -35,15 +35,15 @@ impl pallet_democracy::WeightInfo for WeightInfo { // Storage: Democracy Blacklist (r:1 w:0) // Storage: Democracy DepositOf (r:0 w:1) fn propose() -> Weight { - // Minimum execution time: 95_102 nanoseconds. - Weight::from_ref_time(103_603_000 as u64) + // Minimum execution time: 102_703 nanoseconds. + Weight::from_ref_time(106_203_000 as u64) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } // Storage: Democracy DepositOf (r:1 w:1) fn second() -> Weight { - // Minimum execution time: 86_102 nanoseconds. - Weight::from_ref_time(89_102_000 as u64) + // Minimum execution time: 87_902 nanoseconds. + Weight::from_ref_time(89_502_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } @@ -51,8 +51,8 @@ impl pallet_democracy::WeightInfo for WeightInfo { // Storage: Democracy VotingOf (r:1 w:1) // Storage: Balances Locks (r:1 w:1) fn vote_new() -> Weight { - // Minimum execution time: 106_102 nanoseconds. - Weight::from_ref_time(109_702_000 as u64) + // Minimum execution time: 108_403 nanoseconds. + Weight::from_ref_time(110_903_000 as u64) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -60,16 +60,16 @@ impl pallet_democracy::WeightInfo for WeightInfo { // Storage: Democracy VotingOf (r:1 w:1) // Storage: Balances Locks (r:1 w:1) fn vote_existing() -> Weight { - // Minimum execution time: 101_902 nanoseconds. - Weight::from_ref_time(109_502_000 as u64) + // Minimum execution time: 109_003 nanoseconds. + Weight::from_ref_time(110_702_000 as u64) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } // Storage: Democracy ReferendumInfoOf (r:1 w:1) // Storage: Democracy Cancellations (r:1 w:1) fn emergency_cancel() -> Weight { - // Minimum execution time: 42_801 nanoseconds. - Weight::from_ref_time(43_501_000 as u64) + // Minimum execution time: 41_901 nanoseconds. + Weight::from_ref_time(43_901_000 as u64) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } @@ -80,45 +80,45 @@ impl pallet_democracy::WeightInfo for WeightInfo { // Storage: Democracy ReferendumInfoOf (r:1 w:1) // Storage: Democracy Blacklist (r:0 w:1) fn blacklist() -> Weight { - // Minimum execution time: 165_703 nanoseconds. - Weight::from_ref_time(170_204_000 as u64) + // Minimum execution time: 168_504 nanoseconds. + Weight::from_ref_time(171_404_000 as u64) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(7 as u64)) } // Storage: Democracy NextExternal (r:1 w:1) // Storage: Democracy Blacklist (r:1 w:0) fn external_propose() -> Weight { - // Minimum execution time: 30_800 nanoseconds. - Weight::from_ref_time(31_700_000 as u64) + // Minimum execution time: 32_200 nanoseconds. + Weight::from_ref_time(32_601_000 as u64) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Democracy NextExternal (r:0 w:1) fn external_propose_majority() -> Weight { - // Minimum execution time: 10_200 nanoseconds. - Weight::from_ref_time(10_500_000 as u64) + // Minimum execution time: 10_600 nanoseconds. + Weight::from_ref_time(10_800_000 as u64) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Democracy NextExternal (r:0 w:1) fn external_propose_default() -> Weight { - // Minimum execution time: 9_800 nanoseconds. - Weight::from_ref_time(10_201_000 as u64) + // Minimum execution time: 10_300 nanoseconds. + Weight::from_ref_time(10_600_000 as u64) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Democracy NextExternal (r:1 w:1) // Storage: Democracy ReferendumCount (r:1 w:1) // Storage: Democracy ReferendumInfoOf (r:0 w:1) fn fast_track() -> Weight { - // Minimum execution time: 39_701 nanoseconds. - Weight::from_ref_time(43_801_000 as u64) + // Minimum execution time: 42_301 nanoseconds. + Weight::from_ref_time(43_001_000 as u64) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } // Storage: Democracy NextExternal (r:1 w:1) // Storage: Democracy Blacklist (r:1 w:1) fn veto_external() -> Weight { - // Minimum execution time: 47_901 nanoseconds. - Weight::from_ref_time(52_401_000 as u64) + // Minimum execution time: 52_002 nanoseconds. + Weight::from_ref_time(52_601_000 as u64) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } @@ -126,15 +126,15 @@ impl pallet_democracy::WeightInfo for WeightInfo { // Storage: Democracy DepositOf (r:1 w:1) // Storage: System Account (r:2 w:2) fn cancel_proposal() -> Weight { - // Minimum execution time: 140_203 nanoseconds. - Weight::from_ref_time(146_603_000 as u64) + // Minimum execution time: 144_803 nanoseconds. + Weight::from_ref_time(146_703_000 as u64) .saturating_add(T::DbWeight::get().reads(4 as u64)) .saturating_add(T::DbWeight::get().writes(4 as u64)) } // Storage: Democracy ReferendumInfoOf (r:0 w:1) fn cancel_referendum() -> Weight { - // Minimum execution time: 27_801 nanoseconds. - Weight::from_ref_time(28_601_000 as u64) + // Minimum execution time: 33_301 nanoseconds. + Weight::from_ref_time(33_701_000 as u64) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Democracy LowestUnbaked (r:1 w:1) @@ -142,10 +142,10 @@ impl pallet_democracy::WeightInfo for WeightInfo { // Storage: Democracy ReferendumInfoOf (r:2 w:0) /// The range of component `r` is `[0, 99]`. fn on_initialize_base(r: u32, ) -> Weight { - // Minimum execution time: 12_601 nanoseconds. - Weight::from_ref_time(19_125_902 as u64) - // Standard Error: 8_997 - .saturating_add(Weight::from_ref_time(4_067_788 as u64).saturating_mul(r as u64)) + // Minimum execution time: 12_501 nanoseconds. + Weight::from_ref_time(18_704_825 as u64) + // Standard Error: 7_209 + .saturating_add(Weight::from_ref_time(4_003_707 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().reads((1 as u64).saturating_mul(r as u64))) .saturating_add(T::DbWeight::get().writes(1 as u64)) @@ -158,10 +158,10 @@ impl pallet_democracy::WeightInfo for WeightInfo { // Storage: Democracy ReferendumInfoOf (r:2 w:0) /// The range of component `r` is `[0, 99]`. fn on_initialize_base_with_launch_period(r: u32, ) -> Weight { - // Minimum execution time: 17_600 nanoseconds. - Weight::from_ref_time(24_893_668 as u64) - // Standard Error: 9_430 - .saturating_add(Weight::from_ref_time(4_054_213 as u64).saturating_mul(r as u64)) + // Minimum execution time: 22_800 nanoseconds. + Weight::from_ref_time(23_536_577 as u64) + // Standard Error: 6_637 + .saturating_add(Weight::from_ref_time(4_013_686 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(5 as u64)) .saturating_add(T::DbWeight::get().reads((1 as u64).saturating_mul(r as u64))) .saturating_add(T::DbWeight::get().writes(1 as u64)) @@ -171,10 +171,10 @@ impl pallet_democracy::WeightInfo for WeightInfo { // Storage: Democracy ReferendumInfoOf (r:2 w:2) /// The range of component `r` is `[0, 99]`. fn delegate(r: u32, ) -> Weight { - // Minimum execution time: 83_901 nanoseconds. - Weight::from_ref_time(91_165_021 as u64) - // Standard Error: 9_818 - .saturating_add(Weight::from_ref_time(6_202_233 as u64).saturating_mul(r as u64)) + // Minimum execution time: 81_802 nanoseconds. + Weight::from_ref_time(88_265_440 as u64) + // Standard Error: 10_023 + .saturating_add(Weight::from_ref_time(6_248_403 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(4 as u64)) .saturating_add(T::DbWeight::get().reads((1 as u64).saturating_mul(r as u64))) .saturating_add(T::DbWeight::get().writes(4 as u64)) @@ -184,10 +184,10 @@ impl pallet_democracy::WeightInfo for WeightInfo { // Storage: Democracy ReferendumInfoOf (r:2 w:2) /// The range of component `r` is `[0, 99]`. fn undelegate(r: u32, ) -> Weight { - // Minimum execution time: 51_301 nanoseconds. - Weight::from_ref_time(55_202_350 as u64) - // Standard Error: 9_697 - .saturating_add(Weight::from_ref_time(6_102_441 as u64).saturating_mul(r as u64)) + // Minimum execution time: 48_801 nanoseconds. + Weight::from_ref_time(53_009_019 as u64) + // Standard Error: 9_366 + .saturating_add(Weight::from_ref_time(6_174_097 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().reads((1 as u64).saturating_mul(r as u64))) .saturating_add(T::DbWeight::get().writes(2 as u64)) @@ -195,8 +195,8 @@ impl pallet_democracy::WeightInfo for WeightInfo { } // Storage: Democracy PublicProps (r:0 w:1) fn clear_public_proposals() -> Weight { - // Minimum execution time: 11_700 nanoseconds. - Weight::from_ref_time(12_200_000 as u64) + // Minimum execution time: 12_800 nanoseconds. + Weight::from_ref_time(13_100_000 as u64) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Democracy VotingOf (r:1 w:1) @@ -204,10 +204,10 @@ impl pallet_democracy::WeightInfo for WeightInfo { // Storage: System Account (r:1 w:1) /// The range of component `r` is `[0, 99]`. fn unlock_remove(r: u32, ) -> Weight { - // Minimum execution time: 49_801 nanoseconds. - Weight::from_ref_time(60_491_330 as u64) - // Standard Error: 3_064 - .saturating_add(Weight::from_ref_time(145_194 as u64).saturating_mul(r as u64)) + // Minimum execution time: 50_002 nanoseconds. + Weight::from_ref_time(61_601_397 as u64) + // Standard Error: 3_901 + .saturating_add(Weight::from_ref_time(143_348 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -216,10 +216,10 @@ impl pallet_democracy::WeightInfo for WeightInfo { // Storage: System Account (r:1 w:1) /// The range of component `r` is `[0, 99]`. fn unlock_set(r: u32, ) -> Weight { - // Minimum execution time: 57_101 nanoseconds. - Weight::from_ref_time(59_152_639 as u64) - // Standard Error: 2_211 - .saturating_add(Weight::from_ref_time(218_465 as u64).saturating_mul(r as u64)) + // Minimum execution time: 58_001 nanoseconds. + Weight::from_ref_time(59_939_250 as u64) + // Standard Error: 1_732 + .saturating_add(Weight::from_ref_time(244_131 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -227,10 +227,10 @@ impl pallet_democracy::WeightInfo for WeightInfo { // Storage: Democracy VotingOf (r:1 w:1) /// The range of component `r` is `[1, 100]`. fn remove_vote(r: u32, ) -> Weight { - // Minimum execution time: 30_900 nanoseconds. - Weight::from_ref_time(35_886_616 as u64) - // Standard Error: 1_687 - .saturating_add(Weight::from_ref_time(224_177 as u64).saturating_mul(r as u64)) + // Minimum execution time: 32_500 nanoseconds. + Weight::from_ref_time(36_169_195 as u64) + // Standard Error: 2_271 + .saturating_add(Weight::from_ref_time(240_868 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } @@ -238,10 +238,10 @@ impl pallet_democracy::WeightInfo for WeightInfo { // Storage: Democracy VotingOf (r:1 w:1) /// The range of component `r` is `[1, 100]`. fn remove_other_vote(r: u32, ) -> Weight { - // Minimum execution time: 30_100 nanoseconds. - Weight::from_ref_time(35_429_670 as u64) - // Standard Error: 1_937 - .saturating_add(Weight::from_ref_time(227_094 as u64).saturating_mul(r as u64)) + // Minimum execution time: 32_401 nanoseconds. + Weight::from_ref_time(35_922_521 as u64) + // Standard Error: 2_302 + .saturating_add(Weight::from_ref_time(244_461 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } diff --git a/runtime/centrifuge/src/weights/pallet_elections_phragmen.rs b/runtime/centrifuge/src/weights/pallet_elections_phragmen.rs index 6d9e34cdbb..3c956d3830 100644 --- a/runtime/centrifuge/src/weights/pallet_elections_phragmen.rs +++ b/runtime/centrifuge/src/weights/pallet_elections_phragmen.rs @@ -1,3 +1,25 @@ + +//! Autogenerated weights for `pallet_elections_phragmen` +//! +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev +//! DATE: 2023-04-04, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` +//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("centrifuge-dev"), DB CACHE: 1024 + +// Executed Command: +// target/release/centrifuge-chain +// benchmark +// pallet +// --chain=centrifuge-dev +// --steps=50 +// --repeat=20 +// --pallet=pallet_elections_phragmen +// --extrinsic=* +// --execution=wasm +// --wasm-execution=compiled +// --heap-pages=4096 +// --output=/tmp/runtime/centrifuge/src/weights/pallet_elections_phragmen.rs + #![cfg_attr(rustfmt, rustfmt_skip)] #![allow(unused_parens)] #![allow(unused_imports)] @@ -5,137 +27,159 @@ use frame_support::{traits::Get, weights::Weight}; use sp_std::marker::PhantomData; -/// Weight functions for `pallet_crowdloan_reward`. +/// Weight functions for `pallet_elections_phragmen`. pub struct WeightInfo(PhantomData); impl pallet_elections_phragmen::WeightInfo for WeightInfo { - fn vote_equal(v: u32, ) -> Weight { - Weight::from_ref_time(27_011_000 as u64) - // Standard Error: 3_000 - .saturating_add(Weight::from_ref_time(214_000 as u64).saturating_mul(v as u64)) - .saturating_add(T::DbWeight::get().reads(5 as u64)) - .saturating_add(T::DbWeight::get().writes(2 as u64)) - } - // Storage: Elections Candidates (r:1 w:0) - // Storage: Elections Members (r:1 w:0) - // Storage: Elections RunnersUp (r:1 w:0) - // Storage: Elections Voting (r:1 w:1) - // Storage: Balances Locks (r:1 w:1) - /// The range of component `v` is `[2, 16]`. - fn vote_more(v: u32, ) -> Weight { - Weight::from_ref_time(40_240_000 as u64) - // Standard Error: 5_000 - .saturating_add(Weight::from_ref_time(244_000 as u64).saturating_mul(v as u64)) - .saturating_add(T::DbWeight::get().reads(5 as u64)) - .saturating_add(T::DbWeight::get().writes(2 as u64)) - } - // Storage: Elections Candidates (r:1 w:0) - // Storage: Elections Members (r:1 w:0) - // Storage: Elections RunnersUp (r:1 w:0) - // Storage: Elections Voting (r:1 w:1) - // Storage: Balances Locks (r:1 w:1) - /// The range of component `v` is `[2, 16]`. - fn vote_less(v: u32, ) -> Weight { - Weight::from_ref_time(40_394_000 as u64) - // Standard Error: 5_000 - .saturating_add(Weight::from_ref_time(217_000 as u64).saturating_mul(v as u64)) - .saturating_add(T::DbWeight::get().reads(5 as u64)) - .saturating_add(T::DbWeight::get().writes(2 as u64)) - } - // Storage: Elections Voting (r:1 w:1) - // Storage: Balances Locks (r:1 w:1) - fn remove_voter() -> Weight { - Weight::from_ref_time(37_651_000 as u64) - .saturating_add(T::DbWeight::get().reads(2 as u64)) - .saturating_add(T::DbWeight::get().writes(2 as u64)) - } - // Storage: Elections Candidates (r:1 w:1) - // Storage: Elections Members (r:1 w:0) - // Storage: Elections RunnersUp (r:1 w:0) - /// The range of component `c` is `[1, 1000]`. - fn submit_candidacy(c: u32, ) -> Weight { - Weight::from_ref_time(42_217_000 as u64) - // Standard Error: 0 - .saturating_add(Weight::from_ref_time(50_000 as u64).saturating_mul(c as u64)) - .saturating_add(T::DbWeight::get().reads(3 as u64)) - .saturating_add(T::DbWeight::get().writes(1 as u64)) - } - // Storage: Elections Candidates (r:1 w:1) - /// The range of component `c` is `[1, 1000]`. - fn renounce_candidacy_candidate(c: u32, ) -> Weight { - Weight::from_ref_time(46_459_000 as u64) - // Standard Error: 0 - .saturating_add(Weight::from_ref_time(26_000 as u64).saturating_mul(c as u64)) - .saturating_add(T::DbWeight::get().reads(1 as u64)) - .saturating_add(T::DbWeight::get().writes(1 as u64)) - } - // Storage: Elections Members (r:1 w:1) - // Storage: Elections RunnersUp (r:1 w:1) - // Storage: Council Prime (r:1 w:1) - // Storage: Council Proposals (r:1 w:0) - // Storage: Council Members (r:0 w:1) - fn renounce_candidacy_members() -> Weight { - Weight::from_ref_time(45_189_000 as u64) - .saturating_add(T::DbWeight::get().reads(4 as u64)) - .saturating_add(T::DbWeight::get().writes(4 as u64)) - } - // Storage: Elections RunnersUp (r:1 w:1) - fn renounce_candidacy_runners_up() -> Weight { - Weight::from_ref_time(34_516_000 as u64) - .saturating_add(T::DbWeight::get().reads(1 as u64)) - .saturating_add(T::DbWeight::get().writes(1 as u64)) - } - // Storage: Benchmark Override (r:0 w:0) - fn remove_member_without_replacement() -> Weight { - Weight::from_ref_time(2_000_000_000_000 as u64) - } - // Storage: Elections Members (r:1 w:1) - // Storage: System Account (r:1 w:1) - // Storage: Elections RunnersUp (r:1 w:1) - // Storage: Council Prime (r:1 w:1) - // Storage: Council Proposals (r:1 w:0) - // Storage: Council Members (r:0 w:1) - fn remove_member_with_replacement() -> Weight { - Weight::from_ref_time(51_838_000 as u64) - .saturating_add(T::DbWeight::get().reads(5 as u64)) - .saturating_add(T::DbWeight::get().writes(5 as u64)) - } - // Storage: Elections Voting (r:5001 w:5000) - // Storage: Elections Members (r:1 w:0) - // Storage: Elections RunnersUp (r:1 w:0) - // Storage: Elections Candidates (r:1 w:0) - // Storage: Balances Locks (r:5000 w:5000) - // Storage: System Account (r:5000 w:5000) - /// The range of component `v` is `[5000, 10000]`. - /// The range of component `d` is `[1, 5000]`. - fn clean_defunct_voters(v: u32, _d: u32, ) -> Weight { - Weight::from_ref_time(0 as u64) - // Standard Error: 76_000 - .saturating_add(Weight::from_ref_time(63_721_000 as u64).saturating_mul(v as u64)) - .saturating_add(T::DbWeight::get().reads(4 as u64)) - .saturating_add(T::DbWeight::get().reads((3 as u64).saturating_mul(v as u64))) - .saturating_add(T::DbWeight::get().writes((3 as u64).saturating_mul(v as u64))) - } - // Storage: Elections Candidates (r:1 w:1) - // Storage: Elections Members (r:1 w:1) - // Storage: Elections RunnersUp (r:1 w:1) - // Storage: Elections Voting (r:10001 w:0) - // Storage: Council Proposals (r:1 w:0) - // Storage: Elections ElectionRounds (r:1 w:1) - // Storage: Council Members (r:0 w:1) - // Storage: Council Prime (r:0 w:1) - // Storage: System Account (r:1 w:1) - /// The range of component `c` is `[1, 1000]`. - /// The range of component `v` is `[1, 10000]`. - /// The range of component `e` is `[10000, 160000]`. - fn election_phragmen(c: u32, v: u32, e: u32, ) -> Weight { - Weight::from_ref_time(0 as u64) - // Standard Error: 773_000 - .saturating_add(Weight::from_ref_time(81_534_000 as u64).saturating_mul(v as u64)) - // Standard Error: 51_000 - .saturating_add(Weight::from_ref_time(4_453_000 as u64).saturating_mul(e as u64)) - .saturating_add(T::DbWeight::get().reads(280 as u64)) - .saturating_add(T::DbWeight::get().reads((1 as u64).saturating_mul(c as u64))) - .saturating_add(T::DbWeight::get().reads((1 as u64).saturating_mul(v as u64))) - .saturating_add(T::DbWeight::get().writes((1 as u64).saturating_mul(c as u64))) - } + // Storage: Elections Candidates (r:1 w:0) + // Storage: Elections Members (r:1 w:0) + // Storage: Elections RunnersUp (r:1 w:0) + // Storage: Elections Voting (r:1 w:1) + // Storage: Balances Locks (r:1 w:1) + /// The range of component `v` is `[1, 16]`. + fn vote_equal(v: u32, ) -> Weight { + // Minimum execution time: 63_901 nanoseconds. + Weight::from_ref_time(65_309_969 as u64) + // Standard Error: 7_594 + .saturating_add(Weight::from_ref_time(342_539 as u64).saturating_mul(v as u64)) + .saturating_add(T::DbWeight::get().reads(5 as u64)) + .saturating_add(T::DbWeight::get().writes(2 as u64)) + } + // Storage: Elections Candidates (r:1 w:0) + // Storage: Elections Members (r:1 w:0) + // Storage: Elections RunnersUp (r:1 w:0) + // Storage: Elections Voting (r:1 w:1) + // Storage: Balances Locks (r:1 w:1) + /// The range of component `v` is `[2, 16]`. + fn vote_more(v: u32, ) -> Weight { + // Minimum execution time: 84_802 nanoseconds. + Weight::from_ref_time(86_223_873 as u64) + // Standard Error: 7_690 + .saturating_add(Weight::from_ref_time(326_659 as u64).saturating_mul(v as u64)) + .saturating_add(T::DbWeight::get().reads(5 as u64)) + .saturating_add(T::DbWeight::get().writes(2 as u64)) + } + // Storage: Elections Candidates (r:1 w:0) + // Storage: Elections Members (r:1 w:0) + // Storage: Elections RunnersUp (r:1 w:0) + // Storage: Elections Voting (r:1 w:1) + // Storage: Balances Locks (r:1 w:1) + /// The range of component `v` is `[2, 16]`. + fn vote_less(v: u32, ) -> Weight { + // Minimum execution time: 84_101 nanoseconds. + Weight::from_ref_time(85_229_121 as u64) + // Standard Error: 6_890 + .saturating_add(Weight::from_ref_time(420_454 as u64).saturating_mul(v as u64)) + .saturating_add(T::DbWeight::get().reads(5 as u64)) + .saturating_add(T::DbWeight::get().writes(2 as u64)) + } + // Storage: Elections Voting (r:1 w:1) + // Storage: Balances Locks (r:1 w:1) + fn remove_voter() -> Weight { + // Minimum execution time: 81_301 nanoseconds. + Weight::from_ref_time(83_402_000 as u64) + .saturating_add(T::DbWeight::get().reads(2 as u64)) + .saturating_add(T::DbWeight::get().writes(2 as u64)) + } + // Storage: Elections Candidates (r:1 w:1) + // Storage: Elections Members (r:1 w:0) + // Storage: Elections RunnersUp (r:1 w:0) + /// The range of component `c` is `[1, 100]`. + fn submit_candidacy(c: u32, ) -> Weight { + // Minimum execution time: 74_201 nanoseconds. + Weight::from_ref_time(75_924_426 as u64) + // Standard Error: 2_382 + .saturating_add(Weight::from_ref_time(213_577 as u64).saturating_mul(c as u64)) + .saturating_add(T::DbWeight::get().reads(3 as u64)) + .saturating_add(T::DbWeight::get().writes(1 as u64)) + } + // Storage: Elections Candidates (r:1 w:1) + /// The range of component `c` is `[1, 100]`. + fn renounce_candidacy_candidate(c: u32, ) -> Weight { + // Minimum execution time: 68_302 nanoseconds. + Weight::from_ref_time(70_114_230 as u64) + // Standard Error: 2_571 + .saturating_add(Weight::from_ref_time(176_249 as u64).saturating_mul(c as u64)) + .saturating_add(T::DbWeight::get().reads(1 as u64)) + .saturating_add(T::DbWeight::get().writes(1 as u64)) + } + // Storage: Elections Members (r:1 w:1) + // Storage: Elections RunnersUp (r:1 w:1) + // Storage: Council Prime (r:1 w:1) + // Storage: Council Proposals (r:1 w:0) + // Storage: Council Members (r:0 w:1) + fn renounce_candidacy_members() -> Weight { + // Minimum execution time: 92_102 nanoseconds. + Weight::from_ref_time(93_502_000 as u64) + .saturating_add(T::DbWeight::get().reads(4 as u64)) + .saturating_add(T::DbWeight::get().writes(4 as u64)) + } + // Storage: Elections RunnersUp (r:1 w:1) + fn renounce_candidacy_runners_up() -> Weight { + // Minimum execution time: 71_702 nanoseconds. + Weight::from_ref_time(74_002_000 as u64) + .saturating_add(T::DbWeight::get().reads(1 as u64)) + .saturating_add(T::DbWeight::get().writes(1 as u64)) + } + // Storage: Benchmark Override (r:0 w:0) + fn remove_member_without_replacement() -> Weight { + // Minimum execution time: 500_000_000 nanoseconds. + Weight::from_ref_time(500_000_000_000 as u64) + } + // Storage: Elections Members (r:1 w:1) + // Storage: System Account (r:2 w:2) + // Storage: Elections RunnersUp (r:1 w:1) + // Storage: Council Prime (r:1 w:1) + // Storage: Council Proposals (r:1 w:0) + // Storage: Council Members (r:0 w:1) + fn remove_member_with_replacement() -> Weight { + // Minimum execution time: 122_103 nanoseconds. + Weight::from_ref_time(124_803_000 as u64) + .saturating_add(T::DbWeight::get().reads(6 as u64)) + .saturating_add(T::DbWeight::get().writes(6 as u64)) + } + // Storage: Elections Voting (r:501 w:500) + // Storage: Elections Members (r:1 w:0) + // Storage: Elections RunnersUp (r:1 w:0) + // Storage: Elections Candidates (r:1 w:0) + // Storage: Balances Locks (r:500 w:500) + // Storage: System Account (r:500 w:500) + /// The range of component `v` is `[500, 1000]`. + /// The range of component `d` is `[0, 500]`. + fn clean_defunct_voters(v: u32, d: u32, ) -> Weight { + // Minimum execution time: 52_809_193 nanoseconds. + Weight::from_ref_time(615_950_395 as u64) + // Standard Error: 231_786 + .saturating_add(Weight::from_ref_time(105_277_626 as u64).saturating_mul(v as u64)) + // Standard Error: 231_786 + .saturating_add(Weight::from_ref_time(2_941_983 as u64).saturating_mul(d as u64)) + .saturating_add(T::DbWeight::get().reads(4 as u64)) + .saturating_add(T::DbWeight::get().reads((3 as u64).saturating_mul(v as u64))) + .saturating_add(T::DbWeight::get().writes(1500 as u64)) + .saturating_add(T::DbWeight::get().writes((2 as u64).saturating_mul(v as u64))) + } + // Storage: Elections Candidates (r:1 w:1) + // Storage: Elections Members (r:1 w:1) + // Storage: Elections RunnersUp (r:1 w:1) + // Storage: Elections Voting (r:1001 w:0) + // Storage: Council Proposals (r:1 w:0) + // Storage: Elections ElectionRounds (r:1 w:1) + // Storage: Council Members (r:0 w:1) + // Storage: Council Prime (r:0 w:1) + // Storage: System Account (r:2 w:2) + /// The range of component `c` is `[1, 100]`. + /// The range of component `v` is `[1, 1000]`. + /// The range of component `e` is `[1000, 16000]`. + fn election_phragmen(c: u32, v: u32, e: u32, ) -> Weight { + // Minimum execution time: 4_760_807 nanoseconds. + Weight::from_ref_time(4_817_808_000 as u64) + // Standard Error: 1_348_366 + .saturating_add(Weight::from_ref_time(48_837_129 as u64).saturating_mul(v as u64)) + // Standard Error: 86_531 + .saturating_add(Weight::from_ref_time(2_457_163 as u64).saturating_mul(e as u64)) + .saturating_add(T::DbWeight::get().reads(25 as u64)) + .saturating_add(T::DbWeight::get().reads((1 as u64).saturating_mul(c as u64))) + .saturating_add(T::DbWeight::get().reads((1 as u64).saturating_mul(v as u64))) + .saturating_add(T::DbWeight::get().writes(6 as u64)) + .saturating_add(T::DbWeight::get().writes((1 as u64).saturating_mul(c as u64))) + } } diff --git a/runtime/centrifuge/src/weights/pallet_fees.rs b/runtime/centrifuge/src/weights/pallet_fees.rs index 3a3e61a8b3..5cf65ecc0a 100644 --- a/runtime/centrifuge/src/weights/pallet_fees.rs +++ b/runtime/centrifuge/src/weights/pallet_fees.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_fees` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-03-27, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-04-04, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("centrifuge-dev"), DB CACHE: 1024 @@ -32,8 +32,8 @@ pub struct WeightInfo(PhantomData); impl pallet_fees::WeightInfo for WeightInfo { // Storage: Fees FeeBalances (r:0 w:1) fn set_fee() -> Weight { - // Minimum execution time: 28_200 nanoseconds. - Weight::from_ref_time(28_800_000 as u64) + // Minimum execution time: 27_800 nanoseconds. + Weight::from_ref_time(28_400_000 as u64) .saturating_add(T::DbWeight::get().writes(1 as u64)) } } diff --git a/runtime/centrifuge/src/weights/pallet_identity.rs b/runtime/centrifuge/src/weights/pallet_identity.rs index cf4d70a8ae..add2b3aeb4 100644 --- a/runtime/centrifuge/src/weights/pallet_identity.rs +++ b/runtime/centrifuge/src/weights/pallet_identity.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_identity` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-03-27, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-04-04, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("centrifuge-dev"), DB CACHE: 1024 @@ -33,10 +33,10 @@ impl pallet_identity::WeightInfo for WeightInfo { // Storage: Identity Registrars (r:1 w:1) /// The range of component `r` is `[1, 19]`. fn add_registrar(r: u32, ) -> Weight { - // Minimum execution time: 33_901 nanoseconds. - Weight::from_ref_time(36_565_115 as u64) - // Standard Error: 6_014 - .saturating_add(Weight::from_ref_time(355_051 as u64).saturating_mul(r as u64)) + // Minimum execution time: 35_301 nanoseconds. + Weight::from_ref_time(37_235_905 as u64) + // Standard Error: 7_047 + .saturating_add(Weight::from_ref_time(289_224 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } @@ -44,12 +44,12 @@ impl pallet_identity::WeightInfo for WeightInfo { /// The range of component `r` is `[1, 20]`. /// The range of component `x` is `[0, 100]`. fn set_identity(r: u32, x: u32, ) -> Weight { - // Minimum execution time: 71_001 nanoseconds. - Weight::from_ref_time(71_971_184 as u64) - // Standard Error: 17_290 - .saturating_add(Weight::from_ref_time(212_597 as u64).saturating_mul(r as u64)) - // Standard Error: 3_373 - .saturating_add(Weight::from_ref_time(687_353 as u64).saturating_mul(x as u64)) + // Minimum execution time: 71_502 nanoseconds. + Weight::from_ref_time(69_357_137 as u64) + // Standard Error: 6_081 + .saturating_add(Weight::from_ref_time(277_429 as u64).saturating_mul(r as u64)) + // Standard Error: 1_186 + .saturating_add(Weight::from_ref_time(730_922 as u64).saturating_mul(x as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } @@ -58,10 +58,10 @@ impl pallet_identity::WeightInfo for WeightInfo { // Storage: Identity SuperOf (r:2 w:2) /// The range of component `s` is `[0, 100]`. fn set_subs_new(s: u32, ) -> Weight { - // Minimum execution time: 21_701 nanoseconds. - Weight::from_ref_time(58_678_180 as u64) - // Standard Error: 17_227 - .saturating_add(Weight::from_ref_time(4_947_930 as u64).saturating_mul(s as u64)) + // Minimum execution time: 22_200 nanoseconds. + Weight::from_ref_time(56_591_886 as u64) + // Standard Error: 16_558 + .saturating_add(Weight::from_ref_time(4_962_584 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().reads((1 as u64).saturating_mul(s as u64))) .saturating_add(T::DbWeight::get().writes(1 as u64)) @@ -72,10 +72,10 @@ impl pallet_identity::WeightInfo for WeightInfo { // Storage: Identity SuperOf (r:0 w:2) /// The range of component `p` is `[0, 100]`. fn set_subs_old(p: u32, ) -> Weight { - // Minimum execution time: 21_600 nanoseconds. - Weight::from_ref_time(56_976_382 as u64) - // Standard Error: 9_475 - .saturating_add(Weight::from_ref_time(2_138_866 as u64).saturating_mul(p as u64)) + // Minimum execution time: 21_800 nanoseconds. + Weight::from_ref_time(53_258_274 as u64) + // Standard Error: 33_608 + .saturating_add(Weight::from_ref_time(2_245_579 as u64).saturating_mul(p as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) .saturating_add(T::DbWeight::get().writes((1 as u64).saturating_mul(p as u64))) @@ -87,14 +87,14 @@ impl pallet_identity::WeightInfo for WeightInfo { /// The range of component `s` is `[0, 100]`. /// The range of component `x` is `[0, 100]`. fn clear_identity(r: u32, s: u32, x: u32, ) -> Weight { - // Minimum execution time: 97_602 nanoseconds. - Weight::from_ref_time(67_749_322 as u64) - // Standard Error: 14_449 - .saturating_add(Weight::from_ref_time(327_577 as u64).saturating_mul(r as u64)) - // Standard Error: 2_821 - .saturating_add(Weight::from_ref_time(2_092_108 as u64).saturating_mul(s as u64)) - // Standard Error: 2_821 - .saturating_add(Weight::from_ref_time(373_695 as u64).saturating_mul(x as u64)) + // Minimum execution time: 102_902 nanoseconds. + Weight::from_ref_time(72_068_945 as u64) + // Standard Error: 13_005 + .saturating_add(Weight::from_ref_time(140_450 as u64).saturating_mul(r as u64)) + // Standard Error: 2_539 + .saturating_add(Weight::from_ref_time(2_045_561 as u64).saturating_mul(s as u64)) + // Standard Error: 2_539 + .saturating_add(Weight::from_ref_time(375_246 as u64).saturating_mul(x as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) .saturating_add(T::DbWeight::get().writes((1 as u64).saturating_mul(s as u64))) @@ -104,12 +104,12 @@ impl pallet_identity::WeightInfo for WeightInfo { /// The range of component `r` is `[1, 20]`. /// The range of component `x` is `[0, 100]`. fn request_judgement(r: u32, x: u32, ) -> Weight { - // Minimum execution time: 70_402 nanoseconds. - Weight::from_ref_time(71_112_279 as u64) - // Standard Error: 16_853 - .saturating_add(Weight::from_ref_time(413_327 as u64).saturating_mul(r as u64)) - // Standard Error: 3_288 - .saturating_add(Weight::from_ref_time(711_853 as u64).saturating_mul(x as u64)) + // Minimum execution time: 73_202 nanoseconds. + Weight::from_ref_time(70_559_786 as u64) + // Standard Error: 8_453 + .saturating_add(Weight::from_ref_time(350_879 as u64).saturating_mul(r as u64)) + // Standard Error: 1_649 + .saturating_add(Weight::from_ref_time(749_995 as u64).saturating_mul(x as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } @@ -117,42 +117,42 @@ impl pallet_identity::WeightInfo for WeightInfo { /// The range of component `r` is `[1, 20]`. /// The range of component `x` is `[0, 100]`. fn cancel_request(r: u32, x: u32, ) -> Weight { - // Minimum execution time: 66_402 nanoseconds. - Weight::from_ref_time(66_553_026 as u64) - // Standard Error: 7_137 - .saturating_add(Weight::from_ref_time(306_576 as u64).saturating_mul(r as u64)) - // Standard Error: 1_392 - .saturating_add(Weight::from_ref_time(705_712 as u64).saturating_mul(x as u64)) + // Minimum execution time: 68_002 nanoseconds. + Weight::from_ref_time(66_477_873 as u64) + // Standard Error: 9_139 + .saturating_add(Weight::from_ref_time(250_897 as u64).saturating_mul(r as u64)) + // Standard Error: 1_783 + .saturating_add(Weight::from_ref_time(743_675 as u64).saturating_mul(x as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Identity Registrars (r:1 w:1) /// The range of component `r` is `[1, 19]`. fn set_fee(r: u32, ) -> Weight { - // Minimum execution time: 17_800 nanoseconds. - Weight::from_ref_time(19_502_048 as u64) - // Standard Error: 4_244 - .saturating_add(Weight::from_ref_time(274_499 as u64).saturating_mul(r as u64)) + // Minimum execution time: 18_000 nanoseconds. + Weight::from_ref_time(19_621_126 as u64) + // Standard Error: 5_067 + .saturating_add(Weight::from_ref_time(253_926 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Identity Registrars (r:1 w:1) /// The range of component `r` is `[1, 19]`. fn set_account_id(r: u32, ) -> Weight { - // Minimum execution time: 18_500 nanoseconds. - Weight::from_ref_time(19_873_597 as u64) - // Standard Error: 3_337 - .saturating_add(Weight::from_ref_time(275_676 as u64).saturating_mul(r as u64)) + // Minimum execution time: 18_600 nanoseconds. + Weight::from_ref_time(20_044_307 as u64) + // Standard Error: 4_142 + .saturating_add(Weight::from_ref_time(248_973 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Identity Registrars (r:1 w:1) /// The range of component `r` is `[1, 19]`. fn set_fields(r: u32, ) -> Weight { - // Minimum execution time: 17_901 nanoseconds. - Weight::from_ref_time(19_739_614 as u64) - // Standard Error: 3_708 - .saturating_add(Weight::from_ref_time(283_260 as u64).saturating_mul(r as u64)) + // Minimum execution time: 18_501 nanoseconds. + Weight::from_ref_time(19_565_373 as u64) + // Standard Error: 4_277 + .saturating_add(Weight::from_ref_time(255_202 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } @@ -161,12 +161,12 @@ impl pallet_identity::WeightInfo for WeightInfo { /// The range of component `r` is `[1, 19]`. /// The range of component `x` is `[0, 100]`. fn provide_judgement(r: u32, x: u32, ) -> Weight { - // Minimum execution time: 54_001 nanoseconds. - Weight::from_ref_time(53_284_974 as u64) - // Standard Error: 7_268 - .saturating_add(Weight::from_ref_time(372_905 as u64).saturating_mul(r as u64)) - // Standard Error: 1_344 - .saturating_add(Weight::from_ref_time(1_145_325 as u64).saturating_mul(x as u64)) + // Minimum execution time: 53_101 nanoseconds. + Weight::from_ref_time(54_986_544 as u64) + // Standard Error: 8_534 + .saturating_add(Weight::from_ref_time(251_919 as u64).saturating_mul(r as u64)) + // Standard Error: 1_579 + .saturating_add(Weight::from_ref_time(1_199_138 as u64).saturating_mul(x as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } @@ -178,14 +178,14 @@ impl pallet_identity::WeightInfo for WeightInfo { /// The range of component `s` is `[0, 100]`. /// The range of component `x` is `[0, 100]`. fn kill_identity(r: u32, s: u32, x: u32, ) -> Weight { - // Minimum execution time: 119_502 nanoseconds. - Weight::from_ref_time(88_057_690 as u64) - // Standard Error: 16_781 - .saturating_add(Weight::from_ref_time(515_023 as u64).saturating_mul(r as u64)) - // Standard Error: 3_277 - .saturating_add(Weight::from_ref_time(2_085_492 as u64).saturating_mul(s as u64)) - // Standard Error: 3_277 - .saturating_add(Weight::from_ref_time(380_020 as u64).saturating_mul(x as u64)) + // Minimum execution time: 121_002 nanoseconds. + Weight::from_ref_time(89_243_904 as u64) + // Standard Error: 16_466 + .saturating_add(Weight::from_ref_time(401_157 as u64).saturating_mul(r as u64)) + // Standard Error: 3_215 + .saturating_add(Weight::from_ref_time(2_052_537 as u64).saturating_mul(s as u64)) + // Standard Error: 3_215 + .saturating_add(Weight::from_ref_time(386_202 as u64).saturating_mul(x as u64)) .saturating_add(T::DbWeight::get().reads(4 as u64)) .saturating_add(T::DbWeight::get().writes(4 as u64)) .saturating_add(T::DbWeight::get().writes((1 as u64).saturating_mul(s as u64))) @@ -195,10 +195,10 @@ impl pallet_identity::WeightInfo for WeightInfo { // Storage: Identity SubsOf (r:1 w:1) /// The range of component `s` is `[0, 99]`. fn add_sub(s: u32, ) -> Weight { - // Minimum execution time: 66_501 nanoseconds. - Weight::from_ref_time(76_420_433 as u64) - // Standard Error: 7_023 - .saturating_add(Weight::from_ref_time(198_860 as u64).saturating_mul(s as u64)) + // Minimum execution time: 64_701 nanoseconds. + Weight::from_ref_time(72_825_179 as u64) + // Standard Error: 3_500 + .saturating_add(Weight::from_ref_time(207_214 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } @@ -206,10 +206,10 @@ impl pallet_identity::WeightInfo for WeightInfo { // Storage: Identity SuperOf (r:1 w:1) /// The range of component `s` is `[1, 100]`. fn rename_sub(s: u32, ) -> Weight { - // Minimum execution time: 28_000 nanoseconds. - Weight::from_ref_time(31_341_109 as u64) - // Standard Error: 1_659 - .saturating_add(Weight::from_ref_time(126_133 as u64).saturating_mul(s as u64)) + // Minimum execution time: 27_600 nanoseconds. + Weight::from_ref_time(32_126_358 as u64) + // Standard Error: 2_618 + .saturating_add(Weight::from_ref_time(101_397 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } @@ -218,10 +218,10 @@ impl pallet_identity::WeightInfo for WeightInfo { // Storage: Identity SubsOf (r:1 w:1) /// The range of component `s` is `[1, 100]`. fn remove_sub(s: u32, ) -> Weight { - // Minimum execution time: 69_301 nanoseconds. - Weight::from_ref_time(76_520_242 as u64) - // Standard Error: 2_347 - .saturating_add(Weight::from_ref_time(202_555 as u64).saturating_mul(s as u64)) + // Minimum execution time: 69_101 nanoseconds. + Weight::from_ref_time(76_166_722 as u64) + // Standard Error: 5_014 + .saturating_add(Weight::from_ref_time(172_355 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } @@ -229,10 +229,10 @@ impl pallet_identity::WeightInfo for WeightInfo { // Storage: Identity SubsOf (r:1 w:1) /// The range of component `s` is `[0, 99]`. fn quit_sub(s: u32, ) -> Weight { - // Minimum execution time: 50_001 nanoseconds. - Weight::from_ref_time(56_016_262 as u64) - // Standard Error: 2_689 - .saturating_add(Weight::from_ref_time(187_217 as u64).saturating_mul(s as u64)) + // Minimum execution time: 47_401 nanoseconds. + Weight::from_ref_time(53_478_421 as u64) + // Standard Error: 3_063 + .saturating_add(Weight::from_ref_time(193_582 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } diff --git a/runtime/centrifuge/src/weights/pallet_interest_accrual.rs b/runtime/centrifuge/src/weights/pallet_interest_accrual.rs index 866929708f..6b7048f982 100644 --- a/runtime/centrifuge/src/weights/pallet_interest_accrual.rs +++ b/runtime/centrifuge/src/weights/pallet_interest_accrual.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_interest_accrual` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-03-27, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-04-04, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("centrifuge-dev"), DB CACHE: 1024 @@ -32,9 +32,9 @@ pub struct WeightInfo(PhantomData); impl pallet_interest_accrual::WeightInfo for WeightInfo { /// The range of component `n` is `[1, 25]`. fn calculate_accumulated_rate(n: u32, ) -> Weight { - // Minimum execution time: 800 nanoseconds. - Weight::from_ref_time(900_000 as u64) - // Standard Error: 2_663 - .saturating_add(Weight::from_ref_time(993_693 as u64).saturating_mul(n as u64)) + // Minimum execution time: 700 nanoseconds. + Weight::from_ref_time(800_000 as u64) + // Standard Error: 2_281 + .saturating_add(Weight::from_ref_time(820_332 as u64).saturating_mul(n as u64)) } } diff --git a/runtime/centrifuge/src/weights/pallet_keystore.rs b/runtime/centrifuge/src/weights/pallet_keystore.rs index c8c941d36e..8dbf4b09cf 100644 --- a/runtime/centrifuge/src/weights/pallet_keystore.rs +++ b/runtime/centrifuge/src/weights/pallet_keystore.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_keystore` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-03-27, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-04-04, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("centrifuge-dev"), DB CACHE: 1024 @@ -36,10 +36,10 @@ impl pallet_keystore::WeightInfo for WeightInfo { // Storage: Keystore LastKeyByPurpose (r:0 w:1) /// The range of component `n` is `[1, 10]`. fn add_keys(n: u32, ) -> Weight { - // Minimum execution time: 59_301 nanoseconds. - Weight::from_ref_time(38_695_384 as u64) - // Standard Error: 38_128 - .saturating_add(Weight::from_ref_time(26_742_823 as u64).saturating_mul(n as u64)) + // Minimum execution time: 58_501 nanoseconds. + Weight::from_ref_time(37_620_158 as u64) + // Standard Error: 21_314 + .saturating_add(Weight::from_ref_time(26_822_101 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().reads((1 as u64).saturating_mul(n as u64))) .saturating_add(T::DbWeight::get().writes(2 as u64)) @@ -48,17 +48,17 @@ impl pallet_keystore::WeightInfo for WeightInfo { // Storage: Keystore Keys (r:1 w:1) /// The range of component `n` is `[1, 10]`. fn revoke_keys(n: u32, ) -> Weight { - // Minimum execution time: 39_801 nanoseconds. - Weight::from_ref_time(26_934_593 as u64) - // Standard Error: 19_158 - .saturating_add(Weight::from_ref_time(15_472_918 as u64).saturating_mul(n as u64)) + // Minimum execution time: 37_600 nanoseconds. + Weight::from_ref_time(27_240_809 as u64) + // Standard Error: 23_595 + .saturating_add(Weight::from_ref_time(15_414_736 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads((1 as u64).saturating_mul(n as u64))) .saturating_add(T::DbWeight::get().writes((1 as u64).saturating_mul(n as u64))) } // Storage: Keystore KeyDeposit (r:0 w:1) fn set_deposit() -> Weight { - // Minimum execution time: 36_000 nanoseconds. - Weight::from_ref_time(36_901_000 as u64) + // Minimum execution time: 27_300 nanoseconds. + Weight::from_ref_time(28_001_000 as u64) .saturating_add(T::DbWeight::get().writes(1 as u64)) } } diff --git a/runtime/centrifuge/src/weights/pallet_loans_ref.rs b/runtime/centrifuge/src/weights/pallet_loans_ref.rs index e40e8af2ea..fe453aba7e 100644 --- a/runtime/centrifuge/src/weights/pallet_loans_ref.rs +++ b/runtime/centrifuge/src/weights/pallet_loans_ref.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_loans_ref` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-03-27, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-04-04, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("centrifuge-dev"), DB CACHE: 1024 @@ -40,14 +40,15 @@ impl pallet_loans_ref::WeightInfo for WeightInfo { // Storage: Uniques Account (r:0 w:2) // Storage: Uniques ItemPriceOf (r:0 w:1) fn create() -> Weight { - // Minimum execution time: 116_502 nanoseconds. - Weight::from_ref_time(119_203_000 as u64) + // Minimum execution time: 107_902 nanoseconds. + Weight::from_ref_time(117_103_000 as u64) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(6 as u64)) } // Storage: Loans CreatedLoan (r:1 w:1) // Storage: Timestamp Now (r:1 w:0) // Storage: InterestAccrual Rates (r:1 w:1) + // Storage: InterestAccrual LastUpdated (r:1 w:0) // Storage: Loans PortfolioValuation (r:1 w:1) // Storage: Loans ActiveLoans (r:1 w:1) // Storage: PoolSystem Pool (r:1 w:1) @@ -55,56 +56,59 @@ impl pallet_loans_ref::WeightInfo for WeightInfo { // Storage: System Account (r:1 w:0) /// The range of component `n` is `[1, 999]`. fn borrow(n: u32, ) -> Weight { - // Minimum execution time: 308_006 nanoseconds. - Weight::from_ref_time(316_993_186 as u64) - // Standard Error: 2_927 - .saturating_add(Weight::from_ref_time(633_288 as u64).saturating_mul(n as u64)) - .saturating_add(T::DbWeight::get().reads(9 as u64)) + // Minimum execution time: 282_307 nanoseconds. + Weight::from_ref_time(283_899_253 as u64) + // Standard Error: 4_981 + .saturating_add(Weight::from_ref_time(800_531 as u64).saturating_mul(n as u64)) + .saturating_add(T::DbWeight::get().reads(10 as u64)) .saturating_add(T::DbWeight::get().writes(7 as u64)) } // Storage: Loans PortfolioValuation (r:1 w:1) // Storage: Loans ActiveLoans (r:1 w:1) - // Storage: Timestamp Now (r:1 w:0) // Storage: InterestAccrual Rates (r:1 w:0) + // Storage: InterestAccrual LastUpdated (r:1 w:0) + // Storage: Timestamp Now (r:1 w:0) // Storage: PoolSystem Pool (r:1 w:1) // Storage: OrmlTokens Accounts (r:2 w:2) // Storage: System Account (r:1 w:0) /// The range of component `n` is `[1, 999]`. fn repay(n: u32, ) -> Weight { - // Minimum execution time: 240_804 nanoseconds. - Weight::from_ref_time(244_230_368 as u64) - // Standard Error: 5_699 - .saturating_add(Weight::from_ref_time(730_962 as u64).saturating_mul(n as u64)) - .saturating_add(T::DbWeight::get().reads(8 as u64)) + // Minimum execution time: 275_706 nanoseconds. + Weight::from_ref_time(285_156_089 as u64) + // Standard Error: 3_346 + .saturating_add(Weight::from_ref_time(741_436 as u64).saturating_mul(n as u64)) + .saturating_add(T::DbWeight::get().reads(9 as u64)) .saturating_add(T::DbWeight::get().writes(5 as u64)) } // Storage: Loans PortfolioValuation (r:1 w:1) // Storage: Loans ActiveLoans (r:1 w:1) - // Storage: Timestamp Now (r:1 w:0) // Storage: InterestAccrual Rates (r:1 w:1) + // Storage: InterestAccrual LastUpdated (r:1 w:0) // Storage: Loans WriteOffPolicy (r:1 w:0) + // Storage: Timestamp Now (r:1 w:0) /// The range of component `n` is `[1, 999]`. fn write_off(n: u32, ) -> Weight { - // Minimum execution time: 268_205 nanoseconds. - Weight::from_ref_time(274_550_761 as u64) - // Standard Error: 4_802 - .saturating_add(Weight::from_ref_time(690_348 as u64).saturating_mul(n as u64)) - .saturating_add(T::DbWeight::get().reads(5 as u64)) + // Minimum execution time: 272_906 nanoseconds. + Weight::from_ref_time(280_572_778 as u64) + // Standard Error: 4_555 + .saturating_add(Weight::from_ref_time(784_789 as u64).saturating_mul(n as u64)) + .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } // Storage: Permissions Permission (r:1 w:0) // Storage: Loans PortfolioValuation (r:1 w:1) // Storage: Loans ActiveLoans (r:1 w:1) - // Storage: Timestamp Now (r:1 w:0) // Storage: InterestAccrual Rates (r:1 w:1) + // Storage: InterestAccrual LastUpdated (r:1 w:0) // Storage: Loans WriteOffPolicy (r:1 w:0) + // Storage: Timestamp Now (r:1 w:0) /// The range of component `n` is `[1, 999]`. fn admin_write_off(n: u32, ) -> Weight { - // Minimum execution time: 282_105 nanoseconds. - Weight::from_ref_time(290_877_496 as u64) - // Standard Error: 3_721 - .saturating_add(Weight::from_ref_time(663_174 as u64).saturating_mul(n as u64)) - .saturating_add(T::DbWeight::get().reads(6 as u64)) + // Minimum execution time: 303_808 nanoseconds. + Weight::from_ref_time(336_592_045 as u64) + // Standard Error: 4_711 + .saturating_add(Weight::from_ref_time(717_323 as u64).saturating_mul(n as u64)) + .saturating_add(T::DbWeight::get().reads(7 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } // Storage: Loans CreatedLoan (r:1 w:0) @@ -117,10 +121,10 @@ impl pallet_loans_ref::WeightInfo for WeightInfo { // Storage: Uniques ItemPriceOf (r:0 w:1) /// The range of component `n` is `[1, 999]`. fn close(n: u32, ) -> Weight { - // Minimum execution time: 158_403 nanoseconds. - Weight::from_ref_time(160_732_151 as u64) - // Standard Error: 4_195 - .saturating_add(Weight::from_ref_time(647_491 as u64).saturating_mul(n as u64)) + // Minimum execution time: 161_703 nanoseconds. + Weight::from_ref_time(166_436_250 as u64) + // Standard Error: 4_529 + .saturating_add(Weight::from_ref_time(812_309 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(5 as u64)) .saturating_add(T::DbWeight::get().writes(7 as u64)) } @@ -128,8 +132,8 @@ impl pallet_loans_ref::WeightInfo for WeightInfo { // Storage: PoolSystem Pool (r:1 w:0) // Storage: Loans WriteOffPolicy (r:0 w:1) fn update_write_off_policy() -> Weight { - // Minimum execution time: 108_302 nanoseconds. - Weight::from_ref_time(109_402_000 as u64) + // Minimum execution time: 69_202 nanoseconds. + Weight::from_ref_time(70_601_000 as u64) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } @@ -140,10 +144,10 @@ impl pallet_loans_ref::WeightInfo for WeightInfo { // Storage: Loans PortfolioValuation (r:0 w:1) /// The range of component `n` is `[1, 1000]`. fn update_portfolio_valuation(n: u32, ) -> Weight { - // Minimum execution time: 119_102 nanoseconds. - Weight::from_ref_time(110_694_941 as u64) - // Standard Error: 3_065 - .saturating_add(Weight::from_ref_time(13_439_124 as u64).saturating_mul(n as u64)) + // Minimum execution time: 120_103 nanoseconds. + Weight::from_ref_time(128_977_918 as u64) + // Standard Error: 3_534 + .saturating_add(Weight::from_ref_time(13_717_915 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(4 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } diff --git a/runtime/centrifuge/src/weights/pallet_migration_manager.rs b/runtime/centrifuge/src/weights/pallet_migration_manager.rs index c5a9550b58..218abd7d27 100644 --- a/runtime/centrifuge/src/weights/pallet_migration_manager.rs +++ b/runtime/centrifuge/src/weights/pallet_migration_manager.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_migration_manager` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-03-27, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-04-04, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("centrifuge-dev"), DB CACHE: 1024 @@ -32,8 +32,8 @@ pub struct WeightInfo(PhantomData); impl pallet_migration_manager::WeightInfo for WeightInfo { // Storage: Migration Status (r:1 w:1) fn finalize() -> Weight { - // Minimum execution time: 35_900 nanoseconds. - Weight::from_ref_time(36_800_000 as u64) + // Minimum execution time: 35_800 nanoseconds. + Weight::from_ref_time(36_401_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } @@ -41,18 +41,18 @@ impl pallet_migration_manager::WeightInfo for WeightInf // Storage: System Account (r:0 w:1) /// The range of component `n` is `[1, 100]`. fn migrate_system_account(n: u32, ) -> Weight { - // Minimum execution time: 38_501 nanoseconds. - Weight::from_ref_time(40_227_441 as u64) - // Standard Error: 4_630 - .saturating_add(Weight::from_ref_time(1_440_647 as u64).saturating_mul(n as u64)) + // Minimum execution time: 38_901 nanoseconds. + Weight::from_ref_time(41_005_900 as u64) + // Standard Error: 6_150 + .saturating_add(Weight::from_ref_time(1_477_651 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) .saturating_add(T::DbWeight::get().writes((1 as u64).saturating_mul(n as u64))) } // Storage: Migration Status (r:1 w:1) fn migrate_balances_issuance() -> Weight { - // Minimum execution time: 42_501 nanoseconds. - Weight::from_ref_time(43_200_000 as u64) + // Minimum execution time: 42_201 nanoseconds. + Weight::from_ref_time(43_201_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } @@ -62,10 +62,10 @@ impl pallet_migration_manager::WeightInfo for WeightInf // Storage: System Account (r:1 w:1) /// The range of component `n` is `[1, 10]`. fn migrate_vesting_vesting(n: u32, ) -> Weight { - // Minimum execution time: 184_903 nanoseconds. - Weight::from_ref_time(166_771_787 as u64) - // Standard Error: 114_897 - .saturating_add(Weight::from_ref_time(42_758_513 as u64).saturating_mul(n as u64)) + // Minimum execution time: 204_004 nanoseconds. + Weight::from_ref_time(176_509_257 as u64) + // Standard Error: 150_508 + .saturating_add(Weight::from_ref_time(45_926_411 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().reads((3 as u64).saturating_mul(n as u64))) .saturating_add(T::DbWeight::get().writes(1 as u64)) @@ -75,10 +75,10 @@ impl pallet_migration_manager::WeightInfo for WeightInf // Storage: Proxy Proxies (r:0 w:1) /// The range of component `n` is `[1, 10]`. fn migrate_proxy_proxies(n: u32, ) -> Weight { - // Minimum execution time: 138_502 nanoseconds. - Weight::from_ref_time(144_494_493 as u64) - // Standard Error: 101_499 - .saturating_add(Weight::from_ref_time(8_449_470 as u64).saturating_mul(n as u64)) + // Minimum execution time: 167_304 nanoseconds. + Weight::from_ref_time(185_821_251 as u64) + // Standard Error: 131_547 + .saturating_add(Weight::from_ref_time(8_287_112 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) .saturating_add(T::DbWeight::get().writes((1 as u64).saturating_mul(n as u64))) diff --git a/runtime/centrifuge/src/weights/pallet_multisig.rs b/runtime/centrifuge/src/weights/pallet_multisig.rs index c3820a74c5..2333235246 100644 --- a/runtime/centrifuge/src/weights/pallet_multisig.rs +++ b/runtime/centrifuge/src/weights/pallet_multisig.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_multisig` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-03-27, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-04-04, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("centrifuge-dev"), DB CACHE: 1024 @@ -32,22 +32,22 @@ pub struct WeightInfo(PhantomData); impl pallet_multisig::WeightInfo for WeightInfo { /// The range of component `z` is `[0, 10000]`. fn as_multi_threshold_1(z: u32, ) -> Weight { - // Minimum execution time: 35_400 nanoseconds. - Weight::from_ref_time(37_542_343 as u64) - // Standard Error: 10 - .saturating_add(Weight::from_ref_time(514 as u64).saturating_mul(z as u64)) + // Minimum execution time: 34_601 nanoseconds. + Weight::from_ref_time(38_130_884 as u64) + // Standard Error: 21 + .saturating_add(Weight::from_ref_time(933 as u64).saturating_mul(z as u64)) } // Storage: Multisig Multisigs (r:1 w:1) // Storage: unknown [0x3a65787472696e7369635f696e646578] (r:1 w:0) /// The range of component `s` is `[2, 100]`. /// The range of component `z` is `[0, 10000]`. fn as_multi_create(s: u32, z: u32, ) -> Weight { - // Minimum execution time: 85_501 nanoseconds. - Weight::from_ref_time(70_300_485 as u64) - // Standard Error: 3_335 - .saturating_add(Weight::from_ref_time(197_291 as u64).saturating_mul(s as u64)) + // Minimum execution time: 82_502 nanoseconds. + Weight::from_ref_time(70_619_123 as u64) + // Standard Error: 3_360 + .saturating_add(Weight::from_ref_time(224_323 as u64).saturating_mul(s as u64)) // Standard Error: 32 - .saturating_add(Weight::from_ref_time(2_147 as u64).saturating_mul(z as u64)) + .saturating_add(Weight::from_ref_time(2_266 as u64).saturating_mul(z as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } @@ -55,12 +55,12 @@ impl pallet_multisig::WeightInfo for WeightInfo { /// The range of component `s` is `[3, 100]`. /// The range of component `z` is `[0, 10000]`. fn as_multi_approve(s: u32, z: u32, ) -> Weight { - // Minimum execution time: 67_501 nanoseconds. - Weight::from_ref_time(49_100_770 as u64) - // Standard Error: 6_091 - .saturating_add(Weight::from_ref_time(212_852 as u64).saturating_mul(s as u64)) - // Standard Error: 59 - .saturating_add(Weight::from_ref_time(2_171 as u64).saturating_mul(z as u64)) + // Minimum execution time: 70_601 nanoseconds. + Weight::from_ref_time(54_736_323 as u64) + // Standard Error: 3_625 + .saturating_add(Weight::from_ref_time(190_967 as u64).saturating_mul(s as u64)) + // Standard Error: 35 + .saturating_add(Weight::from_ref_time(2_133 as u64).saturating_mul(z as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } @@ -69,12 +69,12 @@ impl pallet_multisig::WeightInfo for WeightInfo { /// The range of component `s` is `[2, 100]`. /// The range of component `z` is `[0, 10000]`. fn as_multi_complete(s: u32, z: u32, ) -> Weight { - // Minimum execution time: 92_401 nanoseconds. - Weight::from_ref_time(75_364_334 as u64) - // Standard Error: 1_554 - .saturating_add(Weight::from_ref_time(242_175 as u64).saturating_mul(s as u64)) - // Standard Error: 15 - .saturating_add(Weight::from_ref_time(2_076 as u64).saturating_mul(z as u64)) + // Minimum execution time: 93_402 nanoseconds. + Weight::from_ref_time(73_384_057 as u64) + // Standard Error: 1_762 + .saturating_add(Weight::from_ref_time(281_005 as u64).saturating_mul(s as u64)) + // Standard Error: 17 + .saturating_add(Weight::from_ref_time(2_407 as u64).saturating_mul(z as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } @@ -82,30 +82,30 @@ impl pallet_multisig::WeightInfo for WeightInfo { // Storage: unknown [0x3a65787472696e7369635f696e646578] (r:1 w:0) /// The range of component `s` is `[2, 100]`. fn approve_as_multi_create(s: u32, ) -> Weight { - // Minimum execution time: 64_901 nanoseconds. - Weight::from_ref_time(68_371_584 as u64) - // Standard Error: 3_459 - .saturating_add(Weight::from_ref_time(195_491 as u64).saturating_mul(s as u64)) + // Minimum execution time: 65_201 nanoseconds. + Weight::from_ref_time(67_622_872 as u64) + // Standard Error: 2_151 + .saturating_add(Weight::from_ref_time(225_041 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Multisig Multisigs (r:1 w:1) /// The range of component `s` is `[2, 100]`. fn approve_as_multi_approve(s: u32, ) -> Weight { - // Minimum execution time: 45_701 nanoseconds. - Weight::from_ref_time(48_100_070 as u64) - // Standard Error: 2_287 - .saturating_add(Weight::from_ref_time(203_019 as u64).saturating_mul(s as u64)) + // Minimum execution time: 45_301 nanoseconds. + Weight::from_ref_time(48_639_060 as u64) + // Standard Error: 2_895 + .saturating_add(Weight::from_ref_time(220_161 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Multisig Multisigs (r:1 w:1) /// The range of component `s` is `[2, 100]`. fn cancel_as_multi(s: u32, ) -> Weight { - // Minimum execution time: 64_401 nanoseconds. - Weight::from_ref_time(68_283_025 as u64) - // Standard Error: 1_666 - .saturating_add(Weight::from_ref_time(199_581 as u64).saturating_mul(s as u64)) + // Minimum execution time: 64_101 nanoseconds. + Weight::from_ref_time(67_160_189 as u64) + // Standard Error: 2_569 + .saturating_add(Weight::from_ref_time(222_085 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } diff --git a/runtime/centrifuge/src/weights/pallet_permissions.rs b/runtime/centrifuge/src/weights/pallet_permissions.rs index b9b65608d9..3b0d5b7812 100644 --- a/runtime/centrifuge/src/weights/pallet_permissions.rs +++ b/runtime/centrifuge/src/weights/pallet_permissions.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_permissions` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-03-27, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-04-04, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("centrifuge-dev"), DB CACHE: 1024 @@ -33,46 +33,46 @@ impl pallet_permissions::WeightInfo for WeightInfo { // Storage: Permissions PermissionCount (r:1 w:1) // Storage: Permissions Permission (r:1 w:1) fn add_as_admin() -> Weight { - // Minimum execution time: 39_601 nanoseconds. - Weight::from_ref_time(41_001_000 as u64) + // Minimum execution time: 40_901 nanoseconds. + Weight::from_ref_time(41_701_000 as u64) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } // Storage: Permissions Permission (r:2 w:1) // Storage: Permissions PermissionCount (r:1 w:1) fn add_as_editor() -> Weight { - // Minimum execution time: 50_601 nanoseconds. - Weight::from_ref_time(51_601_000 as u64) + // Minimum execution time: 50_301 nanoseconds. + Weight::from_ref_time(51_401_000 as u64) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } // Storage: Permissions PermissionCount (r:1 w:1) // Storage: Permissions Permission (r:1 w:1) fn remove_as_admin() -> Weight { - // Minimum execution time: 44_400 nanoseconds. - Weight::from_ref_time(47_500_000 as u64) + // Minimum execution time: 44_101 nanoseconds. + Weight::from_ref_time(45_001_000 as u64) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } // Storage: Permissions Permission (r:2 w:1) // Storage: Permissions PermissionCount (r:1 w:1) fn remove_as_editor() -> Weight { - // Minimum execution time: 53_301 nanoseconds. + // Minimum execution time: 53_701 nanoseconds. Weight::from_ref_time(54_101_000 as u64) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } // Storage: Permissions Permission (r:1 w:1) fn purge() -> Weight { - // Minimum execution time: 40_200 nanoseconds. - Weight::from_ref_time(41_001_000 as u64) + // Minimum execution time: 40_001 nanoseconds. + Weight::from_ref_time(40_701_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Permissions Permission (r:1 w:1) fn admin_purge() -> Weight { - // Minimum execution time: 40_301 nanoseconds. - Weight::from_ref_time(41_601_000 as u64) + // Minimum execution time: 40_601 nanoseconds. + Weight::from_ref_time(41_201_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } diff --git a/runtime/centrifuge/src/weights/pallet_pool_registry.rs b/runtime/centrifuge/src/weights/pallet_pool_registry.rs index fe82c8c2f4..541d9839de 100644 --- a/runtime/centrifuge/src/weights/pallet_pool_registry.rs +++ b/runtime/centrifuge/src/weights/pallet_pool_registry.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_pool_registry` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-03-27, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-04-04, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("centrifuge-dev"), DB CACHE: 1024 @@ -43,10 +43,10 @@ impl pallet_pool_registry::WeightInfo for WeightInfo // Storage: PoolSystem PoolDeposit (r:0 w:1) /// The range of component `n` is `[1, 5]`. fn register(n: u32, ) -> Weight { - // Minimum execution time: 147_003 nanoseconds. - Weight::from_ref_time(126_507_641 as u64) - // Standard Error: 53_902 - .saturating_add(Weight::from_ref_time(27_441_361 as u64).saturating_mul(n as u64)) + // Minimum execution time: 154_103 nanoseconds. + Weight::from_ref_time(130_627_382 as u64) + // Standard Error: 49_140 + .saturating_add(Weight::from_ref_time(28_006_696 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(9 as u64)) .saturating_add(T::DbWeight::get().reads((2 as u64).saturating_mul(n as u64))) .saturating_add(T::DbWeight::get().writes(7 as u64)) @@ -60,10 +60,10 @@ impl pallet_pool_registry::WeightInfo for WeightInfo // Storage: PoolSystem ScheduledUpdate (r:0 w:1) /// The range of component `n` is `[1, 5]`. fn update_no_execution(n: u32, ) -> Weight { - // Minimum execution time: 77_602 nanoseconds. - Weight::from_ref_time(78_517_069 as u64) - // Standard Error: 23_582 - .saturating_add(Weight::from_ref_time(3_041_958 as u64).saturating_mul(n as u64)) + // Minimum execution time: 80_302 nanoseconds. + Weight::from_ref_time(78_714_119 as u64) + // Standard Error: 16_407 + .saturating_add(Weight::from_ref_time(2_998_494 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(4 as u64)) .saturating_add(T::DbWeight::get().reads((1 as u64).saturating_mul(n as u64))) .saturating_add(T::DbWeight::get().writes(1 as u64)) @@ -77,10 +77,10 @@ impl pallet_pool_registry::WeightInfo for WeightInfo // Storage: PoolSystem ScheduledUpdate (r:0 w:1) /// The range of component `n` is `[1, 5]`. fn update_and_execute(n: u32, ) -> Weight { - // Minimum execution time: 116_102 nanoseconds. - Weight::from_ref_time(112_049_966 as u64) - // Standard Error: 59_704 - .saturating_add(Weight::from_ref_time(9_384_025 as u64).saturating_mul(n as u64)) + // Minimum execution time: 120_203 nanoseconds. + Weight::from_ref_time(113_234_223 as u64) + // Standard Error: 39_004 + .saturating_add(Weight::from_ref_time(9_668_906 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().reads((1 as u64).saturating_mul(n as u64))) .saturating_add(T::DbWeight::get().writes(3 as u64)) @@ -93,10 +93,10 @@ impl pallet_pool_registry::WeightInfo for WeightInfo // Storage: OrmlAssetRegistry Metadata (r:2 w:1) /// The range of component `n` is `[1, 5]`. fn execute_update(n: u32, ) -> Weight { - // Minimum execution time: 102_802 nanoseconds. - Weight::from_ref_time(98_871_774 as u64) - // Standard Error: 68_633 - .saturating_add(Weight::from_ref_time(9_818_786 as u64).saturating_mul(n as u64)) + // Minimum execution time: 107_402 nanoseconds. + Weight::from_ref_time(99_305_869 as u64) + // Standard Error: 37_358 + .saturating_add(Weight::from_ref_time(10_036_394 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().reads((1 as u64).saturating_mul(n as u64))) .saturating_add(T::DbWeight::get().writes(3 as u64)) @@ -105,10 +105,10 @@ impl pallet_pool_registry::WeightInfo for WeightInfo // Storage: PoolRegistry PoolMetadata (r:0 w:1) /// The range of component `n` is `[0, 46]`. fn set_metadata(n: u32, ) -> Weight { - // Minimum execution time: 42_701 nanoseconds. - Weight::from_ref_time(45_371_985 as u64) - // Standard Error: 9_407 - .saturating_add(Weight::from_ref_time(38_760 as u64).saturating_mul(n as u64)) + // Minimum execution time: 43_501 nanoseconds. + Weight::from_ref_time(45_756_984 as u64) + // Standard Error: 8_729 + .saturating_add(Weight::from_ref_time(18_369 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } diff --git a/runtime/centrifuge/src/weights/pallet_pool_system.rs b/runtime/centrifuge/src/weights/pallet_pool_system.rs index e552e2d32f..ddc48b455f 100644 --- a/runtime/centrifuge/src/weights/pallet_pool_system.rs +++ b/runtime/centrifuge/src/weights/pallet_pool_system.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_pool_system` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-03-27, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-04-04, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("centrifuge-dev"), DB CACHE: 1024 @@ -33,8 +33,8 @@ impl pallet_pool_system::WeightInfo for WeightInfo { // Storage: Permissions Permission (r:1 w:0) // Storage: PoolSystem Pool (r:1 w:1) fn set_max_reserve() -> Weight { - // Minimum execution time: 55_901 nanoseconds. - Weight::from_ref_time(56_801_000 as u64) + // Minimum execution time: 54_601 nanoseconds. + Weight::from_ref_time(55_801_000 as u64) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } @@ -54,10 +54,10 @@ impl pallet_pool_system::WeightInfo for WeightInfo { // Storage: Investments ClearedRedeemOrders (r:0 w:1) /// The range of component `n` is `[1, 5]`. fn close_epoch_no_orders(n: u32, ) -> Weight { - // Minimum execution time: 168_703 nanoseconds. - Weight::from_ref_time(80_971_132 as u64) - // Standard Error: 84_302 - .saturating_add(Weight::from_ref_time(95_860_498 as u64).saturating_mul(n as u64)) + // Minimum execution time: 169_804 nanoseconds. + Weight::from_ref_time(80_056_335 as u64) + // Standard Error: 42_936 + .saturating_add(Weight::from_ref_time(93_054_345 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(4 as u64)) .saturating_add(T::DbWeight::get().reads((8 as u64).saturating_mul(n as u64))) .saturating_add(T::DbWeight::get().writes(1 as u64)) @@ -76,10 +76,10 @@ impl pallet_pool_system::WeightInfo for WeightInfo { // Storage: Investments RedeemOrderId (r:1 w:1) /// The range of component `n` is `[1, 5]`. fn close_epoch_no_execution(n: u32, ) -> Weight { - // Minimum execution time: 121_102 nanoseconds. - Weight::from_ref_time(85_663_946 as u64) - // Standard Error: 58_487 - .saturating_add(Weight::from_ref_time(41_017_688 as u64).saturating_mul(n as u64)) + // Minimum execution time: 122_003 nanoseconds. + Weight::from_ref_time(84_875_867 as u64) + // Standard Error: 44_598 + .saturating_add(Weight::from_ref_time(40_095_203 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(4 as u64)) .saturating_add(T::DbWeight::get().reads((7 as u64).saturating_mul(n as u64))) .saturating_add(T::DbWeight::get().writes(2 as u64)) @@ -102,10 +102,10 @@ impl pallet_pool_system::WeightInfo for WeightInfo { // Storage: Investments ClearedRedeemOrders (r:0 w:1) /// The range of component `n` is `[1, 5]`. fn close_epoch_execute(n: u32, ) -> Weight { - // Minimum execution time: 276_605 nanoseconds. - Weight::from_ref_time(190_507_310 as u64) - // Standard Error: 115_318 - .saturating_add(Weight::from_ref_time(98_009_530 as u64).saturating_mul(n as u64)) + // Minimum execution time: 278_006 nanoseconds. + Weight::from_ref_time(187_029_990 as u64) + // Standard Error: 125_755 + .saturating_add(Weight::from_ref_time(95_586_622 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(8 as u64)) .saturating_add(T::DbWeight::get().reads((8 as u64).saturating_mul(n as u64))) .saturating_add(T::DbWeight::get().writes(7 as u64)) @@ -115,10 +115,10 @@ impl pallet_pool_system::WeightInfo for WeightInfo { // Storage: PoolSystem Pool (r:1 w:0) /// The range of component `n` is `[1, 5]`. fn submit_solution(n: u32, ) -> Weight { - // Minimum execution time: 55_201 nanoseconds. - Weight::from_ref_time(55_890_543 as u64) - // Standard Error: 16_826 - .saturating_add(Weight::from_ref_time(2_594_854 as u64).saturating_mul(n as u64)) + // Minimum execution time: 56_002 nanoseconds. + Weight::from_ref_time(55_012_795 as u64) + // Standard Error: 15_164 + .saturating_add(Weight::from_ref_time(2_574_612 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } @@ -138,10 +138,10 @@ impl pallet_pool_system::WeightInfo for WeightInfo { // Storage: Investments ClearedRedeemOrders (r:0 w:1) /// The range of component `n` is `[1, 5]`. fn execute_epoch(n: u32, ) -> Weight { - // Minimum execution time: 240_905 nanoseconds. - Weight::from_ref_time(174_747_251 as u64) - // Standard Error: 82_683 - .saturating_add(Weight::from_ref_time(70_884_880 as u64).saturating_mul(n as u64)) + // Minimum execution time: 233_805 nanoseconds. + Weight::from_ref_time(172_585_423 as u64) + // Standard Error: 46_082 + .saturating_add(Weight::from_ref_time(69_555_334 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(8 as u64)) .saturating_add(T::DbWeight::get().reads((7 as u64).saturating_mul(n as u64))) .saturating_add(T::DbWeight::get().writes(8 as u64)) diff --git a/runtime/centrifuge/src/weights/pallet_preimage.rs b/runtime/centrifuge/src/weights/pallet_preimage.rs index 7772be1522..468278c907 100644 --- a/runtime/centrifuge/src/weights/pallet_preimage.rs +++ b/runtime/centrifuge/src/weights/pallet_preimage.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_preimage` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-03-27, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-04-04, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("centrifuge-dev"), DB CACHE: 1024 @@ -34,10 +34,10 @@ impl pallet_preimage::WeightInfo for WeightInfo { // Storage: Preimage PreimageFor (r:0 w:1) /// The range of component `s` is `[0, 4194304]`. fn note_preimage(s: u32, ) -> Weight { - // Minimum execution time: 60_801 nanoseconds. - Weight::from_ref_time(61_001_000 as u64) + // Minimum execution time: 60_802 nanoseconds. + Weight::from_ref_time(61_201_000 as u64) // Standard Error: 2 - .saturating_add(Weight::from_ref_time(2_326 as u64).saturating_mul(s as u64)) + .saturating_add(Weight::from_ref_time(2_561 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } @@ -45,10 +45,10 @@ impl pallet_preimage::WeightInfo for WeightInfo { // Storage: Preimage PreimageFor (r:0 w:1) /// The range of component `s` is `[0, 4194304]`. fn note_requested_preimage(s: u32, ) -> Weight { - // Minimum execution time: 42_001 nanoseconds. - Weight::from_ref_time(42_401_000 as u64) - // Standard Error: 2 - .saturating_add(Weight::from_ref_time(2_318 as u64).saturating_mul(s as u64)) + // Minimum execution time: 42_601 nanoseconds. + Weight::from_ref_time(42_901_000 as u64) + // Standard Error: 3 + .saturating_add(Weight::from_ref_time(2_591 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } @@ -56,76 +56,76 @@ impl pallet_preimage::WeightInfo for WeightInfo { // Storage: Preimage PreimageFor (r:0 w:1) /// The range of component `s` is `[0, 4194304]`. fn note_no_deposit_preimage(s: u32, ) -> Weight { - // Minimum execution time: 39_701 nanoseconds. - Weight::from_ref_time(39_901_000 as u64) - // Standard Error: 1 - .saturating_add(Weight::from_ref_time(2_275 as u64).saturating_mul(s as u64)) + // Minimum execution time: 40_001 nanoseconds. + Weight::from_ref_time(40_201_000 as u64) + // Standard Error: 2 + .saturating_add(Weight::from_ref_time(2_548 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } // Storage: Preimage StatusFor (r:1 w:1) // Storage: Preimage PreimageFor (r:0 w:1) fn unnote_preimage() -> Weight { - // Minimum execution time: 83_302 nanoseconds. - Weight::from_ref_time(90_001_000 as u64) + // Minimum execution time: 90_802 nanoseconds. + Weight::from_ref_time(104_602_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } // Storage: Preimage StatusFor (r:1 w:1) // Storage: Preimage PreimageFor (r:0 w:1) fn unnote_no_deposit_preimage() -> Weight { - // Minimum execution time: 62_101 nanoseconds. - Weight::from_ref_time(69_001_000 as u64) + // Minimum execution time: 64_301 nanoseconds. + Weight::from_ref_time(77_002_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } // Storage: Preimage StatusFor (r:1 w:1) fn request_preimage() -> Weight { - // Minimum execution time: 63_701 nanoseconds. - Weight::from_ref_time(74_401_000 as u64) + // Minimum execution time: 61_701 nanoseconds. + Weight::from_ref_time(68_401_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Preimage StatusFor (r:1 w:1) fn request_no_deposit_preimage() -> Weight { - // Minimum execution time: 38_201 nanoseconds. - Weight::from_ref_time(45_801_000 as u64) + // Minimum execution time: 35_401 nanoseconds. + Weight::from_ref_time(43_101_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Preimage StatusFor (r:1 w:1) fn request_unnoted_preimage() -> Weight { - // Minimum execution time: 37_000 nanoseconds. - Weight::from_ref_time(39_201_000 as u64) + // Minimum execution time: 37_700 nanoseconds. + Weight::from_ref_time(40_901_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Preimage StatusFor (r:1 w:1) fn request_requested_preimage() -> Weight { - // Minimum execution time: 18_500 nanoseconds. - Weight::from_ref_time(19_201_000 as u64) + // Minimum execution time: 19_700 nanoseconds. + Weight::from_ref_time(20_401_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Preimage StatusFor (r:1 w:1) // Storage: Preimage PreimageFor (r:0 w:1) fn unrequest_preimage() -> Weight { - // Minimum execution time: 56_801 nanoseconds. - Weight::from_ref_time(61_401_000 as u64) + // Minimum execution time: 63_701 nanoseconds. + Weight::from_ref_time(73_901_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } // Storage: Preimage StatusFor (r:1 w:1) fn unrequest_unnoted_preimage() -> Weight { - // Minimum execution time: 17_600 nanoseconds. - Weight::from_ref_time(18_700_000 as u64) + // Minimum execution time: 19_000 nanoseconds. + Weight::from_ref_time(19_700_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Preimage StatusFor (r:1 w:1) fn unrequest_multi_referenced_preimage() -> Weight { - // Minimum execution time: 18_400 nanoseconds. - Weight::from_ref_time(18_901_000 as u64) + // Minimum execution time: 18_500 nanoseconds. + Weight::from_ref_time(20_100_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } diff --git a/runtime/centrifuge/src/weights/pallet_proxy.rs b/runtime/centrifuge/src/weights/pallet_proxy.rs index 2dcc5ef4b8..2753e29006 100644 --- a/runtime/centrifuge/src/weights/pallet_proxy.rs +++ b/runtime/centrifuge/src/weights/pallet_proxy.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_proxy` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-03-27, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-04-04, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("centrifuge-dev"), DB CACHE: 1024 @@ -33,10 +33,10 @@ impl pallet_proxy::WeightInfo for WeightInfo { // Storage: Proxy Proxies (r:1 w:0) /// The range of component `p` is `[1, 31]`. fn proxy(p: u32, ) -> Weight { - // Minimum execution time: 41_201 nanoseconds. - Weight::from_ref_time(44_102_408 as u64) - // Standard Error: 9_675 - .saturating_add(Weight::from_ref_time(50_853 as u64).saturating_mul(p as u64)) + // Minimum execution time: 41_401 nanoseconds. + Weight::from_ref_time(43_226_842 as u64) + // Standard Error: 5_650 + .saturating_add(Weight::from_ref_time(71_659 as u64).saturating_mul(p as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) } // Storage: Proxy Proxies (r:1 w:0) @@ -45,12 +45,12 @@ impl pallet_proxy::WeightInfo for WeightInfo { /// The range of component `a` is `[0, 31]`. /// The range of component `p` is `[1, 31]`. fn proxy_announced(a: u32, p: u32, ) -> Weight { - // Minimum execution time: 74_801 nanoseconds. - Weight::from_ref_time(78_072_257 as u64) - // Standard Error: 3_917 - .saturating_add(Weight::from_ref_time(251_140 as u64).saturating_mul(a as u64)) - // Standard Error: 4_048 - .saturating_add(Weight::from_ref_time(75_347 as u64).saturating_mul(p as u64)) + // Minimum execution time: 76_702 nanoseconds. + Weight::from_ref_time(79_537_535 as u64) + // Standard Error: 7_107 + .saturating_add(Weight::from_ref_time(230_835 as u64).saturating_mul(a as u64)) + // Standard Error: 7_343 + .saturating_add(Weight::from_ref_time(53_641 as u64).saturating_mul(p as u64)) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } @@ -59,12 +59,12 @@ impl pallet_proxy::WeightInfo for WeightInfo { /// The range of component `a` is `[0, 31]`. /// The range of component `p` is `[1, 31]`. fn remove_announcement(a: u32, p: u32, ) -> Weight { - // Minimum execution time: 52_101 nanoseconds. - Weight::from_ref_time(55_135_786 as u64) - // Standard Error: 11_361 - .saturating_add(Weight::from_ref_time(285_562 as u64).saturating_mul(a as u64)) - // Standard Error: 11_738 - .saturating_add(Weight::from_ref_time(11_912 as u64).saturating_mul(p as u64)) + // Minimum execution time: 52_001 nanoseconds. + Weight::from_ref_time(54_121_879 as u64) + // Standard Error: 3_698 + .saturating_add(Weight::from_ref_time(268_488 as u64).saturating_mul(a as u64)) + // Standard Error: 3_820 + .saturating_add(Weight::from_ref_time(15_209 as u64).saturating_mul(p as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } @@ -73,12 +73,12 @@ impl pallet_proxy::WeightInfo for WeightInfo { /// The range of component `a` is `[0, 31]`. /// The range of component `p` is `[1, 31]`. fn reject_announcement(a: u32, p: u32, ) -> Weight { - // Minimum execution time: 53_301 nanoseconds. - Weight::from_ref_time(55_285_482 as u64) - // Standard Error: 3_332 - .saturating_add(Weight::from_ref_time(258_517 as u64).saturating_mul(a as u64)) - // Standard Error: 3_443 - .saturating_add(Weight::from_ref_time(19_307 as u64).saturating_mul(p as u64)) + // Minimum execution time: 50_301 nanoseconds. + Weight::from_ref_time(53_294_246 as u64) + // Standard Error: 3_137 + .saturating_add(Weight::from_ref_time(285_724 as u64).saturating_mul(a as u64)) + // Standard Error: 3_241 + .saturating_add(Weight::from_ref_time(27_951 as u64).saturating_mul(p as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } @@ -88,42 +88,42 @@ impl pallet_proxy::WeightInfo for WeightInfo { /// The range of component `a` is `[0, 31]`. /// The range of component `p` is `[1, 31]`. fn announce(a: u32, p: u32, ) -> Weight { - // Minimum execution time: 69_002 nanoseconds. - Weight::from_ref_time(69_889_425 as u64) - // Standard Error: 5_302 - .saturating_add(Weight::from_ref_time(264_850 as u64).saturating_mul(a as u64)) - // Standard Error: 5_478 - .saturating_add(Weight::from_ref_time(73_912 as u64).saturating_mul(p as u64)) + // Minimum execution time: 67_003 nanoseconds. + Weight::from_ref_time(69_325_661 as u64) + // Standard Error: 3_197 + .saturating_add(Weight::from_ref_time(281_148 as u64).saturating_mul(a as u64)) + // Standard Error: 3_303 + .saturating_add(Weight::from_ref_time(80_852 as u64).saturating_mul(p as u64)) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } // Storage: Proxy Proxies (r:1 w:1) /// The range of component `p` is `[1, 31]`. fn add_proxy(p: u32, ) -> Weight { - // Minimum execution time: 58_401 nanoseconds. - Weight::from_ref_time(60_507_759 as u64) - // Standard Error: 11_610 - .saturating_add(Weight::from_ref_time(153_853 as u64).saturating_mul(p as u64)) + // Minimum execution time: 57_101 nanoseconds. + Weight::from_ref_time(58_831_373 as u64) + // Standard Error: 2_744 + .saturating_add(Weight::from_ref_time(152_925 as u64).saturating_mul(p as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Proxy Proxies (r:1 w:1) /// The range of component `p` is `[1, 31]`. fn remove_proxy(p: u32, ) -> Weight { - // Minimum execution time: 57_001 nanoseconds. - Weight::from_ref_time(59_786_610 as u64) - // Standard Error: 3_540 - .saturating_add(Weight::from_ref_time(158_927 as u64).saturating_mul(p as u64)) + // Minimum execution time: 56_601 nanoseconds. + Weight::from_ref_time(59_119_853 as u64) + // Standard Error: 12_548 + .saturating_add(Weight::from_ref_time(151_608 as u64).saturating_mul(p as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Proxy Proxies (r:1 w:1) /// The range of component `p` is `[1, 31]`. fn remove_proxies(p: u32, ) -> Weight { - // Minimum execution time: 49_701 nanoseconds. - Weight::from_ref_time(51_564_928 as u64) - // Standard Error: 10_444 - .saturating_add(Weight::from_ref_time(123_007 as u64).saturating_mul(p as u64)) + // Minimum execution time: 48_502 nanoseconds. + Weight::from_ref_time(50_627_418 as u64) + // Standard Error: 10_447 + .saturating_add(Weight::from_ref_time(95_617 as u64).saturating_mul(p as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } @@ -131,20 +131,20 @@ impl pallet_proxy::WeightInfo for WeightInfo { // Storage: Proxy Proxies (r:1 w:1) /// The range of component `p` is `[1, 31]`. fn create_pure(p: u32, ) -> Weight { - // Minimum execution time: 62_002 nanoseconds. - Weight::from_ref_time(65_312_895 as u64) - // Standard Error: 16_159 - .saturating_add(Weight::from_ref_time(27_972 as u64).saturating_mul(p as u64)) + // Minimum execution time: 61_701 nanoseconds. + Weight::from_ref_time(64_014_365 as u64) + // Standard Error: 2_359 + .saturating_add(Weight::from_ref_time(38_206 as u64).saturating_mul(p as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Proxy Proxies (r:1 w:1) /// The range of component `p` is `[0, 30]`. fn kill_pure(p: u32, ) -> Weight { - // Minimum execution time: 52_001 nanoseconds. - Weight::from_ref_time(54_907_508 as u64) - // Standard Error: 14_726 - .saturating_add(Weight::from_ref_time(62_805 as u64).saturating_mul(p as u64)) + // Minimum execution time: 50_302 nanoseconds. + Weight::from_ref_time(53_745_629 as u64) + // Standard Error: 15_648 + .saturating_add(Weight::from_ref_time(53_680 as u64).saturating_mul(p as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } diff --git a/runtime/centrifuge/src/weights/pallet_restricted_tokens.rs b/runtime/centrifuge/src/weights/pallet_restricted_tokens.rs index f9c3f32bcd..b9383f6fee 100644 --- a/runtime/centrifuge/src/weights/pallet_restricted_tokens.rs +++ b/runtime/centrifuge/src/weights/pallet_restricted_tokens.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_restricted_tokens` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-03-27, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-04-04, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("centrifuge-dev"), DB CACHE: 1024 @@ -32,68 +32,68 @@ pub struct WeightInfo(PhantomData); impl pallet_restricted_tokens::WeightInfo for WeightInfo { // Storage: System Account (r:1 w:1) fn transfer_native() -> Weight { - // Minimum execution time: 81_501 nanoseconds. - Weight::from_ref_time(82_401_000 as u64) + // Minimum execution time: 104_103 nanoseconds. + Weight::from_ref_time(105_302_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: OrmlTokens Accounts (r:2 w:2) // Storage: System Account (r:1 w:1) fn transfer_other() -> Weight { - // Minimum execution time: 85_802 nanoseconds. - Weight::from_ref_time(87_601_000 as u64) + // Minimum execution time: 86_902 nanoseconds. + Weight::from_ref_time(88_002_000 as u64) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } // Storage: System Account (r:1 w:1) fn transfer_keep_alive_native() -> Weight { - // Minimum execution time: 73_801 nanoseconds. - Weight::from_ref_time(74_902_000 as u64) + // Minimum execution time: 75_102 nanoseconds. + Weight::from_ref_time(76_202_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: OrmlTokens Accounts (r:2 w:2) // Storage: System Account (r:1 w:1) fn transfer_keep_alive_other() -> Weight { - // Minimum execution time: 80_902 nanoseconds. - Weight::from_ref_time(82_101_000 as u64) + // Minimum execution time: 80_402 nanoseconds. + Weight::from_ref_time(81_602_000 as u64) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } // Storage: System Account (r:1 w:1) fn transfer_all_native() -> Weight { - // Minimum execution time: 86_302 nanoseconds. - Weight::from_ref_time(86_901_000 as u64) + // Minimum execution time: 87_402 nanoseconds. + Weight::from_ref_time(88_702_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: OrmlTokens Accounts (r:2 w:2) // Storage: System Account (r:1 w:1) fn transfer_all_other() -> Weight { - // Minimum execution time: 91_201 nanoseconds. - Weight::from_ref_time(92_501_000 as u64) + // Minimum execution time: 91_302 nanoseconds. + Weight::from_ref_time(92_402_000 as u64) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } // Storage: System Account (r:1 w:1) fn force_transfer_native() -> Weight { - // Minimum execution time: 81_802 nanoseconds. - Weight::from_ref_time(83_101_000 as u64) + // Minimum execution time: 83_001 nanoseconds. + Weight::from_ref_time(84_302_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: OrmlTokens Accounts (r:2 w:2) // Storage: System Account (r:1 w:1) fn force_transfer_other() -> Weight { - // Minimum execution time: 84_501 nanoseconds. - Weight::from_ref_time(87_201_000 as u64) + // Minimum execution time: 86_602 nanoseconds. + Weight::from_ref_time(87_702_000 as u64) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } // Storage: System Account (r:1 w:1) fn set_balance_native() -> Weight { - // Minimum execution time: 84_202 nanoseconds. - Weight::from_ref_time(86_101_000 as u64) + // Minimum execution time: 86_302 nanoseconds. + Weight::from_ref_time(87_302_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } @@ -101,8 +101,8 @@ impl pallet_restricted_tokens::WeightInfo for WeightInf // Storage: OrmlTokens TotalIssuance (r:1 w:1) // Storage: System Account (r:1 w:1) fn set_balance_other() -> Weight { - // Minimum execution time: 95_301 nanoseconds. - Weight::from_ref_time(98_502_000 as u64) + // Minimum execution time: 98_302 nanoseconds. + Weight::from_ref_time(99_503_000 as u64) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } diff --git a/runtime/centrifuge/src/weights/pallet_scheduler.rs b/runtime/centrifuge/src/weights/pallet_scheduler.rs index 13467756a1..076811290f 100644 --- a/runtime/centrifuge/src/weights/pallet_scheduler.rs +++ b/runtime/centrifuge/src/weights/pallet_scheduler.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_scheduler` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-03-27, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-04-04, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("centrifuge-dev"), DB CACHE: 1024 @@ -33,60 +33,60 @@ impl pallet_scheduler::WeightInfo for WeightInfo { // Storage: Scheduler IncompleteSince (r:1 w:1) fn service_agendas_base() -> Weight { // Minimum execution time: 8_900 nanoseconds. - Weight::from_ref_time(9_000_000 as u64) + Weight::from_ref_time(9_200_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Scheduler Agenda (r:1 w:1) /// The range of component `s` is `[0, 50]`. fn service_agenda_base(s: u32, ) -> Weight { - // Minimum execution time: 7_800 nanoseconds. - Weight::from_ref_time(15_543_177 as u64) - // Standard Error: 7_503 - .saturating_add(Weight::from_ref_time(1_044_127 as u64).saturating_mul(s as u64)) + // Minimum execution time: 8_000 nanoseconds. + Weight::from_ref_time(14_930_467 as u64) + // Standard Error: 4_415 + .saturating_add(Weight::from_ref_time(1_281_312 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } fn service_task_base() -> Weight { - // Minimum execution time: 25_700 nanoseconds. - Weight::from_ref_time(26_900_000 as u64) + // Minimum execution time: 19_800 nanoseconds. + Weight::from_ref_time(20_200_000 as u64) } // Storage: Preimage PreimageFor (r:1 w:1) // Storage: Preimage StatusFor (r:1 w:1) /// The range of component `s` is `[128, 4194304]`. fn service_task_fetched(s: u32, ) -> Weight { - // Minimum execution time: 44_001 nanoseconds. - Weight::from_ref_time(44_600_000 as u64) - // Standard Error: 2 - .saturating_add(Weight::from_ref_time(1_628 as u64).saturating_mul(s as u64)) + // Minimum execution time: 44_701 nanoseconds. + Weight::from_ref_time(45_301_000 as u64) + // Standard Error: 3 + .saturating_add(Weight::from_ref_time(1_946 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } // Storage: Scheduler Lookup (r:0 w:1) fn service_task_named() -> Weight { - // Minimum execution time: 22_501 nanoseconds. - Weight::from_ref_time(23_001_000 as u64) + // Minimum execution time: 22_601 nanoseconds. + Weight::from_ref_time(23_200_000 as u64) .saturating_add(T::DbWeight::get().writes(1 as u64)) } fn service_task_periodic() -> Weight { - // Minimum execution time: 19_500 nanoseconds. - Weight::from_ref_time(20_101_000 as u64) + // Minimum execution time: 19_400 nanoseconds. + Weight::from_ref_time(19_700_000 as u64) } fn execute_dispatch_signed() -> Weight { - // Minimum execution time: 8_600 nanoseconds. - Weight::from_ref_time(9_200_000 as u64) + // Minimum execution time: 9_500 nanoseconds. + Weight::from_ref_time(9_800_000 as u64) } fn execute_dispatch_unsigned() -> Weight { - // Minimum execution time: 8_900 nanoseconds. - Weight::from_ref_time(9_200_000 as u64) + // Minimum execution time: 9_500 nanoseconds. + Weight::from_ref_time(9_701_000 as u64) } // Storage: Scheduler Agenda (r:1 w:1) /// The range of component `s` is `[0, 49]`. fn schedule(s: u32, ) -> Weight { - // Minimum execution time: 36_201 nanoseconds. - Weight::from_ref_time(42_419_519 as u64) - // Standard Error: 7_915 - .saturating_add(Weight::from_ref_time(1_111_884 as u64).saturating_mul(s as u64)) + // Minimum execution time: 35_700 nanoseconds. + Weight::from_ref_time(42_946_429 as u64) + // Standard Error: 5_216 + .saturating_add(Weight::from_ref_time(1_326_660 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } @@ -94,10 +94,10 @@ impl pallet_scheduler::WeightInfo for WeightInfo { // Storage: Scheduler Lookup (r:0 w:1) /// The range of component `s` is `[1, 50]`. fn cancel(s: u32, ) -> Weight { - // Minimum execution time: 38_300 nanoseconds. - Weight::from_ref_time(42_970_519 as u64) - // Standard Error: 7_718 - .saturating_add(Weight::from_ref_time(1_045_685 as u64).saturating_mul(s as u64)) + // Minimum execution time: 40_001 nanoseconds. + Weight::from_ref_time(44_539_508 as u64) + // Standard Error: 20_195 + .saturating_add(Weight::from_ref_time(1_271_391 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } @@ -105,10 +105,10 @@ impl pallet_scheduler::WeightInfo for WeightInfo { // Storage: Scheduler Agenda (r:1 w:1) /// The range of component `s` is `[0, 49]`. fn schedule_named(s: u32, ) -> Weight { - // Minimum execution time: 41_701 nanoseconds. - Weight::from_ref_time(49_540_867 as u64) - // Standard Error: 8_349 - .saturating_add(Weight::from_ref_time(1_126_183 as u64).saturating_mul(s as u64)) + // Minimum execution time: 40_901 nanoseconds. + Weight::from_ref_time(49_531_934 as u64) + // Standard Error: 5_584 + .saturating_add(Weight::from_ref_time(1_363_956 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } @@ -116,10 +116,10 @@ impl pallet_scheduler::WeightInfo for WeightInfo { // Storage: Scheduler Agenda (r:1 w:1) /// The range of component `s` is `[1, 50]`. fn cancel_named(s: u32, ) -> Weight { - // Minimum execution time: 41_500 nanoseconds. - Weight::from_ref_time(45_237_657 as u64) - // Standard Error: 4_528 - .saturating_add(Weight::from_ref_time(1_107_767 as u64).saturating_mul(s as u64)) + // Minimum execution time: 43_001 nanoseconds. + Weight::from_ref_time(47_573_259 as u64) + // Standard Error: 10_717 + .saturating_add(Weight::from_ref_time(1_296_854 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } diff --git a/runtime/centrifuge/src/weights/pallet_timestamp.rs b/runtime/centrifuge/src/weights/pallet_timestamp.rs index 2c287975e8..63b34d9ded 100644 --- a/runtime/centrifuge/src/weights/pallet_timestamp.rs +++ b/runtime/centrifuge/src/weights/pallet_timestamp.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_timestamp` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-03-27, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-04-04, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("centrifuge-dev"), DB CACHE: 1024 @@ -33,13 +33,13 @@ impl pallet_timestamp::WeightInfo for WeightInfo { // Storage: Timestamp Now (r:1 w:1) // Storage: Aura CurrentSlot (r:1 w:0) fn set() -> Weight { - // Minimum execution time: 19_600 nanoseconds. - Weight::from_ref_time(20_001_000 as u64) + // Minimum execution time: 19_800 nanoseconds. + Weight::from_ref_time(20_201_000 as u64) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } fn on_finalize() -> Weight { - // Minimum execution time: 8_800 nanoseconds. - Weight::from_ref_time(9_001_000 as u64) + // Minimum execution time: 8_900 nanoseconds. + Weight::from_ref_time(9_100_000 as u64) } } diff --git a/runtime/centrifuge/src/weights/pallet_treasury.rs b/runtime/centrifuge/src/weights/pallet_treasury.rs index 31875d6065..6892a9a336 100644 --- a/runtime/centrifuge/src/weights/pallet_treasury.rs +++ b/runtime/centrifuge/src/weights/pallet_treasury.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_treasury` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-03-27, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-04-04, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("centrifuge-dev"), DB CACHE: 1024 @@ -31,22 +31,22 @@ use sp_std::marker::PhantomData; pub struct WeightInfo(PhantomData); impl pallet_treasury::WeightInfo for WeightInfo { fn spend() -> Weight { - // Minimum execution time: 400 nanoseconds. - Weight::from_ref_time(401_000 as u64) + // Minimum execution time: 300 nanoseconds. + Weight::from_ref_time(400_000 as u64) } // Storage: Treasury ProposalCount (r:1 w:1) // Storage: Treasury Proposals (r:0 w:1) fn propose_spend() -> Weight { - // Minimum execution time: 58_201 nanoseconds. - Weight::from_ref_time(59_101_000 as u64) + // Minimum execution time: 56_602 nanoseconds. + Weight::from_ref_time(57_501_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } // Storage: Treasury Proposals (r:1 w:1) // Storage: System Account (r:2 w:2) fn reject_proposal() -> Weight { - // Minimum execution time: 80_402 nanoseconds. - Weight::from_ref_time(83_402_000 as u64) + // Minimum execution time: 80_601 nanoseconds. + Weight::from_ref_time(81_602_000 as u64) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -54,17 +54,17 @@ impl pallet_treasury::WeightInfo for WeightInfo { // Storage: Treasury Approvals (r:1 w:1) /// The range of component `p` is `[0, 99]`. fn approve_proposal(p: u32, ) -> Weight { - // Minimum execution time: 22_301 nanoseconds. - Weight::from_ref_time(29_165_216 as u64) - // Standard Error: 3_059 - .saturating_add(Weight::from_ref_time(231_989 as u64).saturating_mul(p as u64)) + // Minimum execution time: 22_400 nanoseconds. + Weight::from_ref_time(28_755_242 as u64) + // Standard Error: 2_611 + .saturating_add(Weight::from_ref_time(242_266 as u64).saturating_mul(p as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Treasury Approvals (r:1 w:1) fn remove_approval() -> Weight { - // Minimum execution time: 18_101 nanoseconds. - Weight::from_ref_time(18_801_000 as u64) + // Minimum execution time: 18_400 nanoseconds. + Weight::from_ref_time(19_200_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } @@ -73,10 +73,10 @@ impl pallet_treasury::WeightInfo for WeightInfo { // Storage: Treasury Proposals (r:2 w:0) /// The range of component `p` is `[0, 100]`. fn on_initialize_proposals(p: u32, ) -> Weight { - // Minimum execution time: 51_501 nanoseconds. - Weight::from_ref_time(46_011_480 as u64) - // Standard Error: 6_091 - .saturating_add(Weight::from_ref_time(4_072_340 as u64).saturating_mul(p as u64)) + // Minimum execution time: 52_301 nanoseconds. + Weight::from_ref_time(46_444_338 as u64) + // Standard Error: 6_075 + .saturating_add(Weight::from_ref_time(3_999_788 as u64).saturating_mul(p as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().reads((1 as u64).saturating_mul(p as u64))) .saturating_add(T::DbWeight::get().writes(1 as u64)) diff --git a/runtime/centrifuge/src/weights/pallet_uniques.rs b/runtime/centrifuge/src/weights/pallet_uniques.rs index f1cb9cd037..2ab78d7b32 100644 --- a/runtime/centrifuge/src/weights/pallet_uniques.rs +++ b/runtime/centrifuge/src/weights/pallet_uniques.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_uniques` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-03-27, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-04-04, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("centrifuge-dev"), DB CACHE: 1024 @@ -33,16 +33,16 @@ impl pallet_uniques::WeightInfo for WeightInfo { // Storage: Uniques Class (r:1 w:1) // Storage: Uniques ClassAccount (r:0 w:1) fn create() -> Weight { - // Minimum execution time: 61_501 nanoseconds. - Weight::from_ref_time(62_701_000 as u64) + // Minimum execution time: 60_602 nanoseconds. + Weight::from_ref_time(61_302_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } // Storage: Uniques Class (r:1 w:1) // Storage: Uniques ClassAccount (r:0 w:1) fn force_create() -> Weight { - // Minimum execution time: 38_501 nanoseconds. - Weight::from_ref_time(39_101_000 as u64) + // Minimum execution time: 38_201 nanoseconds. + Weight::from_ref_time(39_001_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } @@ -58,14 +58,12 @@ impl pallet_uniques::WeightInfo for WeightInfo { /// The range of component `m` is `[0, 1000]`. /// The range of component `a` is `[0, 1000]`. fn destroy(n: u32, m: u32, a: u32, ) -> Weight { - // Minimum execution time: 3_887_472 nanoseconds. - Weight::from_ref_time(3_965_373_000 as u64) - // Standard Error: 45_917 - .saturating_add(Weight::from_ref_time(16_223_970 as u64).saturating_mul(n as u64)) - // Standard Error: 45_917 - .saturating_add(Weight::from_ref_time(481_083 as u64).saturating_mul(m as u64)) - // Standard Error: 45_917 - .saturating_add(Weight::from_ref_time(482_437 as u64).saturating_mul(a as u64)) + // Minimum execution time: 4_251_700 nanoseconds. + Weight::from_ref_time(4_395_404_000 as u64) + // Standard Error: 52_126 + .saturating_add(Weight::from_ref_time(16_627_987 as u64).saturating_mul(n as u64)) + // Standard Error: 52_126 + .saturating_add(Weight::from_ref_time(1_502_979 as u64).saturating_mul(a as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().reads((1 as u64).saturating_mul(n as u64))) .saturating_add(T::DbWeight::get().writes(4 as u64)) @@ -78,8 +76,8 @@ impl pallet_uniques::WeightInfo for WeightInfo { // Storage: Uniques CollectionMaxSupply (r:1 w:0) // Storage: Uniques Account (r:0 w:1) fn mint() -> Weight { - // Minimum execution time: 76_102 nanoseconds. - Weight::from_ref_time(77_202_000 as u64) + // Minimum execution time: 73_301 nanoseconds. + Weight::from_ref_time(75_402_000 as u64) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -88,8 +86,8 @@ impl pallet_uniques::WeightInfo for WeightInfo { // Storage: Uniques Account (r:0 w:1) // Storage: Uniques ItemPriceOf (r:0 w:1) fn burn() -> Weight { - // Minimum execution time: 78_201 nanoseconds. - Weight::from_ref_time(80_502_000 as u64) + // Minimum execution time: 75_901 nanoseconds. + Weight::from_ref_time(78_902_000 as u64) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(4 as u64)) } @@ -98,8 +96,8 @@ impl pallet_uniques::WeightInfo for WeightInfo { // Storage: Uniques Account (r:0 w:2) // Storage: Uniques ItemPriceOf (r:0 w:1) fn transfer() -> Weight { - // Minimum execution time: 62_201 nanoseconds. - Weight::from_ref_time(81_102_000 as u64) + // Minimum execution time: 59_601 nanoseconds. + Weight::from_ref_time(61_102_000 as u64) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(4 as u64)) } @@ -107,10 +105,10 @@ impl pallet_uniques::WeightInfo for WeightInfo { // Storage: Uniques Asset (r:102 w:102) /// The range of component `i` is `[0, 5000]`. fn redeposit(i: u32, ) -> Weight { - // Minimum execution time: 39_101 nanoseconds. + // Minimum execution time: 39_901 nanoseconds. Weight::from_ref_time(40_501_000 as u64) - // Standard Error: 14_203 - .saturating_add(Weight::from_ref_time(23_090_650 as u64).saturating_mul(i as u64)) + // Standard Error: 15_433 + .saturating_add(Weight::from_ref_time(23_045_971 as u64).saturating_mul(i as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().reads((1 as u64).saturating_mul(i as u64))) .saturating_add(T::DbWeight::get().writes(1 as u64)) @@ -119,22 +117,22 @@ impl pallet_uniques::WeightInfo for WeightInfo { // Storage: Uniques Asset (r:1 w:1) // Storage: Uniques Class (r:1 w:0) fn freeze() -> Weight { - // Minimum execution time: 45_901 nanoseconds. - Weight::from_ref_time(47_801_000 as u64) + // Minimum execution time: 46_701 nanoseconds. + Weight::from_ref_time(47_301_000 as u64) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Uniques Asset (r:1 w:1) // Storage: Uniques Class (r:1 w:0) fn thaw() -> Weight { - // Minimum execution time: 48_201 nanoseconds. - Weight::from_ref_time(52_801_000 as u64) + // Minimum execution time: 45_501 nanoseconds. + Weight::from_ref_time(47_200_000 as u64) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Uniques Class (r:1 w:1) fn freeze_collection() -> Weight { - // Minimum execution time: 37_900 nanoseconds. + // Minimum execution time: 37_700 nanoseconds. Weight::from_ref_time(38_701_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) @@ -142,7 +140,7 @@ impl pallet_uniques::WeightInfo for WeightInfo { // Storage: Uniques Class (r:1 w:1) fn thaw_collection() -> Weight { // Minimum execution time: 37_901 nanoseconds. - Weight::from_ref_time(38_501_000 as u64) + Weight::from_ref_time(38_401_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } @@ -150,23 +148,23 @@ impl pallet_uniques::WeightInfo for WeightInfo { // Storage: Uniques Class (r:1 w:1) // Storage: Uniques ClassAccount (r:0 w:2) fn transfer_ownership() -> Weight { - // Minimum execution time: 53_001 nanoseconds. - Weight::from_ref_time(53_501_000 as u64) + // Minimum execution time: 52_600 nanoseconds. + Weight::from_ref_time(53_301_000 as u64) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(4 as u64)) } // Storage: Uniques Class (r:1 w:1) fn set_team() -> Weight { - // Minimum execution time: 39_301 nanoseconds. - Weight::from_ref_time(39_901_000 as u64) + // Minimum execution time: 38_701 nanoseconds. + Weight::from_ref_time(39_200_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Uniques Class (r:1 w:1) // Storage: Uniques ClassAccount (r:0 w:1) fn force_item_status() -> Weight { - // Minimum execution time: 43_701 nanoseconds. - Weight::from_ref_time(44_201_000 as u64) + // Minimum execution time: 43_501 nanoseconds. + Weight::from_ref_time(44_101_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } @@ -174,8 +172,8 @@ impl pallet_uniques::WeightInfo for WeightInfo { // Storage: Uniques InstanceMetadataOf (r:1 w:0) // Storage: Uniques Attribute (r:1 w:1) fn set_attribute() -> Weight { - // Minimum execution time: 89_701 nanoseconds. - Weight::from_ref_time(91_101_000 as u64) + // Minimum execution time: 87_001 nanoseconds. + Weight::from_ref_time(89_701_000 as u64) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } @@ -183,79 +181,79 @@ impl pallet_uniques::WeightInfo for WeightInfo { // Storage: Uniques InstanceMetadataOf (r:1 w:0) // Storage: Uniques Attribute (r:1 w:1) fn clear_attribute() -> Weight { - // Minimum execution time: 89_201 nanoseconds. - Weight::from_ref_time(90_302_000 as u64) + // Minimum execution time: 85_401 nanoseconds. + Weight::from_ref_time(88_801_000 as u64) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } // Storage: Uniques Class (r:1 w:1) // Storage: Uniques InstanceMetadataOf (r:1 w:1) fn set_metadata() -> Weight { - // Minimum execution time: 70_402 nanoseconds. - Weight::from_ref_time(71_601_000 as u64) + // Minimum execution time: 68_601 nanoseconds. + Weight::from_ref_time(69_401_000 as u64) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } // Storage: Uniques Class (r:1 w:1) // Storage: Uniques InstanceMetadataOf (r:1 w:1) fn clear_metadata() -> Weight { - // Minimum execution time: 71_802 nanoseconds. - Weight::from_ref_time(72_601_000 as u64) + // Minimum execution time: 70_701 nanoseconds. + Weight::from_ref_time(71_301_000 as u64) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } // Storage: Uniques Class (r:1 w:1) // Storage: Uniques ClassMetadataOf (r:1 w:1) fn set_collection_metadata() -> Weight { - // Minimum execution time: 87_402 nanoseconds. - Weight::from_ref_time(89_001_000 as u64) + // Minimum execution time: 66_501 nanoseconds. + Weight::from_ref_time(67_701_000 as u64) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } // Storage: Uniques Class (r:1 w:0) // Storage: Uniques ClassMetadataOf (r:1 w:1) fn clear_collection_metadata() -> Weight { - // Minimum execution time: 66_202 nanoseconds. - Weight::from_ref_time(67_301_000 as u64) + // Minimum execution time: 65_001 nanoseconds. + Weight::from_ref_time(65_901_000 as u64) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Uniques Class (r:1 w:0) // Storage: Uniques Asset (r:1 w:1) fn approve_transfer() -> Weight { - // Minimum execution time: 48_401 nanoseconds. - Weight::from_ref_time(49_401_000 as u64) + // Minimum execution time: 48_101 nanoseconds. + Weight::from_ref_time(48_701_000 as u64) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Uniques Class (r:1 w:0) // Storage: Uniques Asset (r:1 w:1) fn cancel_approval() -> Weight { - // Minimum execution time: 48_601 nanoseconds. - Weight::from_ref_time(49_101_000 as u64) + // Minimum execution time: 47_000 nanoseconds. + Weight::from_ref_time(48_701_000 as u64) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Uniques OwnershipAcceptance (r:1 w:1) fn set_accept_ownership() -> Weight { - // Minimum execution time: 45_200 nanoseconds. - Weight::from_ref_time(45_801_000 as u64) + // Minimum execution time: 44_401 nanoseconds. + Weight::from_ref_time(45_300_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Uniques CollectionMaxSupply (r:1 w:1) // Storage: Uniques Class (r:1 w:0) fn set_collection_max_supply() -> Weight { - // Minimum execution time: 41_801 nanoseconds. - Weight::from_ref_time(42_601_000 as u64) + // Minimum execution time: 41_200 nanoseconds. + Weight::from_ref_time(42_201_000 as u64) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Uniques Asset (r:1 w:0) // Storage: Uniques ItemPriceOf (r:0 w:1) fn set_price() -> Weight { - // Minimum execution time: 43_401 nanoseconds. - Weight::from_ref_time(44_001_000 as u64) + // Minimum execution time: 42_501 nanoseconds. + Weight::from_ref_time(43_301_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } @@ -264,8 +262,8 @@ impl pallet_uniques::WeightInfo for WeightInfo { // Storage: Uniques Class (r:1 w:0) // Storage: Uniques Account (r:0 w:2) fn buy_item() -> Weight { - // Minimum execution time: 80_901 nanoseconds. - Weight::from_ref_time(83_602_000 as u64) + // Minimum execution time: 78_502 nanoseconds. + Weight::from_ref_time(81_502_000 as u64) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(4 as u64)) } diff --git a/runtime/centrifuge/src/weights/pallet_utility.rs b/runtime/centrifuge/src/weights/pallet_utility.rs index 9e9859815f..10ff0a2909 100644 --- a/runtime/centrifuge/src/weights/pallet_utility.rs +++ b/runtime/centrifuge/src/weights/pallet_utility.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_utility` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-03-27, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-04-04, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("centrifuge-dev"), DB CACHE: 1024 @@ -32,31 +32,31 @@ pub struct WeightInfo(PhantomData); impl pallet_utility::WeightInfo for WeightInfo { /// The range of component `c` is `[0, 1000]`. fn batch(c: u32, ) -> Weight { - // Minimum execution time: 24_500 nanoseconds. - Weight::from_ref_time(43_489_908 as u64) - // Standard Error: 3_492 - .saturating_add(Weight::from_ref_time(8_266_513 as u64).saturating_mul(c as u64)) + // Minimum execution time: 24_901 nanoseconds. + Weight::from_ref_time(56_970_678 as u64) + // Standard Error: 4_914 + .saturating_add(Weight::from_ref_time(9_083_817 as u64).saturating_mul(c as u64)) } fn as_derivative() -> Weight { - // Minimum execution time: 13_900 nanoseconds. - Weight::from_ref_time(14_300_000 as u64) + // Minimum execution time: 14_900 nanoseconds. + Weight::from_ref_time(20_100_000 as u64) } /// The range of component `c` is `[0, 1000]`. fn batch_all(c: u32, ) -> Weight { - // Minimum execution time: 24_700 nanoseconds. - Weight::from_ref_time(37_264_511 as u64) - // Standard Error: 3_193 - .saturating_add(Weight::from_ref_time(8_694_898 as u64).saturating_mul(c as u64)) + // Minimum execution time: 25_000 nanoseconds. + Weight::from_ref_time(52_613_760 as u64) + // Standard Error: 5_026 + .saturating_add(Weight::from_ref_time(9_489_517 as u64).saturating_mul(c as u64)) } fn dispatch_as() -> Weight { - // Minimum execution time: 29_601 nanoseconds. - Weight::from_ref_time(30_301_000 as u64) + // Minimum execution time: 39_901 nanoseconds. + Weight::from_ref_time(40_501_000 as u64) } /// The range of component `c` is `[0, 1000]`. fn force_batch(c: u32, ) -> Weight { - // Minimum execution time: 24_800 nanoseconds. - Weight::from_ref_time(42_619_495 as u64) - // Standard Error: 3_435 - .saturating_add(Weight::from_ref_time(8_240_228 as u64).saturating_mul(c as u64)) + // Minimum execution time: 25_001 nanoseconds. + Weight::from_ref_time(43_369_294 as u64) + // Standard Error: 4_991 + .saturating_add(Weight::from_ref_time(9_025_120 as u64).saturating_mul(c as u64)) } } diff --git a/runtime/centrifuge/src/weights/pallet_vesting.rs b/runtime/centrifuge/src/weights/pallet_vesting.rs index 8ca1d1fd37..6ab7b98459 100644 --- a/runtime/centrifuge/src/weights/pallet_vesting.rs +++ b/runtime/centrifuge/src/weights/pallet_vesting.rs @@ -2,7 +2,7 @@ //! Autogenerated weights for `pallet_vesting` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-03-27, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-04-04, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `runner`, CPU: `Intel(R) Xeon(R) Platinum 8272CL CPU @ 2.60GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("centrifuge-dev"), DB CACHE: 1024 @@ -35,12 +35,12 @@ impl pallet_vesting::WeightInfo for WeightInfo { /// The range of component `l` is `[0, 49]`. /// The range of component `s` is `[1, 3]`. fn vest_locked(l: u32, s: u32, ) -> Weight { - // Minimum execution time: 69_902 nanoseconds. - Weight::from_ref_time(75_652_784 as u64) - // Standard Error: 8_138 - .saturating_add(Weight::from_ref_time(24_046 as u64).saturating_mul(l as u64)) - // Standard Error: 155_929 - .saturating_add(Weight::from_ref_time(6_565 as u64).saturating_mul(s as u64)) + // Minimum execution time: 71_302 nanoseconds. + Weight::from_ref_time(74_683_604 as u64) + // Standard Error: 8_434 + .saturating_add(Weight::from_ref_time(68_115 as u64).saturating_mul(l as u64)) + // Standard Error: 161_609 + .saturating_add(Weight::from_ref_time(451_601 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } @@ -49,12 +49,12 @@ impl pallet_vesting::WeightInfo for WeightInfo { /// The range of component `l` is `[0, 49]`. /// The range of component `s` is `[1, 3]`. fn vest_unlocked(l: u32, s: u32, ) -> Weight { - // Minimum execution time: 70_101 nanoseconds. - Weight::from_ref_time(72_176_978 as u64) - // Standard Error: 5_519 - .saturating_add(Weight::from_ref_time(64_027 as u64).saturating_mul(l as u64)) - // Standard Error: 105_750 - .saturating_add(Weight::from_ref_time(344_739 as u64).saturating_mul(s as u64)) + // Minimum execution time: 70_202 nanoseconds. + Weight::from_ref_time(75_018_811 as u64) + // Standard Error: 7_280 + .saturating_add(Weight::from_ref_time(35_230 as u64).saturating_mul(l as u64)) + // Standard Error: 139_501 + .saturating_add(Weight::from_ref_time(97_827 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(2 as u64)) } @@ -65,11 +65,11 @@ impl pallet_vesting::WeightInfo for WeightInfo { /// The range of component `s` is `[1, 3]`. fn vest_other_locked(l: u32, s: u32, ) -> Weight { // Minimum execution time: 69_401 nanoseconds. - Weight::from_ref_time(74_016_121 as u64) - // Standard Error: 16_171 - .saturating_add(Weight::from_ref_time(25_187 as u64).saturating_mul(l as u64)) - // Standard Error: 309_849 - .saturating_add(Weight::from_ref_time(598_970 as u64).saturating_mul(s as u64)) + Weight::from_ref_time(76_023_514 as u64) + // Standard Error: 13_118 + .saturating_add(Weight::from_ref_time(25_606 as u64).saturating_mul(l as u64)) + // Standard Error: 251_355 + .saturating_add(Weight::from_ref_time(121_167 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -78,11 +78,13 @@ impl pallet_vesting::WeightInfo for WeightInfo { // Storage: System Account (r:1 w:1) /// The range of component `l` is `[0, 49]`. /// The range of component `s` is `[1, 3]`. - fn vest_other_unlocked(l: u32, _s: u32, ) -> Weight { - // Minimum execution time: 67_301 nanoseconds. - Weight::from_ref_time(73_529_174 as u64) - // Standard Error: 9_866 - .saturating_add(Weight::from_ref_time(33_360 as u64).saturating_mul(l as u64)) + fn vest_other_unlocked(l: u32, s: u32, ) -> Weight { + // Minimum execution time: 65_902 nanoseconds. + Weight::from_ref_time(73_412_650 as u64) + // Standard Error: 13_248 + .saturating_add(Weight::from_ref_time(53_254 as u64).saturating_mul(l as u64)) + // Standard Error: 253_834 + .saturating_add(Weight::from_ref_time(526_848 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -92,8 +94,8 @@ impl pallet_vesting::WeightInfo for WeightInfo { /// The range of component `l` is `[0, 49]`. /// The range of component `s` is `[0, 2]`. fn vested_transfer(_l: u32, _s: u32, ) -> Weight { - // Minimum execution time: 97_602 nanoseconds. - Weight::from_ref_time(119_805_609 as u64) + // Minimum execution time: 97_702 nanoseconds. + Weight::from_ref_time(120_175_614 as u64) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -103,8 +105,8 @@ impl pallet_vesting::WeightInfo for WeightInfo { /// The range of component `l` is `[0, 49]`. /// The range of component `s` is `[0, 2]`. fn force_vested_transfer(_l: u32, _s: u32, ) -> Weight { - // Minimum execution time: 95_002 nanoseconds. - Weight::from_ref_time(116_072_549 as u64) + // Minimum execution time: 97_202 nanoseconds. + Weight::from_ref_time(121_825_164 as u64) .saturating_add(T::DbWeight::get().reads(4 as u64)) .saturating_add(T::DbWeight::get().writes(4 as u64)) } @@ -113,13 +115,11 @@ impl pallet_vesting::WeightInfo for WeightInfo { // Storage: System Account (r:1 w:1) /// The range of component `l` is `[0, 49]`. /// The range of component `s` is `[2, 3]`. - fn not_unlocking_merge_schedules(l: u32, s: u32, ) -> Weight { - // Minimum execution time: 70_601 nanoseconds. - Weight::from_ref_time(70_269_553 as u64) - // Standard Error: 9_184 - .saturating_add(Weight::from_ref_time(103_885 as u64).saturating_mul(l as u64)) - // Standard Error: 292_906 - .saturating_add(Weight::from_ref_time(1_413_467 as u64).saturating_mul(s as u64)) + fn not_unlocking_merge_schedules(l: u32, _s: u32, ) -> Weight { + // Minimum execution time: 70_801 nanoseconds. + Weight::from_ref_time(78_957_579 as u64) + // Standard Error: 11_185 + .saturating_add(Weight::from_ref_time(35_625 as u64).saturating_mul(l as u64)) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -128,13 +128,9 @@ impl pallet_vesting::WeightInfo for WeightInfo { // Storage: System Account (r:1 w:1) /// The range of component `l` is `[0, 49]`. /// The range of component `s` is `[2, 3]`. - fn unlocking_merge_schedules(l: u32, s: u32, ) -> Weight { - // Minimum execution time: 69_701 nanoseconds. - Weight::from_ref_time(73_302_702 as u64) - // Standard Error: 4_632 - .saturating_add(Weight::from_ref_time(93_834 as u64).saturating_mul(l as u64)) - // Standard Error: 147_736 - .saturating_add(Weight::from_ref_time(218_659 as u64).saturating_mul(s as u64)) + fn unlocking_merge_schedules(_l: u32, _s: u32, ) -> Weight { + // Minimum execution time: 72_601 nanoseconds. + Weight::from_ref_time(82_035_986 as u64) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) }