diff --git a/frame/contracts/primitives/src/lib.rs b/frame/contracts/primitives/src/lib.rs index cc21e29e67b3d..3f830ca92486d 100644 --- a/frame/contracts/primitives/src/lib.rs +++ b/frame/contracts/primitives/src/lib.rs @@ -105,6 +105,8 @@ pub enum ContractAccessError { DoesntExist, /// Storage key cannot be decoded from the provided input data. KeyDecodingFailed, + /// Storage is migrating. Try again later. + MigrationInProgress, } bitflags! { diff --git a/frame/contracts/src/benchmarking/mod.rs b/frame/contracts/src/benchmarking/mod.rs index fa9417a59042d..b98c05f2503c2 100644 --- a/frame/contracts/src/benchmarking/mod.rs +++ b/frame/contracts/src/benchmarking/mod.rs @@ -21,7 +21,6 @@ mod code; mod sandbox; - use self::{ code::{ body::{self, DynInstr::*}, @@ -31,12 +30,13 @@ use self::{ }; use crate::{ exec::{AccountIdOf, Key}, + migration::{v10, v11, v9, Migrate}, wasm::CallFlags, Pallet as Contracts, *, }; use codec::{Encode, MaxEncodedLen}; use frame_benchmarking::v1::{account, benchmarks, whitelisted_caller}; -use frame_support::weights::Weight; +use frame_support::{pallet_prelude::StorageVersion, weights::Weight}; use frame_system::RawOrigin; use sp_runtime::{ traits::{Bounded, Hash}, @@ -234,6 +234,94 @@ benchmarks! { Contracts::::reinstrument_module(&mut module, &schedule)?; } + // This benchmarks the v9 migration step. (update codeStorage) + #[pov_mode = Measured] + v9_migration_step { + let c in 0 .. Perbill::from_percent(49).mul_ceil(T::MaxCodeLen::get()); + v9::store_old_dummy_code::(c as usize); + let mut m = v9::Migration::::default(); + }: { + m.step(); + } + + // This benchmarks the v10 migration step. (use dedicated deposit_account) + #[pov_mode = Measured] + v10_migration_step { + let contract = >::with_caller( + whitelisted_caller(), WasmModule::dummy(), vec![], + )?; + + v10::store_old_contrat_info::(contract.account_id.clone(), contract.info()?); + let mut m = v10::Migration::::default(); + }: { + m.step(); + } + + // This benchmarks the v11 migration step. + #[pov_mode = Measured] + v11_migration_step { + let k in 0 .. 1024; + v11::fill_old_queue::(k as usize); + let mut m = v11::Migration::::default(); + }: { + m.step(); + } + + // This benchmarks the weight of executing Migration::migrate to execute a noop migration. + #[pov_mode = Measured] + migration_noop { + assert_eq!(StorageVersion::get::>(), 2); + }: { + Migration::::migrate(Weight::MAX) + } verify { + assert_eq!(StorageVersion::get::>(), 2); + } + + // This benchmarks the weight of executing Migration::migrate when there are no migration in progress. + #[pov_mode = Measured] + migrate { + StorageVersion::new(0).put::>(); + as frame_support::traits::OnRuntimeUpgrade>::on_runtime_upgrade(); + let origin: RawOrigin<::AccountId> = RawOrigin::Signed(whitelisted_caller()); + }: { + >::migrate(origin.into(), Weight::MAX).unwrap() + } verify { + assert_eq!(StorageVersion::get::>(), 1); + } + + // This benchmarks the weight of running on_runtime_upgrade when there are no migration in progress. + #[pov_mode = Measured] + on_runtime_upgrade_noop { + assert_eq!(StorageVersion::get::>(), 2); + }: { + as frame_support::traits::OnRuntimeUpgrade>::on_runtime_upgrade() + } verify { + assert!(MigrationInProgress::::get().is_none()); + } + + // This benchmarks the weight of running on_runtime_upgrade when there is a migration in progress. + #[pov_mode = Measured] + on_runtime_upgrade_in_progress { + StorageVersion::new(0).put::>(); + let v = vec![42u8].try_into().ok(); + MigrationInProgress::::set(v.clone()); + }: { + as frame_support::traits::OnRuntimeUpgrade>::on_runtime_upgrade() + } verify { + assert!(MigrationInProgress::::get().is_some()); + assert_eq!(MigrationInProgress::::get(), v); + } + + // This benchmarks the weight of running on_runtime_upgrade when there is a migration to process. + #[pov_mode = Measured] + on_runtime_upgrade { + StorageVersion::new(0).put::>(); + }: { + as frame_support::traits::OnRuntimeUpgrade>::on_runtime_upgrade() + } verify { + assert!(MigrationInProgress::::get().is_some()); + } + // This benchmarks the overhead of loading a code of size `c` byte from storage and into // the sandbox. This does **not** include the actual execution for which the gas meter // is responsible. This is achieved by generating all code to the `deploy` function diff --git a/frame/contracts/src/lib.rs b/frame/contracts/src/lib.rs index e0e8e2d15b06d..779b713795b64 100644 --- a/frame/contracts/src/lib.rs +++ b/frame/contracts/src/lib.rs @@ -107,7 +107,10 @@ use crate::{ use codec::{Codec, Decode, Encode, HasCompact}; use environmental::*; use frame_support::{ - dispatch::{DispatchError, Dispatchable, GetDispatchInfo, Pays, PostDispatchInfo, RawOrigin}, + dispatch::{ + DispatchError, Dispatchable, GetDispatchInfo, Pays, PostDispatchInfo, RawOrigin, + WithPostDispatchInfo, + }, ensure, error::BadOrigin, traits::{ @@ -120,18 +123,18 @@ use frame_support::{ use frame_system::{ensure_signed, pallet_prelude::OriginFor, EventRecord, Pallet as System}; use pallet_contracts_primitives::{ Code, CodeUploadResult, CodeUploadReturnValue, ContractAccessError, ContractExecResult, - ContractInstantiateResult, ExecReturnValue, GetStorageResult, InstantiateReturnValue, - StorageDeposit, + ContractInstantiateResult, ContractResult, ExecReturnValue, GetStorageResult, + InstantiateReturnValue, StorageDeposit, }; use scale_info::TypeInfo; use smallvec::Array; -use sp_runtime::traits::{Convert, Hash, Saturating, StaticLookup}; +use sp_runtime::traits::{Convert, Hash, Saturating, StaticLookup, Zero}; use sp_std::{fmt::Debug, marker::PhantomData, prelude::*}; pub use crate::{ address::{AddressGenerator, DefaultAddressGenerator}, exec::Frame, - migration::Migration, + migration::{MigrateSequence, Migration, NoopMigration}, pallet::*, schedule::{HostFnWeights, InstructionWeights, Limits, Schedule}, wasm::Determinism, @@ -179,7 +182,12 @@ pub mod pallet { use frame_system::pallet_prelude::*; /// The current storage version. - const STORAGE_VERSION: StorageVersion = StorageVersion::new(9); + #[cfg(not(any(test, feature = "runtime-benchmarks")))] + const STORAGE_VERSION: StorageVersion = StorageVersion::new(11); + + /// Hard coded storage version for running tests that depend on the current storage version. + #[cfg(any(test, feature = "runtime-benchmarks"))] + const STORAGE_VERSION: StorageVersion = StorageVersion::new(2); #[pallet::pallet] #[pallet::storage_version(STORAGE_VERSION)] @@ -316,11 +324,22 @@ pub mod pallet { #[pallet::hooks] impl Hooks> for Pallet { fn on_idle(_block: T::BlockNumber, remaining_weight: Weight) -> Weight { + use migration::MigrateResult::*; + + let (result, weight) = Migration::::migrate(remaining_weight); + let remaining_weight = remaining_weight.saturating_sub(weight); + + if !matches!(result, Completed | NoMigrationInProgress) { + return weight + } + ContractInfo::::process_deletion_queue_batch(remaining_weight) .saturating_add(T::WeightInfo::on_process_deletion_queue_batch()) } fn integrity_test() { + Migration::::integrity_test(); + // Total runtime memory limit let max_runtime_mem: u32 = T::Schedule::get().limits.runtime_memory; // Memory limits for a single contract: @@ -499,6 +518,7 @@ pub mod pallet { storage_deposit_limit: Option< as codec::HasCompact>::Type>, determinism: Determinism, ) -> DispatchResult { + Migration::::ensure_migrated()?; let origin = ensure_signed(origin)?; Self::bare_upload_code(origin, code, storage_deposit_limit.map(Into::into), determinism) .map(|_| ()) @@ -514,6 +534,7 @@ pub mod pallet { origin: OriginFor, code_hash: CodeHash, ) -> DispatchResultWithPostInfo { + Migration::::ensure_migrated()?; let origin = ensure_signed(origin)?; >::remove(&origin, code_hash)?; // we waive the fee because removing unused code is beneficial @@ -537,6 +558,7 @@ pub mod pallet { dest: AccountIdLookupOf, code_hash: CodeHash, ) -> DispatchResult { + Migration::::ensure_migrated()?; ensure_root(origin)?; let dest = T::Lookup::lookup(dest)?; >::try_mutate(&dest, |contract| { @@ -586,6 +608,7 @@ pub mod pallet { storage_deposit_limit: Option< as codec::HasCompact>::Type>, data: Vec, ) -> DispatchResultWithPostInfo { + Migration::::ensure_migrated()?; let common = CommonInput { origin: Origin::from_runtime_origin(origin)?, value, @@ -645,6 +668,7 @@ pub mod pallet { data: Vec, salt: Vec, ) -> DispatchResultWithPostInfo { + Migration::::ensure_migrated()?; let code_len = code.len() as u32; let data_len = data.len() as u32; let salt_len = salt.len() as u32; @@ -687,6 +711,7 @@ pub mod pallet { data: Vec, salt: Vec, ) -> DispatchResultWithPostInfo { + Migration::::ensure_migrated()?; let data_len = data.len() as u32; let salt_len = salt.len() as u32; let common = CommonInput { @@ -709,6 +734,33 @@ pub mod pallet { T::WeightInfo::instantiate(data_len, salt_len), ) } + + /// When a migration is in progress, this dispatchable can be used to run migration steps. + /// Calls that contribute to advancing the migration have their fees waived, as it's helpful + /// for the chain. Note that while the migration is in progress, the pallet will also + /// leverage the `on_idle` hooks to run migration steps. + #[pallet::call_index(9)] + #[pallet::weight(T::WeightInfo::migrate().saturating_add(*weight_limit))] + pub fn migrate(origin: OriginFor, weight_limit: Weight) -> DispatchResultWithPostInfo { + use migration::MigrateResult::*; + ensure_signed(origin)?; + + let weight_limit = weight_limit.saturating_add(T::WeightInfo::migrate()); + let (result, weight) = Migration::::migrate(weight_limit); + + match result { + Completed => + Ok(PostDispatchInfo { actual_weight: Some(weight), pays_fee: Pays::No }), + InProgress { steps_done, .. } if steps_done > 0 => + Ok(PostDispatchInfo { actual_weight: Some(weight), pays_fee: Pays::No }), + InProgress { .. } => + Ok(PostDispatchInfo { actual_weight: Some(weight), pays_fee: Pays::Yes }), + NoMigrationInProgress | NoMigrationPerformed => { + let err: DispatchError = >::NoMigrationPerformed.into(); + Err(err.with_weight(T::WeightInfo::migrate())) + }, + } + } } #[pallet::event] @@ -861,6 +913,10 @@ pub mod pallet { CodeRejected, /// An indetermistic code was used in a context where this is not permitted. Indeterministic, + /// A pending migration needs to complete before the extrinsic can be called. + MigrationInProgress, + /// Migrate dispatch call was attempted but no migration was performed. + NoMigrationPerformed, } /// A mapping from an original code hash to the original code, untouched by instrumentation. @@ -920,6 +976,10 @@ pub mod pallet { #[pallet::storage] pub(crate) type DeletionQueueCounter = StorageValue<_, DeletionQueueManager, ValueQuery>; + + #[pallet::storage] + pub(crate) type MigrationInProgress = + StorageValue<_, migration::Cursor, OptionQuery>; } /// The type of origins supported by the contracts pallet. @@ -1210,6 +1270,21 @@ impl Invokable for InstantiateInput { } } +macro_rules! ensure_no_migration_in_progress { + () => { + if Migration::::in_progress() { + return ContractResult { + gas_consumed: Zero::zero(), + gas_required: Zero::zero(), + storage_deposit: Default::default(), + debug_message: Vec::new(), + result: Err(Error::::MigrationInProgress.into()), + events: None, + } + } + }; +} + impl Pallet { /// Perform a call to a specified contract. /// @@ -1234,6 +1309,8 @@ impl Pallet { collect_events: CollectEvents, determinism: Determinism, ) -> ContractExecResult, EventRecordOf> { + ensure_no_migration_in_progress!(); + let mut debug_message = if matches!(debug, DebugInfo::UnsafeDebug) { Some(DebugBufferVec::::default()) } else { @@ -1290,6 +1367,8 @@ impl Pallet { debug: DebugInfo, collect_events: CollectEvents, ) -> ContractInstantiateResult, EventRecordOf> { + ensure_no_migration_in_progress!(); + let mut debug_message = if debug == DebugInfo::UnsafeDebug { Some(DebugBufferVec::::default()) } else { @@ -1333,6 +1412,7 @@ impl Pallet { storage_deposit_limit: Option>, determinism: Determinism, ) -> CodeUploadResult, BalanceOf> { + Migration::::ensure_migrated()?; let schedule = T::Schedule::get(); let module = PrefabWasmModule::from_code( code, @@ -1353,6 +1433,9 @@ impl Pallet { /// Query storage of a specified contract under a specified key. pub fn get_storage(address: T::AccountId, key: Vec) -> GetStorageResult { + if Migration::::in_progress() { + return Err(ContractAccessError::MigrationInProgress) + } let contract_info = ContractInfoOf::::get(&address).ok_or(ContractAccessError::DoesntExist)?; diff --git a/frame/contracts/src/migration.rs b/frame/contracts/src/migration.rs index 0b7c094ddb176..a75d5cc1a1f4d 100644 --- a/frame/contracts/src/migration.rs +++ b/frame/contracts/src/migration.rs @@ -15,462 +15,589 @@ // See the License for the specific language governing permissions and // limitations under the License. -use crate::{BalanceOf, CodeHash, Config, Pallet, TrieId, Weight}; -use codec::{Decode, Encode}; +//! Migration framework for pallets. + +/// Macro to include all migration modules. +/// We only want to make these modules public when `runtime-benchmarks` is +/// enabled, so we can access migration code in benchmarks. +macro_rules! use_modules { + ($($module:ident),*) => { + $( + #[cfg(feature = "runtime-benchmarks")] + pub mod $module; + #[cfg(not(feature = "runtime-benchmarks"))] + mod $module; + )* + }; +} + +use_modules!(v9, v10, v11); +use crate::{weights::WeightInfo, Config, Error, MigrationInProgress, Pallet, Weight, LOG_TARGET}; +use codec::{Codec, Decode}; use frame_support::{ codec, pallet_prelude::*, - storage::migration, - storage_alias, - traits::{Get, OnRuntimeUpgrade}, - Identity, Twox64Concat, + traits::{ConstU32, OnRuntimeUpgrade}, }; -use sp_runtime::traits::Saturating; -use sp_std::{marker::PhantomData, prelude::*}; +use sp_std::marker::PhantomData; + +#[cfg(feature = "try-runtime")] +use sp_std::prelude::*; #[cfg(feature = "try-runtime")] use sp_runtime::TryRuntimeError; -/// Performs all necessary migrations based on `StorageVersion`. -pub struct Migration(PhantomData); -impl OnRuntimeUpgrade for Migration { - fn on_runtime_upgrade() -> Weight { - let version = >::on_chain_storage_version(); - let mut weight = Weight::zero(); +const PROOF_ENCODE: &str = "Tuple::max_encoded_len() < Cursor::max_encoded_len()` is verified in `Self::integrity_test()`; qed"; +const PROOF_DECODE: &str = + "We encode to the same type in this trait only. No other code touches this item; qed"; - if version < 4 { - v4::migrate::(&mut weight); - } +fn invalid_version(version: StorageVersion) -> ! { + panic!("Required migration {version:?} not supported by this runtime. This is a bug."); +} - if version < 5 { - v5::migrate::(&mut weight); - } +/// The cursor used to store the state of the current migration step. +pub type Cursor = BoundedVec>; - if version < 6 { - v6::migrate::(&mut weight); - } +// In benchmark and tests we use noop migrations, to test and bench the migration framework itself. +#[cfg(not(any(feature = "runtime-benchmarks", test)))] +type Migrations = (v9::Migration, v10::Migration, v11::Migration); - if version < 7 { - v7::migrate::(&mut weight); - } +/// IsFinished describes whether a migration is finished or not. +pub enum IsFinished { + Yes, + No, +} - if version < 8 { - v8::migrate::(&mut weight); +/// A trait that allows to migrate storage from one version to another. +/// +/// The migration is done in steps. The migration is finished when +/// `step()` returns `IsFinished::Yes`. +pub trait Migrate: Codec + MaxEncodedLen + Default { + /// Returns the version of the migration. + const VERSION: u16; + + /// Returns the maximum weight that can be consumed in a single step. + fn max_step_weight() -> Weight; + + /// Process one step of the migration. + /// + /// Returns whether the migration is finished and the weight consumed. + fn step(&mut self) -> (IsFinished, Weight); + + /// Verify that the migration step fits into `Cursor`, and that `max_step_weight` is not greater + /// than `max_block_weight`. + fn integrity_test(max_block_weight: Weight) { + if Self::max_step_weight().any_gt(max_block_weight) { + panic!( + "Invalid max_step_weight for Migration {}. Value should be lower than {}", + Self::VERSION, + max_block_weight + ); } - if version < 9 { - v9::migrate::(&mut weight); + let len = ::max_encoded_len(); + let max = Cursor::bound(); + if len > max { + panic!( + "Migration {} has size {} which is bigger than the maximum of {}", + Self::VERSION, + len, + max, + ); } - - StorageVersion::new(9).put::>(); - weight.saturating_accrue(T::DbWeight::get().writes(1)); - - weight } + /// Execute some pre-checks prior to running the first step of this migration. #[cfg(feature = "try-runtime")] - fn pre_upgrade() -> Result, TryRuntimeError> { - let version = >::on_chain_storage_version(); - - if version == 7 { - v8::pre_upgrade::()?; - } - - Ok(version.encode()) + fn pre_upgrade_step() -> Result, TryRuntimeError> { + Ok(Vec::new()) } + /// Execute some post-checks after running the last step of this migration. #[cfg(feature = "try-runtime")] - fn post_upgrade(state: Vec) -> Result<(), TryRuntimeError> { - let version = Decode::decode(&mut state.as_ref()).map_err(|_| "Cannot decode version")?; - post_checks::post_upgrade::(version) + fn post_upgrade_step(_state: Vec) -> Result<(), TryRuntimeError> { + Ok(()) } } -/// V4: `Schedule` is changed to be a config item rather than an in-storage value. -mod v4 { - use super::*; +/// A noop migration that can be used when there is no migration to be done for a given version. +#[doc(hidden)] +#[derive(frame_support::DefaultNoBound, Encode, Decode, MaxEncodedLen)] +pub struct NoopMigration; - pub fn migrate(weight: &mut Weight) { - #[allow(deprecated)] - migration::remove_storage_prefix(>::name().as_bytes(), b"CurrentSchedule", b""); - weight.saturating_accrue(T::DbWeight::get().writes(1)); +impl Migrate for NoopMigration { + const VERSION: u16 = N; + fn max_step_weight() -> Weight { + Weight::zero() + } + fn step(&mut self) -> (IsFinished, Weight) { + log::debug!(target: LOG_TARGET, "Noop migration for version {}", N); + (IsFinished::Yes, Weight::zero()) } } -/// V5: State rent is removed which obsoletes some fields in `ContractInfo`. -mod v5 { - use super::*; +mod private { + use crate::migration::Migrate; + pub trait Sealed {} + #[impl_trait_for_tuples::impl_for_tuples(10)] + #[tuple_types_custom_trait_bound(Migrate)] + impl Sealed for Tuple {} +} + +/// Defines a sequence of migrations. +/// +/// The sequence must be defined by a tuple of migrations, each of which must implement the +/// `Migrate` trait. Migrations must be ordered by their versions with no gaps. +pub trait MigrateSequence: private::Sealed { + /// Returns the range of versions that this migration can handle. + /// Migrations must be ordered by their versions with no gaps. + /// The following code will fail to compile: + /// + /// The following code will fail to compile: + /// ```compile_fail + /// # use pallet_contracts::{NoopMigration, MigrateSequence}; + /// let _ = <(NoopMigration<1>, NoopMigration<3>)>::VERSION_RANGE; + /// ``` + /// The following code will compile: + /// ``` + /// # use pallet_contracts::{NoopMigration, MigrateSequence}; + /// let _ = <(NoopMigration<1>, NoopMigration<2>)>::VERSION_RANGE; + /// ``` + const VERSION_RANGE: (u16, u16); + + /// Returns the default cursor for the given version. + fn new(version: StorageVersion) -> Cursor; - type AliveContractInfo = - RawAliveContractInfo, BalanceOf, ::BlockNumber>; - type TombstoneContractInfo = RawTombstoneContractInfo< - ::Hash, - ::Hashing, - >; - - #[derive(Decode)] - enum OldContractInfo { - Alive(AliveContractInfo), - Tombstone(TombstoneContractInfo), + #[cfg(feature = "try-runtime")] + fn pre_upgrade_step(_version: StorageVersion) -> Result, TryRuntimeError> { + Ok(Vec::new()) } - #[derive(Decode)] - struct RawAliveContractInfo { - trie_id: TrieId, - _storage_size: u32, - _pair_count: u32, - code_hash: CodeHash, - _rent_allowance: Balance, - _rent_paid: Balance, - _deduct_block: BlockNumber, - _last_write: Option, - _reserved: Option<()>, + #[cfg(feature = "try-runtime")] + fn post_upgrade_step(_version: StorageVersion, _state: Vec) -> Result<(), TryRuntimeError> { + Ok(()) } - #[derive(Decode)] - struct RawTombstoneContractInfo(H, PhantomData); + /// Execute the migration step until the weight limit is reached. + fn steps(version: StorageVersion, cursor: &[u8], weight_left: &mut Weight) -> StepResult; - #[derive(Decode)] - struct OldDeletedContract { - _pair_count: u32, - trie_id: TrieId, - } + /// Verify that the migration step fits into `Cursor`, and that `max_step_weight` is not greater + /// than `max_block_weight`. + fn integrity_test(max_block_weight: Weight); - pub type ContractInfo = RawContractInfo>; + /// Returns whether migrating from `in_storage` to `target` is supported. + /// + /// A migration is supported if (in_storage + 1, target) is contained by `VERSION_RANGE`. + fn is_upgrade_supported(in_storage: StorageVersion, target: StorageVersion) -> bool { + if in_storage == target { + return true + } + if in_storage > target { + return false + } - #[derive(Encode, Decode)] - pub struct RawContractInfo { - pub trie_id: TrieId, - pub code_hash: CodeHash, - pub _reserved: Option<()>, - } + let (low, high) = Self::VERSION_RANGE; + let Some(first_supported) = low.checked_sub(1) else { + return false + }; - #[derive(Encode, Decode)] - struct DeletedContract { - trie_id: TrieId, + in_storage >= first_supported && target == high } +} - #[storage_alias] - type ContractInfoOf = StorageMap< - Pallet, - Twox64Concat, - ::AccountId, - ContractInfo, - >; - - #[storage_alias] - type DeletionQueue = StorageValue, Vec>; - - pub fn migrate(weight: &mut Weight) { - >::translate(|_key, old: OldContractInfo| { - weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 1)); - match old { - OldContractInfo::Alive(old) => Some(ContractInfo:: { - trie_id: old.trie_id, - code_hash: old.code_hash, - _reserved: old._reserved, - }), - OldContractInfo::Tombstone(_) => None, +/// Performs all necessary migrations based on `StorageVersion`. +#[cfg(not(any(feature = "runtime-benchmarks", test)))] +pub struct Migration>(PhantomData<(T, M)>); + +/// Custom migration for running runtime-benchmarks and tests. +#[cfg(any(feature = "runtime-benchmarks", test))] +pub struct Migration, NoopMigration<2>)>( + PhantomData<(T, M)>, +); + +#[cfg(feature = "try-runtime")] +impl Migration { + fn run_all_steps() -> Result<(), TryRuntimeError> { + let mut weight = Weight::zero(); + let name = >::name(); + loop { + let in_progress_version = >::on_chain_storage_version() + 1; + let state = M::pre_upgrade_step(in_progress_version)?; + let (status, w) = Self::migrate(Weight::MAX); + weight.saturating_accrue(w); + log::info!( + target: LOG_TARGET, + "{name}: Migration step {:?} weight = {}", + in_progress_version, + weight + ); + M::post_upgrade_step(in_progress_version, state)?; + if matches!(status, MigrateResult::Completed) { + break } - }); + } - DeletionQueue::::translate(|old: Option>| { - weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 1)); - old.map(|old| old.into_iter().map(|o| DeletedContract { trie_id: o.trie_id }).collect()) - }) - .ok(); + let name = >::name(); + log::info!(target: LOG_TARGET, "{name}: Migration steps weight = {}", weight); + Ok(()) } } -/// V6: Added storage deposits -mod v6 { - use super::*; +impl OnRuntimeUpgrade for Migration { + fn on_runtime_upgrade() -> Weight { + let name = >::name(); + let latest_version = >::current_storage_version(); + let storage_version = >::on_chain_storage_version(); + + if storage_version == latest_version { + log::warn!( + target: LOG_TARGET, + "{name}: No Migration performed storage_version = latest_version = {:?}", + &storage_version + ); + return T::WeightInfo::on_runtime_upgrade_noop() + } - #[derive(Encode, Decode)] - struct OldPrefabWasmModule { - #[codec(compact)] - instruction_weights_version: u32, - #[codec(compact)] - initial: u32, - #[codec(compact)] - maximum: u32, - #[codec(compact)] - refcount: u64, - _reserved: Option<()>, - code: Vec, - original_code_len: u32, - } + // In case a migration is already in progress we create the next migration + // (if any) right when the current one finishes. + if Self::in_progress() { + log::warn!( + target: LOG_TARGET, + "{name}: Migration already in progress {:?}", + &storage_version + ); + return T::WeightInfo::on_runtime_upgrade_in_progress() + } - #[derive(Encode, Decode)] - pub struct PrefabWasmModule { - #[codec(compact)] - pub instruction_weights_version: u32, - #[codec(compact)] - pub initial: u32, - #[codec(compact)] - pub maximum: u32, - pub code: Vec, - } + log::info!( + target: LOG_TARGET, + "{name}: Upgrading storage from {storage_version:?} to {latest_version:?}.", + ); - use v5::ContractInfo as OldContractInfo; + let cursor = M::new(storage_version + 1); + MigrationInProgress::::set(Some(cursor)); - #[derive(Encode, Decode)] - pub struct RawContractInfo { - pub trie_id: TrieId, - pub code_hash: CodeHash, - pub storage_deposit: Balance, - } + #[cfg(feature = "try-runtime")] + Self::run_all_steps().unwrap(); - #[derive(Encode, Decode)] - pub struct OwnerInfo { - owner: T::AccountId, - #[codec(compact)] - deposit: BalanceOf, - #[codec(compact)] - refcount: u64, + return T::WeightInfo::on_runtime_upgrade() } - pub type ContractInfo = RawContractInfo, BalanceOf>; - - #[storage_alias] - type ContractInfoOf = StorageMap< - Pallet, - Twox64Concat, - ::AccountId, - ContractInfo, - >; - - #[storage_alias] - type CodeStorage = StorageMap, Identity, CodeHash, PrefabWasmModule>; - - #[storage_alias] - type OwnerInfoOf = StorageMap, Identity, CodeHash, OwnerInfo>; - - pub fn migrate(weight: &mut Weight) { - >::translate(|_key, old: OldContractInfo| { - weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 1)); - Some(ContractInfo:: { - trie_id: old.trie_id, - code_hash: old.code_hash, - storage_deposit: Default::default(), - }) - }); - - let nobody = T::AccountId::decode(&mut sp_runtime::traits::TrailingZeroInput::zeroes()) - .expect("Infinite input; no dead input space; qed"); - - >::translate(|key, old: OldPrefabWasmModule| { - weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2)); - >::insert( - key, - OwnerInfo { - refcount: old.refcount, - owner: nobody.clone(), - deposit: Default::default(), - }, - ); - Some(PrefabWasmModule { - instruction_weights_version: old.instruction_weights_version, - initial: old.initial, - maximum: old.maximum, - code: old.code, - }) - }); + #[cfg(feature = "try-runtime")] + fn pre_upgrade() -> Result, TryRuntimeError> { + // We can't really do much here as our migrations do not happen during the runtime upgrade. + // Instead, we call the migrations `pre_upgrade` and `post_upgrade` hooks when we iterate + // over our migrations. + let storage_version = >::on_chain_storage_version(); + let target_version = >::current_storage_version(); + + log::debug!( + target: LOG_TARGET, + "{}: Range supported {:?}, range requested {:?}", + >::name(), + M::VERSION_RANGE, + (storage_version, target_version) + ); + + ensure!(M::is_upgrade_supported(storage_version, target_version), "Unsupported upgrade"); + Ok(Default::default()) } } -/// Rename `AccountCounter` to `Nonce`. -mod v7 { - use super::*; - - pub fn migrate(weight: &mut Weight) { - #[storage_alias] - type AccountCounter = StorageValue, u64, ValueQuery>; - #[storage_alias] - type Nonce = StorageValue, u64, ValueQuery>; +/// The result of running the migration. +#[derive(Debug, PartialEq)] +pub enum MigrateResult { + /// No migration was performed + NoMigrationPerformed, + /// No migration currently in progress + NoMigrationInProgress, + /// A migration is in progress + InProgress { steps_done: u32 }, + /// All migrations are completed + Completed, +} - Nonce::::set(AccountCounter::::take()); - weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 2)) - } +/// The result of running a migration step. +#[derive(Debug, PartialEq)] +pub enum StepResult { + InProgress { cursor: Cursor, steps_done: u32 }, + Completed { steps_done: u32 }, } -/// Update `ContractInfo` with new fields that track storage deposits. -mod v8 { - use super::*; - use sp_io::default_child_storage as child; - use v6::ContractInfo as OldContractInfo; - - #[derive(Encode, Decode)] - pub struct ContractInfo { - pub trie_id: TrieId, - pub code_hash: CodeHash, - pub storage_bytes: u32, - pub storage_items: u32, - pub storage_byte_deposit: BalanceOf, - pub storage_item_deposit: BalanceOf, - pub storage_base_deposit: BalanceOf, +impl Migration { + /// Verify that each migration's step of the MigrateSequence fits into `Cursor`. + pub(crate) fn integrity_test() { + let max_weight = ::BlockWeights::get().max_block; + M::integrity_test(max_weight) } - #[storage_alias] - type ContractInfoOf = - StorageMap, Twox64Concat, ::AccountId, V>; - - pub fn migrate(weight: &mut Weight) { - >>::translate_values(|old: OldContractInfo| { - // Count storage items of this contract - let mut storage_bytes = 0u32; - let mut storage_items = 0u32; - let mut key = Vec::new(); - while let Some(next) = child::next_key(&old.trie_id, &key) { - key = next; - let mut val_out = []; - let len = child::read(&old.trie_id, &key, &mut val_out, 0) - .expect("The loop conditions checks for existence of the key; qed"); - storage_bytes.saturating_accrue(len); - storage_items.saturating_accrue(1); - } + /// Migrate + /// Return the weight used and whether or not a migration is in progress + pub(crate) fn migrate(weight_limit: Weight) -> (MigrateResult, Weight) { + let name = >::name(); + let mut weight_left = weight_limit; + + if weight_left.checked_reduce(T::WeightInfo::migrate()).is_none() { + return (MigrateResult::NoMigrationPerformed, Weight::zero()) + } + + MigrationInProgress::::mutate_exists(|progress| { + let Some(cursor_before) = progress.as_mut() else { + return (MigrateResult::NoMigrationInProgress, T::WeightInfo::migration_noop()) + }; + + // if a migration is running it is always upgrading to the next version + let storage_version = >::on_chain_storage_version(); + let in_progress_version = storage_version + 1; - let storage_byte_deposit = - T::DepositPerByte::get().saturating_mul(storage_bytes.into()); - let storage_item_deposit = - T::DepositPerItem::get().saturating_mul(storage_items.into()); - let storage_base_deposit = old - .storage_deposit - .saturating_sub(storage_byte_deposit) - .saturating_sub(storage_item_deposit); - - // Reads: One read for each storage item plus the contract info itself. - // Writes: Only the new contract info. - weight.saturating_accrue( - T::DbWeight::get().reads_writes(u64::from(storage_items) + 1, 1), + log::info!( + target: LOG_TARGET, + "{name}: Migrating from {:?} to {:?},", + storage_version, + in_progress_version, ); - Some(ContractInfo { - trie_id: old.trie_id, - code_hash: old.code_hash, - storage_bytes, - storage_items, - storage_byte_deposit, - storage_item_deposit, - storage_base_deposit, - }) - }); + let result = + match M::steps(in_progress_version, cursor_before.as_ref(), &mut weight_left) { + StepResult::InProgress { cursor, steps_done } => { + *progress = Some(cursor); + MigrateResult::InProgress { steps_done } + }, + StepResult::Completed { steps_done } => { + in_progress_version.put::>(); + if >::current_storage_version() != in_progress_version { + log::info!( + target: LOG_TARGET, + "{name}: Next migration is {:?},", + in_progress_version + 1 + ); + *progress = Some(M::new(in_progress_version + 1)); + MigrateResult::InProgress { steps_done } + } else { + log::info!( + target: LOG_TARGET, + "{name}: All migrations done. At version {:?},", + in_progress_version + ); + *progress = None; + MigrateResult::Completed + } + }, + }; + + (result, weight_limit.saturating_sub(weight_left)) + }) } - #[cfg(feature = "try-runtime")] - pub fn pre_upgrade() -> Result<(), TryRuntimeError> { - use frame_support::traits::ReservableCurrency; - for (key, value) in ContractInfoOf::>::iter() { - let reserved = T::Currency::reserved_balance(&key); - ensure!(reserved >= value.storage_deposit, "Reserved balance out of sync."); + pub(crate) fn ensure_migrated() -> DispatchResult { + if Self::in_progress() { + Err(Error::::MigrationInProgress.into()) + } else { + Ok(()) } - Ok(()) + } + + pub(crate) fn in_progress() -> bool { + MigrationInProgress::::exists() } } -/// Update `CodeStorage` with the new `determinism` field. -mod v9 { - use super::*; - use crate::Determinism; - use v6::PrefabWasmModule as OldPrefabWasmModule; - - #[derive(Encode, Decode)] - pub struct PrefabWasmModule { - #[codec(compact)] - pub instruction_weights_version: u32, - #[codec(compact)] - pub initial: u32, - #[codec(compact)] - pub maximum: u32, - pub code: Vec, - pub determinism: Determinism, +#[impl_trait_for_tuples::impl_for_tuples(10)] +#[tuple_types_custom_trait_bound(Migrate)] +impl MigrateSequence for Tuple { + const VERSION_RANGE: (u16, u16) = { + let mut versions: (u16, u16) = (0, 0); + for_tuples!( + #( + match versions { + (0, 0) => { + versions = (Tuple::VERSION, Tuple::VERSION); + }, + (min_version, last_version) if Tuple::VERSION == last_version + 1 => { + versions = (min_version, Tuple::VERSION); + }, + _ => panic!("Migrations must be ordered by their versions with no gaps.") + } + )* + ); + versions + }; + + fn new(version: StorageVersion) -> Cursor { + for_tuples!( + #( + if version == Tuple::VERSION { + return Tuple::default().encode().try_into().expect(PROOF_ENCODE) + } + )* + ); + invalid_version(version) } - #[storage_alias] - type CodeStorage = StorageMap, Identity, CodeHash, PrefabWasmModule>; - - pub fn migrate(weight: &mut Weight) { - >::translate_values(|old: OldPrefabWasmModule| { - weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 1)); - Some(PrefabWasmModule { - instruction_weights_version: old.instruction_weights_version, - initial: old.initial, - maximum: old.maximum, - code: old.code, - determinism: Determinism::Enforced, - }) - }); + #[cfg(feature = "try-runtime")] + /// Execute the pre-checks of the step associated with this version. + fn pre_upgrade_step(version: StorageVersion) -> Result, TryRuntimeError> { + for_tuples!( + #( + if version == Tuple::VERSION { + return Tuple::pre_upgrade_step() + } + )* + ); + invalid_version(version) + } + + #[cfg(feature = "try-runtime")] + /// Execute the post-checks of the step associated with this version. + fn post_upgrade_step(version: StorageVersion, state: Vec) -> Result<(), TryRuntimeError> { + for_tuples!( + #( + if version == Tuple::VERSION { + return Tuple::post_upgrade_step(state) + } + )* + ); + invalid_version(version) + } + + fn steps(version: StorageVersion, mut cursor: &[u8], weight_left: &mut Weight) -> StepResult { + for_tuples!( + #( + if version == Tuple::VERSION { + let mut migration = ::decode(&mut cursor) + .expect(PROOF_DECODE); + let max_weight = Tuple::max_step_weight(); + let mut steps_done = 0; + while weight_left.all_gt(max_weight) { + let (finished, weight) = migration.step(); + steps_done += 1; + weight_left.saturating_reduce(weight); + if matches!(finished, IsFinished::Yes) { + return StepResult::Completed{ steps_done } + } + } + return StepResult::InProgress{cursor: migration.encode().try_into().expect(PROOF_ENCODE), steps_done } + } + )* + ); + invalid_version(version) + } + + fn integrity_test(max_block_weight: Weight) { + for_tuples!( + #( + Tuple::integrity_test(max_block_weight); + )* + ); } } -// Post checks always need to be run against the latest storage version. This is why we -// do not scope them in the per version modules. They always need to be ported to the latest -// version. -#[cfg(feature = "try-runtime")] -mod post_checks { +#[cfg(test)] +mod test { use super::*; - use crate::Determinism; - use sp_io::default_child_storage as child; - use v8::ContractInfo; - use v9::PrefabWasmModule; - - #[storage_alias] - type CodeStorage = StorageMap, Identity, CodeHash, PrefabWasmModule>; + use crate::tests::{ExtBuilder, Test}; - #[storage_alias] - type ContractInfoOf = - StorageMap, Twox64Concat, ::AccountId, V>; + #[derive(Default, Encode, Decode, MaxEncodedLen)] + struct MockMigration { + // MockMigration needs `N` steps to finish + count: u16, + } - pub fn post_upgrade(old_version: StorageVersion) -> Result<(), TryRuntimeError> { - if old_version < 7 { - return Ok(()) + impl Migrate for MockMigration { + const VERSION: u16 = N; + fn max_step_weight() -> Weight { + Weight::from_all(1) } - - if old_version < 8 { - v8::()?; + fn step(&mut self) -> (IsFinished, Weight) { + assert!(self.count != N); + self.count += 1; + if self.count == N { + (IsFinished::Yes, Weight::from_all(1)) + } else { + (IsFinished::No, Weight::from_all(1)) + } } + } - if old_version < 9 { - v9::()?; - } + #[test] + fn version_range_works() { + let range = <(MockMigration<1>, MockMigration<2>)>::VERSION_RANGE; + assert_eq!(range, (1, 2)); + } - Ok(()) + #[test] + fn is_upgrade_supported_works() { + type M = (MockMigration<9>, MockMigration<10>, MockMigration<11>); + + [(1, 1), (8, 11), (9, 11)].into_iter().for_each(|(from, to)| { + assert!( + M::is_upgrade_supported(StorageVersion::new(from), StorageVersion::new(to)), + "{} -> {} is supported", + from, + to + ) + }); + + [(1, 0), (0, 3), (7, 11), (8, 10)].into_iter().for_each(|(from, to)| { + assert!( + !M::is_upgrade_supported(StorageVersion::new(from), StorageVersion::new(to)), + "{} -> {} is not supported", + from, + to + ) + }); } - fn v8() -> Result<(), TryRuntimeError> { - use frame_support::traits::ReservableCurrency; - for (key, value) in ContractInfoOf::>::iter() { - let reserved = T::Currency::reserved_balance(&key); - let stored = value - .storage_base_deposit - .saturating_add(value.storage_byte_deposit) - .saturating_add(value.storage_item_deposit); - ensure!(reserved >= stored, "Reserved balance out of sync."); - - let mut storage_bytes = 0u32; - let mut storage_items = 0u32; - let mut key = Vec::new(); - while let Some(next) = child::next_key(&value.trie_id, &key) { - key = next; - let mut val_out = []; - let len = child::read(&value.trie_id, &key, &mut val_out, 0) - .expect("The loop conditions checks for existence of the key; qed"); - storage_bytes.saturating_accrue(len); - storage_items.saturating_accrue(1); - } - ensure!(storage_bytes == value.storage_bytes, "Storage bytes do not match."); - ensure!(storage_items == value.storage_items, "Storage items do not match."); - } - Ok(()) + #[test] + fn steps_works() { + type M = (MockMigration<2>, MockMigration<3>); + let version = StorageVersion::new(2); + let mut cursor = M::new(version); + + let mut weight = Weight::from_all(2); + let result = M::steps(version, &cursor, &mut weight); + cursor = vec![1u8, 0].try_into().unwrap(); + assert_eq!(result, StepResult::InProgress { cursor: cursor.clone(), steps_done: 1 }); + assert_eq!(weight, Weight::from_all(1)); + + let mut weight = Weight::from_all(2); + assert_eq!( + M::steps(version, &cursor, &mut weight), + StepResult::Completed { steps_done: 1 } + ); } - fn v9() -> Result<(), TryRuntimeError> { - for value in CodeStorage::::iter_values() { - ensure!( - value.determinism == Determinism::Enforced, - "All pre-existing codes need to be deterministic." - ); - } - Ok(()) + #[test] + fn no_migration_in_progress_works() { + type M = (MockMigration<1>, MockMigration<2>); + type TestMigration = Migration; + + ExtBuilder::default().build().execute_with(|| { + assert_eq!(StorageVersion::get::>(), 2); + assert_eq!(TestMigration::migrate(Weight::MAX).0, MigrateResult::NoMigrationInProgress) + }); + } + + #[test] + fn migration_works() { + type M = (MockMigration<1>, MockMigration<2>); + type TestMigration = Migration; + + ExtBuilder::default().set_storage_version(0).build().execute_with(|| { + assert_eq!(StorageVersion::get::>(), 0); + TestMigration::on_runtime_upgrade(); + for (version, status) in + [(1, MigrateResult::InProgress { steps_done: 1 }), (2, MigrateResult::Completed)] + { + assert_eq!(TestMigration::migrate(Weight::MAX).0, status); + assert_eq!( + >::on_chain_storage_version(), + StorageVersion::new(version) + ); + } + + assert_eq!(TestMigration::migrate(Weight::MAX).0, MigrateResult::NoMigrationInProgress); + assert_eq!(StorageVersion::get::>(), 2); + }); } } diff --git a/frame/contracts/src/migration/v10.rs b/frame/contracts/src/migration/v10.rs new file mode 100644 index 0000000000000..cddf67a53c4f8 --- /dev/null +++ b/frame/contracts/src/migration/v10.rs @@ -0,0 +1,272 @@ +// This file is part of Substrate. + +// Copyright (C) Parity Technologies (UK) Ltd. +// SPDX-License-Identifier: Apache-2.0 + +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +//! Don't rely on reserved balances keeping an account alive +//! See . + +use crate::{ + address::AddressGenerator, + exec::AccountIdOf, + migration::{IsFinished, Migrate}, + weights::WeightInfo, + BalanceOf, CodeHash, Config, Pallet, TrieId, Weight, LOG_TARGET, +}; +use codec::{Decode, Encode}; +use core::cmp::{max, min}; +use frame_support::{ + codec, + pallet_prelude::*, + storage_alias, + traits::{ + fungible::Inspect, + tokens::{Fortitude::Polite, Preservation::Preserve}, + Currency, ExistenceRequirement, ReservableCurrency, + }, + DefaultNoBound, +}; +use sp_core::hexdisplay::HexDisplay; +#[cfg(feature = "try-runtime")] +use sp_runtime::TryRuntimeError; +use sp_runtime::{traits::Zero, Perbill, Saturating}; +use sp_std::{marker::PhantomData, ops::Deref, prelude::*}; + +mod old { + use super::*; + + #[derive(Encode, Decode, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo, MaxEncodedLen)] + #[scale_info(skip_type_params(T))] + pub struct ContractInfo { + pub trie_id: TrieId, + pub code_hash: CodeHash, + pub storage_bytes: u32, + pub storage_items: u32, + pub storage_byte_deposit: BalanceOf, + pub storage_item_deposit: BalanceOf, + pub storage_base_deposit: BalanceOf, + } + + #[storage_alias] + pub type ContractInfoOf = StorageMap< + Pallet, + Twox64Concat, + ::AccountId, + ContractInfo, + >; +} + +#[cfg(feature = "runtime-benchmarks")] +pub fn store_old_contrat_info(account: T::AccountId, info: crate::ContractInfo) { + let info = old::ContractInfo { + trie_id: info.trie_id, + code_hash: info.code_hash, + storage_bytes: Default::default(), + storage_items: Default::default(), + storage_byte_deposit: Default::default(), + storage_item_deposit: Default::default(), + storage_base_deposit: Default::default(), + }; + old::ContractInfoOf::::insert(account, info); +} + +#[derive(Encode, Decode, Clone, PartialEq, Eq, RuntimeDebugNoBound, TypeInfo, MaxEncodedLen)] +#[scale_info(skip_type_params(T))] +pub struct DepositAccount(AccountIdOf); + +impl Deref for DepositAccount { + type Target = AccountIdOf; + + fn deref(&self) -> &Self::Target { + &self.0 + } +} + +#[derive(Encode, Decode, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo, MaxEncodedLen)] +#[scale_info(skip_type_params(T))] +pub struct ContractInfo { + pub trie_id: TrieId, + deposit_account: DepositAccount, + pub code_hash: CodeHash, + storage_bytes: u32, + storage_items: u32, + pub storage_byte_deposit: BalanceOf, + storage_item_deposit: BalanceOf, + storage_base_deposit: BalanceOf, +} + +#[derive(Encode, Decode, MaxEncodedLen, DefaultNoBound)] +pub struct Migration { + last_key: Option>>, + _phantom: PhantomData, +} + +#[storage_alias] +type ContractInfoOf = + StorageMap, Twox64Concat, ::AccountId, ContractInfo>; + +impl Migrate for Migration { + const VERSION: u16 = 10; + + fn max_step_weight() -> Weight { + T::WeightInfo::v10_migration_step() + } + + fn step(&mut self) -> (IsFinished, Weight) { + let mut iter = if let Some(last_key) = self.last_key.take() { + old::ContractInfoOf::::iter_from(last_key.to_vec()) + } else { + old::ContractInfoOf::::iter() + }; + + if let Some((account, contract)) = iter.next() { + let min_balance = Pallet::::min_balance(); + log::debug!(target: LOG_TARGET, "Account: 0x{} ", HexDisplay::from(&account.encode())); + + // Store last key for next migration step + self.last_key = Some(iter.last_raw_key().to_vec().try_into().unwrap()); + + // Get the new deposit account address + let deposit_account: DepositAccount = + DepositAccount(T::AddressGenerator::deposit_address(&account)); + + // Calculate the existing deposit, that should be reserved on the contract account + let old_deposit = contract + .storage_base_deposit + .saturating_add(contract.storage_item_deposit) + .saturating_add(contract.storage_byte_deposit); + + // Unreserve the existing deposit + // Note we can't use repatriate_reserve, because it only works with existing accounts + let remaining = T::Currency::unreserve(&account, old_deposit); + if !remaining.is_zero() { + log::warn!( + target: LOG_TARGET, + "Partially unreserved. Remaining {:?} out of {:?} asked", + remaining, + old_deposit + ); + } + + // Attempt to transfer the old deposit to the deposit account. + let amount = old_deposit + .saturating_sub(min_balance) + .min(T::Currency::reducible_balance(&account, Preserve, Polite)); + + let new_deposit = T::Currency::transfer( + &account, + &deposit_account, + amount, + ExistenceRequirement::KeepAlive, + ) + .map(|_| { + log::debug!( + target: LOG_TARGET, + "Transferred deposit ({:?}) to deposit account", + amount + ); + amount + }) + // If it fails we fallback to minting the ED. + .unwrap_or_else(|err| { + log::error!(target: LOG_TARGET, "Failed to transfer ED, reason: {:?}", err); + T::Currency::deposit_creating(&deposit_account, min_balance); + min_balance + }); + + // Calculate the new base_deposit to store in the contract: + // Ideally: it should be the same as the old one + // Ideally, it should be at least 2xED (for the contract and deposit account). + // It can't be more than the `new_deposit`. + let new_base_deposit = min( + max(contract.storage_base_deposit, min_balance.saturating_add(min_balance)), + new_deposit, + ); + + // Calculate the ratio to adjust storage_byte and storage_item deposits. + let new_deposit_without_base = new_deposit.saturating_sub(new_base_deposit); + let old_deposit_without_base = + old_deposit.saturating_sub(contract.storage_base_deposit); + let ratio = Perbill::from_rational(new_deposit_without_base, old_deposit_without_base); + + // Calculate the new storage deposits based on the ratio + let storage_byte_deposit = ratio.mul_ceil(contract.storage_byte_deposit); + let storage_item_deposit = ratio.mul_ceil(contract.storage_item_deposit); + + // Recalculate the new base deposit, instead of using new_base_deposit to avoid rounding + // errors + let storage_base_deposit = new_deposit + .saturating_sub(storage_byte_deposit) + .saturating_sub(storage_item_deposit); + + let new_contract_info = ContractInfo { + trie_id: contract.trie_id, + deposit_account, + code_hash: contract.code_hash, + storage_bytes: contract.storage_bytes, + storage_items: contract.storage_items, + storage_byte_deposit, + storage_item_deposit, + storage_base_deposit, + }; + + ContractInfoOf::::insert(&account, new_contract_info); + (IsFinished::No, T::WeightInfo::v10_migration_step()) + } else { + log::debug!(target: LOG_TARGET, "Done Migrating contract info"); + (IsFinished::Yes, T::WeightInfo::v10_migration_step()) + } + } + + #[cfg(feature = "try-runtime")] + fn pre_upgrade_step() -> Result, TryRuntimeError> { + let sample: Vec<_> = old::ContractInfoOf::::iter().take(10).collect(); + + log::debug!(target: LOG_TARGET, "Taking sample of {} contracts", sample.len()); + Ok(sample.encode()) + } + + #[cfg(feature = "try-runtime")] + fn post_upgrade_step(state: Vec) -> Result<(), TryRuntimeError> { + let sample = + )> as Decode>::decode(&mut &state[..]).unwrap(); + + log::debug!(target: LOG_TARGET, "Validating sample of {} contracts", sample.len()); + for (account, old_contract) in sample { + log::debug!(target: LOG_TARGET, "==="); + log::debug!(target: LOG_TARGET, "Account: 0x{} ", HexDisplay::from(&account.encode())); + let contract = ContractInfoOf::::get(&account).unwrap(); + ensure!(old_contract.trie_id == contract.trie_id, "invalid trie_id"); + ensure!(old_contract.code_hash == contract.code_hash, "invalid code_hash"); + ensure!(old_contract.storage_bytes == contract.storage_bytes, "invalid storage_bytes"); + ensure!(old_contract.storage_items == contract.storage_items, "invalid storage_items"); + + let deposit = + <::Currency as frame_support::traits::Currency<_>>::total_balance( + &contract.deposit_account, + ); + ensure!( + deposit == + contract + .storage_base_deposit + .saturating_add(contract.storage_item_deposit) + .saturating_add(contract.storage_byte_deposit), + "deposit mismatch" + ); + } + + Ok(()) + } +} diff --git a/frame/contracts/src/migration/v11.rs b/frame/contracts/src/migration/v11.rs new file mode 100644 index 0000000000000..27a4b96431e06 --- /dev/null +++ b/frame/contracts/src/migration/v11.rs @@ -0,0 +1,130 @@ +// This file is part of Substrate. + +// Copyright (C) Parity Technologies (UK) Ltd. +// SPDX-License-Identifier: Apache-2.0 + +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +//! Overflowing bounded DeletionQueue. +//! See . + +use crate::{ + migration::{IsFinished, Migrate}, + weights::WeightInfo, + Config, Pallet, TrieId, Weight, LOG_TARGET, +}; +#[cfg(feature = "try-runtime")] +use sp_runtime::TryRuntimeError; + +use codec::{Decode, Encode}; +use frame_support::{codec, pallet_prelude::*, storage_alias, DefaultNoBound}; +use sp_std::{marker::PhantomData, prelude::*}; +mod old { + use super::*; + + #[derive(Encode, Decode, TypeInfo, MaxEncodedLen)] + pub struct DeletedContract { + pub(crate) trie_id: TrieId, + } + + #[storage_alias] + pub type DeletionQueue = StorageValue, Vec>; +} + +#[derive(Encode, Decode, TypeInfo, MaxEncodedLen, DefaultNoBound, Clone)] +#[scale_info(skip_type_params(T))] +pub struct DeletionQueueManager { + insert_counter: u32, + delete_counter: u32, + _phantom: PhantomData, +} + +#[cfg(any(feature = "runtime-benchmarks", feature = "try-runtime"))] +pub fn fill_old_queue(len: usize) { + let queue: Vec = + core::iter::repeat_with(|| old::DeletedContract { trie_id: Default::default() }) + .take(len) + .collect(); + old::DeletionQueue::::set(Some(queue)); +} + +#[storage_alias] +type DeletionQueue = StorageMap, Twox64Concat, u32, TrieId>; + +#[storage_alias] +type DeletionQueueCounter = StorageValue, DeletionQueueManager, ValueQuery>; + +#[derive(Encode, Decode, MaxEncodedLen, DefaultNoBound)] +pub struct Migration { + _phantom: PhantomData, +} + +impl Migrate for Migration { + const VERSION: u16 = 11; + + // It would be more correct to make our use the now removed [DeletionQueueDepth](https://github.com/paritytech/substrate/pull/13702/files#diff-70e9723e9db62816e35f6f885b6770a8449c75a6c2733e9fa7a245fe52c4656c) + // but in practice the queue is always empty, so 128 is a good enough approximation for not + // underestimating the weight of our migration. + fn max_step_weight() -> Weight { + T::WeightInfo::v11_migration_step(128) + } + + fn step(&mut self) -> (IsFinished, Weight) { + let Some(old_queue) = old::DeletionQueue::::take() else { return (IsFinished::Yes, Weight::zero()) }; + let len = old_queue.len(); + + log::debug!( + target: LOG_TARGET, + "Migrating deletion queue with {} deleted contracts", + old_queue.len() + ); + + if !old_queue.is_empty() { + let mut queue = DeletionQueueManager::::default(); + for contract in old_queue { + >::insert(queue.insert_counter, contract.trie_id); + queue.insert_counter += 1; + } + + >::set(queue); + } + + (IsFinished::Yes, T::WeightInfo::v11_migration_step(len as u32)) + } + + #[cfg(feature = "try-runtime")] + fn pre_upgrade_step() -> Result, TryRuntimeError> { + let old_queue = old::DeletionQueue::::take().unwrap_or_default(); + + if old_queue.is_empty() { + let len = 10u32; + log::debug!( + target: LOG_TARGET, + "Injecting {len} entries to deletion queue to test migration" + ); + fill_old_queue::(len as usize); + return Ok(len.encode()) + } + + Ok((old_queue.len() as u32).encode()) + } + + #[cfg(feature = "try-runtime")] + fn post_upgrade_step(state: Vec) -> Result<(), TryRuntimeError> { + let len = ::decode(&mut &state[..]).unwrap(); + let counter = >::get(); + ensure!(counter.insert_counter == len, "invalid insert counter"); + ensure!(counter.delete_counter == 0, "invalid delete counter"); + Ok(()) + } +} diff --git a/frame/contracts/src/migration/v9.rs b/frame/contracts/src/migration/v9.rs new file mode 100644 index 0000000000000..3dd86a89cf06d --- /dev/null +++ b/frame/contracts/src/migration/v9.rs @@ -0,0 +1,149 @@ +// This file is part of Substrate. + +// Copyright (C) Parity Technologies (UK) Ltd. +// SPDX-License-Identifier: Apache-2.0 + +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +//! Update `CodeStorage` with the new `determinism` field. + +use crate::{ + migration::{IsFinished, Migrate}, + weights::WeightInfo, + CodeHash, Config, Determinism, Pallet, Weight, LOG_TARGET, +}; +use codec::{Decode, Encode}; +use frame_support::{ + codec, pallet_prelude::*, storage_alias, BoundedVec, DefaultNoBound, Identity, +}; +#[cfg(feature = "try-runtime")] +use sp_runtime::TryRuntimeError; +use sp_std::{marker::PhantomData, prelude::*}; + +mod old { + use super::*; + + #[derive(Encode, Decode)] + pub struct PrefabWasmModule { + #[codec(compact)] + pub instruction_weights_version: u32, + #[codec(compact)] + pub initial: u32, + #[codec(compact)] + pub maximum: u32, + pub code: Vec, + } + + #[storage_alias] + pub type CodeStorage = + StorageMap, Identity, CodeHash, PrefabWasmModule>; +} + +#[cfg(feature = "runtime-benchmarks")] +pub fn store_old_dummy_code(len: usize) { + use sp_runtime::traits::Hash; + let module = old::PrefabWasmModule { + instruction_weights_version: 0, + initial: 0, + maximum: 0, + code: vec![42u8; len], + }; + let hash = T::Hashing::hash(&module.code); + old::CodeStorage::::insert(hash, module); +} + +#[derive(Encode, Decode)] +struct PrefabWasmModule { + #[codec(compact)] + pub instruction_weights_version: u32, + #[codec(compact)] + pub initial: u32, + #[codec(compact)] + pub maximum: u32, + pub code: Vec, + pub determinism: Determinism, +} + +#[storage_alias] +type CodeStorage = StorageMap, Identity, CodeHash, PrefabWasmModule>; + +#[derive(Encode, Decode, MaxEncodedLen, DefaultNoBound)] +pub struct Migration { + last_key: Option>>, + _phantom: PhantomData, +} + +impl Migrate for Migration { + const VERSION: u16 = 9; + + fn max_step_weight() -> Weight { + T::WeightInfo::v9_migration_step(T::MaxCodeLen::get()) + } + + fn step(&mut self) -> (IsFinished, Weight) { + let mut iter = if let Some(last_key) = self.last_key.take() { + old::CodeStorage::::iter_from(last_key.to_vec()) + } else { + old::CodeStorage::::iter() + }; + + if let Some((key, old)) = iter.next() { + log::debug!(target: LOG_TARGET, "Migrating contract code {:?}", key); + let len = old.code.len() as u32; + let module = PrefabWasmModule { + instruction_weights_version: old.instruction_weights_version, + initial: old.initial, + maximum: old.maximum, + code: old.code, + determinism: Determinism::Enforced, + }; + CodeStorage::::insert(key, module); + self.last_key = Some(iter.last_raw_key().to_vec().try_into().unwrap()); + (IsFinished::No, T::WeightInfo::v9_migration_step(len)) + } else { + log::debug!(target: LOG_TARGET, "No more contracts code to migrate"); + (IsFinished::Yes, T::WeightInfo::v9_migration_step(0)) + } + } + + #[cfg(feature = "try-runtime")] + fn pre_upgrade_step() -> Result, TryRuntimeError> { + let sample: Vec<_> = old::CodeStorage::::iter().take(100).collect(); + + log::debug!(target: LOG_TARGET, "Taking sample of {} contract codes", sample.len()); + Ok(sample.encode()) + } + + #[cfg(feature = "try-runtime")] + fn post_upgrade_step(state: Vec) -> Result<(), TryRuntimeError> { + let sample = + , old::PrefabWasmModule)> as Decode>::decode(&mut &state[..]).unwrap(); + + log::debug!(target: LOG_TARGET, "Validating sample of {} contract codes", sample.len()); + for (code_hash, old) in sample { + let module = CodeStorage::::get(&code_hash).unwrap(); + ensure!( + module.instruction_weights_version == old.instruction_weights_version, + "invalid isntruction weights version" + ); + ensure!(module.determinism == Determinism::Enforced, "invalid determinism"); + ensure!(module.initial == old.initial, "invalid initial"); + ensure!(module.maximum == old.maximum, "invalid maximum"); + ensure!(module.code == old.code, "invalid code"); + ensure!(module.maximum == old.maximum, "invalid maximum"); + ensure!(module.code == old.code, "invalid code"); + } + + Ok(()) + } +} diff --git a/frame/contracts/src/tests.rs b/frame/contracts/src/tests.rs index ed754b5908f52..d23a238dcd158 100644 --- a/frame/contracts/src/tests.rs +++ b/frame/contracts/src/tests.rs @@ -28,7 +28,8 @@ use crate::{ wasm::{Determinism, PrefabWasmModule, ReturnCode as RuntimeReturnCode}, weights::WeightInfo, BalanceOf, Code, CodeStorage, CollectEvents, Config, ContractInfo, ContractInfoOf, DebugInfo, - DefaultAddressGenerator, DeletionQueueCounter, Error, Origin, Pallet, Schedule, + DefaultAddressGenerator, DeletionQueueCounter, Error, MigrationInProgress, Origin, Pallet, + Schedule, }; use assert_matches::assert_matches; use codec::Encode; @@ -39,7 +40,7 @@ use frame_support::{ storage::child, traits::{ ConstU32, ConstU64, Contains, Currency, ExistenceRequirement, LockableCurrency, OnIdle, - OnInitialize, WithdrawReasons, + OnInitialize, StorageVersion, WithdrawReasons, }, weights::{constants::WEIGHT_REF_TIME_PER_SECOND, Weight}, }; @@ -438,10 +439,11 @@ pub const GAS_LIMIT: Weight = Weight::from_parts(100_000_000_000, 3 * 1024 * 102 pub struct ExtBuilder { existential_deposit: u64, + storage_version: Option, } impl Default for ExtBuilder { fn default() -> Self { - Self { existential_deposit: ExistentialDeposit::get() } + Self { existential_deposit: ExistentialDeposit::get(), storage_version: None } } } impl ExtBuilder { @@ -452,6 +454,10 @@ impl ExtBuilder { pub fn set_associated_consts(&self) { EXISTENTIAL_DEPOSIT.with(|v| *v.borrow_mut() = self.existential_deposit); } + pub fn set_storage_version(mut self, version: u16) -> Self { + self.storage_version = Some(StorageVersion::new(version)); + self + } pub fn build(self) -> sp_io::TestExternalities { use env_logger::{Builder, Env}; let env = Env::new().default_filter_or("runtime=debug"); @@ -463,7 +469,15 @@ impl ExtBuilder { .unwrap(); let mut ext = sp_io::TestExternalities::new(t); ext.register_extension(KeystoreExt::new(MemoryKeystore::new())); - ext.execute_with(|| System::set_block_number(1)); + ext.execute_with(|| { + use frame_support::traits::OnGenesis; + + Pallet::::on_genesis(); + if let Some(storage_version) = self.storage_version { + storage_version.put::>(); + } + System::set_block_number(1) + }); ext } } @@ -544,6 +558,62 @@ fn calling_plain_account_fails() { }); } +#[test] +fn migration_in_progress_works() { + let (wasm, code_hash) = compile_module::("dummy").unwrap(); + + ExtBuilder::default().existential_deposit(1).build().execute_with(|| { + let _ = Balances::deposit_creating(&ALICE, 1_000_000); + MigrationInProgress::::set(Some(Default::default())); + + assert_err!( + Contracts::upload_code( + RuntimeOrigin::signed(ALICE), + vec![], + None, + Determinism::Enforced + ), + Error::::MigrationInProgress, + ); + assert_err!( + Contracts::remove_code(RuntimeOrigin::signed(ALICE), code_hash), + Error::::MigrationInProgress, + ); + assert_err!( + Contracts::set_code(RuntimeOrigin::signed(ALICE), BOB.clone(), code_hash), + Error::::MigrationInProgress, + ); + assert_err_ignore_postinfo!( + Contracts::call(RuntimeOrigin::signed(ALICE), BOB, 0, GAS_LIMIT, None, vec![],), + Error::::MigrationInProgress, + ); + assert_err_ignore_postinfo!( + Contracts::instantiate_with_code( + RuntimeOrigin::signed(ALICE), + 100_000, + GAS_LIMIT, + None, + wasm, + vec![], + vec![], + ), + Error::::MigrationInProgress, + ); + assert_err_ignore_postinfo!( + Contracts::instantiate( + RuntimeOrigin::signed(ALICE), + 100_000, + GAS_LIMIT, + None, + code_hash, + vec![], + vec![], + ), + Error::::MigrationInProgress, + ); + }); +} + #[test] fn instantiate_and_call_and_deposit_event() { let (wasm, code_hash) = compile_module::("event_and_return_on_deploy").unwrap(); diff --git a/frame/contracts/src/weights.rs b/frame/contracts/src/weights.rs index 0a7f3ddf1ca4f..0d2a804152048 100644 --- a/frame/contracts/src/weights.rs +++ b/frame/contracts/src/weights.rs @@ -18,7 +18,7 @@ //! Autogenerated weights for pallet_contracts //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-04-27, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-05-16, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` //! HOSTNAME: `bm3`, CPU: `Intel(R) Core(TM) i7-7700K CPU @ 4.20GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("dev"), DB CACHE: 1024 @@ -53,6 +53,14 @@ pub trait WeightInfo { fn on_process_deletion_queue_batch() -> Weight; fn on_initialize_per_trie_key(k: u32, ) -> Weight; fn reinstrument(c: u32, ) -> Weight; + fn v9_migration_step(c: u32, ) -> Weight; + fn v10_migration_step() -> Weight; + fn v11_migration_step(k: u32, ) -> Weight; + fn migration_noop() -> Weight; + fn migrate() -> Weight; + fn on_runtime_upgrade_noop() -> Weight; + fn on_runtime_upgrade_in_progress() -> Weight; + fn on_runtime_upgrade() -> Weight; fn call_with_code_per_byte(c: u32, ) -> Weight; fn instantiate_with_code(c: u32, i: u32, s: u32, ) -> Weight; fn instantiate(i: u32, s: u32, ) -> Weight; @@ -180,8 +188,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `109` // Estimated: `1594` - // Minimum execution time: 2_627_000 picoseconds. - Weight::from_parts(2_748_000, 1594) + // Minimum execution time: 2_630_000 picoseconds. + Weight::from_parts(2_778_000, 1594) .saturating_add(T::DbWeight::get().reads(1_u64)) } /// Storage: Skipped Metadata (r:0 w:0) @@ -191,10 +199,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `488 + k * (69 ±0)` // Estimated: `478 + k * (70 ±0)` - // Minimum execution time: 13_607_000 picoseconds. - Weight::from_parts(8_026_118, 478) - // Standard Error: 1_323 - .saturating_add(Weight::from_parts(980_583, 0).saturating_mul(k.into())) + // Minimum execution time: 13_453_000 picoseconds. + Weight::from_parts(10_904_078, 478) + // Standard Error: 931 + .saturating_add(Weight::from_parts(982_122, 0).saturating_mul(k.into())) .saturating_add(T::DbWeight::get().reads(2_u64)) .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(k.into()))) .saturating_add(T::DbWeight::get().writes(2_u64)) @@ -210,14 +218,121 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `238 + c * (1 ±0)` // Estimated: `3708 + c * (1 ±0)` - // Minimum execution time: 30_563_000 picoseconds. - Weight::from_parts(22_292_544, 3708) - // Standard Error: 60 - .saturating_add(Weight::from_parts(54_541, 0).saturating_mul(c.into())) + // Minimum execution time: 30_972_000 picoseconds. + Weight::from_parts(31_129_287, 3708) + // Standard Error: 52 + .saturating_add(Weight::from_parts(54_996, 0).saturating_mul(c.into())) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(c.into())) } + /// Storage: Contracts CodeStorage (r:2 w:1) + /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) + /// The range of component `c` is `[0, 61717]`. + fn v9_migration_step(c: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `178 + c * (1 ±0)` + // Estimated: `6114 + c * (1 ±0)` + // Minimum execution time: 9_696_000 picoseconds. + Weight::from_parts(10_697_026, 6114) + // Standard Error: 0 + .saturating_add(Weight::from_parts(1_307, 0).saturating_mul(c.into())) + .saturating_add(T::DbWeight::get().reads(2_u64)) + .saturating_add(T::DbWeight::get().writes(1_u64)) + .saturating_add(Weight::from_parts(0, 1).saturating_mul(c.into())) + } + /// Storage: Contracts ContractInfoOf (r:2 w:1) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) + /// Storage: System Account (r:1 w:0) + /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) + fn v10_migration_step() -> Weight { + // Proof Size summary in bytes: + // Measured: `544` + // Estimated: `6484` + // Minimum execution time: 18_132_000 picoseconds. + Weight::from_parts(18_842_000, 6484) + .saturating_add(T::DbWeight::get().reads(3_u64)) + .saturating_add(T::DbWeight::get().writes(1_u64)) + } + /// Storage: Contracts DeletionQueue (r:1 w:1025) + /// Proof: Contracts DeletionQueue (max_values: None, max_size: Some(142), added: 2617, mode: Measured) + /// Storage: Contracts DeletionQueueCounter (r:0 w:1) + /// Proof: Contracts DeletionQueueCounter (max_values: Some(1), max_size: Some(8), added: 503, mode: Measured) + /// The range of component `k` is `[0, 1024]`. + fn v11_migration_step(k: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `138 + k * (1 ±0)` + // Estimated: `3602 + k * (1 ±0)` + // Minimum execution time: 3_952_000 picoseconds. + Weight::from_parts(4_129_000, 3602) + // Standard Error: 1_521 + .saturating_add(Weight::from_parts(1_013_657, 0).saturating_mul(k.into())) + .saturating_add(T::DbWeight::get().reads(1_u64)) + .saturating_add(T::DbWeight::get().writes(2_u64)) + .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(k.into()))) + .saturating_add(Weight::from_parts(0, 1).saturating_mul(k.into())) + } + /// Storage: Contracts MigrationInProgress (r:1 w:1) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) + fn migration_noop() -> Weight { + // Proof Size summary in bytes: + // Measured: `109` + // Estimated: `1594` + // Minimum execution time: 3_528_000 picoseconds. + Weight::from_parts(3_641_000, 1594) + .saturating_add(T::DbWeight::get().reads(1_u64)) + .saturating_add(T::DbWeight::get().writes(1_u64)) + } + /// Storage: Contracts MigrationInProgress (r:1 w:1) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) + /// Storage: unknown `0x4342193e496fab7ec59d615ed0dc55304e7b9012096b41c4eb3aaf947f6ea429` (r:1 w:1) + /// Proof Skipped: unknown `0x4342193e496fab7ec59d615ed0dc55304e7b9012096b41c4eb3aaf947f6ea429` (r:1 w:1) + fn migrate() -> Weight { + // Proof Size summary in bytes: + // Measured: `133` + // Estimated: `3598` + // Minimum execution time: 13_433_000 picoseconds. + Weight::from_parts(13_710_000, 3598) + .saturating_add(T::DbWeight::get().reads(2_u64)) + .saturating_add(T::DbWeight::get().writes(2_u64)) + } + /// Storage: unknown `0x4342193e496fab7ec59d615ed0dc55304e7b9012096b41c4eb3aaf947f6ea429` (r:1 w:0) + /// Proof Skipped: unknown `0x4342193e496fab7ec59d615ed0dc55304e7b9012096b41c4eb3aaf947f6ea429` (r:1 w:0) + fn on_runtime_upgrade_noop() -> Weight { + // Proof Size summary in bytes: + // Measured: `109` + // Estimated: `3574` + // Minimum execution time: 5_502_000 picoseconds. + Weight::from_parts(5_689_000, 3574) + .saturating_add(T::DbWeight::get().reads(1_u64)) + } + /// Storage: unknown `0x4342193e496fab7ec59d615ed0dc55304e7b9012096b41c4eb3aaf947f6ea429` (r:1 w:0) + /// Proof Skipped: unknown `0x4342193e496fab7ec59d615ed0dc55304e7b9012096b41c4eb3aaf947f6ea429` (r:1 w:0) + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) + fn on_runtime_upgrade_in_progress() -> Weight { + // Proof Size summary in bytes: + // Measured: `134` + // Estimated: `3599` + // Minimum execution time: 7_846_000 picoseconds. + Weight::from_parts(8_078_000, 3599) + .saturating_add(T::DbWeight::get().reads(2_u64)) + } + /// Storage: unknown `0x4342193e496fab7ec59d615ed0dc55304e7b9012096b41c4eb3aaf947f6ea429` (r:1 w:0) + /// Proof Skipped: unknown `0x4342193e496fab7ec59d615ed0dc55304e7b9012096b41c4eb3aaf947f6ea429` (r:1 w:0) + /// Storage: Contracts MigrationInProgress (r:1 w:1) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) + fn on_runtime_upgrade() -> Weight { + // Proof Size summary in bytes: + // Measured: `109` + // Estimated: `3574` + // Minimum execution time: 8_390_000 picoseconds. + Weight::from_parts(8_602_000, 3574) + .saturating_add(T::DbWeight::get().reads(2_u64)) + .saturating_add(T::DbWeight::get().writes(1_u64)) + } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: Contracts ContractInfoOf (r:1 w:1) /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:1 w:0) @@ -233,14 +348,16 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `707` // Estimated: `6656 + c * (1 ±0)` - // Minimum execution time: 268_884_000 picoseconds. - Weight::from_parts(277_799_331, 6656) - // Standard Error: 23 - .saturating_add(Weight::from_parts(37_876, 0).saturating_mul(c.into())) - .saturating_add(T::DbWeight::get().reads(6_u64)) + // Minimum execution time: 280_993_000 picoseconds. + Weight::from_parts(289_622_441, 6656) + // Standard Error: 26 + .saturating_add(Weight::from_parts(38_061, 0).saturating_mul(c.into())) + .saturating_add(T::DbWeight::get().reads(7_u64)) .saturating_add(T::DbWeight::get().writes(4_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(c.into())) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: Contracts OwnerInfoOf (r:1 w:1) /// Proof: Contracts OwnerInfoOf (max_values: None, max_size: Some(88), added: 2563, mode: Measured) /// Storage: Contracts Nonce (r:1 w:1) @@ -264,17 +381,19 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `270` // Estimated: `8659` - // Minimum execution time: 3_159_921_000 picoseconds. - Weight::from_parts(594_826_134, 8659) - // Standard Error: 290 - .saturating_add(Weight::from_parts(106_471, 0).saturating_mul(c.into())) - // Standard Error: 17 - .saturating_add(Weight::from_parts(1_160, 0).saturating_mul(i.into())) - // Standard Error: 17 - .saturating_add(Weight::from_parts(1_417, 0).saturating_mul(s.into())) - .saturating_add(T::DbWeight::get().reads(9_u64)) + // Minimum execution time: 3_136_130_000 picoseconds. + Weight::from_parts(568_808_049, 8659) + // Standard Error: 288 + .saturating_add(Weight::from_parts(108_649, 0).saturating_mul(c.into())) + // Standard Error: 16 + .saturating_add(Weight::from_parts(1_103, 0).saturating_mul(i.into())) + // Standard Error: 16 + .saturating_add(Weight::from_parts(1_502, 0).saturating_mul(s.into())) + .saturating_add(T::DbWeight::get().reads(10_u64)) .saturating_add(T::DbWeight::get().writes(10_u64)) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: Contracts CodeStorage (r:1 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) /// Storage: Contracts Nonce (r:1 w:1) @@ -295,15 +414,17 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `482` // Estimated: `6408` - // Minimum execution time: 1_653_811_000 picoseconds. - Weight::from_parts(296_038_081, 6408) - // Standard Error: 9 - .saturating_add(Weight::from_parts(1_461, 0).saturating_mul(i.into())) - // Standard Error: 9 - .saturating_add(Weight::from_parts(1_430, 0).saturating_mul(s.into())) - .saturating_add(T::DbWeight::get().reads(9_u64)) + // Minimum execution time: 1_655_107_000 picoseconds. + Weight::from_parts(266_843_437, 6408) + // Standard Error: 8 + .saturating_add(Weight::from_parts(1_463, 0).saturating_mul(i.into())) + // Standard Error: 8 + .saturating_add(Weight::from_parts(1_458, 0).saturating_mul(s.into())) + .saturating_add(T::DbWeight::get().reads(10_u64)) .saturating_add(T::DbWeight::get().writes(7_u64)) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: Contracts ContractInfoOf (r:1 w:1) /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:1 w:0) @@ -318,11 +439,13 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `759` // Estimated: `6699` - // Minimum execution time: 195_916_000 picoseconds. - Weight::from_parts(196_706_000, 6699) - .saturating_add(T::DbWeight::get().reads(6_u64)) + // Minimum execution time: 197_684_000 picoseconds. + Weight::from_parts(199_222_000, 6699) + .saturating_add(T::DbWeight::get().reads(7_u64)) .saturating_add(T::DbWeight::get().writes(4_u64)) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: Contracts OwnerInfoOf (r:1 w:1) /// Proof: Contracts OwnerInfoOf (max_values: None, max_size: Some(88), added: 2563, mode: Measured) /// Storage: System EventTopics (r:1 w:1) @@ -336,13 +459,15 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `109` // Estimated: `3574` - // Minimum execution time: 251_137_000 picoseconds. - Weight::from_parts(252_985_435, 3574) - // Standard Error: 88 - .saturating_add(Weight::from_parts(108_141, 0).saturating_mul(c.into())) - .saturating_add(T::DbWeight::get().reads(2_u64)) + // Minimum execution time: 254_766_000 picoseconds. + Weight::from_parts(247_865_224, 3574) + // Standard Error: 146 + .saturating_add(Weight::from_parts(108_830, 0).saturating_mul(c.into())) + .saturating_add(T::DbWeight::get().reads(3_u64)) .saturating_add(T::DbWeight::get().writes(4_u64)) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: Contracts OwnerInfoOf (r:1 w:1) /// Proof: Contracts OwnerInfoOf (max_values: None, max_size: Some(88), added: 2563, mode: Measured) /// Storage: System EventTopics (r:1 w:1) @@ -355,11 +480,13 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `255` // Estimated: `3720` - // Minimum execution time: 33_521_000 picoseconds. - Weight::from_parts(34_039_000, 3720) - .saturating_add(T::DbWeight::get().reads(2_u64)) + // Minimum execution time: 36_038_000 picoseconds. + Weight::from_parts(36_503_000, 3720) + .saturating_add(T::DbWeight::get().reads(3_u64)) .saturating_add(T::DbWeight::get().writes(4_u64)) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: Contracts ContractInfoOf (r:1 w:1) /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts OwnerInfoOf (r:2 w:2) @@ -370,11 +497,13 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `570` // Estimated: `8985` - // Minimum execution time: 33_477_000 picoseconds. - Weight::from_parts(33_890_000, 8985) - .saturating_add(T::DbWeight::get().reads(6_u64)) + // Minimum execution time: 35_312_000 picoseconds. + Weight::from_parts(35_852_000, 8985) + .saturating_add(T::DbWeight::get().reads(7_u64)) .saturating_add(T::DbWeight::get().writes(6_u64)) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: System Account (r:1 w:0) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:1 w:1) @@ -390,14 +519,16 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `781 + r * (6 ±0)` // Estimated: `6722 + r * (6 ±0)` - // Minimum execution time: 239_374_000 picoseconds. - Weight::from_parts(246_017_099, 6722) - // Standard Error: 539 - .saturating_add(Weight::from_parts(323_826, 0).saturating_mul(r.into())) - .saturating_add(T::DbWeight::get().reads(6_u64)) + // Minimum execution time: 241_668_000 picoseconds. + Weight::from_parts(256_167_627, 6722) + // Standard Error: 2_447 + .saturating_add(Weight::from_parts(328_424, 0).saturating_mul(r.into())) + .saturating_add(T::DbWeight::get().reads(7_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) .saturating_add(Weight::from_parts(0, 6).saturating_mul(r.into())) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: System Account (r:1 w:0) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:1601 w:1) @@ -413,15 +544,17 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `839 + r * (240 ±0)` // Estimated: `6743 + r * (2715 ±0)` - // Minimum execution time: 240_656_000 picoseconds. - Weight::from_parts(87_361_934, 6743) - // Standard Error: 5_912 - .saturating_add(Weight::from_parts(3_329_840, 0).saturating_mul(r.into())) - .saturating_add(T::DbWeight::get().reads(6_u64)) + // Minimum execution time: 242_353_000 picoseconds. + Weight::from_parts(82_743_116, 6743) + // Standard Error: 6_271 + .saturating_add(Weight::from_parts(3_331_316, 0).saturating_mul(r.into())) + .saturating_add(T::DbWeight::get().reads(7_u64)) .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(r.into()))) .saturating_add(T::DbWeight::get().writes(3_u64)) .saturating_add(Weight::from_parts(0, 2715).saturating_mul(r.into())) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: System Account (r:1 w:0) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:1601 w:1) @@ -437,15 +570,17 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `831 + r * (244 ±0)` // Estimated: `6747 + r * (2719 ±0)` - // Minimum execution time: 243_026_000 picoseconds. - Weight::from_parts(76_953_007, 6747) - // Standard Error: 6_640 - .saturating_add(Weight::from_parts(4_132_521, 0).saturating_mul(r.into())) - .saturating_add(T::DbWeight::get().reads(6_u64)) + // Minimum execution time: 243_370_000 picoseconds. + Weight::from_parts(77_198_453, 6747) + // Standard Error: 6_968 + .saturating_add(Weight::from_parts(4_162_946, 0).saturating_mul(r.into())) + .saturating_add(T::DbWeight::get().reads(7_u64)) .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(r.into()))) .saturating_add(T::DbWeight::get().writes(3_u64)) .saturating_add(Weight::from_parts(0, 2719).saturating_mul(r.into())) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: System Account (r:1 w:0) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:1 w:1) @@ -461,14 +596,16 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `788 + r * (6 ±0)` // Estimated: `6730 + r * (6 ±0)` - // Minimum execution time: 242_736_000 picoseconds. - Weight::from_parts(243_136_007, 6730) - // Standard Error: 912 - .saturating_add(Weight::from_parts(414_717, 0).saturating_mul(r.into())) - .saturating_add(T::DbWeight::get().reads(6_u64)) + // Minimum execution time: 244_083_000 picoseconds. + Weight::from_parts(239_899_316, 6730) + // Standard Error: 5_254 + .saturating_add(Weight::from_parts(423_863, 0).saturating_mul(r.into())) + .saturating_add(T::DbWeight::get().reads(7_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) .saturating_add(Weight::from_parts(0, 6).saturating_mul(r.into())) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: System Account (r:1 w:0) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:1 w:1) @@ -484,14 +621,16 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `778 + r * (3 ±0)` // Estimated: `6723 + r * (3 ±0)` - // Minimum execution time: 240_130_000 picoseconds. - Weight::from_parts(244_517_187, 6723) - // Standard Error: 384 - .saturating_add(Weight::from_parts(167_431, 0).saturating_mul(r.into())) - .saturating_add(T::DbWeight::get().reads(6_u64)) + // Minimum execution time: 239_835_000 picoseconds. + Weight::from_parts(247_929_454, 6723) + // Standard Error: 2_309 + .saturating_add(Weight::from_parts(169_642, 0).saturating_mul(r.into())) + .saturating_add(T::DbWeight::get().reads(7_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) .saturating_add(Weight::from_parts(0, 3).saturating_mul(r.into())) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: Contracts ContractInfoOf (r:1 w:1) /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:1 w:0) @@ -505,14 +644,16 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `668 + r * (3 ±0)` // Estimated: `6608 + r * (3 ±0)` - // Minimum execution time: 228_022_000 picoseconds. - Weight::from_parts(232_385_198, 6608) - // Standard Error: 300 - .saturating_add(Weight::from_parts(145_143, 0).saturating_mul(r.into())) - .saturating_add(T::DbWeight::get().reads(5_u64)) + // Minimum execution time: 229_091_000 picoseconds. + Weight::from_parts(235_369_797, 6608) + // Standard Error: 283 + .saturating_add(Weight::from_parts(146_485, 0).saturating_mul(r.into())) + .saturating_add(T::DbWeight::get().reads(6_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) .saturating_add(Weight::from_parts(0, 3).saturating_mul(r.into())) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: System Account (r:1 w:0) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:1 w:1) @@ -528,14 +669,16 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `782 + r * (6 ±0)` // Estimated: `6724 + r * (6 ±0)` - // Minimum execution time: 240_250_000 picoseconds. - Weight::from_parts(240_268_824, 6724) - // Standard Error: 945 - .saturating_add(Weight::from_parts(329_577, 0).saturating_mul(r.into())) - .saturating_add(T::DbWeight::get().reads(6_u64)) + // Minimum execution time: 242_638_000 picoseconds. + Weight::from_parts(245_890_126, 6724) + // Standard Error: 508 + .saturating_add(Weight::from_parts(323_232, 0).saturating_mul(r.into())) + .saturating_add(T::DbWeight::get().reads(7_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) .saturating_add(Weight::from_parts(0, 6).saturating_mul(r.into())) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: System Account (r:1 w:0) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:1 w:1) @@ -551,14 +694,16 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `778 + r * (6 ±0)` // Estimated: `6719 + r * (6 ±0)` - // Minimum execution time: 242_370_000 picoseconds. - Weight::from_parts(242_389_500, 6719) - // Standard Error: 712 - .saturating_add(Weight::from_parts(518_380, 0).saturating_mul(r.into())) - .saturating_add(T::DbWeight::get().reads(6_u64)) + // Minimum execution time: 241_740_000 picoseconds. + Weight::from_parts(244_490_855, 6719) + // Standard Error: 1_872 + .saturating_add(Weight::from_parts(543_651, 0).saturating_mul(r.into())) + .saturating_add(T::DbWeight::get().reads(7_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) .saturating_add(Weight::from_parts(0, 6).saturating_mul(r.into())) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: System Account (r:2 w:0) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:1 w:1) @@ -574,14 +719,16 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `922 + r * (6 ±0)` // Estimated: `6846 + r * (6 ±0)` - // Minimum execution time: 238_563_000 picoseconds. - Weight::from_parts(253_511_314, 6846) - // Standard Error: 1_571 - .saturating_add(Weight::from_parts(1_454_089, 0).saturating_mul(r.into())) - .saturating_add(T::DbWeight::get().reads(7_u64)) + // Minimum execution time: 241_787_000 picoseconds. + Weight::from_parts(243_819_464, 6846) + // Standard Error: 5_017 + .saturating_add(Weight::from_parts(1_496_444, 0).saturating_mul(r.into())) + .saturating_add(T::DbWeight::get().reads(8_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) .saturating_add(Weight::from_parts(0, 6).saturating_mul(r.into())) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: System Account (r:1 w:0) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:1 w:1) @@ -597,14 +744,16 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `792 + r * (6 ±0)` // Estimated: `6741 + r * (6 ±0)` - // Minimum execution time: 242_995_000 picoseconds. - Weight::from_parts(240_061_456, 6741) - // Standard Error: 2_650 - .saturating_add(Weight::from_parts(326_813, 0).saturating_mul(r.into())) - .saturating_add(T::DbWeight::get().reads(6_u64)) + // Minimum execution time: 243_498_000 picoseconds. + Weight::from_parts(251_019_668, 6741) + // Standard Error: 1_479 + .saturating_add(Weight::from_parts(318_979, 0).saturating_mul(r.into())) + .saturating_add(T::DbWeight::get().reads(7_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) .saturating_add(Weight::from_parts(0, 6).saturating_mul(r.into())) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: System Account (r:1 w:0) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:1 w:1) @@ -620,14 +769,16 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `790 + r * (6 ±0)` // Estimated: `6739 + r * (6 ±0)` - // Minimum execution time: 241_342_000 picoseconds. - Weight::from_parts(240_875_314, 6739) - // Standard Error: 669 - .saturating_add(Weight::from_parts(324_519, 0).saturating_mul(r.into())) - .saturating_add(T::DbWeight::get().reads(6_u64)) + // Minimum execution time: 242_572_000 picoseconds. + Weight::from_parts(246_453_396, 6739) + // Standard Error: 978 + .saturating_add(Weight::from_parts(320_095, 0).saturating_mul(r.into())) + .saturating_add(T::DbWeight::get().reads(7_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) .saturating_add(Weight::from_parts(0, 6).saturating_mul(r.into())) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: System Account (r:1 w:0) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:1 w:1) @@ -643,14 +794,16 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `787 + r * (6 ±0)` // Estimated: `6737 + r * (6 ±0)` - // Minimum execution time: 238_954_000 picoseconds. - Weight::from_parts(242_269_896, 6737) - // Standard Error: 1_453 - .saturating_add(Weight::from_parts(317_998, 0).saturating_mul(r.into())) - .saturating_add(T::DbWeight::get().reads(6_u64)) + // Minimum execution time: 241_872_000 picoseconds. + Weight::from_parts(257_272_904, 6737) + // Standard Error: 4_146 + .saturating_add(Weight::from_parts(314_645, 0).saturating_mul(r.into())) + .saturating_add(T::DbWeight::get().reads(7_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) .saturating_add(Weight::from_parts(0, 6).saturating_mul(r.into())) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: System Account (r:1 w:0) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:1 w:1) @@ -666,14 +819,16 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `778 + r * (6 ±0)` // Estimated: `6723 + r * (6 ±0)` - // Minimum execution time: 240_935_000 picoseconds. - Weight::from_parts(242_938_271, 6723) - // Standard Error: 792 - .saturating_add(Weight::from_parts(316_782, 0).saturating_mul(r.into())) - .saturating_add(T::DbWeight::get().reads(6_u64)) + // Minimum execution time: 242_139_000 picoseconds. + Weight::from_parts(244_667_764, 6723) + // Standard Error: 580 + .saturating_add(Weight::from_parts(323_005, 0).saturating_mul(r.into())) + .saturating_add(T::DbWeight::get().reads(7_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) .saturating_add(Weight::from_parts(0, 6).saturating_mul(r.into())) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: System Account (r:1 w:0) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:1 w:1) @@ -691,14 +846,16 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `852 + r * (14 ±0)` // Estimated: `6785 + r * (14 ±0)` - // Minimum execution time: 240_142_000 picoseconds. - Weight::from_parts(241_386_730, 6785) - // Standard Error: 2_116 - .saturating_add(Weight::from_parts(1_387_202, 0).saturating_mul(r.into())) - .saturating_add(T::DbWeight::get().reads(7_u64)) + // Minimum execution time: 242_370_000 picoseconds. + Weight::from_parts(247_330_421, 6785) + // Standard Error: 1_832 + .saturating_add(Weight::from_parts(1_396_737, 0).saturating_mul(r.into())) + .saturating_add(T::DbWeight::get().reads(8_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) .saturating_add(Weight::from_parts(0, 14).saturating_mul(r.into())) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: System Account (r:1 w:0) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:1 w:1) @@ -714,14 +871,16 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `745 + r * (4 ±0)` // Estimated: `6687 + r * (4 ±0)` - // Minimum execution time: 165_617_000 picoseconds. - Weight::from_parts(170_794_127, 6687) - // Standard Error: 209 - .saturating_add(Weight::from_parts(127_931, 0).saturating_mul(r.into())) - .saturating_add(T::DbWeight::get().reads(6_u64)) + // Minimum execution time: 167_583_000 picoseconds. + Weight::from_parts(173_694_884, 6687) + // Standard Error: 2_880 + .saturating_add(Weight::from_parts(133_811, 0).saturating_mul(r.into())) + .saturating_add(T::DbWeight::get().reads(7_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) .saturating_add(Weight::from_parts(0, 4).saturating_mul(r.into())) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: System Account (r:1 w:0) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:1 w:1) @@ -737,14 +896,16 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `780 + r * (6 ±0)` // Estimated: `6724 + r * (6 ±0)` - // Minimum execution time: 238_832_000 picoseconds. - Weight::from_parts(237_110_694, 6724) - // Standard Error: 539 - .saturating_add(Weight::from_parts(280_610, 0).saturating_mul(r.into())) - .saturating_add(T::DbWeight::get().reads(6_u64)) + // Minimum execution time: 242_932_000 picoseconds. + Weight::from_parts(246_356_239, 6724) + // Standard Error: 479 + .saturating_add(Weight::from_parts(268_456, 0).saturating_mul(r.into())) + .saturating_add(T::DbWeight::get().reads(7_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) .saturating_add(Weight::from_parts(0, 6).saturating_mul(r.into())) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: System Account (r:1 w:0) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:1 w:1) @@ -760,13 +921,15 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `784` // Estimated: `6724` - // Minimum execution time: 241_070_000 picoseconds. - Weight::from_parts(242_162_279, 6724) + // Minimum execution time: 245_611_000 picoseconds. + Weight::from_parts(246_102_856, 6724) // Standard Error: 1 - .saturating_add(Weight::from_parts(595, 0).saturating_mul(n.into())) - .saturating_add(T::DbWeight::get().reads(6_u64)) + .saturating_add(Weight::from_parts(596, 0).saturating_mul(n.into())) + .saturating_add(T::DbWeight::get().reads(7_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: System Account (r:1 w:0) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:1 w:1) @@ -782,14 +945,16 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `768 + r * (45 ±0)` // Estimated: `6708 + r * (45 ±0)` - // Minimum execution time: 236_337_000 picoseconds. - Weight::from_parts(238_883_828, 6708) - // Standard Error: 188_978 - .saturating_add(Weight::from_parts(926_671, 0).saturating_mul(r.into())) - .saturating_add(T::DbWeight::get().reads(6_u64)) + // Minimum execution time: 238_764_000 picoseconds. + Weight::from_parts(241_225_075, 6708) + // Standard Error: 196_899 + .saturating_add(Weight::from_parts(3_361_624, 0).saturating_mul(r.into())) + .saturating_add(T::DbWeight::get().reads(7_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) .saturating_add(Weight::from_parts(0, 45).saturating_mul(r.into())) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: System Account (r:1 w:0) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:1 w:1) @@ -805,13 +970,15 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `778` // Estimated: `6731` - // Minimum execution time: 239_103_000 picoseconds. - Weight::from_parts(240_382_910, 6731) + // Minimum execution time: 243_075_000 picoseconds. + Weight::from_parts(244_139_227, 6731) // Standard Error: 0 - .saturating_add(Weight::from_parts(181, 0).saturating_mul(n.into())) - .saturating_add(T::DbWeight::get().reads(6_u64)) + .saturating_add(Weight::from_parts(178, 0).saturating_mul(n.into())) + .saturating_add(T::DbWeight::get().reads(7_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: System Account (r:4 w:4) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:1 w:1) @@ -833,16 +1000,18 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `810 + r * (356 ±0)` // Estimated: `6750 + r * (7781 ±0)` - // Minimum execution time: 238_739_000 picoseconds. - Weight::from_parts(241_041_330, 6750) - // Standard Error: 176_820 - .saturating_add(Weight::from_parts(115_332_869, 0).saturating_mul(r.into())) - .saturating_add(T::DbWeight::get().reads(6_u64)) + // Minimum execution time: 241_330_000 picoseconds. + Weight::from_parts(244_187_673, 6750) + // Standard Error: 473_741 + .saturating_add(Weight::from_parts(117_358_926, 0).saturating_mul(r.into())) + .saturating_add(T::DbWeight::get().reads(7_u64)) .saturating_add(T::DbWeight::get().reads((6_u64).saturating_mul(r.into()))) .saturating_add(T::DbWeight::get().writes(3_u64)) .saturating_add(T::DbWeight::get().writes((8_u64).saturating_mul(r.into()))) .saturating_add(Weight::from_parts(0, 7781).saturating_mul(r.into())) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: System Account (r:1 w:0) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:1 w:1) @@ -860,14 +1029,16 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `825 + r * (10 ±0)` // Estimated: `6769 + r * (10 ±0)` - // Minimum execution time: 240_888_000 picoseconds. - Weight::from_parts(259_901_113, 6769) - // Standard Error: 5_935 - .saturating_add(Weight::from_parts(1_764_269, 0).saturating_mul(r.into())) - .saturating_add(T::DbWeight::get().reads(7_u64)) + // Minimum execution time: 243_298_000 picoseconds. + Weight::from_parts(246_393_253, 6769) + // Standard Error: 4_125 + .saturating_add(Weight::from_parts(1_876_317, 0).saturating_mul(r.into())) + .saturating_add(T::DbWeight::get().reads(8_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) .saturating_add(Weight::from_parts(0, 10).saturating_mul(r.into())) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: System Account (r:1 w:0) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:1 w:1) @@ -883,14 +1054,16 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `778 + r * (10 ±0)` // Estimated: `6723 + r * (10 ±0)` - // Minimum execution time: 237_478_000 picoseconds. - Weight::from_parts(264_915_436, 6723) - // Standard Error: 4_644 - .saturating_add(Weight::from_parts(3_452_918, 0).saturating_mul(r.into())) - .saturating_add(T::DbWeight::get().reads(6_u64)) + // Minimum execution time: 240_477_000 picoseconds. + Weight::from_parts(252_579_330, 6723) + // Standard Error: 1_993 + .saturating_add(Weight::from_parts(3_510_388, 0).saturating_mul(r.into())) + .saturating_add(T::DbWeight::get().reads(7_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) .saturating_add(Weight::from_parts(0, 10).saturating_mul(r.into())) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: System Account (r:1 w:0) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:1 w:1) @@ -907,18 +1080,20 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `797 + t * (32 ±0)` // Estimated: `6744 + t * (2508 ±0)` - // Minimum execution time: 255_720_000 picoseconds. - Weight::from_parts(247_945_758, 6744) - // Standard Error: 73_390 - .saturating_add(Weight::from_parts(2_483_239, 0).saturating_mul(t.into())) - // Standard Error: 20 - .saturating_add(Weight::from_parts(756, 0).saturating_mul(n.into())) - .saturating_add(T::DbWeight::get().reads(6_u64)) + // Minimum execution time: 259_029_000 picoseconds. + Weight::from_parts(252_262_484, 6744) + // Standard Error: 35_710 + .saturating_add(Weight::from_parts(2_236_764, 0).saturating_mul(t.into())) + // Standard Error: 9 + .saturating_add(Weight::from_parts(648, 0).saturating_mul(n.into())) + .saturating_add(T::DbWeight::get().reads(7_u64)) .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(t.into()))) .saturating_add(T::DbWeight::get().writes(3_u64)) .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(t.into()))) .saturating_add(Weight::from_parts(0, 2508).saturating_mul(t.into())) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: System Account (r:1 w:0) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:1 w:1) @@ -934,14 +1109,16 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `777 + r * (7 ±0)` // Estimated: `6721 + r * (7 ±0)` - // Minimum execution time: 172_214_000 picoseconds. - Weight::from_parts(177_306_567, 6721) - // Standard Error: 839 - .saturating_add(Weight::from_parts(230_558, 0).saturating_mul(r.into())) - .saturating_add(T::DbWeight::get().reads(6_u64)) + // Minimum execution time: 170_544_000 picoseconds. + Weight::from_parts(174_555_287, 6721) + // Standard Error: 320 + .saturating_add(Weight::from_parts(233_911, 0).saturating_mul(r.into())) + .saturating_add(T::DbWeight::get().reads(7_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) .saturating_add(Weight::from_parts(0, 7).saturating_mul(r.into())) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: MaxEncodedLen) /// Storage: System Account (r:1 w:0) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen) /// Storage: Contracts ContractInfoOf (r:1 w:1) @@ -957,11 +1134,11 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `125728` // Estimated: `131670` - // Minimum execution time: 354_105_000 picoseconds. - Weight::from_parts(360_649_854, 131670) - // Standard Error: 2 - .saturating_add(Weight::from_parts(737, 0).saturating_mul(i.into())) - .saturating_add(T::DbWeight::get().reads(6_u64)) + // Minimum execution time: 357_160_000 picoseconds. + Weight::from_parts(359_930_328, 131670) + // Standard Error: 1 + .saturating_add(Weight::from_parts(738, 0).saturating_mul(i.into())) + .saturating_add(T::DbWeight::get().reads(7_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) } /// Storage: Skipped Metadata (r:0 w:0) @@ -971,11 +1148,11 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `845 + r * (292 ±0)` // Estimated: `843 + r * (293 ±0)` - // Minimum execution time: 239_637_000 picoseconds. - Weight::from_parts(136_431_436, 843) - // Standard Error: 10_238 - .saturating_add(Weight::from_parts(6_070_221, 0).saturating_mul(r.into())) - .saturating_add(T::DbWeight::get().reads(6_u64)) + // Minimum execution time: 242_846_000 picoseconds. + Weight::from_parts(135_611_732, 843) + // Standard Error: 10_708 + .saturating_add(Weight::from_parts(6_146_995, 0).saturating_mul(r.into())) + .saturating_add(T::DbWeight::get().reads(7_u64)) .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(r.into()))) .saturating_add(T::DbWeight::get().writes(3_u64)) .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(r.into()))) @@ -988,11 +1165,11 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `1304` // Estimated: `1280` - // Minimum execution time: 256_198_000 picoseconds. - Weight::from_parts(289_972_802, 1280) - // Standard Error: 54 - .saturating_add(Weight::from_parts(438, 0).saturating_mul(n.into())) - .saturating_add(T::DbWeight::get().reads(8_u64)) + // Minimum execution time: 258_885_000 picoseconds. + Weight::from_parts(292_699_689, 1280) + // Standard Error: 47 + .saturating_add(Weight::from_parts(433, 0).saturating_mul(n.into())) + .saturating_add(T::DbWeight::get().reads(9_u64)) .saturating_add(T::DbWeight::get().writes(6_u64)) } /// Storage: Skipped Metadata (r:0 w:0) @@ -1002,11 +1179,9 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `1167 + n * (1 ±0)` // Estimated: `1167 + n * (1 ±0)` - // Minimum execution time: 255_519_000 picoseconds. - Weight::from_parts(257_668_217, 1167) - // Standard Error: 19 - .saturating_add(Weight::from_parts(105, 0).saturating_mul(n.into())) - .saturating_add(T::DbWeight::get().reads(7_u64)) + // Minimum execution time: 258_297_000 picoseconds. + Weight::from_parts(262_380_805, 1167) + .saturating_add(T::DbWeight::get().reads(8_u64)) .saturating_add(T::DbWeight::get().writes(4_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) } @@ -1017,11 +1192,11 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `841 + r * (288 ±0)` // Estimated: `845 + r * (289 ±0)` - // Minimum execution time: 239_461_000 picoseconds. - Weight::from_parts(131_630_528, 845) - // Standard Error: 10_483 - .saturating_add(Weight::from_parts(5_910_066, 0).saturating_mul(r.into())) - .saturating_add(T::DbWeight::get().reads(6_u64)) + // Minimum execution time: 242_945_000 picoseconds. + Weight::from_parts(126_721_339, 845) + // Standard Error: 11_891 + .saturating_add(Weight::from_parts(6_134_319, 0).saturating_mul(r.into())) + .saturating_add(T::DbWeight::get().reads(7_u64)) .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(r.into()))) .saturating_add(T::DbWeight::get().writes(3_u64)) .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(r.into()))) @@ -1034,11 +1209,11 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `1163 + n * (1 ±0)` // Estimated: `1163 + n * (1 ±0)` - // Minimum execution time: 254_904_000 picoseconds. - Weight::from_parts(261_213_399, 1163) - // Standard Error: 178 - .saturating_add(Weight::from_parts(125, 0).saturating_mul(n.into())) - .saturating_add(T::DbWeight::get().reads(7_u64)) + // Minimum execution time: 259_872_000 picoseconds. + Weight::from_parts(259_910_037, 1163) + // Standard Error: 142 + .saturating_add(Weight::from_parts(629, 0).saturating_mul(n.into())) + .saturating_add(T::DbWeight::get().reads(8_u64)) .saturating_add(T::DbWeight::get().writes(4_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) } @@ -1049,11 +1224,11 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `835 + r * (296 ±0)` // Estimated: `840 + r * (297 ±0)` - // Minimum execution time: 239_995_000 picoseconds. - Weight::from_parts(151_326_508, 840) - // Standard Error: 8_960 - .saturating_add(Weight::from_parts(4_937_728, 0).saturating_mul(r.into())) - .saturating_add(T::DbWeight::get().reads(6_u64)) + // Minimum execution time: 245_005_000 picoseconds. + Weight::from_parts(155_891_939, 840) + // Standard Error: 9_938 + .saturating_add(Weight::from_parts(4_992_231, 0).saturating_mul(r.into())) + .saturating_add(T::DbWeight::get().reads(7_u64)) .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(r.into()))) .saturating_add(T::DbWeight::get().writes(3_u64)) .saturating_add(Weight::from_parts(0, 297).saturating_mul(r.into())) @@ -1065,11 +1240,11 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `1179 + n * (1 ±0)` // Estimated: `1179 + n * (1 ±0)` - // Minimum execution time: 254_515_000 picoseconds. - Weight::from_parts(256_728_817, 1179) - // Standard Error: 22 - .saturating_add(Weight::from_parts(706, 0).saturating_mul(n.into())) - .saturating_add(T::DbWeight::get().reads(7_u64)) + // Minimum execution time: 257_926_000 picoseconds. + Weight::from_parts(261_438_340, 1179) + // Standard Error: 24 + .saturating_add(Weight::from_parts(659, 0).saturating_mul(n.into())) + .saturating_add(T::DbWeight::get().reads(8_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) } @@ -1080,11 +1255,11 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `856 + r * (288 ±0)` // Estimated: `857 + r * (289 ±0)` - // Minimum execution time: 240_601_000 picoseconds. - Weight::from_parts(154_476_561, 857) - // Standard Error: 8_872 - .saturating_add(Weight::from_parts(4_805_043, 0).saturating_mul(r.into())) - .saturating_add(T::DbWeight::get().reads(6_u64)) + // Minimum execution time: 244_392_000 picoseconds. + Weight::from_parts(156_243_434, 857) + // Standard Error: 8_716 + .saturating_add(Weight::from_parts(4_813_682, 0).saturating_mul(r.into())) + .saturating_add(T::DbWeight::get().reads(7_u64)) .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(r.into()))) .saturating_add(T::DbWeight::get().writes(3_u64)) .saturating_add(Weight::from_parts(0, 289).saturating_mul(r.into())) @@ -1096,9 +1271,11 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `1166 + n * (1 ±0)` // Estimated: `1166 + n * (1 ±0)` - // Minimum execution time: 253_654_000 picoseconds. - Weight::from_parts(257_288_586, 1166) - .saturating_add(T::DbWeight::get().reads(7_u64)) + // Minimum execution time: 255_731_000 picoseconds. + Weight::from_parts(258_937_245, 1166) + // Standard Error: 26 + .saturating_add(Weight::from_parts(61, 0).saturating_mul(n.into())) + .saturating_add(T::DbWeight::get().reads(8_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) } @@ -1109,11 +1286,11 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `829 + r * (296 ±0)` // Estimated: `836 + r * (297 ±0)` - // Minimum execution time: 239_869_000 picoseconds. - Weight::from_parts(135_258_204, 836) - // Standard Error: 10_378 - .saturating_add(Weight::from_parts(6_144_770, 0).saturating_mul(r.into())) - .saturating_add(T::DbWeight::get().reads(6_u64)) + // Minimum execution time: 242_902_000 picoseconds. + Weight::from_parts(140_670_703, 836) + // Standard Error: 10_042 + .saturating_add(Weight::from_parts(6_206_728, 0).saturating_mul(r.into())) + .saturating_add(T::DbWeight::get().reads(7_u64)) .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(r.into()))) .saturating_add(T::DbWeight::get().writes(3_u64)) .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(r.into()))) @@ -1126,14 +1303,16 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `1180 + n * (1 ±0)` // Estimated: `1180 + n * (1 ±0)` - // Minimum execution time: 258_153_000 picoseconds. - Weight::from_parts(260_068_186, 1180) - // Standard Error: 25 - .saturating_add(Weight::from_parts(744, 0).saturating_mul(n.into())) - .saturating_add(T::DbWeight::get().reads(7_u64)) + // Minimum execution time: 258_425_000 picoseconds. + Weight::from_parts(266_011_498, 1180) + // Standard Error: 137 + .saturating_add(Weight::from_parts(383, 0).saturating_mul(n.into())) + .saturating_add(T::DbWeight::get().reads(8_u64)) .saturating_add(T::DbWeight::get().writes(4_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: System Account (r:1602 w:1601) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:1 w:1) @@ -1149,16 +1328,18 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `1373 + r * (45 ±0)` // Estimated: `7270 + r * (2520 ±0)` - // Minimum execution time: 243_189_000 picoseconds. - Weight::from_parts(243_465_000, 7270) - // Standard Error: 30_961 - .saturating_add(Weight::from_parts(35_376_623, 0).saturating_mul(r.into())) - .saturating_add(T::DbWeight::get().reads(7_u64)) + // Minimum execution time: 243_533_000 picoseconds. + Weight::from_parts(67_275_548, 7270) + // Standard Error: 29_687 + .saturating_add(Weight::from_parts(36_086_917, 0).saturating_mul(r.into())) + .saturating_add(T::DbWeight::get().reads(8_u64)) .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(r.into()))) .saturating_add(T::DbWeight::get().writes(4_u64)) .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(r.into()))) .saturating_add(Weight::from_parts(0, 2520).saturating_mul(r.into())) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: System Account (r:1 w:0) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:801 w:801) @@ -1174,16 +1355,18 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `1140 + r * (276 ±0)` // Estimated: `9332 + r * (2752 ±0)` - // Minimum execution time: 243_656_000 picoseconds. - Weight::from_parts(244_221_000, 9332) - // Standard Error: 69_762 - .saturating_add(Weight::from_parts(216_905_619, 0).saturating_mul(r.into())) - .saturating_add(T::DbWeight::get().reads(8_u64)) + // Minimum execution time: 246_206_000 picoseconds. + Weight::from_parts(246_946_000, 9332) + // Standard Error: 74_648 + .saturating_add(Weight::from_parts(217_429_651, 0).saturating_mul(r.into())) + .saturating_add(T::DbWeight::get().reads(9_u64)) .saturating_add(T::DbWeight::get().reads((2_u64).saturating_mul(r.into()))) .saturating_add(T::DbWeight::get().writes(4_u64)) .saturating_add(T::DbWeight::get().writes((2_u64).saturating_mul(r.into()))) .saturating_add(Weight::from_parts(0, 2752).saturating_mul(r.into())) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: System Account (r:1 w:0) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:1 w:1) @@ -1199,16 +1382,18 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `0 + r * (502 ±0)` // Estimated: `6727 + r * (2572 ±10)` - // Minimum execution time: 242_632_000 picoseconds. - Weight::from_parts(243_068_000, 6727) - // Standard Error: 126_218 - .saturating_add(Weight::from_parts(213_096_291, 0).saturating_mul(r.into())) - .saturating_add(T::DbWeight::get().reads(6_u64)) + // Minimum execution time: 245_170_000 picoseconds. + Weight::from_parts(245_460_000, 6727) + // Standard Error: 110_429 + .saturating_add(Weight::from_parts(212_316_013, 0).saturating_mul(r.into())) + .saturating_add(T::DbWeight::get().reads(7_u64)) .saturating_add(T::DbWeight::get().reads((2_u64).saturating_mul(r.into()))) .saturating_add(T::DbWeight::get().writes(3_u64)) .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(r.into()))) .saturating_add(Weight::from_parts(0, 2572).saturating_mul(r.into())) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: System Account (r:3 w:2) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:2 w:2) @@ -1225,18 +1410,20 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `1154 + t * (204 ±0)` // Estimated: `12044 + t * (5154 ±0)` - // Minimum execution time: 421_691_000 picoseconds. - Weight::from_parts(394_587_369, 12044) - // Standard Error: 1_104_014 - .saturating_add(Weight::from_parts(30_461_758, 0).saturating_mul(t.into())) + // Minimum execution time: 424_523_000 picoseconds. + Weight::from_parts(392_267_161, 12044) + // Standard Error: 956_686 + .saturating_add(Weight::from_parts(36_399_297, 0).saturating_mul(t.into())) // Standard Error: 1 - .saturating_add(Weight::from_parts(601, 0).saturating_mul(c.into())) - .saturating_add(T::DbWeight::get().reads(10_u64)) + .saturating_add(Weight::from_parts(600, 0).saturating_mul(c.into())) + .saturating_add(T::DbWeight::get().reads(11_u64)) .saturating_add(T::DbWeight::get().reads((2_u64).saturating_mul(t.into()))) .saturating_add(T::DbWeight::get().writes(6_u64)) .saturating_add(T::DbWeight::get().writes((2_u64).saturating_mul(t.into()))) .saturating_add(Weight::from_parts(0, 5154).saturating_mul(t.into())) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: System Account (r:1602 w:1602) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:801 w:801) @@ -1256,16 +1443,18 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `1322 + r * (254 ±0)` // Estimated: `7146 + r * (5205 ±0)` - // Minimum execution time: 581_252_000 picoseconds. - Weight::from_parts(582_275_000, 7146) - // Standard Error: 279_771 - .saturating_add(Weight::from_parts(349_770_967, 0).saturating_mul(r.into())) - .saturating_add(T::DbWeight::get().reads(8_u64)) + // Minimum execution time: 582_323_000 picoseconds. + Weight::from_parts(584_276_000, 7146) + // Standard Error: 280_418 + .saturating_add(Weight::from_parts(349_510_405, 0).saturating_mul(r.into())) + .saturating_add(T::DbWeight::get().reads(9_u64)) .saturating_add(T::DbWeight::get().reads((6_u64).saturating_mul(r.into()))) .saturating_add(T::DbWeight::get().writes(6_u64)) .saturating_add(T::DbWeight::get().writes((5_u64).saturating_mul(r.into()))) .saturating_add(Weight::from_parts(0, 5205).saturating_mul(r.into())) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: System Account (r:4 w:4) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:2 w:2) @@ -1287,20 +1476,22 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `1071 + t * (187 ±0)` // Estimated: `9492 + t * (2634 ±2)` - // Minimum execution time: 1_623_241_000 picoseconds. - Weight::from_parts(317_076_173, 9492) - // Standard Error: 4_549_416 - .saturating_add(Weight::from_parts(125_360_446, 0).saturating_mul(t.into())) + // Minimum execution time: 1_627_228_000 picoseconds. + Weight::from_parts(358_838_236, 9492) + // Standard Error: 4_785_521 + .saturating_add(Weight::from_parts(114_920_186, 0).saturating_mul(t.into())) // Standard Error: 7 - .saturating_add(Weight::from_parts(1_183, 0).saturating_mul(i.into())) + .saturating_add(Weight::from_parts(1_163, 0).saturating_mul(i.into())) // Standard Error: 7 - .saturating_add(Weight::from_parts(1_352, 0).saturating_mul(s.into())) - .saturating_add(T::DbWeight::get().reads(13_u64)) + .saturating_add(Weight::from_parts(1_336, 0).saturating_mul(s.into())) + .saturating_add(T::DbWeight::get().reads(14_u64)) .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(t.into()))) .saturating_add(T::DbWeight::get().writes(10_u64)) .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(t.into()))) .saturating_add(Weight::from_parts(0, 2634).saturating_mul(t.into())) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: System Account (r:1 w:0) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:1 w:1) @@ -1316,14 +1507,16 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `777 + r * (8 ±0)` // Estimated: `6718 + r * (8 ±0)` - // Minimum execution time: 238_262_000 picoseconds. - Weight::from_parts(243_093_288, 6718) - // Standard Error: 870 - .saturating_add(Weight::from_parts(573_939, 0).saturating_mul(r.into())) - .saturating_add(T::DbWeight::get().reads(6_u64)) + // Minimum execution time: 239_228_000 picoseconds. + Weight::from_parts(245_525_858, 6718) + // Standard Error: 1_774 + .saturating_add(Weight::from_parts(578_001, 0).saturating_mul(r.into())) + .saturating_add(T::DbWeight::get().reads(7_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) .saturating_add(Weight::from_parts(0, 8).saturating_mul(r.into())) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: System Account (r:1 w:0) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:1 w:1) @@ -1339,13 +1532,15 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `785` // Estimated: `6725` - // Minimum execution time: 239_888_000 picoseconds. - Weight::from_parts(242_849_333, 6725) - // Standard Error: 3 - .saturating_add(Weight::from_parts(3_949, 0).saturating_mul(n.into())) - .saturating_add(T::DbWeight::get().reads(6_u64)) + // Minimum execution time: 241_876_000 picoseconds. + Weight::from_parts(240_629_797, 6725) + // Standard Error: 2 + .saturating_add(Weight::from_parts(3_947, 0).saturating_mul(n.into())) + .saturating_add(T::DbWeight::get().reads(7_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: System Account (r:1 w:0) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:1 w:1) @@ -1361,14 +1556,16 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `779 + r * (8 ±0)` // Estimated: `6721 + r * (8 ±0)` - // Minimum execution time: 237_288_000 picoseconds. - Weight::from_parts(242_510_631, 6721) - // Standard Error: 977 - .saturating_add(Weight::from_parts(742_726, 0).saturating_mul(r.into())) - .saturating_add(T::DbWeight::get().reads(6_u64)) + // Minimum execution time: 239_345_000 picoseconds. + Weight::from_parts(245_512_118, 6721) + // Standard Error: 771 + .saturating_add(Weight::from_parts(735_528, 0).saturating_mul(r.into())) + .saturating_add(T::DbWeight::get().reads(7_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) .saturating_add(Weight::from_parts(0, 8).saturating_mul(r.into())) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: System Account (r:1 w:0) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:1 w:1) @@ -1384,13 +1581,15 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `787` // Estimated: `6729` - // Minimum execution time: 240_006_000 picoseconds. - Weight::from_parts(233_802_510, 6729) + // Minimum execution time: 242_741_000 picoseconds. + Weight::from_parts(232_209_398, 6729) // Standard Error: 2 - .saturating_add(Weight::from_parts(3_161, 0).saturating_mul(n.into())) - .saturating_add(T::DbWeight::get().reads(6_u64)) + .saturating_add(Weight::from_parts(3_099, 0).saturating_mul(n.into())) + .saturating_add(T::DbWeight::get().reads(7_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: System Account (r:1 w:0) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:1 w:1) @@ -1406,14 +1605,16 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `779 + r * (8 ±0)` // Estimated: `6724 + r * (8 ±0)` - // Minimum execution time: 237_532_000 picoseconds. - Weight::from_parts(243_087_565, 6724) - // Standard Error: 656 - .saturating_add(Weight::from_parts(417_850, 0).saturating_mul(r.into())) - .saturating_add(T::DbWeight::get().reads(6_u64)) + // Minimum execution time: 239_254_000 picoseconds. + Weight::from_parts(244_250_047, 6724) + // Standard Error: 2_223 + .saturating_add(Weight::from_parts(421_533, 0).saturating_mul(r.into())) + .saturating_add(T::DbWeight::get().reads(7_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) .saturating_add(Weight::from_parts(0, 8).saturating_mul(r.into())) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: System Account (r:1 w:0) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:1 w:1) @@ -1429,13 +1630,15 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `787` // Estimated: `6733` - // Minimum execution time: 241_429_000 picoseconds. - Weight::from_parts(233_528_258, 6733) - // Standard Error: 1 - .saturating_add(Weight::from_parts(913, 0).saturating_mul(n.into())) - .saturating_add(T::DbWeight::get().reads(6_u64)) + // Minimum execution time: 240_848_000 picoseconds. + Weight::from_parts(239_049_162, 6733) + // Standard Error: 3 + .saturating_add(Weight::from_parts(914, 0).saturating_mul(n.into())) + .saturating_add(T::DbWeight::get().reads(7_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: System Account (r:1 w:0) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:1 w:1) @@ -1451,14 +1654,16 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `779 + r * (8 ±0)` // Estimated: `6725 + r * (8 ±0)` - // Minimum execution time: 237_622_000 picoseconds. - Weight::from_parts(240_476_401, 6725) - // Standard Error: 795 - .saturating_add(Weight::from_parts(416_869, 0).saturating_mul(r.into())) - .saturating_add(T::DbWeight::get().reads(6_u64)) + // Minimum execution time: 240_496_000 picoseconds. + Weight::from_parts(245_279_278, 6725) + // Standard Error: 1_047 + .saturating_add(Weight::from_parts(414_108, 0).saturating_mul(r.into())) + .saturating_add(T::DbWeight::get().reads(7_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) .saturating_add(Weight::from_parts(0, 8).saturating_mul(r.into())) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: System Account (r:1 w:0) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:1 w:1) @@ -1474,13 +1679,15 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `787` // Estimated: `6727` - // Minimum execution time: 241_134_000 picoseconds. - Weight::from_parts(234_043_271, 6727) - // Standard Error: 3 - .saturating_add(Weight::from_parts(919, 0).saturating_mul(n.into())) - .saturating_add(T::DbWeight::get().reads(6_u64)) + // Minimum execution time: 241_529_000 picoseconds. + Weight::from_parts(234_715_148, 6727) + // Standard Error: 1 + .saturating_add(Weight::from_parts(914, 0).saturating_mul(n.into())) + .saturating_add(T::DbWeight::get().reads(7_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: System Account (r:1 w:0) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:1 w:1) @@ -1496,14 +1703,16 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `912 + n * (1 ±0)` // Estimated: `6849 + n * (1 ±0)` - // Minimum execution time: 292_699_000 picoseconds. - Weight::from_parts(301_523_608, 6849) - // Standard Error: 14 - .saturating_add(Weight::from_parts(4_676, 0).saturating_mul(n.into())) - .saturating_add(T::DbWeight::get().reads(6_u64)) + // Minimum execution time: 294_982_000 picoseconds. + Weight::from_parts(299_613_855, 6849) + // Standard Error: 7 + .saturating_add(Weight::from_parts(4_668, 0).saturating_mul(n.into())) + .saturating_add(T::DbWeight::get().reads(7_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: System Account (r:1 w:0) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:1 w:1) @@ -1517,16 +1726,18 @@ impl WeightInfo for SubstrateWeight { /// The range of component `r` is `[0, 160]`. fn seal_sr25519_verify(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `727 + r * (112 ±0)` + // Measured: `726 + r * (112 ±0)` // Estimated: `6666 + r * (112 ±0)` - // Minimum execution time: 241_126_000 picoseconds. - Weight::from_parts(248_796_458, 6666) - // Standard Error: 21_501 - .saturating_add(Weight::from_parts(48_091_265, 0).saturating_mul(r.into())) - .saturating_add(T::DbWeight::get().reads(6_u64)) + // Minimum execution time: 242_583_000 picoseconds. + Weight::from_parts(251_860_767, 6666) + // Standard Error: 24_034 + .saturating_add(Weight::from_parts(48_144_071, 0).saturating_mul(r.into())) + .saturating_add(T::DbWeight::get().reads(7_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) .saturating_add(Weight::from_parts(0, 112).saturating_mul(r.into())) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: System Account (r:1 w:0) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:1 w:1) @@ -1541,15 +1752,17 @@ impl WeightInfo for SubstrateWeight { fn seal_ecdsa_recover(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `822 + r * (76 ±0)` - // Estimated: `6717 + r * (77 ±0)` - // Minimum execution time: 242_379_000 picoseconds. - Weight::from_parts(261_355_525, 6717) - // Standard Error: 18_862 - .saturating_add(Weight::from_parts(37_603_073, 0).saturating_mul(r.into())) - .saturating_add(T::DbWeight::get().reads(6_u64)) + // Estimated: `6716 + r * (77 ±0)` + // Minimum execution time: 242_331_000 picoseconds. + Weight::from_parts(254_816_298, 6716) + // Standard Error: 17_941 + .saturating_add(Weight::from_parts(37_725_489, 0).saturating_mul(r.into())) + .saturating_add(T::DbWeight::get().reads(7_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) .saturating_add(Weight::from_parts(0, 77).saturating_mul(r.into())) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: System Account (r:1 w:0) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:1 w:1) @@ -1565,14 +1778,16 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `792 + r * (42 ±0)` // Estimated: `6731 + r * (42 ±0)` - // Minimum execution time: 241_270_000 picoseconds. - Weight::from_parts(245_135_291, 6731) - // Standard Error: 10_757 - .saturating_add(Weight::from_parts(9_344_876, 0).saturating_mul(r.into())) - .saturating_add(T::DbWeight::get().reads(6_u64)) + // Minimum execution time: 242_951_000 picoseconds. + Weight::from_parts(246_055_289, 6731) + // Standard Error: 10_074 + .saturating_add(Weight::from_parts(9_421_877, 0).saturating_mul(r.into())) + .saturating_add(T::DbWeight::get().reads(7_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) .saturating_add(Weight::from_parts(0, 42).saturating_mul(r.into())) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: System Account (r:1 w:0) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:1 w:1) @@ -1590,16 +1805,18 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `0 + r * (964 ±0)` // Estimated: `8190 + r * (3090 ±7)` - // Minimum execution time: 240_506_000 picoseconds. - Weight::from_parts(241_653_000, 8190) - // Standard Error: 46_785 - .saturating_add(Weight::from_parts(22_107_816, 0).saturating_mul(r.into())) - .saturating_add(T::DbWeight::get().reads(6_u64)) + // Minimum execution time: 245_310_000 picoseconds. + Weight::from_parts(245_703_000, 8190) + // Standard Error: 45_813 + .saturating_add(Weight::from_parts(21_837_058, 0).saturating_mul(r.into())) + .saturating_add(T::DbWeight::get().reads(7_u64)) .saturating_add(T::DbWeight::get().reads((3_u64).saturating_mul(r.into()))) .saturating_add(T::DbWeight::get().writes(3_u64)) .saturating_add(T::DbWeight::get().writes((2_u64).saturating_mul(r.into()))) .saturating_add(Weight::from_parts(0, 3090).saturating_mul(r.into())) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: System Account (r:1 w:0) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:1 w:1) @@ -1615,14 +1832,16 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `773 + r * (3 ±0)` // Estimated: `6723 + r * (3 ±0)` - // Minimum execution time: 241_539_000 picoseconds. - Weight::from_parts(245_471_045, 6723) - // Standard Error: 416 - .saturating_add(Weight::from_parts(159_577, 0).saturating_mul(r.into())) - .saturating_add(T::DbWeight::get().reads(6_u64)) + // Minimum execution time: 241_955_000 picoseconds. + Weight::from_parts(246_148_234, 6723) + // Standard Error: 384 + .saturating_add(Weight::from_parts(162_123, 0).saturating_mul(r.into())) + .saturating_add(T::DbWeight::get().reads(7_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) .saturating_add(Weight::from_parts(0, 3).saturating_mul(r.into())) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: System Account (r:1 w:0) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:1 w:1) @@ -1638,14 +1857,16 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `1975 + r * (39 ±0)` // Estimated: `7805 + r * (40 ±0)` - // Minimum execution time: 242_702_000 picoseconds. - Weight::from_parts(274_518_595, 7805) - // Standard Error: 1_138 - .saturating_add(Weight::from_parts(256_973, 0).saturating_mul(r.into())) - .saturating_add(T::DbWeight::get().reads(6_u64)) + // Minimum execution time: 243_928_000 picoseconds. + Weight::from_parts(276_404_668, 7805) + // Standard Error: 1_263 + .saturating_add(Weight::from_parts(262_830, 0).saturating_mul(r.into())) + .saturating_add(T::DbWeight::get().reads(7_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) .saturating_add(Weight::from_parts(0, 40).saturating_mul(r.into())) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: System Account (r:1 w:0) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:1 w:1) @@ -1663,11 +1884,11 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `776 + r * (3 ±0)` // Estimated: `6723 + r * (3 ±0)` - // Minimum execution time: 239_360_000 picoseconds. - Weight::from_parts(245_990_810, 6723) - // Standard Error: 3_188 - .saturating_add(Weight::from_parts(143_408, 0).saturating_mul(r.into())) - .saturating_add(T::DbWeight::get().reads(7_u64)) + // Minimum execution time: 242_853_000 picoseconds. + Weight::from_parts(250_429_787, 6723) + // Standard Error: 433 + .saturating_add(Weight::from_parts(139_180, 0).saturating_mul(r.into())) + .saturating_add(T::DbWeight::get().reads(8_u64)) .saturating_add(T::DbWeight::get().writes(4_u64)) .saturating_add(Weight::from_parts(0, 3).saturating_mul(r.into())) } @@ -1676,510 +1897,508 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_617_000 picoseconds. - Weight::from_parts(1_900_268, 0) + // Minimum execution time: 1_620_000 picoseconds. + Weight::from_parts(1_894_980, 0) // Standard Error: 2 - .saturating_add(Weight::from_parts(2_950, 0).saturating_mul(r.into())) + .saturating_add(Weight::from_parts(2_995, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 5000]`. fn instr_i64load(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_739_000 picoseconds. - Weight::from_parts(2_109_373, 0) - // Standard Error: 43 - .saturating_add(Weight::from_parts(6_586, 0).saturating_mul(r.into())) + // Minimum execution time: 1_716_000 picoseconds. + Weight::from_parts(2_353_783, 0) + // Standard Error: 3 + .saturating_add(Weight::from_parts(6_414, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 5000]`. fn instr_i64store(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_726_000 picoseconds. - Weight::from_parts(2_268_507, 0) + // Minimum execution time: 1_735_000 picoseconds. + Weight::from_parts(2_266_096, 0) // Standard Error: 4 - .saturating_add(Weight::from_parts(6_022, 0).saturating_mul(r.into())) + .saturating_add(Weight::from_parts(6_015, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 5000]`. fn instr_select(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_628_000 picoseconds. - Weight::from_parts(2_042_521, 0) + // Minimum execution time: 1_698_000 picoseconds. + Weight::from_parts(2_080_936, 0) // Standard Error: 3 - .saturating_add(Weight::from_parts(7_935, 0).saturating_mul(r.into())) + .saturating_add(Weight::from_parts(7_921, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 5000]`. fn instr_if(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_648_000 picoseconds. - Weight::from_parts(1_902_691, 0) - // Standard Error: 7 - .saturating_add(Weight::from_parts(10_572, 0).saturating_mul(r.into())) + // Minimum execution time: 1_636_000 picoseconds. + Weight::from_parts(1_913_876, 0) + // Standard Error: 11 + .saturating_add(Weight::from_parts(10_836, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 5000]`. fn instr_br(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_626_000 picoseconds. - Weight::from_parts(1_891_843, 0) - // Standard Error: 14 - .saturating_add(Weight::from_parts(4_612, 0).saturating_mul(r.into())) + // Minimum execution time: 1_703_000 picoseconds. + Weight::from_parts(1_838_470, 0) + // Standard Error: 11 + .saturating_add(Weight::from_parts(4_613, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 5000]`. fn instr_br_if(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_581_000 picoseconds. - Weight::from_parts(1_139_823, 0) - // Standard Error: 74 - .saturating_add(Weight::from_parts(8_008, 0).saturating_mul(r.into())) + // Minimum execution time: 1_662_000 picoseconds. + Weight::from_parts(1_744_254, 0) + // Standard Error: 13 + .saturating_add(Weight::from_parts(7_020, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 5000]`. fn instr_br_table(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_591_000 picoseconds. - Weight::from_parts(1_258_400, 0) - // Standard Error: 34 - .saturating_add(Weight::from_parts(9_706, 0).saturating_mul(r.into())) + // Minimum execution time: 1_621_000 picoseconds. + Weight::from_parts(1_511_579, 0) + // Standard Error: 33 + .saturating_add(Weight::from_parts(9_479, 0).saturating_mul(r.into())) } /// The range of component `e` is `[1, 256]`. - fn instr_br_table_per_entry(e: u32, ) -> Weight { + fn instr_br_table_per_entry(_e: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_701_000 picoseconds. - Weight::from_parts(1_876_118, 0) - // Standard Error: 23 - .saturating_add(Weight::from_parts(4, 0).saturating_mul(e.into())) + // Minimum execution time: 1_758_000 picoseconds. + Weight::from_parts(2_066_494, 0) } /// The range of component `r` is `[0, 5000]`. fn instr_call(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_617_000 picoseconds. - Weight::from_parts(1_565_613, 0) - // Standard Error: 629 - .saturating_add(Weight::from_parts(19_575, 0).saturating_mul(r.into())) + // Minimum execution time: 1_690_000 picoseconds. + Weight::from_parts(2_029_755, 0) + // Standard Error: 9 + .saturating_add(Weight::from_parts(17_946, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 5000]`. fn instr_call_indirect(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_875_000 picoseconds. - Weight::from_parts(4_549_584, 0) - // Standard Error: 278 - .saturating_add(Weight::from_parts(24_336, 0).saturating_mul(r.into())) + // Minimum execution time: 1_894_000 picoseconds. + Weight::from_parts(5_533_643, 0) + // Standard Error: 176 + .saturating_add(Weight::from_parts(23_511, 0).saturating_mul(r.into())) } /// The range of component `l` is `[0, 1024]`. fn instr_call_per_local(l: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_742_000 picoseconds. - Weight::from_parts(2_087_387, 0) - // Standard Error: 26 - .saturating_add(Weight::from_parts(1_041, 0).saturating_mul(l.into())) + // Minimum execution time: 1_756_000 picoseconds. + Weight::from_parts(1_978_038, 0) + // Standard Error: 13 + .saturating_add(Weight::from_parts(1_176, 0).saturating_mul(l.into())) } /// The range of component `r` is `[0, 5000]`. fn instr_local_get(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_861_000 picoseconds. - Weight::from_parts(3_552_428, 0) - // Standard Error: 23 - .saturating_add(Weight::from_parts(2_339, 0).saturating_mul(r.into())) + // Minimum execution time: 2_889_000 picoseconds. + Weight::from_parts(3_181_705, 0) + // Standard Error: 2 + .saturating_add(Weight::from_parts(2_516, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 5000]`. fn instr_local_set(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_866_000 picoseconds. - Weight::from_parts(3_151_948, 0) - // Standard Error: 4 - .saturating_add(Weight::from_parts(3_667, 0).saturating_mul(r.into())) + // Minimum execution time: 2_871_000 picoseconds. + Weight::from_parts(3_186_198, 0) + // Standard Error: 2 + .saturating_add(Weight::from_parts(3_619, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 5000]`. fn instr_local_tee(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_919_000 picoseconds. - Weight::from_parts(3_214_587, 0) - // Standard Error: 5 - .saturating_add(Weight::from_parts(3_867, 0).saturating_mul(r.into())) + // Minimum execution time: 2_890_000 picoseconds. + Weight::from_parts(3_237_380, 0) + // Standard Error: 3 + .saturating_add(Weight::from_parts(3_963, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 5000]`. fn instr_global_get(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_764_000 picoseconds. - Weight::from_parts(1_815_683, 0) - // Standard Error: 123 - .saturating_add(Weight::from_parts(8_733, 0).saturating_mul(r.into())) + // Minimum execution time: 1_756_000 picoseconds. + Weight::from_parts(2_180_563, 0) + // Standard Error: 2 + .saturating_add(Weight::from_parts(8_400, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 5000]`. fn instr_global_set(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_783_000 picoseconds. - Weight::from_parts(2_437_152, 0) - // Standard Error: 13 - .saturating_add(Weight::from_parts(8_839, 0).saturating_mul(r.into())) + // Minimum execution time: 1_807_000 picoseconds. + Weight::from_parts(2_247_402, 0) + // Standard Error: 3 + .saturating_add(Weight::from_parts(8_798, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 5000]`. fn instr_memory_current(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_745_000 picoseconds. - Weight::from_parts(2_018_078, 0) + // Minimum execution time: 1_703_000 picoseconds. + Weight::from_parts(2_050_199, 0) // Standard Error: 2 - .saturating_add(Weight::from_parts(3_756, 0).saturating_mul(r.into())) + .saturating_add(Weight::from_parts(3_833, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 16]`. fn instr_memory_grow(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_648_000 picoseconds. - Weight::from_parts(648_059, 0) - // Standard Error: 142_299 - .saturating_add(Weight::from_parts(13_313_060, 0).saturating_mul(r.into())) + // Minimum execution time: 1_686_000 picoseconds. + Weight::from_parts(720_378, 0) + // Standard Error: 141_036 + .saturating_add(Weight::from_parts(13_193_405, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 5000]`. fn instr_i64clz(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_652_000 picoseconds. - Weight::from_parts(1_953_179, 0) - // Standard Error: 2 - .saturating_add(Weight::from_parts(3_828, 0).saturating_mul(r.into())) + // Minimum execution time: 1_654_000 picoseconds. + Weight::from_parts(1_934_279, 0) + // Standard Error: 3 + .saturating_add(Weight::from_parts(4_049, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 5000]`. fn instr_i64ctz(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_607_000 picoseconds. - Weight::from_parts(1_924_759, 0) - // Standard Error: 2 - .saturating_add(Weight::from_parts(3_762, 0).saturating_mul(r.into())) + // Minimum execution time: 1_609_000 picoseconds. + Weight::from_parts(1_938_511, 0) + // Standard Error: 20 + .saturating_add(Weight::from_parts(3_780, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 5000]`. fn instr_i64popcnt(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_687_000 picoseconds. - Weight::from_parts(1_959_683, 0) - // Standard Error: 2 - .saturating_add(Weight::from_parts(3_754, 0).saturating_mul(r.into())) + // Minimum execution time: 1_634_000 picoseconds. + Weight::from_parts(1_941_109, 0) + // Standard Error: 4 + .saturating_add(Weight::from_parts(3_770, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 5000]`. fn instr_i64eqz(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_641_000 picoseconds. - Weight::from_parts(1_975_838, 0) + // Minimum execution time: 1_652_000 picoseconds. + Weight::from_parts(1_939_447, 0) // Standard Error: 2 - .saturating_add(Weight::from_parts(3_681, 0).saturating_mul(r.into())) + .saturating_add(Weight::from_parts(3_666, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 5000]`. fn instr_i64extendsi32(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_689_000 picoseconds. - Weight::from_parts(1_980_109, 0) + // Minimum execution time: 1_637_000 picoseconds. + Weight::from_parts(1_921_355, 0) // Standard Error: 2 - .saturating_add(Weight::from_parts(3_880, 0).saturating_mul(r.into())) + .saturating_add(Weight::from_parts(3_977, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 5000]`. fn instr_i64extendui32(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_671_000 picoseconds. - Weight::from_parts(1_912_089, 0) - // Standard Error: 29 - .saturating_add(Weight::from_parts(3_896, 0).saturating_mul(r.into())) + // Minimum execution time: 1_668_000 picoseconds. + Weight::from_parts(1_993_872, 0) + // Standard Error: 3 + .saturating_add(Weight::from_parts(3_809, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 5000]`. fn instr_i32wrapi64(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_643_000 picoseconds. - Weight::from_parts(1_951_485, 0) + // Minimum execution time: 1_657_000 picoseconds. + Weight::from_parts(1_954_737, 0) // Standard Error: 2 - .saturating_add(Weight::from_parts(3_725, 0).saturating_mul(r.into())) + .saturating_add(Weight::from_parts(3_734, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 5000]`. fn instr_i64eq(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_649_000 picoseconds. - Weight::from_parts(1_937_598, 0) - // Standard Error: 4 - .saturating_add(Weight::from_parts(6_045, 0).saturating_mul(r.into())) + // Minimum execution time: 1_688_000 picoseconds. + Weight::from_parts(1_993_611, 0) + // Standard Error: 10 + .saturating_add(Weight::from_parts(5_962, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 5000]`. fn instr_i64ne(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_651_000 picoseconds. - Weight::from_parts(2_202_977, 0) - // Standard Error: 313 - .saturating_add(Weight::from_parts(6_299, 0).saturating_mul(r.into())) + // Minimum execution time: 1_662_000 picoseconds. + Weight::from_parts(1_965_361, 0) + // Standard Error: 2 + .saturating_add(Weight::from_parts(5_965, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 5000]`. fn instr_i64lts(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_589_000 picoseconds. - Weight::from_parts(1_946_304, 0) + // Minimum execution time: 1_679_000 picoseconds. + Weight::from_parts(1_946_910, 0) // Standard Error: 2 - .saturating_add(Weight::from_parts(6_019, 0).saturating_mul(r.into())) + .saturating_add(Weight::from_parts(5_987, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 5000]`. fn instr_i64ltu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_614_000 picoseconds. - Weight::from_parts(1_933_375, 0) - // Standard Error: 2 - .saturating_add(Weight::from_parts(6_020, 0).saturating_mul(r.into())) + // Minimum execution time: 1_650_000 picoseconds. + Weight::from_parts(1_925_830, 0) + // Standard Error: 4 + .saturating_add(Weight::from_parts(6_001, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 5000]`. fn instr_i64gts(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_678_000 picoseconds. - Weight::from_parts(2_003_850, 0) + // Minimum execution time: 1_652_000 picoseconds. + Weight::from_parts(1_984_702, 0) // Standard Error: 2 - .saturating_add(Weight::from_parts(5_816, 0).saturating_mul(r.into())) + .saturating_add(Weight::from_parts(5_817, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 5000]`. fn instr_i64gtu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_651_000 picoseconds. - Weight::from_parts(1_971_321, 0) - // Standard Error: 3 - .saturating_add(Weight::from_parts(6_114, 0).saturating_mul(r.into())) + // Minimum execution time: 1_660_000 picoseconds. + Weight::from_parts(1_978_370, 0) + // Standard Error: 2 + .saturating_add(Weight::from_parts(6_115, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 5000]`. fn instr_i64les(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_647_000 picoseconds. - Weight::from_parts(2_017_232, 0) + // Minimum execution time: 1_655_000 picoseconds. + Weight::from_parts(2_008_659, 0) // Standard Error: 2 - .saturating_add(Weight::from_parts(5_990, 0).saturating_mul(r.into())) + .saturating_add(Weight::from_parts(5_985, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 5000]`. fn instr_i64leu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_635_000 picoseconds. - Weight::from_parts(3_232_848, 0) - // Standard Error: 105 - .saturating_add(Weight::from_parts(5_816, 0).saturating_mul(r.into())) + // Minimum execution time: 1_608_000 picoseconds. + Weight::from_parts(1_912_542, 0) + // Standard Error: 2 + .saturating_add(Weight::from_parts(6_084, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 5000]`. fn instr_i64ges(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_623_000 picoseconds. - Weight::from_parts(1_996_165, 0) + // Minimum execution time: 1_644_000 picoseconds. + Weight::from_parts(1_959_896, 0) // Standard Error: 3 - .saturating_add(Weight::from_parts(5_964, 0).saturating_mul(r.into())) + .saturating_add(Weight::from_parts(5_968, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 5000]`. fn instr_i64geu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_668_000 picoseconds. - Weight::from_parts(1_973_238, 0) - // Standard Error: 20 - .saturating_add(Weight::from_parts(6_021, 0).saturating_mul(r.into())) + // Minimum execution time: 1_653_000 picoseconds. + Weight::from_parts(1_984_715, 0) + // Standard Error: 2 + .saturating_add(Weight::from_parts(5_971, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 5000]`. fn instr_i64add(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_674_000 picoseconds. - Weight::from_parts(1_981_762, 0) - // Standard Error: 3 - .saturating_add(Weight::from_parts(5_898, 0).saturating_mul(r.into())) + // Minimum execution time: 1_610_000 picoseconds. + Weight::from_parts(1_919_305, 0) + // Standard Error: 2 + .saturating_add(Weight::from_parts(5_877, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 5000]`. fn instr_i64sub(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_632_000 picoseconds. - Weight::from_parts(1_935_700, 0) - // Standard Error: 3 - .saturating_add(Weight::from_parts(6_154, 0).saturating_mul(r.into())) + // Minimum execution time: 1_691_000 picoseconds. + Weight::from_parts(2_284_292, 0) + // Standard Error: 16 + .saturating_add(Weight::from_parts(6_027, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 5000]`. fn instr_i64mul(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_607_000 picoseconds. - Weight::from_parts(1_942_734, 0) - // Standard Error: 2 - .saturating_add(Weight::from_parts(5_797, 0).saturating_mul(r.into())) + // Minimum execution time: 1_644_000 picoseconds. + Weight::from_parts(1_960_370, 0) + // Standard Error: 5 + .saturating_add(Weight::from_parts(5_760, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 5000]`. fn instr_i64divs(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_611_000 picoseconds. - Weight::from_parts(2_960_454, 0) - // Standard Error: 177 - .saturating_add(Weight::from_parts(11_666, 0).saturating_mul(r.into())) + // Minimum execution time: 1_656_000 picoseconds. + Weight::from_parts(1_915_002, 0) + // Standard Error: 21 + .saturating_add(Weight::from_parts(11_896, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 5000]`. fn instr_i64divu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_641_000 picoseconds. - Weight::from_parts(2_104_200, 0) - // Standard Error: 5 - .saturating_add(Weight::from_parts(10_540, 0).saturating_mul(r.into())) + // Minimum execution time: 1_645_000 picoseconds. + Weight::from_parts(2_952_497, 0) + // Standard Error: 122 + .saturating_add(Weight::from_parts(10_646, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 5000]`. fn instr_i64rems(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_643_000 picoseconds. - Weight::from_parts(2_602_908, 0) - // Standard Error: 24 - .saturating_add(Weight::from_parts(11_900, 0).saturating_mul(r.into())) + // Minimum execution time: 1_669_000 picoseconds. + Weight::from_parts(1_661_488, 0) + // Standard Error: 10 + .saturating_add(Weight::from_parts(12_330, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 5000]`. fn instr_i64remu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_584_000 picoseconds. - Weight::from_parts(2_056_817, 0) - // Standard Error: 3 - .saturating_add(Weight::from_parts(10_722, 0).saturating_mul(r.into())) + // Minimum execution time: 1_650_000 picoseconds. + Weight::from_parts(1_989_633, 0) + // Standard Error: 2 + .saturating_add(Weight::from_parts(10_649, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 5000]`. fn instr_i64and(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_652_000 picoseconds. - Weight::from_parts(1_988_892, 0) - // Standard Error: 4 - .saturating_add(Weight::from_parts(5_683, 0).saturating_mul(r.into())) + // Minimum execution time: 1_715_000 picoseconds. + Weight::from_parts(1_994_636, 0) + // Standard Error: 2 + .saturating_add(Weight::from_parts(5_667, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 5000]`. fn instr_i64or(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_660_000 picoseconds. - Weight::from_parts(2_148_537, 0) - // Standard Error: 38 - .saturating_add(Weight::from_parts(5_756, 0).saturating_mul(r.into())) + // Minimum execution time: 1_685_000 picoseconds. + Weight::from_parts(2_075_238, 0) + // Standard Error: 2 + .saturating_add(Weight::from_parts(5_743, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 5000]`. fn instr_i64xor(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_629_000 picoseconds. - Weight::from_parts(1_955_010, 0) + // Minimum execution time: 1_649_000 picoseconds. + Weight::from_parts(1_911_373, 0) // Standard Error: 3 - .saturating_add(Weight::from_parts(5_931, 0).saturating_mul(r.into())) + .saturating_add(Weight::from_parts(5_894, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 5000]`. fn instr_i64shl(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_569_000 picoseconds. - Weight::from_parts(1_982_403, 0) + // Minimum execution time: 1_682_000 picoseconds. + Weight::from_parts(2_000_076, 0) // Standard Error: 2 - .saturating_add(Weight::from_parts(5_867, 0).saturating_mul(r.into())) + .saturating_add(Weight::from_parts(5_932, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 5000]`. fn instr_i64shrs(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_615_000 picoseconds. - Weight::from_parts(1_989_920, 0) - // Standard Error: 3 - .saturating_add(Weight::from_parts(6_137, 0).saturating_mul(r.into())) + // Minimum execution time: 1_686_000 picoseconds. + Weight::from_parts(1_999_600, 0) + // Standard Error: 4 + .saturating_add(Weight::from_parts(6_129, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 5000]`. fn instr_i64shru(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_646_000 picoseconds. - Weight::from_parts(2_020_935, 0) - // Standard Error: 2 - .saturating_add(Weight::from_parts(5_863, 0).saturating_mul(r.into())) + // Minimum execution time: 1_628_000 picoseconds. + Weight::from_parts(1_893_440, 0) + // Standard Error: 15 + .saturating_add(Weight::from_parts(5_938, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 5000]`. fn instr_i64rotl(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_661_000 picoseconds. - Weight::from_parts(2_320_710, 0) - // Standard Error: 27 - .saturating_add(Weight::from_parts(5_922, 0).saturating_mul(r.into())) + // Minimum execution time: 1_721_000 picoseconds. + Weight::from_parts(1_982_227, 0) + // Standard Error: 3 + .saturating_add(Weight::from_parts(6_008, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 5000]`. fn instr_i64rotr(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_674_000 picoseconds. - Weight::from_parts(2_044_188, 0) - // Standard Error: 2 - .saturating_add(Weight::from_parts(5_855, 0).saturating_mul(r.into())) + // Minimum execution time: 1_648_000 picoseconds. + Weight::from_parts(2_003_359, 0) + // Standard Error: 3 + .saturating_add(Weight::from_parts(5_875, 0).saturating_mul(r.into())) } } @@ -2191,8 +2410,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `109` // Estimated: `1594` - // Minimum execution time: 2_627_000 picoseconds. - Weight::from_parts(2_748_000, 1594) + // Minimum execution time: 2_630_000 picoseconds. + Weight::from_parts(2_778_000, 1594) .saturating_add(RocksDbWeight::get().reads(1_u64)) } /// Storage: Skipped Metadata (r:0 w:0) @@ -2202,10 +2421,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `488 + k * (69 ±0)` // Estimated: `478 + k * (70 ±0)` - // Minimum execution time: 13_607_000 picoseconds. - Weight::from_parts(8_026_118, 478) - // Standard Error: 1_323 - .saturating_add(Weight::from_parts(980_583, 0).saturating_mul(k.into())) + // Minimum execution time: 13_453_000 picoseconds. + Weight::from_parts(10_904_078, 478) + // Standard Error: 931 + .saturating_add(Weight::from_parts(982_122, 0).saturating_mul(k.into())) .saturating_add(RocksDbWeight::get().reads(2_u64)) .saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(k.into()))) .saturating_add(RocksDbWeight::get().writes(2_u64)) @@ -2221,14 +2440,121 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `238 + c * (1 ±0)` // Estimated: `3708 + c * (1 ±0)` - // Minimum execution time: 30_563_000 picoseconds. - Weight::from_parts(22_292_544, 3708) - // Standard Error: 60 - .saturating_add(Weight::from_parts(54_541, 0).saturating_mul(c.into())) + // Minimum execution time: 30_972_000 picoseconds. + Weight::from_parts(31_129_287, 3708) + // Standard Error: 52 + .saturating_add(Weight::from_parts(54_996, 0).saturating_mul(c.into())) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(c.into())) } + /// Storage: Contracts CodeStorage (r:2 w:1) + /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) + /// The range of component `c` is `[0, 61717]`. + fn v9_migration_step(c: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `178 + c * (1 ±0)` + // Estimated: `6114 + c * (1 ±0)` + // Minimum execution time: 9_696_000 picoseconds. + Weight::from_parts(10_697_026, 6114) + // Standard Error: 0 + .saturating_add(Weight::from_parts(1_307, 0).saturating_mul(c.into())) + .saturating_add(RocksDbWeight::get().reads(2_u64)) + .saturating_add(RocksDbWeight::get().writes(1_u64)) + .saturating_add(Weight::from_parts(0, 1).saturating_mul(c.into())) + } + /// Storage: Contracts ContractInfoOf (r:2 w:1) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) + /// Storage: System Account (r:1 w:0) + /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) + fn v10_migration_step() -> Weight { + // Proof Size summary in bytes: + // Measured: `544` + // Estimated: `6484` + // Minimum execution time: 18_132_000 picoseconds. + Weight::from_parts(18_842_000, 6484) + .saturating_add(RocksDbWeight::get().reads(3_u64)) + .saturating_add(RocksDbWeight::get().writes(1_u64)) + } + /// Storage: Contracts DeletionQueue (r:1 w:1025) + /// Proof: Contracts DeletionQueue (max_values: None, max_size: Some(142), added: 2617, mode: Measured) + /// Storage: Contracts DeletionQueueCounter (r:0 w:1) + /// Proof: Contracts DeletionQueueCounter (max_values: Some(1), max_size: Some(8), added: 503, mode: Measured) + /// The range of component `k` is `[0, 1024]`. + fn v11_migration_step(k: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `138 + k * (1 ±0)` + // Estimated: `3602 + k * (1 ±0)` + // Minimum execution time: 3_952_000 picoseconds. + Weight::from_parts(4_129_000, 3602) + // Standard Error: 1_521 + .saturating_add(Weight::from_parts(1_013_657, 0).saturating_mul(k.into())) + .saturating_add(RocksDbWeight::get().reads(1_u64)) + .saturating_add(RocksDbWeight::get().writes(2_u64)) + .saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(k.into()))) + .saturating_add(Weight::from_parts(0, 1).saturating_mul(k.into())) + } + /// Storage: Contracts MigrationInProgress (r:1 w:1) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) + fn migration_noop() -> Weight { + // Proof Size summary in bytes: + // Measured: `109` + // Estimated: `1594` + // Minimum execution time: 3_528_000 picoseconds. + Weight::from_parts(3_641_000, 1594) + .saturating_add(RocksDbWeight::get().reads(1_u64)) + .saturating_add(RocksDbWeight::get().writes(1_u64)) + } + /// Storage: Contracts MigrationInProgress (r:1 w:1) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) + /// Storage: unknown `0x4342193e496fab7ec59d615ed0dc55304e7b9012096b41c4eb3aaf947f6ea429` (r:1 w:1) + /// Proof Skipped: unknown `0x4342193e496fab7ec59d615ed0dc55304e7b9012096b41c4eb3aaf947f6ea429` (r:1 w:1) + fn migrate() -> Weight { + // Proof Size summary in bytes: + // Measured: `133` + // Estimated: `3598` + // Minimum execution time: 13_433_000 picoseconds. + Weight::from_parts(13_710_000, 3598) + .saturating_add(RocksDbWeight::get().reads(2_u64)) + .saturating_add(RocksDbWeight::get().writes(2_u64)) + } + /// Storage: unknown `0x4342193e496fab7ec59d615ed0dc55304e7b9012096b41c4eb3aaf947f6ea429` (r:1 w:0) + /// Proof Skipped: unknown `0x4342193e496fab7ec59d615ed0dc55304e7b9012096b41c4eb3aaf947f6ea429` (r:1 w:0) + fn on_runtime_upgrade_noop() -> Weight { + // Proof Size summary in bytes: + // Measured: `109` + // Estimated: `3574` + // Minimum execution time: 5_502_000 picoseconds. + Weight::from_parts(5_689_000, 3574) + .saturating_add(RocksDbWeight::get().reads(1_u64)) + } + /// Storage: unknown `0x4342193e496fab7ec59d615ed0dc55304e7b9012096b41c4eb3aaf947f6ea429` (r:1 w:0) + /// Proof Skipped: unknown `0x4342193e496fab7ec59d615ed0dc55304e7b9012096b41c4eb3aaf947f6ea429` (r:1 w:0) + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) + fn on_runtime_upgrade_in_progress() -> Weight { + // Proof Size summary in bytes: + // Measured: `134` + // Estimated: `3599` + // Minimum execution time: 7_846_000 picoseconds. + Weight::from_parts(8_078_000, 3599) + .saturating_add(RocksDbWeight::get().reads(2_u64)) + } + /// Storage: unknown `0x4342193e496fab7ec59d615ed0dc55304e7b9012096b41c4eb3aaf947f6ea429` (r:1 w:0) + /// Proof Skipped: unknown `0x4342193e496fab7ec59d615ed0dc55304e7b9012096b41c4eb3aaf947f6ea429` (r:1 w:0) + /// Storage: Contracts MigrationInProgress (r:1 w:1) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) + fn on_runtime_upgrade() -> Weight { + // Proof Size summary in bytes: + // Measured: `109` + // Estimated: `3574` + // Minimum execution time: 8_390_000 picoseconds. + Weight::from_parts(8_602_000, 3574) + .saturating_add(RocksDbWeight::get().reads(2_u64)) + .saturating_add(RocksDbWeight::get().writes(1_u64)) + } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: Contracts ContractInfoOf (r:1 w:1) /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:1 w:0) @@ -2244,14 +2570,16 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `707` // Estimated: `6656 + c * (1 ±0)` - // Minimum execution time: 268_884_000 picoseconds. - Weight::from_parts(277_799_331, 6656) - // Standard Error: 23 - .saturating_add(Weight::from_parts(37_876, 0).saturating_mul(c.into())) - .saturating_add(RocksDbWeight::get().reads(6_u64)) + // Minimum execution time: 280_993_000 picoseconds. + Weight::from_parts(289_622_441, 6656) + // Standard Error: 26 + .saturating_add(Weight::from_parts(38_061, 0).saturating_mul(c.into())) + .saturating_add(RocksDbWeight::get().reads(7_u64)) .saturating_add(RocksDbWeight::get().writes(4_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(c.into())) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: Contracts OwnerInfoOf (r:1 w:1) /// Proof: Contracts OwnerInfoOf (max_values: None, max_size: Some(88), added: 2563, mode: Measured) /// Storage: Contracts Nonce (r:1 w:1) @@ -2275,17 +2603,19 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `270` // Estimated: `8659` - // Minimum execution time: 3_159_921_000 picoseconds. - Weight::from_parts(594_826_134, 8659) - // Standard Error: 290 - .saturating_add(Weight::from_parts(106_471, 0).saturating_mul(c.into())) - // Standard Error: 17 - .saturating_add(Weight::from_parts(1_160, 0).saturating_mul(i.into())) - // Standard Error: 17 - .saturating_add(Weight::from_parts(1_417, 0).saturating_mul(s.into())) - .saturating_add(RocksDbWeight::get().reads(9_u64)) + // Minimum execution time: 3_136_130_000 picoseconds. + Weight::from_parts(568_808_049, 8659) + // Standard Error: 288 + .saturating_add(Weight::from_parts(108_649, 0).saturating_mul(c.into())) + // Standard Error: 16 + .saturating_add(Weight::from_parts(1_103, 0).saturating_mul(i.into())) + // Standard Error: 16 + .saturating_add(Weight::from_parts(1_502, 0).saturating_mul(s.into())) + .saturating_add(RocksDbWeight::get().reads(10_u64)) .saturating_add(RocksDbWeight::get().writes(10_u64)) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: Contracts CodeStorage (r:1 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) /// Storage: Contracts Nonce (r:1 w:1) @@ -2306,15 +2636,17 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `482` // Estimated: `6408` - // Minimum execution time: 1_653_811_000 picoseconds. - Weight::from_parts(296_038_081, 6408) - // Standard Error: 9 - .saturating_add(Weight::from_parts(1_461, 0).saturating_mul(i.into())) - // Standard Error: 9 - .saturating_add(Weight::from_parts(1_430, 0).saturating_mul(s.into())) - .saturating_add(RocksDbWeight::get().reads(9_u64)) + // Minimum execution time: 1_655_107_000 picoseconds. + Weight::from_parts(266_843_437, 6408) + // Standard Error: 8 + .saturating_add(Weight::from_parts(1_463, 0).saturating_mul(i.into())) + // Standard Error: 8 + .saturating_add(Weight::from_parts(1_458, 0).saturating_mul(s.into())) + .saturating_add(RocksDbWeight::get().reads(10_u64)) .saturating_add(RocksDbWeight::get().writes(7_u64)) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: Contracts ContractInfoOf (r:1 w:1) /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:1 w:0) @@ -2329,11 +2661,13 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `759` // Estimated: `6699` - // Minimum execution time: 195_916_000 picoseconds. - Weight::from_parts(196_706_000, 6699) - .saturating_add(RocksDbWeight::get().reads(6_u64)) + // Minimum execution time: 197_684_000 picoseconds. + Weight::from_parts(199_222_000, 6699) + .saturating_add(RocksDbWeight::get().reads(7_u64)) .saturating_add(RocksDbWeight::get().writes(4_u64)) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: Contracts OwnerInfoOf (r:1 w:1) /// Proof: Contracts OwnerInfoOf (max_values: None, max_size: Some(88), added: 2563, mode: Measured) /// Storage: System EventTopics (r:1 w:1) @@ -2347,13 +2681,15 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `109` // Estimated: `3574` - // Minimum execution time: 251_137_000 picoseconds. - Weight::from_parts(252_985_435, 3574) - // Standard Error: 88 - .saturating_add(Weight::from_parts(108_141, 0).saturating_mul(c.into())) - .saturating_add(RocksDbWeight::get().reads(2_u64)) + // Minimum execution time: 254_766_000 picoseconds. + Weight::from_parts(247_865_224, 3574) + // Standard Error: 146 + .saturating_add(Weight::from_parts(108_830, 0).saturating_mul(c.into())) + .saturating_add(RocksDbWeight::get().reads(3_u64)) .saturating_add(RocksDbWeight::get().writes(4_u64)) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: Contracts OwnerInfoOf (r:1 w:1) /// Proof: Contracts OwnerInfoOf (max_values: None, max_size: Some(88), added: 2563, mode: Measured) /// Storage: System EventTopics (r:1 w:1) @@ -2366,11 +2702,13 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `255` // Estimated: `3720` - // Minimum execution time: 33_521_000 picoseconds. - Weight::from_parts(34_039_000, 3720) - .saturating_add(RocksDbWeight::get().reads(2_u64)) + // Minimum execution time: 36_038_000 picoseconds. + Weight::from_parts(36_503_000, 3720) + .saturating_add(RocksDbWeight::get().reads(3_u64)) .saturating_add(RocksDbWeight::get().writes(4_u64)) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: Contracts ContractInfoOf (r:1 w:1) /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts OwnerInfoOf (r:2 w:2) @@ -2381,11 +2719,13 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `570` // Estimated: `8985` - // Minimum execution time: 33_477_000 picoseconds. - Weight::from_parts(33_890_000, 8985) - .saturating_add(RocksDbWeight::get().reads(6_u64)) + // Minimum execution time: 35_312_000 picoseconds. + Weight::from_parts(35_852_000, 8985) + .saturating_add(RocksDbWeight::get().reads(7_u64)) .saturating_add(RocksDbWeight::get().writes(6_u64)) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: System Account (r:1 w:0) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:1 w:1) @@ -2401,14 +2741,16 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `781 + r * (6 ±0)` // Estimated: `6722 + r * (6 ±0)` - // Minimum execution time: 239_374_000 picoseconds. - Weight::from_parts(246_017_099, 6722) - // Standard Error: 539 - .saturating_add(Weight::from_parts(323_826, 0).saturating_mul(r.into())) - .saturating_add(RocksDbWeight::get().reads(6_u64)) + // Minimum execution time: 241_668_000 picoseconds. + Weight::from_parts(256_167_627, 6722) + // Standard Error: 2_447 + .saturating_add(Weight::from_parts(328_424, 0).saturating_mul(r.into())) + .saturating_add(RocksDbWeight::get().reads(7_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) .saturating_add(Weight::from_parts(0, 6).saturating_mul(r.into())) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: System Account (r:1 w:0) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:1601 w:1) @@ -2424,15 +2766,17 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `839 + r * (240 ±0)` // Estimated: `6743 + r * (2715 ±0)` - // Minimum execution time: 240_656_000 picoseconds. - Weight::from_parts(87_361_934, 6743) - // Standard Error: 5_912 - .saturating_add(Weight::from_parts(3_329_840, 0).saturating_mul(r.into())) - .saturating_add(RocksDbWeight::get().reads(6_u64)) + // Minimum execution time: 242_353_000 picoseconds. + Weight::from_parts(82_743_116, 6743) + // Standard Error: 6_271 + .saturating_add(Weight::from_parts(3_331_316, 0).saturating_mul(r.into())) + .saturating_add(RocksDbWeight::get().reads(7_u64)) .saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(r.into()))) .saturating_add(RocksDbWeight::get().writes(3_u64)) .saturating_add(Weight::from_parts(0, 2715).saturating_mul(r.into())) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: System Account (r:1 w:0) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:1601 w:1) @@ -2448,15 +2792,17 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `831 + r * (244 ±0)` // Estimated: `6747 + r * (2719 ±0)` - // Minimum execution time: 243_026_000 picoseconds. - Weight::from_parts(76_953_007, 6747) - // Standard Error: 6_640 - .saturating_add(Weight::from_parts(4_132_521, 0).saturating_mul(r.into())) - .saturating_add(RocksDbWeight::get().reads(6_u64)) + // Minimum execution time: 243_370_000 picoseconds. + Weight::from_parts(77_198_453, 6747) + // Standard Error: 6_968 + .saturating_add(Weight::from_parts(4_162_946, 0).saturating_mul(r.into())) + .saturating_add(RocksDbWeight::get().reads(7_u64)) .saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(r.into()))) .saturating_add(RocksDbWeight::get().writes(3_u64)) .saturating_add(Weight::from_parts(0, 2719).saturating_mul(r.into())) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: System Account (r:1 w:0) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:1 w:1) @@ -2472,14 +2818,16 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `788 + r * (6 ±0)` // Estimated: `6730 + r * (6 ±0)` - // Minimum execution time: 242_736_000 picoseconds. - Weight::from_parts(243_136_007, 6730) - // Standard Error: 912 - .saturating_add(Weight::from_parts(414_717, 0).saturating_mul(r.into())) - .saturating_add(RocksDbWeight::get().reads(6_u64)) + // Minimum execution time: 244_083_000 picoseconds. + Weight::from_parts(239_899_316, 6730) + // Standard Error: 5_254 + .saturating_add(Weight::from_parts(423_863, 0).saturating_mul(r.into())) + .saturating_add(RocksDbWeight::get().reads(7_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) .saturating_add(Weight::from_parts(0, 6).saturating_mul(r.into())) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: System Account (r:1 w:0) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:1 w:1) @@ -2495,14 +2843,16 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `778 + r * (3 ±0)` // Estimated: `6723 + r * (3 ±0)` - // Minimum execution time: 240_130_000 picoseconds. - Weight::from_parts(244_517_187, 6723) - // Standard Error: 384 - .saturating_add(Weight::from_parts(167_431, 0).saturating_mul(r.into())) - .saturating_add(RocksDbWeight::get().reads(6_u64)) + // Minimum execution time: 239_835_000 picoseconds. + Weight::from_parts(247_929_454, 6723) + // Standard Error: 2_309 + .saturating_add(Weight::from_parts(169_642, 0).saturating_mul(r.into())) + .saturating_add(RocksDbWeight::get().reads(7_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) .saturating_add(Weight::from_parts(0, 3).saturating_mul(r.into())) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: Contracts ContractInfoOf (r:1 w:1) /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:1 w:0) @@ -2516,14 +2866,16 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `668 + r * (3 ±0)` // Estimated: `6608 + r * (3 ±0)` - // Minimum execution time: 228_022_000 picoseconds. - Weight::from_parts(232_385_198, 6608) - // Standard Error: 300 - .saturating_add(Weight::from_parts(145_143, 0).saturating_mul(r.into())) - .saturating_add(RocksDbWeight::get().reads(5_u64)) + // Minimum execution time: 229_091_000 picoseconds. + Weight::from_parts(235_369_797, 6608) + // Standard Error: 283 + .saturating_add(Weight::from_parts(146_485, 0).saturating_mul(r.into())) + .saturating_add(RocksDbWeight::get().reads(6_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) .saturating_add(Weight::from_parts(0, 3).saturating_mul(r.into())) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: System Account (r:1 w:0) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:1 w:1) @@ -2539,14 +2891,16 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `782 + r * (6 ±0)` // Estimated: `6724 + r * (6 ±0)` - // Minimum execution time: 240_250_000 picoseconds. - Weight::from_parts(240_268_824, 6724) - // Standard Error: 945 - .saturating_add(Weight::from_parts(329_577, 0).saturating_mul(r.into())) - .saturating_add(RocksDbWeight::get().reads(6_u64)) + // Minimum execution time: 242_638_000 picoseconds. + Weight::from_parts(245_890_126, 6724) + // Standard Error: 508 + .saturating_add(Weight::from_parts(323_232, 0).saturating_mul(r.into())) + .saturating_add(RocksDbWeight::get().reads(7_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) .saturating_add(Weight::from_parts(0, 6).saturating_mul(r.into())) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: System Account (r:1 w:0) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:1 w:1) @@ -2562,14 +2916,16 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `778 + r * (6 ±0)` // Estimated: `6719 + r * (6 ±0)` - // Minimum execution time: 242_370_000 picoseconds. - Weight::from_parts(242_389_500, 6719) - // Standard Error: 712 - .saturating_add(Weight::from_parts(518_380, 0).saturating_mul(r.into())) - .saturating_add(RocksDbWeight::get().reads(6_u64)) + // Minimum execution time: 241_740_000 picoseconds. + Weight::from_parts(244_490_855, 6719) + // Standard Error: 1_872 + .saturating_add(Weight::from_parts(543_651, 0).saturating_mul(r.into())) + .saturating_add(RocksDbWeight::get().reads(7_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) .saturating_add(Weight::from_parts(0, 6).saturating_mul(r.into())) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: System Account (r:2 w:0) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:1 w:1) @@ -2585,14 +2941,16 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `922 + r * (6 ±0)` // Estimated: `6846 + r * (6 ±0)` - // Minimum execution time: 238_563_000 picoseconds. - Weight::from_parts(253_511_314, 6846) - // Standard Error: 1_571 - .saturating_add(Weight::from_parts(1_454_089, 0).saturating_mul(r.into())) - .saturating_add(RocksDbWeight::get().reads(7_u64)) + // Minimum execution time: 241_787_000 picoseconds. + Weight::from_parts(243_819_464, 6846) + // Standard Error: 5_017 + .saturating_add(Weight::from_parts(1_496_444, 0).saturating_mul(r.into())) + .saturating_add(RocksDbWeight::get().reads(8_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) .saturating_add(Weight::from_parts(0, 6).saturating_mul(r.into())) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: System Account (r:1 w:0) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:1 w:1) @@ -2608,14 +2966,16 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `792 + r * (6 ±0)` // Estimated: `6741 + r * (6 ±0)` - // Minimum execution time: 242_995_000 picoseconds. - Weight::from_parts(240_061_456, 6741) - // Standard Error: 2_650 - .saturating_add(Weight::from_parts(326_813, 0).saturating_mul(r.into())) - .saturating_add(RocksDbWeight::get().reads(6_u64)) + // Minimum execution time: 243_498_000 picoseconds. + Weight::from_parts(251_019_668, 6741) + // Standard Error: 1_479 + .saturating_add(Weight::from_parts(318_979, 0).saturating_mul(r.into())) + .saturating_add(RocksDbWeight::get().reads(7_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) .saturating_add(Weight::from_parts(0, 6).saturating_mul(r.into())) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: System Account (r:1 w:0) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:1 w:1) @@ -2631,14 +2991,16 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `790 + r * (6 ±0)` // Estimated: `6739 + r * (6 ±0)` - // Minimum execution time: 241_342_000 picoseconds. - Weight::from_parts(240_875_314, 6739) - // Standard Error: 669 - .saturating_add(Weight::from_parts(324_519, 0).saturating_mul(r.into())) - .saturating_add(RocksDbWeight::get().reads(6_u64)) + // Minimum execution time: 242_572_000 picoseconds. + Weight::from_parts(246_453_396, 6739) + // Standard Error: 978 + .saturating_add(Weight::from_parts(320_095, 0).saturating_mul(r.into())) + .saturating_add(RocksDbWeight::get().reads(7_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) .saturating_add(Weight::from_parts(0, 6).saturating_mul(r.into())) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: System Account (r:1 w:0) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:1 w:1) @@ -2654,14 +3016,16 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `787 + r * (6 ±0)` // Estimated: `6737 + r * (6 ±0)` - // Minimum execution time: 238_954_000 picoseconds. - Weight::from_parts(242_269_896, 6737) - // Standard Error: 1_453 - .saturating_add(Weight::from_parts(317_998, 0).saturating_mul(r.into())) - .saturating_add(RocksDbWeight::get().reads(6_u64)) + // Minimum execution time: 241_872_000 picoseconds. + Weight::from_parts(257_272_904, 6737) + // Standard Error: 4_146 + .saturating_add(Weight::from_parts(314_645, 0).saturating_mul(r.into())) + .saturating_add(RocksDbWeight::get().reads(7_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) .saturating_add(Weight::from_parts(0, 6).saturating_mul(r.into())) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: System Account (r:1 w:0) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:1 w:1) @@ -2677,14 +3041,16 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `778 + r * (6 ±0)` // Estimated: `6723 + r * (6 ±0)` - // Minimum execution time: 240_935_000 picoseconds. - Weight::from_parts(242_938_271, 6723) - // Standard Error: 792 - .saturating_add(Weight::from_parts(316_782, 0).saturating_mul(r.into())) - .saturating_add(RocksDbWeight::get().reads(6_u64)) + // Minimum execution time: 242_139_000 picoseconds. + Weight::from_parts(244_667_764, 6723) + // Standard Error: 580 + .saturating_add(Weight::from_parts(323_005, 0).saturating_mul(r.into())) + .saturating_add(RocksDbWeight::get().reads(7_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) .saturating_add(Weight::from_parts(0, 6).saturating_mul(r.into())) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: System Account (r:1 w:0) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:1 w:1) @@ -2702,14 +3068,16 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `852 + r * (14 ±0)` // Estimated: `6785 + r * (14 ±0)` - // Minimum execution time: 240_142_000 picoseconds. - Weight::from_parts(241_386_730, 6785) - // Standard Error: 2_116 - .saturating_add(Weight::from_parts(1_387_202, 0).saturating_mul(r.into())) - .saturating_add(RocksDbWeight::get().reads(7_u64)) + // Minimum execution time: 242_370_000 picoseconds. + Weight::from_parts(247_330_421, 6785) + // Standard Error: 1_832 + .saturating_add(Weight::from_parts(1_396_737, 0).saturating_mul(r.into())) + .saturating_add(RocksDbWeight::get().reads(8_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) .saturating_add(Weight::from_parts(0, 14).saturating_mul(r.into())) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: System Account (r:1 w:0) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:1 w:1) @@ -2725,14 +3093,16 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `745 + r * (4 ±0)` // Estimated: `6687 + r * (4 ±0)` - // Minimum execution time: 165_617_000 picoseconds. - Weight::from_parts(170_794_127, 6687) - // Standard Error: 209 - .saturating_add(Weight::from_parts(127_931, 0).saturating_mul(r.into())) - .saturating_add(RocksDbWeight::get().reads(6_u64)) + // Minimum execution time: 167_583_000 picoseconds. + Weight::from_parts(173_694_884, 6687) + // Standard Error: 2_880 + .saturating_add(Weight::from_parts(133_811, 0).saturating_mul(r.into())) + .saturating_add(RocksDbWeight::get().reads(7_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) .saturating_add(Weight::from_parts(0, 4).saturating_mul(r.into())) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: System Account (r:1 w:0) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:1 w:1) @@ -2748,14 +3118,16 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `780 + r * (6 ±0)` // Estimated: `6724 + r * (6 ±0)` - // Minimum execution time: 238_832_000 picoseconds. - Weight::from_parts(237_110_694, 6724) - // Standard Error: 539 - .saturating_add(Weight::from_parts(280_610, 0).saturating_mul(r.into())) - .saturating_add(RocksDbWeight::get().reads(6_u64)) + // Minimum execution time: 242_932_000 picoseconds. + Weight::from_parts(246_356_239, 6724) + // Standard Error: 479 + .saturating_add(Weight::from_parts(268_456, 0).saturating_mul(r.into())) + .saturating_add(RocksDbWeight::get().reads(7_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) .saturating_add(Weight::from_parts(0, 6).saturating_mul(r.into())) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: System Account (r:1 w:0) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:1 w:1) @@ -2771,13 +3143,15 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `784` // Estimated: `6724` - // Minimum execution time: 241_070_000 picoseconds. - Weight::from_parts(242_162_279, 6724) + // Minimum execution time: 245_611_000 picoseconds. + Weight::from_parts(246_102_856, 6724) // Standard Error: 1 - .saturating_add(Weight::from_parts(595, 0).saturating_mul(n.into())) - .saturating_add(RocksDbWeight::get().reads(6_u64)) + .saturating_add(Weight::from_parts(596, 0).saturating_mul(n.into())) + .saturating_add(RocksDbWeight::get().reads(7_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: System Account (r:1 w:0) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:1 w:1) @@ -2793,14 +3167,16 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `768 + r * (45 ±0)` // Estimated: `6708 + r * (45 ±0)` - // Minimum execution time: 236_337_000 picoseconds. - Weight::from_parts(238_883_828, 6708) - // Standard Error: 188_978 - .saturating_add(Weight::from_parts(926_671, 0).saturating_mul(r.into())) - .saturating_add(RocksDbWeight::get().reads(6_u64)) + // Minimum execution time: 238_764_000 picoseconds. + Weight::from_parts(241_225_075, 6708) + // Standard Error: 196_899 + .saturating_add(Weight::from_parts(3_361_624, 0).saturating_mul(r.into())) + .saturating_add(RocksDbWeight::get().reads(7_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) .saturating_add(Weight::from_parts(0, 45).saturating_mul(r.into())) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: System Account (r:1 w:0) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:1 w:1) @@ -2816,13 +3192,15 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `778` // Estimated: `6731` - // Minimum execution time: 239_103_000 picoseconds. - Weight::from_parts(240_382_910, 6731) + // Minimum execution time: 243_075_000 picoseconds. + Weight::from_parts(244_139_227, 6731) // Standard Error: 0 - .saturating_add(Weight::from_parts(181, 0).saturating_mul(n.into())) - .saturating_add(RocksDbWeight::get().reads(6_u64)) + .saturating_add(Weight::from_parts(178, 0).saturating_mul(n.into())) + .saturating_add(RocksDbWeight::get().reads(7_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: System Account (r:4 w:4) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:1 w:1) @@ -2844,16 +3222,18 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `810 + r * (356 ±0)` // Estimated: `6750 + r * (7781 ±0)` - // Minimum execution time: 238_739_000 picoseconds. - Weight::from_parts(241_041_330, 6750) - // Standard Error: 176_820 - .saturating_add(Weight::from_parts(115_332_869, 0).saturating_mul(r.into())) - .saturating_add(RocksDbWeight::get().reads(6_u64)) + // Minimum execution time: 241_330_000 picoseconds. + Weight::from_parts(244_187_673, 6750) + // Standard Error: 473_741 + .saturating_add(Weight::from_parts(117_358_926, 0).saturating_mul(r.into())) + .saturating_add(RocksDbWeight::get().reads(7_u64)) .saturating_add(RocksDbWeight::get().reads((6_u64).saturating_mul(r.into()))) .saturating_add(RocksDbWeight::get().writes(3_u64)) .saturating_add(RocksDbWeight::get().writes((8_u64).saturating_mul(r.into()))) .saturating_add(Weight::from_parts(0, 7781).saturating_mul(r.into())) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: System Account (r:1 w:0) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:1 w:1) @@ -2871,14 +3251,16 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `825 + r * (10 ±0)` // Estimated: `6769 + r * (10 ±0)` - // Minimum execution time: 240_888_000 picoseconds. - Weight::from_parts(259_901_113, 6769) - // Standard Error: 5_935 - .saturating_add(Weight::from_parts(1_764_269, 0).saturating_mul(r.into())) - .saturating_add(RocksDbWeight::get().reads(7_u64)) + // Minimum execution time: 243_298_000 picoseconds. + Weight::from_parts(246_393_253, 6769) + // Standard Error: 4_125 + .saturating_add(Weight::from_parts(1_876_317, 0).saturating_mul(r.into())) + .saturating_add(RocksDbWeight::get().reads(8_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) .saturating_add(Weight::from_parts(0, 10).saturating_mul(r.into())) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: System Account (r:1 w:0) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:1 w:1) @@ -2894,14 +3276,16 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `778 + r * (10 ±0)` // Estimated: `6723 + r * (10 ±0)` - // Minimum execution time: 237_478_000 picoseconds. - Weight::from_parts(264_915_436, 6723) - // Standard Error: 4_644 - .saturating_add(Weight::from_parts(3_452_918, 0).saturating_mul(r.into())) - .saturating_add(RocksDbWeight::get().reads(6_u64)) + // Minimum execution time: 240_477_000 picoseconds. + Weight::from_parts(252_579_330, 6723) + // Standard Error: 1_993 + .saturating_add(Weight::from_parts(3_510_388, 0).saturating_mul(r.into())) + .saturating_add(RocksDbWeight::get().reads(7_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) .saturating_add(Weight::from_parts(0, 10).saturating_mul(r.into())) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: System Account (r:1 w:0) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:1 w:1) @@ -2918,18 +3302,20 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `797 + t * (32 ±0)` // Estimated: `6744 + t * (2508 ±0)` - // Minimum execution time: 255_720_000 picoseconds. - Weight::from_parts(247_945_758, 6744) - // Standard Error: 73_390 - .saturating_add(Weight::from_parts(2_483_239, 0).saturating_mul(t.into())) - // Standard Error: 20 - .saturating_add(Weight::from_parts(756, 0).saturating_mul(n.into())) - .saturating_add(RocksDbWeight::get().reads(6_u64)) + // Minimum execution time: 259_029_000 picoseconds. + Weight::from_parts(252_262_484, 6744) + // Standard Error: 35_710 + .saturating_add(Weight::from_parts(2_236_764, 0).saturating_mul(t.into())) + // Standard Error: 9 + .saturating_add(Weight::from_parts(648, 0).saturating_mul(n.into())) + .saturating_add(RocksDbWeight::get().reads(7_u64)) .saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(t.into()))) .saturating_add(RocksDbWeight::get().writes(3_u64)) .saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(t.into()))) .saturating_add(Weight::from_parts(0, 2508).saturating_mul(t.into())) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: System Account (r:1 w:0) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:1 w:1) @@ -2945,14 +3331,16 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `777 + r * (7 ±0)` // Estimated: `6721 + r * (7 ±0)` - // Minimum execution time: 172_214_000 picoseconds. - Weight::from_parts(177_306_567, 6721) - // Standard Error: 839 - .saturating_add(Weight::from_parts(230_558, 0).saturating_mul(r.into())) - .saturating_add(RocksDbWeight::get().reads(6_u64)) + // Minimum execution time: 170_544_000 picoseconds. + Weight::from_parts(174_555_287, 6721) + // Standard Error: 320 + .saturating_add(Weight::from_parts(233_911, 0).saturating_mul(r.into())) + .saturating_add(RocksDbWeight::get().reads(7_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) .saturating_add(Weight::from_parts(0, 7).saturating_mul(r.into())) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: MaxEncodedLen) /// Storage: System Account (r:1 w:0) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen) /// Storage: Contracts ContractInfoOf (r:1 w:1) @@ -2968,11 +3356,11 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `125728` // Estimated: `131670` - // Minimum execution time: 354_105_000 picoseconds. - Weight::from_parts(360_649_854, 131670) - // Standard Error: 2 - .saturating_add(Weight::from_parts(737, 0).saturating_mul(i.into())) - .saturating_add(RocksDbWeight::get().reads(6_u64)) + // Minimum execution time: 357_160_000 picoseconds. + Weight::from_parts(359_930_328, 131670) + // Standard Error: 1 + .saturating_add(Weight::from_parts(738, 0).saturating_mul(i.into())) + .saturating_add(RocksDbWeight::get().reads(7_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) } /// Storage: Skipped Metadata (r:0 w:0) @@ -2982,11 +3370,11 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `845 + r * (292 ±0)` // Estimated: `843 + r * (293 ±0)` - // Minimum execution time: 239_637_000 picoseconds. - Weight::from_parts(136_431_436, 843) - // Standard Error: 10_238 - .saturating_add(Weight::from_parts(6_070_221, 0).saturating_mul(r.into())) - .saturating_add(RocksDbWeight::get().reads(6_u64)) + // Minimum execution time: 242_846_000 picoseconds. + Weight::from_parts(135_611_732, 843) + // Standard Error: 10_708 + .saturating_add(Weight::from_parts(6_146_995, 0).saturating_mul(r.into())) + .saturating_add(RocksDbWeight::get().reads(7_u64)) .saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(r.into()))) .saturating_add(RocksDbWeight::get().writes(3_u64)) .saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(r.into()))) @@ -2999,11 +3387,11 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `1304` // Estimated: `1280` - // Minimum execution time: 256_198_000 picoseconds. - Weight::from_parts(289_972_802, 1280) - // Standard Error: 54 - .saturating_add(Weight::from_parts(438, 0).saturating_mul(n.into())) - .saturating_add(RocksDbWeight::get().reads(8_u64)) + // Minimum execution time: 258_885_000 picoseconds. + Weight::from_parts(292_699_689, 1280) + // Standard Error: 47 + .saturating_add(Weight::from_parts(433, 0).saturating_mul(n.into())) + .saturating_add(RocksDbWeight::get().reads(9_u64)) .saturating_add(RocksDbWeight::get().writes(6_u64)) } /// Storage: Skipped Metadata (r:0 w:0) @@ -3013,11 +3401,9 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `1167 + n * (1 ±0)` // Estimated: `1167 + n * (1 ±0)` - // Minimum execution time: 255_519_000 picoseconds. - Weight::from_parts(257_668_217, 1167) - // Standard Error: 19 - .saturating_add(Weight::from_parts(105, 0).saturating_mul(n.into())) - .saturating_add(RocksDbWeight::get().reads(7_u64)) + // Minimum execution time: 258_297_000 picoseconds. + Weight::from_parts(262_380_805, 1167) + .saturating_add(RocksDbWeight::get().reads(8_u64)) .saturating_add(RocksDbWeight::get().writes(4_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) } @@ -3028,11 +3414,11 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `841 + r * (288 ±0)` // Estimated: `845 + r * (289 ±0)` - // Minimum execution time: 239_461_000 picoseconds. - Weight::from_parts(131_630_528, 845) - // Standard Error: 10_483 - .saturating_add(Weight::from_parts(5_910_066, 0).saturating_mul(r.into())) - .saturating_add(RocksDbWeight::get().reads(6_u64)) + // Minimum execution time: 242_945_000 picoseconds. + Weight::from_parts(126_721_339, 845) + // Standard Error: 11_891 + .saturating_add(Weight::from_parts(6_134_319, 0).saturating_mul(r.into())) + .saturating_add(RocksDbWeight::get().reads(7_u64)) .saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(r.into()))) .saturating_add(RocksDbWeight::get().writes(3_u64)) .saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(r.into()))) @@ -3045,11 +3431,11 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `1163 + n * (1 ±0)` // Estimated: `1163 + n * (1 ±0)` - // Minimum execution time: 254_904_000 picoseconds. - Weight::from_parts(261_213_399, 1163) - // Standard Error: 178 - .saturating_add(Weight::from_parts(125, 0).saturating_mul(n.into())) - .saturating_add(RocksDbWeight::get().reads(7_u64)) + // Minimum execution time: 259_872_000 picoseconds. + Weight::from_parts(259_910_037, 1163) + // Standard Error: 142 + .saturating_add(Weight::from_parts(629, 0).saturating_mul(n.into())) + .saturating_add(RocksDbWeight::get().reads(8_u64)) .saturating_add(RocksDbWeight::get().writes(4_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) } @@ -3060,11 +3446,11 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `835 + r * (296 ±0)` // Estimated: `840 + r * (297 ±0)` - // Minimum execution time: 239_995_000 picoseconds. - Weight::from_parts(151_326_508, 840) - // Standard Error: 8_960 - .saturating_add(Weight::from_parts(4_937_728, 0).saturating_mul(r.into())) - .saturating_add(RocksDbWeight::get().reads(6_u64)) + // Minimum execution time: 245_005_000 picoseconds. + Weight::from_parts(155_891_939, 840) + // Standard Error: 9_938 + .saturating_add(Weight::from_parts(4_992_231, 0).saturating_mul(r.into())) + .saturating_add(RocksDbWeight::get().reads(7_u64)) .saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(r.into()))) .saturating_add(RocksDbWeight::get().writes(3_u64)) .saturating_add(Weight::from_parts(0, 297).saturating_mul(r.into())) @@ -3076,11 +3462,11 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `1179 + n * (1 ±0)` // Estimated: `1179 + n * (1 ±0)` - // Minimum execution time: 254_515_000 picoseconds. - Weight::from_parts(256_728_817, 1179) - // Standard Error: 22 - .saturating_add(Weight::from_parts(706, 0).saturating_mul(n.into())) - .saturating_add(RocksDbWeight::get().reads(7_u64)) + // Minimum execution time: 257_926_000 picoseconds. + Weight::from_parts(261_438_340, 1179) + // Standard Error: 24 + .saturating_add(Weight::from_parts(659, 0).saturating_mul(n.into())) + .saturating_add(RocksDbWeight::get().reads(8_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) } @@ -3091,11 +3477,11 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `856 + r * (288 ±0)` // Estimated: `857 + r * (289 ±0)` - // Minimum execution time: 240_601_000 picoseconds. - Weight::from_parts(154_476_561, 857) - // Standard Error: 8_872 - .saturating_add(Weight::from_parts(4_805_043, 0).saturating_mul(r.into())) - .saturating_add(RocksDbWeight::get().reads(6_u64)) + // Minimum execution time: 244_392_000 picoseconds. + Weight::from_parts(156_243_434, 857) + // Standard Error: 8_716 + .saturating_add(Weight::from_parts(4_813_682, 0).saturating_mul(r.into())) + .saturating_add(RocksDbWeight::get().reads(7_u64)) .saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(r.into()))) .saturating_add(RocksDbWeight::get().writes(3_u64)) .saturating_add(Weight::from_parts(0, 289).saturating_mul(r.into())) @@ -3107,9 +3493,11 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `1166 + n * (1 ±0)` // Estimated: `1166 + n * (1 ±0)` - // Minimum execution time: 253_654_000 picoseconds. - Weight::from_parts(257_288_586, 1166) - .saturating_add(RocksDbWeight::get().reads(7_u64)) + // Minimum execution time: 255_731_000 picoseconds. + Weight::from_parts(258_937_245, 1166) + // Standard Error: 26 + .saturating_add(Weight::from_parts(61, 0).saturating_mul(n.into())) + .saturating_add(RocksDbWeight::get().reads(8_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) } @@ -3120,11 +3508,11 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `829 + r * (296 ±0)` // Estimated: `836 + r * (297 ±0)` - // Minimum execution time: 239_869_000 picoseconds. - Weight::from_parts(135_258_204, 836) - // Standard Error: 10_378 - .saturating_add(Weight::from_parts(6_144_770, 0).saturating_mul(r.into())) - .saturating_add(RocksDbWeight::get().reads(6_u64)) + // Minimum execution time: 242_902_000 picoseconds. + Weight::from_parts(140_670_703, 836) + // Standard Error: 10_042 + .saturating_add(Weight::from_parts(6_206_728, 0).saturating_mul(r.into())) + .saturating_add(RocksDbWeight::get().reads(7_u64)) .saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(r.into()))) .saturating_add(RocksDbWeight::get().writes(3_u64)) .saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(r.into()))) @@ -3137,14 +3525,16 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `1180 + n * (1 ±0)` // Estimated: `1180 + n * (1 ±0)` - // Minimum execution time: 258_153_000 picoseconds. - Weight::from_parts(260_068_186, 1180) - // Standard Error: 25 - .saturating_add(Weight::from_parts(744, 0).saturating_mul(n.into())) - .saturating_add(RocksDbWeight::get().reads(7_u64)) + // Minimum execution time: 258_425_000 picoseconds. + Weight::from_parts(266_011_498, 1180) + // Standard Error: 137 + .saturating_add(Weight::from_parts(383, 0).saturating_mul(n.into())) + .saturating_add(RocksDbWeight::get().reads(8_u64)) .saturating_add(RocksDbWeight::get().writes(4_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: System Account (r:1602 w:1601) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:1 w:1) @@ -3160,16 +3550,18 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `1373 + r * (45 ±0)` // Estimated: `7270 + r * (2520 ±0)` - // Minimum execution time: 243_189_000 picoseconds. - Weight::from_parts(243_465_000, 7270) - // Standard Error: 30_961 - .saturating_add(Weight::from_parts(35_376_623, 0).saturating_mul(r.into())) - .saturating_add(RocksDbWeight::get().reads(7_u64)) + // Minimum execution time: 243_533_000 picoseconds. + Weight::from_parts(67_275_548, 7270) + // Standard Error: 29_687 + .saturating_add(Weight::from_parts(36_086_917, 0).saturating_mul(r.into())) + .saturating_add(RocksDbWeight::get().reads(8_u64)) .saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(r.into()))) .saturating_add(RocksDbWeight::get().writes(4_u64)) .saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(r.into()))) .saturating_add(Weight::from_parts(0, 2520).saturating_mul(r.into())) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: System Account (r:1 w:0) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:801 w:801) @@ -3185,16 +3577,18 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `1140 + r * (276 ±0)` // Estimated: `9332 + r * (2752 ±0)` - // Minimum execution time: 243_656_000 picoseconds. - Weight::from_parts(244_221_000, 9332) - // Standard Error: 69_762 - .saturating_add(Weight::from_parts(216_905_619, 0).saturating_mul(r.into())) - .saturating_add(RocksDbWeight::get().reads(8_u64)) + // Minimum execution time: 246_206_000 picoseconds. + Weight::from_parts(246_946_000, 9332) + // Standard Error: 74_648 + .saturating_add(Weight::from_parts(217_429_651, 0).saturating_mul(r.into())) + .saturating_add(RocksDbWeight::get().reads(9_u64)) .saturating_add(RocksDbWeight::get().reads((2_u64).saturating_mul(r.into()))) .saturating_add(RocksDbWeight::get().writes(4_u64)) .saturating_add(RocksDbWeight::get().writes((2_u64).saturating_mul(r.into()))) .saturating_add(Weight::from_parts(0, 2752).saturating_mul(r.into())) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: System Account (r:1 w:0) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:1 w:1) @@ -3210,16 +3604,18 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `0 + r * (502 ±0)` // Estimated: `6727 + r * (2572 ±10)` - // Minimum execution time: 242_632_000 picoseconds. - Weight::from_parts(243_068_000, 6727) - // Standard Error: 126_218 - .saturating_add(Weight::from_parts(213_096_291, 0).saturating_mul(r.into())) - .saturating_add(RocksDbWeight::get().reads(6_u64)) + // Minimum execution time: 245_170_000 picoseconds. + Weight::from_parts(245_460_000, 6727) + // Standard Error: 110_429 + .saturating_add(Weight::from_parts(212_316_013, 0).saturating_mul(r.into())) + .saturating_add(RocksDbWeight::get().reads(7_u64)) .saturating_add(RocksDbWeight::get().reads((2_u64).saturating_mul(r.into()))) .saturating_add(RocksDbWeight::get().writes(3_u64)) .saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(r.into()))) .saturating_add(Weight::from_parts(0, 2572).saturating_mul(r.into())) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: System Account (r:3 w:2) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:2 w:2) @@ -3236,18 +3632,20 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `1154 + t * (204 ±0)` // Estimated: `12044 + t * (5154 ±0)` - // Minimum execution time: 421_691_000 picoseconds. - Weight::from_parts(394_587_369, 12044) - // Standard Error: 1_104_014 - .saturating_add(Weight::from_parts(30_461_758, 0).saturating_mul(t.into())) + // Minimum execution time: 424_523_000 picoseconds. + Weight::from_parts(392_267_161, 12044) + // Standard Error: 956_686 + .saturating_add(Weight::from_parts(36_399_297, 0).saturating_mul(t.into())) // Standard Error: 1 - .saturating_add(Weight::from_parts(601, 0).saturating_mul(c.into())) - .saturating_add(RocksDbWeight::get().reads(10_u64)) + .saturating_add(Weight::from_parts(600, 0).saturating_mul(c.into())) + .saturating_add(RocksDbWeight::get().reads(11_u64)) .saturating_add(RocksDbWeight::get().reads((2_u64).saturating_mul(t.into()))) .saturating_add(RocksDbWeight::get().writes(6_u64)) .saturating_add(RocksDbWeight::get().writes((2_u64).saturating_mul(t.into()))) .saturating_add(Weight::from_parts(0, 5154).saturating_mul(t.into())) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: System Account (r:1602 w:1602) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:801 w:801) @@ -3267,16 +3665,18 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `1322 + r * (254 ±0)` // Estimated: `7146 + r * (5205 ±0)` - // Minimum execution time: 581_252_000 picoseconds. - Weight::from_parts(582_275_000, 7146) - // Standard Error: 279_771 - .saturating_add(Weight::from_parts(349_770_967, 0).saturating_mul(r.into())) - .saturating_add(RocksDbWeight::get().reads(8_u64)) + // Minimum execution time: 582_323_000 picoseconds. + Weight::from_parts(584_276_000, 7146) + // Standard Error: 280_418 + .saturating_add(Weight::from_parts(349_510_405, 0).saturating_mul(r.into())) + .saturating_add(RocksDbWeight::get().reads(9_u64)) .saturating_add(RocksDbWeight::get().reads((6_u64).saturating_mul(r.into()))) .saturating_add(RocksDbWeight::get().writes(6_u64)) .saturating_add(RocksDbWeight::get().writes((5_u64).saturating_mul(r.into()))) .saturating_add(Weight::from_parts(0, 5205).saturating_mul(r.into())) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: System Account (r:4 w:4) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:2 w:2) @@ -3298,20 +3698,22 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `1071 + t * (187 ±0)` // Estimated: `9492 + t * (2634 ±2)` - // Minimum execution time: 1_623_241_000 picoseconds. - Weight::from_parts(317_076_173, 9492) - // Standard Error: 4_549_416 - .saturating_add(Weight::from_parts(125_360_446, 0).saturating_mul(t.into())) + // Minimum execution time: 1_627_228_000 picoseconds. + Weight::from_parts(358_838_236, 9492) + // Standard Error: 4_785_521 + .saturating_add(Weight::from_parts(114_920_186, 0).saturating_mul(t.into())) // Standard Error: 7 - .saturating_add(Weight::from_parts(1_183, 0).saturating_mul(i.into())) + .saturating_add(Weight::from_parts(1_163, 0).saturating_mul(i.into())) // Standard Error: 7 - .saturating_add(Weight::from_parts(1_352, 0).saturating_mul(s.into())) - .saturating_add(RocksDbWeight::get().reads(13_u64)) + .saturating_add(Weight::from_parts(1_336, 0).saturating_mul(s.into())) + .saturating_add(RocksDbWeight::get().reads(14_u64)) .saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(t.into()))) .saturating_add(RocksDbWeight::get().writes(10_u64)) .saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(t.into()))) .saturating_add(Weight::from_parts(0, 2634).saturating_mul(t.into())) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: System Account (r:1 w:0) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:1 w:1) @@ -3327,14 +3729,16 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `777 + r * (8 ±0)` // Estimated: `6718 + r * (8 ±0)` - // Minimum execution time: 238_262_000 picoseconds. - Weight::from_parts(243_093_288, 6718) - // Standard Error: 870 - .saturating_add(Weight::from_parts(573_939, 0).saturating_mul(r.into())) - .saturating_add(RocksDbWeight::get().reads(6_u64)) + // Minimum execution time: 239_228_000 picoseconds. + Weight::from_parts(245_525_858, 6718) + // Standard Error: 1_774 + .saturating_add(Weight::from_parts(578_001, 0).saturating_mul(r.into())) + .saturating_add(RocksDbWeight::get().reads(7_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) .saturating_add(Weight::from_parts(0, 8).saturating_mul(r.into())) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: System Account (r:1 w:0) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:1 w:1) @@ -3350,13 +3754,15 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `785` // Estimated: `6725` - // Minimum execution time: 239_888_000 picoseconds. - Weight::from_parts(242_849_333, 6725) - // Standard Error: 3 - .saturating_add(Weight::from_parts(3_949, 0).saturating_mul(n.into())) - .saturating_add(RocksDbWeight::get().reads(6_u64)) + // Minimum execution time: 241_876_000 picoseconds. + Weight::from_parts(240_629_797, 6725) + // Standard Error: 2 + .saturating_add(Weight::from_parts(3_947, 0).saturating_mul(n.into())) + .saturating_add(RocksDbWeight::get().reads(7_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: System Account (r:1 w:0) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:1 w:1) @@ -3372,14 +3778,16 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `779 + r * (8 ±0)` // Estimated: `6721 + r * (8 ±0)` - // Minimum execution time: 237_288_000 picoseconds. - Weight::from_parts(242_510_631, 6721) - // Standard Error: 977 - .saturating_add(Weight::from_parts(742_726, 0).saturating_mul(r.into())) - .saturating_add(RocksDbWeight::get().reads(6_u64)) + // Minimum execution time: 239_345_000 picoseconds. + Weight::from_parts(245_512_118, 6721) + // Standard Error: 771 + .saturating_add(Weight::from_parts(735_528, 0).saturating_mul(r.into())) + .saturating_add(RocksDbWeight::get().reads(7_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) .saturating_add(Weight::from_parts(0, 8).saturating_mul(r.into())) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: System Account (r:1 w:0) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:1 w:1) @@ -3395,13 +3803,15 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `787` // Estimated: `6729` - // Minimum execution time: 240_006_000 picoseconds. - Weight::from_parts(233_802_510, 6729) + // Minimum execution time: 242_741_000 picoseconds. + Weight::from_parts(232_209_398, 6729) // Standard Error: 2 - .saturating_add(Weight::from_parts(3_161, 0).saturating_mul(n.into())) - .saturating_add(RocksDbWeight::get().reads(6_u64)) + .saturating_add(Weight::from_parts(3_099, 0).saturating_mul(n.into())) + .saturating_add(RocksDbWeight::get().reads(7_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: System Account (r:1 w:0) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:1 w:1) @@ -3417,14 +3827,16 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `779 + r * (8 ±0)` // Estimated: `6724 + r * (8 ±0)` - // Minimum execution time: 237_532_000 picoseconds. - Weight::from_parts(243_087_565, 6724) - // Standard Error: 656 - .saturating_add(Weight::from_parts(417_850, 0).saturating_mul(r.into())) - .saturating_add(RocksDbWeight::get().reads(6_u64)) + // Minimum execution time: 239_254_000 picoseconds. + Weight::from_parts(244_250_047, 6724) + // Standard Error: 2_223 + .saturating_add(Weight::from_parts(421_533, 0).saturating_mul(r.into())) + .saturating_add(RocksDbWeight::get().reads(7_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) .saturating_add(Weight::from_parts(0, 8).saturating_mul(r.into())) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: System Account (r:1 w:0) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:1 w:1) @@ -3440,13 +3852,15 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `787` // Estimated: `6733` - // Minimum execution time: 241_429_000 picoseconds. - Weight::from_parts(233_528_258, 6733) - // Standard Error: 1 - .saturating_add(Weight::from_parts(913, 0).saturating_mul(n.into())) - .saturating_add(RocksDbWeight::get().reads(6_u64)) + // Minimum execution time: 240_848_000 picoseconds. + Weight::from_parts(239_049_162, 6733) + // Standard Error: 3 + .saturating_add(Weight::from_parts(914, 0).saturating_mul(n.into())) + .saturating_add(RocksDbWeight::get().reads(7_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: System Account (r:1 w:0) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:1 w:1) @@ -3462,14 +3876,16 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `779 + r * (8 ±0)` // Estimated: `6725 + r * (8 ±0)` - // Minimum execution time: 237_622_000 picoseconds. - Weight::from_parts(240_476_401, 6725) - // Standard Error: 795 - .saturating_add(Weight::from_parts(416_869, 0).saturating_mul(r.into())) - .saturating_add(RocksDbWeight::get().reads(6_u64)) + // Minimum execution time: 240_496_000 picoseconds. + Weight::from_parts(245_279_278, 6725) + // Standard Error: 1_047 + .saturating_add(Weight::from_parts(414_108, 0).saturating_mul(r.into())) + .saturating_add(RocksDbWeight::get().reads(7_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) .saturating_add(Weight::from_parts(0, 8).saturating_mul(r.into())) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: System Account (r:1 w:0) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:1 w:1) @@ -3485,13 +3901,15 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `787` // Estimated: `6727` - // Minimum execution time: 241_134_000 picoseconds. - Weight::from_parts(234_043_271, 6727) - // Standard Error: 3 - .saturating_add(Weight::from_parts(919, 0).saturating_mul(n.into())) - .saturating_add(RocksDbWeight::get().reads(6_u64)) + // Minimum execution time: 241_529_000 picoseconds. + Weight::from_parts(234_715_148, 6727) + // Standard Error: 1 + .saturating_add(Weight::from_parts(914, 0).saturating_mul(n.into())) + .saturating_add(RocksDbWeight::get().reads(7_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: System Account (r:1 w:0) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:1 w:1) @@ -3507,14 +3925,16 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `912 + n * (1 ±0)` // Estimated: `6849 + n * (1 ±0)` - // Minimum execution time: 292_699_000 picoseconds. - Weight::from_parts(301_523_608, 6849) - // Standard Error: 14 - .saturating_add(Weight::from_parts(4_676, 0).saturating_mul(n.into())) - .saturating_add(RocksDbWeight::get().reads(6_u64)) + // Minimum execution time: 294_982_000 picoseconds. + Weight::from_parts(299_613_855, 6849) + // Standard Error: 7 + .saturating_add(Weight::from_parts(4_668, 0).saturating_mul(n.into())) + .saturating_add(RocksDbWeight::get().reads(7_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: System Account (r:1 w:0) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:1 w:1) @@ -3528,16 +3948,18 @@ impl WeightInfo for () { /// The range of component `r` is `[0, 160]`. fn seal_sr25519_verify(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `727 + r * (112 ±0)` + // Measured: `726 + r * (112 ±0)` // Estimated: `6666 + r * (112 ±0)` - // Minimum execution time: 241_126_000 picoseconds. - Weight::from_parts(248_796_458, 6666) - // Standard Error: 21_501 - .saturating_add(Weight::from_parts(48_091_265, 0).saturating_mul(r.into())) - .saturating_add(RocksDbWeight::get().reads(6_u64)) + // Minimum execution time: 242_583_000 picoseconds. + Weight::from_parts(251_860_767, 6666) + // Standard Error: 24_034 + .saturating_add(Weight::from_parts(48_144_071, 0).saturating_mul(r.into())) + .saturating_add(RocksDbWeight::get().reads(7_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) .saturating_add(Weight::from_parts(0, 112).saturating_mul(r.into())) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: System Account (r:1 w:0) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:1 w:1) @@ -3552,15 +3974,17 @@ impl WeightInfo for () { fn seal_ecdsa_recover(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `822 + r * (76 ±0)` - // Estimated: `6717 + r * (77 ±0)` - // Minimum execution time: 242_379_000 picoseconds. - Weight::from_parts(261_355_525, 6717) - // Standard Error: 18_862 - .saturating_add(Weight::from_parts(37_603_073, 0).saturating_mul(r.into())) - .saturating_add(RocksDbWeight::get().reads(6_u64)) + // Estimated: `6716 + r * (77 ±0)` + // Minimum execution time: 242_331_000 picoseconds. + Weight::from_parts(254_816_298, 6716) + // Standard Error: 17_941 + .saturating_add(Weight::from_parts(37_725_489, 0).saturating_mul(r.into())) + .saturating_add(RocksDbWeight::get().reads(7_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) .saturating_add(Weight::from_parts(0, 77).saturating_mul(r.into())) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: System Account (r:1 w:0) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:1 w:1) @@ -3576,14 +4000,16 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `792 + r * (42 ±0)` // Estimated: `6731 + r * (42 ±0)` - // Minimum execution time: 241_270_000 picoseconds. - Weight::from_parts(245_135_291, 6731) - // Standard Error: 10_757 - .saturating_add(Weight::from_parts(9_344_876, 0).saturating_mul(r.into())) - .saturating_add(RocksDbWeight::get().reads(6_u64)) + // Minimum execution time: 242_951_000 picoseconds. + Weight::from_parts(246_055_289, 6731) + // Standard Error: 10_074 + .saturating_add(Weight::from_parts(9_421_877, 0).saturating_mul(r.into())) + .saturating_add(RocksDbWeight::get().reads(7_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) .saturating_add(Weight::from_parts(0, 42).saturating_mul(r.into())) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: System Account (r:1 w:0) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:1 w:1) @@ -3601,16 +4027,18 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `0 + r * (964 ±0)` // Estimated: `8190 + r * (3090 ±7)` - // Minimum execution time: 240_506_000 picoseconds. - Weight::from_parts(241_653_000, 8190) - // Standard Error: 46_785 - .saturating_add(Weight::from_parts(22_107_816, 0).saturating_mul(r.into())) - .saturating_add(RocksDbWeight::get().reads(6_u64)) + // Minimum execution time: 245_310_000 picoseconds. + Weight::from_parts(245_703_000, 8190) + // Standard Error: 45_813 + .saturating_add(Weight::from_parts(21_837_058, 0).saturating_mul(r.into())) + .saturating_add(RocksDbWeight::get().reads(7_u64)) .saturating_add(RocksDbWeight::get().reads((3_u64).saturating_mul(r.into()))) .saturating_add(RocksDbWeight::get().writes(3_u64)) .saturating_add(RocksDbWeight::get().writes((2_u64).saturating_mul(r.into()))) .saturating_add(Weight::from_parts(0, 3090).saturating_mul(r.into())) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: System Account (r:1 w:0) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:1 w:1) @@ -3626,14 +4054,16 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `773 + r * (3 ±0)` // Estimated: `6723 + r * (3 ±0)` - // Minimum execution time: 241_539_000 picoseconds. - Weight::from_parts(245_471_045, 6723) - // Standard Error: 416 - .saturating_add(Weight::from_parts(159_577, 0).saturating_mul(r.into())) - .saturating_add(RocksDbWeight::get().reads(6_u64)) + // Minimum execution time: 241_955_000 picoseconds. + Weight::from_parts(246_148_234, 6723) + // Standard Error: 384 + .saturating_add(Weight::from_parts(162_123, 0).saturating_mul(r.into())) + .saturating_add(RocksDbWeight::get().reads(7_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) .saturating_add(Weight::from_parts(0, 3).saturating_mul(r.into())) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: System Account (r:1 w:0) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:1 w:1) @@ -3649,14 +4079,16 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `1975 + r * (39 ±0)` // Estimated: `7805 + r * (40 ±0)` - // Minimum execution time: 242_702_000 picoseconds. - Weight::from_parts(274_518_595, 7805) - // Standard Error: 1_138 - .saturating_add(Weight::from_parts(256_973, 0).saturating_mul(r.into())) - .saturating_add(RocksDbWeight::get().reads(6_u64)) + // Minimum execution time: 243_928_000 picoseconds. + Weight::from_parts(276_404_668, 7805) + // Standard Error: 1_263 + .saturating_add(Weight::from_parts(262_830, 0).saturating_mul(r.into())) + .saturating_add(RocksDbWeight::get().reads(7_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) .saturating_add(Weight::from_parts(0, 40).saturating_mul(r.into())) } + /// Storage: Contracts MigrationInProgress (r:1 w:0) + /// Proof: Contracts MigrationInProgress (max_values: Some(1), max_size: Some(1026), added: 1521, mode: Measured) /// Storage: System Account (r:1 w:0) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:1 w:1) @@ -3674,11 +4106,11 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `776 + r * (3 ±0)` // Estimated: `6723 + r * (3 ±0)` - // Minimum execution time: 239_360_000 picoseconds. - Weight::from_parts(245_990_810, 6723) - // Standard Error: 3_188 - .saturating_add(Weight::from_parts(143_408, 0).saturating_mul(r.into())) - .saturating_add(RocksDbWeight::get().reads(7_u64)) + // Minimum execution time: 242_853_000 picoseconds. + Weight::from_parts(250_429_787, 6723) + // Standard Error: 433 + .saturating_add(Weight::from_parts(139_180, 0).saturating_mul(r.into())) + .saturating_add(RocksDbWeight::get().reads(8_u64)) .saturating_add(RocksDbWeight::get().writes(4_u64)) .saturating_add(Weight::from_parts(0, 3).saturating_mul(r.into())) } @@ -3687,509 +4119,507 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_617_000 picoseconds. - Weight::from_parts(1_900_268, 0) + // Minimum execution time: 1_620_000 picoseconds. + Weight::from_parts(1_894_980, 0) // Standard Error: 2 - .saturating_add(Weight::from_parts(2_950, 0).saturating_mul(r.into())) + .saturating_add(Weight::from_parts(2_995, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 5000]`. fn instr_i64load(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_739_000 picoseconds. - Weight::from_parts(2_109_373, 0) - // Standard Error: 43 - .saturating_add(Weight::from_parts(6_586, 0).saturating_mul(r.into())) + // Minimum execution time: 1_716_000 picoseconds. + Weight::from_parts(2_353_783, 0) + // Standard Error: 3 + .saturating_add(Weight::from_parts(6_414, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 5000]`. fn instr_i64store(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_726_000 picoseconds. - Weight::from_parts(2_268_507, 0) + // Minimum execution time: 1_735_000 picoseconds. + Weight::from_parts(2_266_096, 0) // Standard Error: 4 - .saturating_add(Weight::from_parts(6_022, 0).saturating_mul(r.into())) + .saturating_add(Weight::from_parts(6_015, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 5000]`. fn instr_select(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_628_000 picoseconds. - Weight::from_parts(2_042_521, 0) + // Minimum execution time: 1_698_000 picoseconds. + Weight::from_parts(2_080_936, 0) // Standard Error: 3 - .saturating_add(Weight::from_parts(7_935, 0).saturating_mul(r.into())) + .saturating_add(Weight::from_parts(7_921, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 5000]`. fn instr_if(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_648_000 picoseconds. - Weight::from_parts(1_902_691, 0) - // Standard Error: 7 - .saturating_add(Weight::from_parts(10_572, 0).saturating_mul(r.into())) + // Minimum execution time: 1_636_000 picoseconds. + Weight::from_parts(1_913_876, 0) + // Standard Error: 11 + .saturating_add(Weight::from_parts(10_836, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 5000]`. fn instr_br(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_626_000 picoseconds. - Weight::from_parts(1_891_843, 0) - // Standard Error: 14 - .saturating_add(Weight::from_parts(4_612, 0).saturating_mul(r.into())) + // Minimum execution time: 1_703_000 picoseconds. + Weight::from_parts(1_838_470, 0) + // Standard Error: 11 + .saturating_add(Weight::from_parts(4_613, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 5000]`. fn instr_br_if(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_581_000 picoseconds. - Weight::from_parts(1_139_823, 0) - // Standard Error: 74 - .saturating_add(Weight::from_parts(8_008, 0).saturating_mul(r.into())) + // Minimum execution time: 1_662_000 picoseconds. + Weight::from_parts(1_744_254, 0) + // Standard Error: 13 + .saturating_add(Weight::from_parts(7_020, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 5000]`. fn instr_br_table(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_591_000 picoseconds. - Weight::from_parts(1_258_400, 0) - // Standard Error: 34 - .saturating_add(Weight::from_parts(9_706, 0).saturating_mul(r.into())) + // Minimum execution time: 1_621_000 picoseconds. + Weight::from_parts(1_511_579, 0) + // Standard Error: 33 + .saturating_add(Weight::from_parts(9_479, 0).saturating_mul(r.into())) } /// The range of component `e` is `[1, 256]`. - fn instr_br_table_per_entry(e: u32, ) -> Weight { + fn instr_br_table_per_entry(_e: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_701_000 picoseconds. - Weight::from_parts(1_876_118, 0) - // Standard Error: 23 - .saturating_add(Weight::from_parts(4, 0).saturating_mul(e.into())) + // Minimum execution time: 1_758_000 picoseconds. + Weight::from_parts(2_066_494, 0) } /// The range of component `r` is `[0, 5000]`. fn instr_call(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_617_000 picoseconds. - Weight::from_parts(1_565_613, 0) - // Standard Error: 629 - .saturating_add(Weight::from_parts(19_575, 0).saturating_mul(r.into())) + // Minimum execution time: 1_690_000 picoseconds. + Weight::from_parts(2_029_755, 0) + // Standard Error: 9 + .saturating_add(Weight::from_parts(17_946, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 5000]`. fn instr_call_indirect(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_875_000 picoseconds. - Weight::from_parts(4_549_584, 0) - // Standard Error: 278 - .saturating_add(Weight::from_parts(24_336, 0).saturating_mul(r.into())) + // Minimum execution time: 1_894_000 picoseconds. + Weight::from_parts(5_533_643, 0) + // Standard Error: 176 + .saturating_add(Weight::from_parts(23_511, 0).saturating_mul(r.into())) } /// The range of component `l` is `[0, 1024]`. fn instr_call_per_local(l: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_742_000 picoseconds. - Weight::from_parts(2_087_387, 0) - // Standard Error: 26 - .saturating_add(Weight::from_parts(1_041, 0).saturating_mul(l.into())) + // Minimum execution time: 1_756_000 picoseconds. + Weight::from_parts(1_978_038, 0) + // Standard Error: 13 + .saturating_add(Weight::from_parts(1_176, 0).saturating_mul(l.into())) } /// The range of component `r` is `[0, 5000]`. fn instr_local_get(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_861_000 picoseconds. - Weight::from_parts(3_552_428, 0) - // Standard Error: 23 - .saturating_add(Weight::from_parts(2_339, 0).saturating_mul(r.into())) + // Minimum execution time: 2_889_000 picoseconds. + Weight::from_parts(3_181_705, 0) + // Standard Error: 2 + .saturating_add(Weight::from_parts(2_516, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 5000]`. fn instr_local_set(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_866_000 picoseconds. - Weight::from_parts(3_151_948, 0) - // Standard Error: 4 - .saturating_add(Weight::from_parts(3_667, 0).saturating_mul(r.into())) + // Minimum execution time: 2_871_000 picoseconds. + Weight::from_parts(3_186_198, 0) + // Standard Error: 2 + .saturating_add(Weight::from_parts(3_619, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 5000]`. fn instr_local_tee(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_919_000 picoseconds. - Weight::from_parts(3_214_587, 0) - // Standard Error: 5 - .saturating_add(Weight::from_parts(3_867, 0).saturating_mul(r.into())) + // Minimum execution time: 2_890_000 picoseconds. + Weight::from_parts(3_237_380, 0) + // Standard Error: 3 + .saturating_add(Weight::from_parts(3_963, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 5000]`. fn instr_global_get(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_764_000 picoseconds. - Weight::from_parts(1_815_683, 0) - // Standard Error: 123 - .saturating_add(Weight::from_parts(8_733, 0).saturating_mul(r.into())) + // Minimum execution time: 1_756_000 picoseconds. + Weight::from_parts(2_180_563, 0) + // Standard Error: 2 + .saturating_add(Weight::from_parts(8_400, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 5000]`. fn instr_global_set(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_783_000 picoseconds. - Weight::from_parts(2_437_152, 0) - // Standard Error: 13 - .saturating_add(Weight::from_parts(8_839, 0).saturating_mul(r.into())) + // Minimum execution time: 1_807_000 picoseconds. + Weight::from_parts(2_247_402, 0) + // Standard Error: 3 + .saturating_add(Weight::from_parts(8_798, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 5000]`. fn instr_memory_current(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_745_000 picoseconds. - Weight::from_parts(2_018_078, 0) + // Minimum execution time: 1_703_000 picoseconds. + Weight::from_parts(2_050_199, 0) // Standard Error: 2 - .saturating_add(Weight::from_parts(3_756, 0).saturating_mul(r.into())) + .saturating_add(Weight::from_parts(3_833, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 16]`. fn instr_memory_grow(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_648_000 picoseconds. - Weight::from_parts(648_059, 0) - // Standard Error: 142_299 - .saturating_add(Weight::from_parts(13_313_060, 0).saturating_mul(r.into())) + // Minimum execution time: 1_686_000 picoseconds. + Weight::from_parts(720_378, 0) + // Standard Error: 141_036 + .saturating_add(Weight::from_parts(13_193_405, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 5000]`. fn instr_i64clz(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_652_000 picoseconds. - Weight::from_parts(1_953_179, 0) - // Standard Error: 2 - .saturating_add(Weight::from_parts(3_828, 0).saturating_mul(r.into())) + // Minimum execution time: 1_654_000 picoseconds. + Weight::from_parts(1_934_279, 0) + // Standard Error: 3 + .saturating_add(Weight::from_parts(4_049, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 5000]`. fn instr_i64ctz(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_607_000 picoseconds. - Weight::from_parts(1_924_759, 0) - // Standard Error: 2 - .saturating_add(Weight::from_parts(3_762, 0).saturating_mul(r.into())) + // Minimum execution time: 1_609_000 picoseconds. + Weight::from_parts(1_938_511, 0) + // Standard Error: 20 + .saturating_add(Weight::from_parts(3_780, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 5000]`. fn instr_i64popcnt(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_687_000 picoseconds. - Weight::from_parts(1_959_683, 0) - // Standard Error: 2 - .saturating_add(Weight::from_parts(3_754, 0).saturating_mul(r.into())) + // Minimum execution time: 1_634_000 picoseconds. + Weight::from_parts(1_941_109, 0) + // Standard Error: 4 + .saturating_add(Weight::from_parts(3_770, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 5000]`. fn instr_i64eqz(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_641_000 picoseconds. - Weight::from_parts(1_975_838, 0) + // Minimum execution time: 1_652_000 picoseconds. + Weight::from_parts(1_939_447, 0) // Standard Error: 2 - .saturating_add(Weight::from_parts(3_681, 0).saturating_mul(r.into())) + .saturating_add(Weight::from_parts(3_666, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 5000]`. fn instr_i64extendsi32(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_689_000 picoseconds. - Weight::from_parts(1_980_109, 0) + // Minimum execution time: 1_637_000 picoseconds. + Weight::from_parts(1_921_355, 0) // Standard Error: 2 - .saturating_add(Weight::from_parts(3_880, 0).saturating_mul(r.into())) + .saturating_add(Weight::from_parts(3_977, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 5000]`. fn instr_i64extendui32(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_671_000 picoseconds. - Weight::from_parts(1_912_089, 0) - // Standard Error: 29 - .saturating_add(Weight::from_parts(3_896, 0).saturating_mul(r.into())) + // Minimum execution time: 1_668_000 picoseconds. + Weight::from_parts(1_993_872, 0) + // Standard Error: 3 + .saturating_add(Weight::from_parts(3_809, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 5000]`. fn instr_i32wrapi64(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_643_000 picoseconds. - Weight::from_parts(1_951_485, 0) + // Minimum execution time: 1_657_000 picoseconds. + Weight::from_parts(1_954_737, 0) // Standard Error: 2 - .saturating_add(Weight::from_parts(3_725, 0).saturating_mul(r.into())) + .saturating_add(Weight::from_parts(3_734, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 5000]`. fn instr_i64eq(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_649_000 picoseconds. - Weight::from_parts(1_937_598, 0) - // Standard Error: 4 - .saturating_add(Weight::from_parts(6_045, 0).saturating_mul(r.into())) + // Minimum execution time: 1_688_000 picoseconds. + Weight::from_parts(1_993_611, 0) + // Standard Error: 10 + .saturating_add(Weight::from_parts(5_962, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 5000]`. fn instr_i64ne(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_651_000 picoseconds. - Weight::from_parts(2_202_977, 0) - // Standard Error: 313 - .saturating_add(Weight::from_parts(6_299, 0).saturating_mul(r.into())) + // Minimum execution time: 1_662_000 picoseconds. + Weight::from_parts(1_965_361, 0) + // Standard Error: 2 + .saturating_add(Weight::from_parts(5_965, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 5000]`. fn instr_i64lts(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_589_000 picoseconds. - Weight::from_parts(1_946_304, 0) + // Minimum execution time: 1_679_000 picoseconds. + Weight::from_parts(1_946_910, 0) // Standard Error: 2 - .saturating_add(Weight::from_parts(6_019, 0).saturating_mul(r.into())) + .saturating_add(Weight::from_parts(5_987, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 5000]`. fn instr_i64ltu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_614_000 picoseconds. - Weight::from_parts(1_933_375, 0) - // Standard Error: 2 - .saturating_add(Weight::from_parts(6_020, 0).saturating_mul(r.into())) + // Minimum execution time: 1_650_000 picoseconds. + Weight::from_parts(1_925_830, 0) + // Standard Error: 4 + .saturating_add(Weight::from_parts(6_001, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 5000]`. fn instr_i64gts(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_678_000 picoseconds. - Weight::from_parts(2_003_850, 0) + // Minimum execution time: 1_652_000 picoseconds. + Weight::from_parts(1_984_702, 0) // Standard Error: 2 - .saturating_add(Weight::from_parts(5_816, 0).saturating_mul(r.into())) + .saturating_add(Weight::from_parts(5_817, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 5000]`. fn instr_i64gtu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_651_000 picoseconds. - Weight::from_parts(1_971_321, 0) - // Standard Error: 3 - .saturating_add(Weight::from_parts(6_114, 0).saturating_mul(r.into())) + // Minimum execution time: 1_660_000 picoseconds. + Weight::from_parts(1_978_370, 0) + // Standard Error: 2 + .saturating_add(Weight::from_parts(6_115, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 5000]`. fn instr_i64les(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_647_000 picoseconds. - Weight::from_parts(2_017_232, 0) + // Minimum execution time: 1_655_000 picoseconds. + Weight::from_parts(2_008_659, 0) // Standard Error: 2 - .saturating_add(Weight::from_parts(5_990, 0).saturating_mul(r.into())) + .saturating_add(Weight::from_parts(5_985, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 5000]`. fn instr_i64leu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_635_000 picoseconds. - Weight::from_parts(3_232_848, 0) - // Standard Error: 105 - .saturating_add(Weight::from_parts(5_816, 0).saturating_mul(r.into())) + // Minimum execution time: 1_608_000 picoseconds. + Weight::from_parts(1_912_542, 0) + // Standard Error: 2 + .saturating_add(Weight::from_parts(6_084, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 5000]`. fn instr_i64ges(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_623_000 picoseconds. - Weight::from_parts(1_996_165, 0) + // Minimum execution time: 1_644_000 picoseconds. + Weight::from_parts(1_959_896, 0) // Standard Error: 3 - .saturating_add(Weight::from_parts(5_964, 0).saturating_mul(r.into())) + .saturating_add(Weight::from_parts(5_968, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 5000]`. fn instr_i64geu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_668_000 picoseconds. - Weight::from_parts(1_973_238, 0) - // Standard Error: 20 - .saturating_add(Weight::from_parts(6_021, 0).saturating_mul(r.into())) + // Minimum execution time: 1_653_000 picoseconds. + Weight::from_parts(1_984_715, 0) + // Standard Error: 2 + .saturating_add(Weight::from_parts(5_971, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 5000]`. fn instr_i64add(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_674_000 picoseconds. - Weight::from_parts(1_981_762, 0) - // Standard Error: 3 - .saturating_add(Weight::from_parts(5_898, 0).saturating_mul(r.into())) + // Minimum execution time: 1_610_000 picoseconds. + Weight::from_parts(1_919_305, 0) + // Standard Error: 2 + .saturating_add(Weight::from_parts(5_877, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 5000]`. fn instr_i64sub(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_632_000 picoseconds. - Weight::from_parts(1_935_700, 0) - // Standard Error: 3 - .saturating_add(Weight::from_parts(6_154, 0).saturating_mul(r.into())) + // Minimum execution time: 1_691_000 picoseconds. + Weight::from_parts(2_284_292, 0) + // Standard Error: 16 + .saturating_add(Weight::from_parts(6_027, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 5000]`. fn instr_i64mul(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_607_000 picoseconds. - Weight::from_parts(1_942_734, 0) - // Standard Error: 2 - .saturating_add(Weight::from_parts(5_797, 0).saturating_mul(r.into())) + // Minimum execution time: 1_644_000 picoseconds. + Weight::from_parts(1_960_370, 0) + // Standard Error: 5 + .saturating_add(Weight::from_parts(5_760, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 5000]`. fn instr_i64divs(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_611_000 picoseconds. - Weight::from_parts(2_960_454, 0) - // Standard Error: 177 - .saturating_add(Weight::from_parts(11_666, 0).saturating_mul(r.into())) + // Minimum execution time: 1_656_000 picoseconds. + Weight::from_parts(1_915_002, 0) + // Standard Error: 21 + .saturating_add(Weight::from_parts(11_896, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 5000]`. fn instr_i64divu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_641_000 picoseconds. - Weight::from_parts(2_104_200, 0) - // Standard Error: 5 - .saturating_add(Weight::from_parts(10_540, 0).saturating_mul(r.into())) + // Minimum execution time: 1_645_000 picoseconds. + Weight::from_parts(2_952_497, 0) + // Standard Error: 122 + .saturating_add(Weight::from_parts(10_646, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 5000]`. fn instr_i64rems(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_643_000 picoseconds. - Weight::from_parts(2_602_908, 0) - // Standard Error: 24 - .saturating_add(Weight::from_parts(11_900, 0).saturating_mul(r.into())) + // Minimum execution time: 1_669_000 picoseconds. + Weight::from_parts(1_661_488, 0) + // Standard Error: 10 + .saturating_add(Weight::from_parts(12_330, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 5000]`. fn instr_i64remu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_584_000 picoseconds. - Weight::from_parts(2_056_817, 0) - // Standard Error: 3 - .saturating_add(Weight::from_parts(10_722, 0).saturating_mul(r.into())) + // Minimum execution time: 1_650_000 picoseconds. + Weight::from_parts(1_989_633, 0) + // Standard Error: 2 + .saturating_add(Weight::from_parts(10_649, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 5000]`. fn instr_i64and(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_652_000 picoseconds. - Weight::from_parts(1_988_892, 0) - // Standard Error: 4 - .saturating_add(Weight::from_parts(5_683, 0).saturating_mul(r.into())) + // Minimum execution time: 1_715_000 picoseconds. + Weight::from_parts(1_994_636, 0) + // Standard Error: 2 + .saturating_add(Weight::from_parts(5_667, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 5000]`. fn instr_i64or(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_660_000 picoseconds. - Weight::from_parts(2_148_537, 0) - // Standard Error: 38 - .saturating_add(Weight::from_parts(5_756, 0).saturating_mul(r.into())) + // Minimum execution time: 1_685_000 picoseconds. + Weight::from_parts(2_075_238, 0) + // Standard Error: 2 + .saturating_add(Weight::from_parts(5_743, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 5000]`. fn instr_i64xor(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_629_000 picoseconds. - Weight::from_parts(1_955_010, 0) + // Minimum execution time: 1_649_000 picoseconds. + Weight::from_parts(1_911_373, 0) // Standard Error: 3 - .saturating_add(Weight::from_parts(5_931, 0).saturating_mul(r.into())) + .saturating_add(Weight::from_parts(5_894, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 5000]`. fn instr_i64shl(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_569_000 picoseconds. - Weight::from_parts(1_982_403, 0) + // Minimum execution time: 1_682_000 picoseconds. + Weight::from_parts(2_000_076, 0) // Standard Error: 2 - .saturating_add(Weight::from_parts(5_867, 0).saturating_mul(r.into())) + .saturating_add(Weight::from_parts(5_932, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 5000]`. fn instr_i64shrs(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_615_000 picoseconds. - Weight::from_parts(1_989_920, 0) - // Standard Error: 3 - .saturating_add(Weight::from_parts(6_137, 0).saturating_mul(r.into())) + // Minimum execution time: 1_686_000 picoseconds. + Weight::from_parts(1_999_600, 0) + // Standard Error: 4 + .saturating_add(Weight::from_parts(6_129, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 5000]`. fn instr_i64shru(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_646_000 picoseconds. - Weight::from_parts(2_020_935, 0) - // Standard Error: 2 - .saturating_add(Weight::from_parts(5_863, 0).saturating_mul(r.into())) + // Minimum execution time: 1_628_000 picoseconds. + Weight::from_parts(1_893_440, 0) + // Standard Error: 15 + .saturating_add(Weight::from_parts(5_938, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 5000]`. fn instr_i64rotl(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_661_000 picoseconds. - Weight::from_parts(2_320_710, 0) - // Standard Error: 27 - .saturating_add(Weight::from_parts(5_922, 0).saturating_mul(r.into())) + // Minimum execution time: 1_721_000 picoseconds. + Weight::from_parts(1_982_227, 0) + // Standard Error: 3 + .saturating_add(Weight::from_parts(6_008, 0).saturating_mul(r.into())) } /// The range of component `r` is `[0, 5000]`. fn instr_i64rotr(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_674_000 picoseconds. - Weight::from_parts(2_044_188, 0) - // Standard Error: 2 - .saturating_add(Weight::from_parts(5_855, 0).saturating_mul(r.into())) + // Minimum execution time: 1_648_000 picoseconds. + Weight::from_parts(2_003_359, 0) + // Standard Error: 3 + .saturating_add(Weight::from_parts(5_875, 0).saturating_mul(r.into())) } } diff --git a/frame/support/src/traits/metadata.rs b/frame/support/src/traits/metadata.rs index 54d264ec65b67..85d8f9a5a74e0 100644 --- a/frame/support/src/traits/metadata.rs +++ b/frame/support/src/traits/metadata.rs @@ -20,7 +20,7 @@ use codec::{Decode, Encode}; use impl_trait_for_tuples::impl_for_tuples; use sp_runtime::RuntimeDebug; -use sp_std::prelude::*; +use sp_std::{ops::Add, prelude::*}; /// Provides information about the pallet itself and its setup in the runtime. /// @@ -232,6 +232,14 @@ impl PartialOrd for StorageVersion { } } +impl Add for StorageVersion { + type Output = StorageVersion; + + fn add(self, rhs: u16) -> Self::Output { + Self::new(self.0 + rhs) + } +} + /// Special marker struct if no storage version is set for a pallet. /// /// If you (the reader) end up here, it probably means that you tried to compare