diff --git a/frame/contracts/src/address.rs b/frame/contracts/src/address.rs index e36fc6fffd6f7..5758daf7b1ff8 100644 --- a/frame/contracts/src/address.rs +++ b/frame/contracts/src/address.rs @@ -40,12 +40,6 @@ pub trait AddressGenerator { input_data: &[u8], salt: &[u8], ) -> T::AccountId; - - /// The address of the deposit account of `contract_addr`. - /// - /// The address is generated once on instantiation and then stored in the contracts - /// metadata. Hence changes do only affect newly created contracts. - fn deposit_address(contract_addr: &T::AccountId) -> T::AccountId; } /// Default address generator. @@ -71,11 +65,4 @@ impl AddressGenerator for DefaultAddressGenerator { Decode::decode(&mut TrailingZeroInput::new(entropy.as_ref())) .expect("infinite length input; no invalid inputs for type; qed") } - - /// Formula: `hash("contract_depo_v1" ++ contract_addr)` - fn deposit_address(contract_addr: &T::AccountId) -> T::AccountId { - let entropy = (b"contract_depo_v1", contract_addr).using_encoded(T::Hashing::hash); - Decode::decode(&mut TrailingZeroInput::new(entropy.as_ref())) - .expect("infinite length input; no invalid inputs for type; qed") - } } diff --git a/frame/contracts/src/benchmarking/mod.rs b/frame/contracts/src/benchmarking/mod.rs index 84e46e47b609f..ac5787e234041 100644 --- a/frame/contracts/src/benchmarking/mod.rs +++ b/frame/contracts/src/benchmarking/mod.rs @@ -30,7 +30,9 @@ use self::{ }; use crate::{ exec::{AccountIdOf, Key}, - migration::{codegen::LATEST_MIGRATION_VERSION, v09, v10, v11, v12, v13, v14, MigrationStep}, + migration::{ + codegen::LATEST_MIGRATION_VERSION, v09, v10, v11, v12, v13, v14, v15, MigrationStep, + }, wasm::CallFlags, Pallet as Contracts, *, }; @@ -296,6 +298,19 @@ benchmarks! { m.step(); } + // This benchmarks the v15 migration step (remove deposit account). + #[pov_mode = Measured] + v15_migration_step { + let contract = >::with_caller( + whitelisted_caller(), WasmModule::dummy(), vec![], + )?; + + v15::store_old_contract_info::(contract.account_id.clone(), contract.info()?); + let mut m = v15::Migration::::default(); + }: { + m.step(); + } + // This benchmarks the weight of executing Migration::migrate to execute a noop migration. #[pov_mode = Measured] migration_noop { @@ -397,10 +412,9 @@ benchmarks! { let addr = Contracts::::contract_address(&caller, &hash, &input, &salt); }: _(origin, value, Weight::MAX, None, code, input, salt) verify { - let deposit_account = Contract::::address_info(&addr)?.deposit_account().clone(); - let deposit = T::Currency::balance(&deposit_account); + let deposit = T::Currency::balance_on_hold(&HoldReason::StorageDepositReserve.into(), &addr); // uploading the code reserves some balance in the callers account - let code_deposit = T::Currency::total_balance_on_hold(&caller); + let code_deposit = T::Currency::balance_on_hold(&HoldReason::CodeUploadDepositReserve.into(), &caller); assert_eq!( T::Currency::balance(&caller), caller_funding::() - value - deposit - code_deposit - Pallet::::min_balance(), @@ -427,8 +441,7 @@ benchmarks! { Contracts::::store_code_raw(code, caller.clone())?; }: _(origin, value, Weight::MAX, None, hash, input, salt) verify { - let deposit_account = Contract::::address_info(&addr)?.deposit_account().clone(); - let deposit = T::Currency::balance(&deposit_account); + let deposit = T::Currency::balance_on_hold(&HoldReason::StorageDepositReserve.into(), &addr); // value was removed from the caller assert_eq!( T::Currency::balance(&caller), @@ -451,15 +464,13 @@ benchmarks! { let instance = Contract::::with_caller( whitelisted_caller(), WasmModule::dummy(), vec![], )?; - let deposit_account = instance.info()?.deposit_account().clone(); let value = Pallet::::min_balance(); let origin = RawOrigin::Signed(instance.caller.clone()); let callee = instance.addr.clone(); let before = T::Currency::balance(&instance.account_id); - let before_deposit = T::Currency::balance(&deposit_account); }: _(origin, callee, value, Weight::MAX, None, data) verify { - let deposit = T::Currency::balance(&deposit_account); + let deposit = T::Currency::balance_on_hold(&HoldReason::StorageDepositReserve.into(), &instance.account_id); // value and value transferred via call should be removed from the caller assert_eq!( T::Currency::balance(&instance.caller), @@ -930,15 +941,14 @@ benchmarks! { }); let instance = Contract::::new(code, vec![])?; let origin = RawOrigin::Signed(instance.caller.clone()); - let deposit_account = instance.info()?.deposit_account().clone(); assert_eq!(T::Currency::total_balance(&beneficiary), 0u32.into()); assert_eq!(T::Currency::balance(&instance.account_id), Pallet::::min_balance() * 2u32.into()); - assert_ne!(T::Currency::balance(&deposit_account), 0u32.into()); + assert_ne!(T::Currency::balance_on_hold(&HoldReason::StorageDepositReserve.into(), &instance.account_id), 0u32.into()); }: call(origin, instance.addr.clone(), 0u32.into(), Weight::MAX, None, vec![]) verify { if r > 0 { assert_eq!(T::Currency::total_balance(&instance.account_id), 0u32.into()); - assert_eq!(T::Currency::total_balance(&deposit_account), 0u32.into()); + assert_eq!(T::Currency::balance_on_hold(&HoldReason::StorageDepositReserve.into(), &instance.account_id), 0u32.into()); assert_eq!(T::Currency::total_balance(&beneficiary), Pallet::::min_balance() * 2u32.into()); } } diff --git a/frame/contracts/src/exec.rs b/frame/contracts/src/exec.rs index 65a9abe0c39b6..a4d0760e6c0ac 100644 --- a/frame/contracts/src/exec.rs +++ b/frame/contracts/src/exec.rs @@ -19,10 +19,10 @@ use crate::unsafe_debug::ExecutionObserver; use crate::{ gas::GasMeter, - storage::{self, meter::Diff, DepositAccount, WriteOutcome}, + storage::{self, meter::Diff, WriteOutcome}, BalanceOf, CodeHash, CodeInfo, CodeInfoOf, Config, ContractInfo, ContractInfoOf, DebugBufferVec, Determinism, Error, Event, Nonce, Origin, Pallet as Contracts, Schedule, - System, WasmBlob, LOG_TARGET, + WasmBlob, LOG_TARGET, }; use frame_support::{ crypto::ecdsa::ECDSAExt, @@ -33,7 +33,7 @@ use frame_support::{ storage::{with_transaction, TransactionOutcome}, traits::{ fungible::{Inspect, Mutate}, - tokens::{Fortitude::Polite, Preservation}, + tokens::Preservation, Contains, OriginTrait, Randomness, Time, }, weights::Weight, @@ -547,7 +547,7 @@ enum CachedContract { /// /// In this case a reload is neither allowed nor possible. Please note that recursive /// calls cannot remove a contract as this is checked and denied. - Terminated(DepositAccount), + Terminated, } impl CachedContract { @@ -568,15 +568,6 @@ impl CachedContract { None } } - - /// Returns `Some` iff the contract is not `Cached::Invalidated`. - fn deposit_account(&self) -> Option<&DepositAccount> { - match self { - CachedContract::Cached(contract) => Some(contract.deposit_account()), - CachedContract::Terminated(deposit_account) => Some(&deposit_account), - CachedContract::Invalidated => None, - } - } } impl Frame { @@ -655,9 +646,7 @@ impl CachedContract { /// Terminate and return the contract info. fn terminate(&mut self, account_id: &T::AccountId) -> ContractInfo { self.load(account_id); - let contract = get_cached_or_panic_after_load!(self); - let deposit_account = contract.deposit_account().clone(); - get_cached_or_panic_after_load!(mem::replace(self, Self::Terminated(deposit_account))) + get_cached_or_panic_after_load!(mem::replace(self, Self::Terminated)) } } @@ -955,7 +944,7 @@ where match (entry_point, delegated_code_hash) { (ExportedFunction::Constructor, _) => { // It is not allowed to terminate a contract inside its constructor. - if matches!(frame.contract_info, CachedContract::Terminated(_)) { + if matches!(frame.contract_info, CachedContract::Terminated) { return Err(Error::::TerminatedInConstructor.into()) } @@ -1059,18 +1048,8 @@ where // in its contract info. The load is necessary to pull it from storage in case // it was invalidated. frame.contract_info.load(account_id); - let deposit_account = frame - .contract_info - .deposit_account() - .expect( - "Is only `None` when the info is invalidated. - We just re-loaded from storage which either makes the state `Cached` or `Terminated`. - qed", - ) - .clone(); let mut contract = frame.contract_info.into_contract(); - prev.nested_storage - .absorb(frame.nested_storage, deposit_account, contract.as_mut()); + prev.nested_storage.absorb(frame.nested_storage, account_id, contract.as_mut()); // In case the contract wasn't terminated we need to persist changes made to it. if let Some(contract) = contract { @@ -1105,14 +1084,10 @@ where if !persist { return } - let deposit_account = self.first_frame.contract_info.deposit_account().expect( - "Is only `None` when the info is invalidated. The first frame can't be invalidated. - qed", - ).clone(); let mut contract = self.first_frame.contract_info.as_contract(); self.storage_meter.absorb( mem::take(&mut self.first_frame.nested_storage), - deposit_account, + &self.first_frame.account_id, contract.as_deref_mut(), ); if let Some(contract) = contract { @@ -1311,14 +1286,8 @@ where } let frame = self.top_frame_mut(); let info = frame.terminate(); - frame.nested_storage.terminate(&info); - System::::dec_consumers(&frame.account_id); - Self::transfer( - Preservation::Expendable, - &frame.account_id, - beneficiary, - T::Currency::reducible_balance(&frame.account_id, Preservation::Expendable, Polite), - )?; + frame.nested_storage.terminate(&info, beneficiary.clone()); + info.queue_trie_for_deletion(); ContractInfoOf::::remove(&frame.account_id); E::decrement_refcount(info.code_hash); @@ -1327,7 +1296,7 @@ where E::decrement_refcount(*code_hash); frame .nested_storage - .charge_deposit(info.deposit_account().clone(), StorageDeposit::Refund(*deposit)); + .charge_deposit(frame.account_id.clone(), StorageDeposit::Refund(*deposit)); } Contracts::::deposit_event( @@ -1521,8 +1490,7 @@ where let deposit = StorageDeposit::Charge(new_base_deposit) .saturating_sub(&StorageDeposit::Charge(old_base_deposit)); - let deposit_account = info.deposit_account().clone(); - frame.nested_storage.charge_deposit(deposit_account, deposit); + frame.nested_storage.charge_deposit(frame.account_id.clone(), deposit); E::increment_refcount(hash)?; E::decrement_refcount(prev_hash); @@ -1573,7 +1541,7 @@ where >::increment_refcount(code_hash)?; frame .nested_storage - .charge_deposit(info.deposit_account().clone(), StorageDeposit::Charge(deposit)); + .charge_deposit(frame.account_id.clone(), StorageDeposit::Charge(deposit)); Ok(()) } @@ -1589,7 +1557,7 @@ where frame .nested_storage - .charge_deposit(info.deposit_account().clone(), StorageDeposit::Refund(deposit)); + .charge_deposit(frame.account_id.clone(), StorageDeposit::Refund(deposit)); Ok(()) } } diff --git a/frame/contracts/src/lib.rs b/frame/contracts/src/lib.rs index 37b79c2d585ad..a511ac81a73b7 100644 --- a/frame/contracts/src/lib.rs +++ b/frame/contracts/src/lib.rs @@ -187,7 +187,7 @@ pub mod pallet { use sp_runtime::Perbill; /// The current storage version. - pub(crate) const STORAGE_VERSION: StorageVersion = StorageVersion::new(14); + pub(crate) const STORAGE_VERSION: StorageVersion = StorageVersion::new(15); #[pallet::pallet] #[pallet::storage_version(STORAGE_VERSION)] @@ -899,6 +899,20 @@ pub mod pallet { /// The code hash that was delegate called. code_hash: CodeHash, }, + + /// Some funds have been transferred and held as storage deposit. + StorageDepositTransferredAndHeld { + from: T::AccountId, + to: T::AccountId, + amount: BalanceOf, + }, + + /// Some storage deposit funds have been transferred and released. + StorageDepositTransferredAndReleased { + from: T::AccountId, + to: T::AccountId, + amount: BalanceOf, + }, } #[pallet::error] @@ -999,6 +1013,8 @@ pub mod pallet { pub enum HoldReason { /// The Pallet has reserved it for storing code on-chain. CodeUploadDepositReserve, + /// The Pallet has reserved it for storage deposit. + StorageDepositReserve, } /// A mapping from a contract's code hash to its code. diff --git a/frame/contracts/src/migration.rs b/frame/contracts/src/migration.rs index 106b68dc4416e..d8ebc25ed9a22 100644 --- a/frame/contracts/src/migration.rs +++ b/frame/contracts/src/migration.rs @@ -63,6 +63,7 @@ pub mod v11; pub mod v12; pub mod v13; pub mod v14; +pub mod v15; include!(concat!(env!("OUT_DIR"), "/migration_codegen.rs")); use crate::{weights::WeightInfo, Config, Error, MigrationInProgress, Pallet, Weight, LOG_TARGET}; diff --git a/frame/contracts/src/migration/v10.rs b/frame/contracts/src/migration/v10.rs index 3fc7cabe94942..e33c8d080ad9f 100644 --- a/frame/contracts/src/migration/v10.rs +++ b/frame/contracts/src/migration/v10.rs @@ -19,7 +19,6 @@ //! See . use crate::{ - address::AddressGenerator, exec::AccountIdOf, migration::{IsFinished, MigrationStep}, weights::WeightInfo, @@ -40,7 +39,10 @@ use frame_support::{ use sp_core::hexdisplay::HexDisplay; #[cfg(feature = "try-runtime")] use sp_runtime::TryRuntimeError; -use sp_runtime::{traits::Zero, Perbill, Saturating}; +use sp_runtime::{ + traits::{Hash, TrailingZeroInput, Zero}, + Perbill, Saturating, +}; use sp_std::{ops::Deref, prelude::*}; mod old { @@ -135,6 +137,16 @@ type ContractInfoOf = StorageMap< ContractInfo, >; +/// Formula: `hash("contract_depo_v1" ++ contract_addr)` +fn deposit_address( + contract_addr: &::AccountId, +) -> ::AccountId { + let entropy = (b"contract_depo_v1", contract_addr) + .using_encoded(::Hashing::hash); + Decode::decode(&mut TrailingZeroInput::new(entropy.as_ref())) + .expect("infinite length input; no invalid inputs for type; qed") +} + impl MigrationStep for Migration where OldCurrency: ReservableCurrency<::AccountId> @@ -162,8 +174,7 @@ where log::debug!(target: LOG_TARGET, "Account: 0x{} ", HexDisplay::from(&account.encode())); // Get the new deposit account address - let deposit_account: DepositAccount = - DepositAccount(T::AddressGenerator::deposit_address(&account)); + let deposit_account: DepositAccount = DepositAccount(deposit_address::(&account)); // Calculate the existing deposit, that should be reserved on the contract account let old_deposit = contract diff --git a/frame/contracts/src/migration/v13.rs b/frame/contracts/src/migration/v13.rs index ade837f46e9b1..774b04a9c65d7 100644 --- a/frame/contracts/src/migration/v13.rs +++ b/frame/contracts/src/migration/v13.rs @@ -20,9 +20,8 @@ use crate::{ migration::{IsFinished, MigrationStep}, - storage::DepositAccount, weights::WeightInfo, - BalanceOf, CodeHash, Config, Pallet, TrieId, Weight, LOG_TARGET, + AccountIdOf, BalanceOf, CodeHash, Config, Pallet, TrieId, Weight, LOG_TARGET, }; use codec::{Decode, Encode}; use frame_support::{codec, pallet_prelude::*, storage_alias, DefaultNoBound}; @@ -30,15 +29,13 @@ use sp_runtime::BoundedBTreeMap; use sp_std::prelude::*; mod old { - use crate::storage::DepositAccount; - 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 deposit_account: DepositAccount, + pub deposit_account: AccountIdOf, pub code_hash: CodeHash, pub storage_bytes: u32, pub storage_items: u32, @@ -58,9 +55,13 @@ mod old { #[cfg(feature = "runtime-benchmarks")] pub fn store_old_contract_info(account: T::AccountId, info: crate::ContractInfo) { + use sp_runtime::traits::{Hash, TrailingZeroInput}; + let entropy = (b"contract_depo_v1", account.clone()).using_encoded(T::Hashing::hash); + let deposit_account = Decode::decode(&mut TrailingZeroInput::new(entropy.as_ref())) + .expect("infinite length input; no invalid inputs for type; qed"); let info = old::ContractInfo { trie_id: info.trie_id.clone(), - deposit_account: info.deposit_account().clone(), + deposit_account, code_hash: info.code_hash, storage_bytes: Default::default(), storage_items: Default::default(), @@ -79,7 +80,7 @@ pub type ContractInfoOf = #[scale_info(skip_type_params(T))] pub struct ContractInfo { trie_id: TrieId, - deposit_account: DepositAccount, + deposit_account: AccountIdOf, code_hash: CodeHash, storage_bytes: u32, storage_items: u32, diff --git a/frame/contracts/src/migration/v14.rs b/frame/contracts/src/migration/v14.rs index ebf97af562ed4..0daa0ceb5548a 100644 --- a/frame/contracts/src/migration/v14.rs +++ b/frame/contracts/src/migration/v14.rs @@ -15,7 +15,10 @@ // See the License for the specific language governing permissions and // limitations under the License. -//! Update the code owner balance, make the storage deposit reserved balance to be held instead. +//! Update the code owner balance, make the code upload deposit balance to be held instead of +//! reserved. Since [`Currency`](frame_support::traits::Currency) has been +//! [deprecated](https://github.com/paritytech/substrate/pull/12951), we need the deposits to be +//! handled by the [`frame_support::traits::fungible`] traits. use crate::{ exec::AccountIdOf, @@ -102,7 +105,7 @@ where T: Config, OldCurrency: ReservableCurrency<::AccountId>, { - /// Total reserved balance as storage deposit for the owner. + /// Total reserved balance as code upload deposit for the owner. reserved: old::BalanceOf, /// Total balance of the owner. total: old::BalanceOf, @@ -140,7 +143,7 @@ where }; if let Some((hash, code_info)) = iter.next() { - log::debug!(target: LOG_TARGET, "Migrating storage deposit for 0x{:?}", HexDisplay::from(&code_info.owner.encode())); + log::debug!(target: LOG_TARGET, "Migrating code upload deposit for 0x{:?}", HexDisplay::from(&code_info.owner.encode())); let remaining = OldCurrency::unreserve(&code_info.owner, code_info.deposit); @@ -185,7 +188,7 @@ where self.last_code_hash = Some(hash); (IsFinished::No, T::WeightInfo::v14_migration_step()) } else { - log::debug!(target: LOG_TARGET, "No more storage deposit to migrate"); + log::debug!(target: LOG_TARGET, "No more code upload deposit to migrate"); (IsFinished::Yes, T::WeightInfo::v14_migration_step()) } } @@ -197,8 +200,8 @@ where let mut owner_balance_allocation = BTreeMap::, BalanceAllocation>::new(); - // Calculates the balance allocation by accumulating the storage deposits of all codes owned - // by an owner. + // Calculates the balance allocation by accumulating the code upload deposits of all codes + // owned by an owner. for (_, code_info) in info { owner_balance_allocation .entry(code_info.owner.clone()) @@ -229,7 +232,7 @@ where T::Currency::balance_on_hold(&HoldReason::CodeUploadDepositReserve.into(), &owner); log::debug!( target: LOG_TARGET, - "Validating storage deposit for owner 0x{:?}, reserved: {:?}, held: {:?}", + "Validating code upload deposit for owner 0x{:?}, reserved: {:?}, held: {:?}", HexDisplay::from(&owner.encode()), old_balance_allocation.reserved, held @@ -260,7 +263,7 @@ where log::info!( target: LOG_TARGET, - "Total held amount for storage deposit: {:?}", + "Total held amount for code upload deposit: {:?}", total_held ); diff --git a/frame/contracts/src/migration/v15.rs b/frame/contracts/src/migration/v15.rs new file mode 100644 index 0000000000000..efece62905ff8 --- /dev/null +++ b/frame/contracts/src/migration/v15.rs @@ -0,0 +1,327 @@ +// 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. + +//! Move contracts' _reserved_ balance from the `deposit_account` to be _held_ in the contract's +//! account instead. Since [`Currency`](frame_support::traits::Currency) has been +//! [deprecated](https://github.com/paritytech/substrate/pull/12951), we need the deposits to be +//! handled by the [`frame_support::traits::fungible`] traits instead. For this transfer the +//! balance from the deposit account to the contract's account and hold it in there. +//! Then the deposit account is not needed anymore and we can get rid of it. + +use crate::{ + migration::{IsFinished, MigrationStep}, + weights::WeightInfo, + AccountIdOf, BalanceOf, CodeHash, Config, HoldReason, Pallet, TrieId, Weight, LOG_TARGET, +}; +#[cfg(feature = "try-runtime")] +use frame_support::{dispatch::Vec, traits::fungible::InspectHold}; +use frame_support::{ + pallet_prelude::*, + storage_alias, + traits::{ + fungible::{Mutate, MutateHold}, + tokens::{fungible::Inspect, Fortitude, Preservation}, + }, + BoundedBTreeMap, DefaultNoBound, +}; +use frame_system::Pallet as System; +use sp_core::hexdisplay::HexDisplay; +#[cfg(feature = "try-runtime")] +use sp_runtime::TryRuntimeError; +use sp_runtime::{traits::Zero, Saturating}; + +mod old { + use super::*; + + #[derive( + Encode, Decode, CloneNoBound, PartialEq, Eq, RuntimeDebug, TypeInfo, MaxEncodedLen, + )] + #[scale_info(skip_type_params(T))] + pub struct ContractInfo { + pub trie_id: TrieId, + pub deposit_account: AccountIdOf, + 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, + pub delegate_dependencies: + BoundedBTreeMap, BalanceOf, T::MaxDelegateDependencies>, + } + + #[storage_alias] + pub type ContractInfoOf = StorageMap< + Pallet, + Twox64Concat, + ::AccountId, + ContractInfo, + >; +} + +#[cfg(feature = "runtime-benchmarks")] +pub fn store_old_contract_info(account: T::AccountId, info: crate::ContractInfo) { + use sp_runtime::traits::{Hash, TrailingZeroInput}; + let entropy = (b"contract_depo_v1", account.clone()).using_encoded(T::Hashing::hash); + let deposit_account = Decode::decode(&mut TrailingZeroInput::new(entropy.as_ref())) + .expect("infinite length input; no invalid inputs for type; qed"); + let info = old::ContractInfo { + trie_id: info.trie_id.clone(), + deposit_account, + code_hash: info.code_hash, + storage_bytes: Default::default(), + storage_items: Default::default(), + storage_byte_deposit: info.storage_byte_deposit, + storage_item_deposit: Default::default(), + storage_base_deposit: info.storage_base_deposit(), + delegate_dependencies: info.delegate_dependencies().clone(), + }; + old::ContractInfoOf::::insert(account, info); +} + +#[derive(Encode, Decode, CloneNoBound, PartialEq, Eq, RuntimeDebug, TypeInfo, MaxEncodedLen)] +#[scale_info(skip_type_params(T))] +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, + pub delegate_dependencies: + BoundedBTreeMap, BalanceOf, T::MaxDelegateDependencies>, +} + +#[storage_alias] +type ContractInfoOf = + StorageMap, Twox64Concat, ::AccountId, ContractInfo>; + +#[derive(Encode, Decode, MaxEncodedLen, DefaultNoBound)] +pub struct Migration { + last_account: Option, +} + +impl MigrationStep for Migration { + const VERSION: u16 = 15; + + fn max_step_weight() -> Weight { + T::WeightInfo::v15_migration_step() + } + + fn step(&mut self) -> (IsFinished, Weight) { + let mut iter = if let Some(last_account) = self.last_account.take() { + old::ContractInfoOf::::iter_from(old::ContractInfoOf::::hashed_key_for( + last_account, + )) + } else { + old::ContractInfoOf::::iter() + }; + + if let Some((account, old_contract)) = iter.next() { + let deposit_account = &old_contract.deposit_account; + System::::dec_consumers(deposit_account); + + // Get the deposit balance to transfer. + let total_deposit_balance = T::Currency::total_balance(deposit_account); + let reducible_deposit_balance = T::Currency::reducible_balance( + deposit_account, + Preservation::Expendable, + Fortitude::Force, + ); + + if total_deposit_balance > reducible_deposit_balance { + // This should never happen, as by design all balance in the deposit account is + // storage deposit and therefore reducible after decrementing the consumer + // reference. + log::warn!( + target: LOG_TARGET, + "Deposit account 0x{:?} for contract 0x{:?} has some non-reducible balance {:?} from a total of {:?} that will remain in there.", + HexDisplay::from(&deposit_account.encode()), + HexDisplay::from(&account.encode()), + total_deposit_balance.saturating_sub(reducible_deposit_balance), + total_deposit_balance + ); + } + + // Move balance reserved from the deposit account back to the contract account. + // Let the deposit account die. + log::debug!( + target: LOG_TARGET, + "Transferring {:?} from the deposit account 0x{:?} to the contract 0x{:?}.", + reducible_deposit_balance, + HexDisplay::from(&deposit_account.encode()), + HexDisplay::from(&account.encode()) + ); + let transferred_deposit_balance = T::Currency::transfer( + deposit_account, + &account, + reducible_deposit_balance, + Preservation::Expendable, + ) + .unwrap_or_else(|err| { + log::error!( + target: LOG_TARGET, + "Failed to transfer {:?} from the deposit account 0x{:?} to the contract 0x{:?}, reason: {:?}.", + reducible_deposit_balance, + HexDisplay::from(&deposit_account.encode()), + HexDisplay::from(&account.encode()), + err + ); + Zero::zero() + }); + + // Hold the reserved balance. + if transferred_deposit_balance == Zero::zero() { + log::warn!( + target: LOG_TARGET, + "No balance to hold as storage deposit on the contract 0x{:?}.", + HexDisplay::from(&account.encode()) + ); + } else { + log::debug!( + target: LOG_TARGET, + "Holding {:?} as storage deposit on the contract 0x{:?}.", + transferred_deposit_balance, + HexDisplay::from(&account.encode()) + ); + + T::Currency::hold( + &HoldReason::StorageDepositReserve.into(), + &account, + transferred_deposit_balance, + ) + .unwrap_or_else(|err| { + log::error!( + target: LOG_TARGET, + "Failed to hold {:?} as storage deposit on the contract 0x{:?}, reason: {:?}.", + transferred_deposit_balance, + HexDisplay::from(&account.encode()), + err + ); + }); + } + + log::debug!(target: LOG_TARGET, "==="); + let info = ContractInfo { + trie_id: old_contract.trie_id, + code_hash: old_contract.code_hash, + storage_bytes: old_contract.storage_bytes, + storage_items: old_contract.storage_items, + storage_byte_deposit: old_contract.storage_byte_deposit, + storage_item_deposit: old_contract.storage_item_deposit, + storage_base_deposit: old_contract.storage_base_deposit, + delegate_dependencies: old_contract.delegate_dependencies, + }; + ContractInfoOf::::insert(account.clone(), info); + + // Store last key for next migration step + self.last_account = Some(account); + + (IsFinished::No, T::WeightInfo::v15_migration_step()) + } else { + log::info!(target: LOG_TARGET, "Done Migrating Storage Deposits."); + (IsFinished::Yes, T::WeightInfo::v15_migration_step()) + } + } + + #[cfg(feature = "try-runtime")] + fn pre_upgrade_step() -> Result, TryRuntimeError> { + let sample: Vec<_> = old::ContractInfoOf::::iter().take(100).collect(); + + log::debug!(target: LOG_TARGET, "Taking sample of {} contracts", sample.len()); + + let state: Vec<(T::AccountId, old::ContractInfo, BalanceOf, BalanceOf)> = sample + .iter() + .map(|(account, contract)| { + ( + account.clone(), + contract.clone(), + T::Currency::total_balance(&account), + T::Currency::total_balance(&contract.deposit_account), + ) + }) + .collect(); + + Ok(state.encode()) + } + + #[cfg(feature = "try-runtime")] + fn post_upgrade_step(state: Vec) -> Result<(), TryRuntimeError> { + let sample = + , BalanceOf, BalanceOf)> as Decode>::decode( + &mut &state[..], + ) + .expect("pre_upgrade_step provides a valid state; qed"); + + log::debug!(target: LOG_TARGET, "Validating sample of {} contracts", sample.len()); + for (account, old_contract, old_account_balance, old_deposit_balance) in sample { + log::debug!(target: LOG_TARGET, "==="); + log::debug!(target: LOG_TARGET, "Account: 0x{} ", HexDisplay::from(&account.encode())); + + let on_hold = + T::Currency::balance_on_hold(&HoldReason::StorageDepositReserve.into(), &account); + let account_balance = T::Currency::total_balance(&account); + + log::debug!( + target: LOG_TARGET, + "Validating balances match. Old deposit account's balance: {:?}. Contract's on hold: {:?}. Old contract's total balance: {:?}, Contract's total balance: {:?}.", + old_deposit_balance, + on_hold, + old_account_balance, + account_balance + ); + ensure!( + old_account_balance.saturating_add(old_deposit_balance) == account_balance, + "total balance mismatch" + ); + ensure!(old_deposit_balance == on_hold, "deposit mismatch"); + ensure!( + !System::::account_exists(&old_contract.deposit_account), + "deposit account still exists" + ); + + let migration_contract_info = ContractInfoOf::::try_get(&account).unwrap(); + let crate_contract_info = crate::ContractInfoOf::::try_get(&account).unwrap(); + ensure!( + migration_contract_info.trie_id == crate_contract_info.trie_id, + "trie_id mismatch" + ); + ensure!( + migration_contract_info.code_hash == crate_contract_info.code_hash, + "code_hash mismatch" + ); + ensure!( + migration_contract_info.storage_byte_deposit == + crate_contract_info.storage_byte_deposit, + "storage_byte_deposit mismatch" + ); + ensure!( + migration_contract_info.storage_base_deposit == + crate_contract_info.storage_base_deposit(), + "storage_base_deposit mismatch" + ); + ensure!( + &migration_contract_info.delegate_dependencies == + crate_contract_info.delegate_dependencies(), + "delegate_dependencies mismatch" + ); + } + + Ok(()) + } +} diff --git a/frame/contracts/src/storage.rs b/frame/contracts/src/storage.rs index 7fbd697e509dc..d58fd0fe9dbdf 100644 --- a/frame/contracts/src/storage.rs +++ b/frame/contracts/src/storage.rs @@ -22,15 +22,15 @@ pub mod meter; use crate::{ exec::{AccountIdOf, Key}, weights::WeightInfo, - AddressGenerator, BalanceOf, CodeHash, CodeInfo, Config, ContractInfoOf, DeletionQueue, - DeletionQueueCounter, Error, Pallet, TrieId, SENTINEL, + BalanceOf, CodeHash, CodeInfo, Config, ContractInfoOf, DeletionQueue, DeletionQueueCounter, + Error, Pallet, TrieId, SENTINEL, }; use codec::{Decode, Encode, MaxEncodedLen}; use frame_support::{ dispatch::DispatchError, storage::child::{self, ChildInfo}, weights::Weight, - CloneNoBound, DefaultNoBound, RuntimeDebugNoBound, + CloneNoBound, DefaultNoBound, }; use scale_info::TypeInfo; use sp_core::Get; @@ -39,7 +39,7 @@ use sp_runtime::{ traits::{Hash, Saturating, Zero}, BoundedBTreeMap, DispatchResult, RuntimeDebug, }; -use sp_std::{marker::PhantomData, ops::Deref, prelude::*}; +use sp_std::{marker::PhantomData, prelude::*}; use self::meter::Diff; @@ -50,10 +50,6 @@ use self::meter::Diff; pub struct ContractInfo { /// Unique ID for the subtree encoded as a bytes vector. pub trie_id: TrieId, - /// The account that holds this contracts storage deposit. - /// - /// This is held in a separate account to prevent the contract from spending it. - deposit_account: DepositAccount, /// The code associated with a given account. pub code_hash: CodeHash, /// How many bytes of storage are accumulated in this contract's child trie. @@ -99,11 +95,8 @@ impl ContractInfo { .expect("Runtime uses a reasonable hash size. Hence sizeof(T::Hash) <= 128; qed") }; - let deposit_account = DepositAccount(T::AddressGenerator::deposit_address(account)); - let contract = Self { trie_id, - deposit_account, code_hash, storage_bytes: 0, storage_items: 0, @@ -133,11 +126,6 @@ impl ContractInfo { .saturating_sub(Pallet::::min_balance()) } - /// Returns the account that storage deposits should be deposited into. - pub fn deposit_account(&self) -> &DepositAccount { - &self.deposit_account - } - /// Returns the storage base deposit of the contract. pub fn storage_base_deposit(&self) -> BalanceOf { self.storage_base_deposit @@ -233,9 +221,9 @@ impl ContractInfo { let upload_deposit = T::CodeHashLockupDepositPercent::get().mul_ceil(code_info.deposit()); // Instantiate needs to transfer at least the minimum balance in order to pull the - // deposit account into existence. - // We also add another `ed` here which goes to the contract's own account into existence. - let deposit = info_deposit.saturating_add(upload_deposit).max(ed).saturating_add(ed); + // contract's own account into existence, as the deposit itself does not contribute to the + // `ed`. + let deposit = info_deposit.saturating_add(upload_deposit).saturating_add(ed); self.storage_base_deposit = deposit; deposit @@ -391,18 +379,6 @@ impl WriteOutcome { } } -#[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 - } -} - /// Manage the removal of contracts storage that are marked for deletion. /// /// When a contract is deleted by calling `seal_terminate` it becomes inaccessible diff --git a/frame/contracts/src/storage/meter.rs b/frame/contracts/src/storage/meter.rs index 93885b37b4795..2a9a083412b00 100644 --- a/frame/contracts/src/storage/meter.rs +++ b/frame/contracts/src/storage/meter.rs @@ -18,25 +18,28 @@ //! This module contains functions to meter the storage deposit. use crate::{ - storage::{ContractInfo, DepositAccount}, - BalanceOf, CodeInfo, Config, Error, Inspect, Origin, Pallet, StorageDeposit as Deposit, System, + storage::ContractInfo, AccountIdOf, BalanceOf, CodeInfo, Config, Error, Event, HoldReason, + Inspect, Origin, Pallet, StorageDeposit as Deposit, System, LOG_TARGET, }; use frame_support::{ dispatch::{fmt::Debug, DispatchError}, ensure, traits::{ - fungible::Mutate, - tokens::{Fortitude::Polite, Preservation, WithdrawConsequence}, + fungible::{Mutate, MutateHold}, + tokens::{ + Fortitude, Fortitude::Polite, Precision, Preservation, Restriction, WithdrawConsequence, + }, Get, }, DefaultNoBound, RuntimeDebugNoBound, }; +use sp_api::HashT; use sp_runtime::{ traits::{Saturating, Zero}, FixedPointNumber, FixedU128, }; -use sp_std::{marker::PhantomData, vec::Vec}; +use sp_std::{marker::PhantomData, vec, vec::Vec}; /// Deposit that uses the native fungible's balance type. pub type DepositOf = Deposit>; @@ -75,16 +78,15 @@ pub trait Ext { /// This is called to inform the implementer that some balance should be charged due to /// some interaction of the `origin` with a `contract`. /// - /// The balance transfer can either flow from `origin` to `deposit_account` or the other way + /// The balance transfer can either flow from `origin` to `contract` or the other way /// around depending on whether `amount` constitutes a `Charge` or a `Refund`. - /// It is guaranteed that this succeeds because no more balance than returned by - /// `check_limit` is ever charged. This is why this function is infallible. - /// `terminated` designates whether the `contract` was terminated. + /// It should be used in combination with `check_limit` to check that no more balance than this + /// limit is ever charged. fn charge( origin: &T::AccountId, - deposit_account: &DepositAccount, + contract: &T::AccountId, amount: &DepositOf, - terminated: bool, + state: &ContractState, ) -> Result<(), DispatchError>; } @@ -220,6 +222,15 @@ impl Diff { } } +/// The state of a contract. +/// +/// In case of termination the beneficiary is indicated. +#[derive(RuntimeDebugNoBound, Clone, PartialEq, Eq)] +pub enum ContractState { + Alive, + Terminated { beneficiary: AccountIdOf }, +} + /// Records information to charge or refund a plain account. /// /// All the charges are deferred to the end of a whole call stack. Reason is that by doing @@ -231,9 +242,9 @@ impl Diff { /// exhausted. #[derive(RuntimeDebugNoBound, Clone)] struct Charge { - deposit_account: DepositAccount, + contract: T::AccountId, amount: DepositOf, - terminated: bool, + state: ContractState, } /// Records the storage changes of a storage meter. @@ -245,8 +256,9 @@ enum Contribution { /// its execution. In this process the [`Diff`] was converted into a [`Deposit`]. Checked(DepositOf), /// The contract was terminated. In this process the [`Diff`] was converted into a [`Deposit`] - /// in order to calculate the refund. - Terminated(DepositOf), + /// in order to calculate the refund. Upon termination the `reducible_balance` in the + /// contract's account is transferred to the [`beneficiary`]. + Terminated { deposit: DepositOf, beneficiary: AccountIdOf }, } impl Contribution { @@ -254,7 +266,8 @@ impl Contribution { fn update_contract(&self, info: Option<&mut ContractInfo>) -> DepositOf { match self { Self::Alive(diff) => diff.update_contract::(info), - Self::Terminated(deposit) | Self::Checked(deposit) => deposit.clone(), + Self::Terminated { deposit, beneficiary: _ } | Self::Checked(deposit) => + deposit.clone(), } } } @@ -279,7 +292,7 @@ where /// usage for this sub call separately. This is necessary because we want to exchange balance /// with the current contract we are interacting with. pub fn nested(&self, limit: BalanceOf) -> RawMeter { - debug_assert!(self.is_alive()); + debug_assert!(matches!(self.contract_state(), ContractState::Alive)); // If a special limit is specified higher than it is available, // we want to enforce the lesser limit to the nested meter, to fail in the sub-call. let limit = self.available().min(limit); @@ -293,7 +306,7 @@ where /// Absorb a child that was spawned to handle a sub call. /// /// This should be called whenever a sub call comes to its end and it is **not** reverted. - /// This does the actual balance transfer from/to `origin` and `deposit_account` based on the + /// This does the actual balance transfer from/to `origin` and `contract` based on the /// overall storage consumption of the call. It also updates the supplied contract info. /// /// In case a contract reverted the child meter should just be dropped in order to revert @@ -303,12 +316,12 @@ where /// /// - `absorbed`: The child storage meter that should be absorbed. /// - `origin`: The origin that spawned the original root meter. - /// - `deposit_account`: The contract's deposit account that this sub call belongs to. + /// - `contract`: The contract's account that this sub call belongs to. /// - `info`: The info of the contract in question. `None` if the contract was terminated. pub fn absorb( &mut self, absorbed: RawMeter, - deposit_account: DepositAccount, + contract: &T::AccountId, info: Option<&mut ContractInfo>, ) { let own_deposit = absorbed.own_contribution.update_contract(info); @@ -319,9 +332,9 @@ where self.charges.extend_from_slice(&absorbed.charges); if !own_deposit.is_zero() { self.charges.push(Charge { - deposit_account, + contract: contract.clone(), amount: own_deposit, - terminated: absorbed.is_terminated(), + state: absorbed.contract_state(), }); } } @@ -331,14 +344,13 @@ where self.total_deposit.available(&self.limit) } - /// True if the contract is alive. - fn is_alive(&self) -> bool { - matches!(self.own_contribution, Contribution::Alive(_)) - } - - /// True if the contract is terminated. - fn is_terminated(&self) -> bool { - matches!(self.own_contribution, Contribution::Terminated(_)) + /// Returns the state of the currently executed contract. + fn contract_state(&self) -> ContractState { + match &self.own_contribution { + Contribution::Terminated { deposit: _, beneficiary } => + ContractState::Terminated { beneficiary: beneficiary.clone() }, + _ => ContractState::Alive, + } } } @@ -375,7 +387,6 @@ where /// /// This drops the root meter in order to make sure it is only called when the whole /// execution did finish. - pub fn try_into_deposit(self, origin: &Origin) -> Result, DispatchError> { // Only refund or charge deposit if the origin is not root. let origin = match origin { @@ -383,10 +394,10 @@ where Origin::Signed(o) => o, }; for charge in self.charges.iter().filter(|c| matches!(c.amount, Deposit::Refund(_))) { - E::charge(origin, &charge.deposit_account, &charge.amount, charge.terminated)?; + E::charge(origin, &charge.contract, &charge.amount, &charge.state)?; } for charge in self.charges.iter().filter(|c| matches!(c.amount, Deposit::Charge(_))) { - E::charge(origin, &charge.deposit_account, &charge.amount, charge.terminated)?; + E::charge(origin, &charge.contract, &charge.amount, &charge.state)?; } Ok(self.total_deposit) } @@ -412,9 +423,9 @@ where /// change. This is the case when a `delegate_dependency` is added or removed, or when the /// `code_hash` is updated. [`Self::charge`] cannot be used here because we keep track of the /// deposit charge separately from the storage charge. - pub fn charge_deposit(&mut self, deposit_account: DepositAccount, amount: DepositOf) { + pub fn charge_deposit(&mut self, contract: T::AccountId, amount: DepositOf) { self.total_deposit = self.total_deposit.saturating_add(&amount); - self.charges.push(Charge { deposit_account, amount, terminated: false }); + self.charges.push(Charge { contract, amount, state: ContractState::Alive }); } /// Charges from `origin` a storage deposit for contract instantiation. @@ -427,7 +438,7 @@ where contract_info: &mut ContractInfo, code_info: &CodeInfo, ) -> Result, DispatchError> { - debug_assert!(self.is_alive()); + debug_assert!(matches!(self.contract_state(), ContractState::Alive)); let ed = Pallet::::min_balance(); let deposit = contract_info.update_base_deposit(&code_info); @@ -439,34 +450,32 @@ where // We do not increase `own_contribution` because this will be charged later when the // contract execution does conclude and hence would lead to a double charge. - self.total_deposit = deposit.clone(); + self.total_deposit = Deposit::Charge(ed); - // Normally, deposit charges are deferred to be able to coalesce them with refunds. - // However, we need to charge immediately so that the account is created before - // charges possibly below the ed are collected and fail. - E::charge( - origin, - contract_info.deposit_account(), - &deposit.saturating_sub(&Deposit::Charge(ed)), - false, - )?; - - System::::inc_consumers(contract_info.deposit_account())?; - - // We also need to make sure that the contract's account itself exists. + // We need to make sure that the contract's account exists. T::Currency::transfer(origin, contract, ed, Preservation::Preserve)?; + + // A consumer is added at account creation and removed it on termination, otherwise the + // runtime could remove the account. As long as a contract exists its account must exist. + // With the consumer, a correct runtime cannot remove the account. System::::inc_consumers(contract)?; + self.charge_deposit(contract.clone(), deposit.saturating_sub(&Deposit::Charge(ed))); + Ok(deposit) } - /// Call to tell the meter that the currently executing contract was executed. + /// Call to tell the meter that the currently executing contract was terminated. /// /// This will manipulate the meter so that all storage deposit accumulated in - /// `contract_info` will be refunded to the `origin` of the meter. - pub fn terminate(&mut self, info: &ContractInfo) { - debug_assert!(self.is_alive()); - self.own_contribution = Contribution::Terminated(Deposit::Refund(info.total_deposit())); + /// `contract_info` will be refunded to the `origin` of the meter. And the free + /// (`reducible_balance`) will be sent to the `beneficiary`. + pub fn terminate(&mut self, info: &ContractInfo, beneficiary: T::AccountId) { + debug_assert!(matches!(self.contract_state(), ContractState::Alive)); + self.own_contribution = Contribution::Terminated { + deposit: Deposit::Refund(info.total_deposit()), + beneficiary, + }; } /// [`Self::charge`] does not enforce the storage limit since we want to do this check as late @@ -485,7 +494,7 @@ where let deposit = self.own_contribution.update_contract(info); let total_deposit = self.total_deposit.saturating_add(&deposit); // We don't want to override a `Terminated` with a `Checked`. - if self.is_alive() { + if matches!(self.contract_state(), ContractState::Alive) { self.own_contribution = Contribution::Checked(deposit); } if let Deposit::Charge(amount) = total_deposit { @@ -533,31 +542,77 @@ impl Ext for ReservingExt { fn charge( origin: &T::AccountId, - deposit_account: &DepositAccount, + contract: &T::AccountId, amount: &DepositOf, - terminated: bool, + state: &ContractState, ) -> Result<(), DispatchError> { match amount { Deposit::Charge(amount) | Deposit::Refund(amount) if amount.is_zero() => return Ok(()), Deposit::Charge(amount) => { - T::Currency::transfer(origin, deposit_account, *amount, Preservation::Preserve)?; - Ok(()) + // This could fail if the `origin` does not have enough liquidity. Ideally, though, + // this should have been checked before with `check_limit`. + T::Currency::transfer_and_hold( + &HoldReason::StorageDepositReserve.into(), + origin, + contract, + *amount, + Precision::Exact, + Preservation::Preserve, + Fortitude::Polite, + )?; + + Pallet::::deposit_event( + vec![T::Hashing::hash_of(&origin), T::Hashing::hash_of(&contract)], + Event::StorageDepositTransferredAndHeld { + from: origin.clone(), + to: contract.clone(), + amount: *amount, + }, + ); }, Deposit::Refund(amount) => { - if terminated { - System::::dec_consumers(&deposit_account); - } - T::Currency::transfer( - deposit_account, + let transferred = T::Currency::transfer_on_hold( + &HoldReason::StorageDepositReserve.into(), + contract, origin, *amount, - // We can safely make it `Expendable` because our own consumer prevents a - // removal. - Preservation::Expendable, + Precision::BestEffort, + Restriction::Free, + Fortitude::Polite, )?; - Ok(()) + + Pallet::::deposit_event( + vec![T::Hashing::hash_of(&contract), T::Hashing::hash_of(&origin)], + Event::StorageDepositTransferredAndReleased { + from: contract.clone(), + to: origin.clone(), + amount: transferred, + }, + ); + + if transferred < *amount { + // This should never happen, if it does it means that there is a bug in the + // runtime logic. In the rare case this happens we try to refund as much as we + // can, thus the `Precision::BestEffort`. + log::error!( + target: LOG_TARGET, + "Failed to repatriate full storage deposit {:?} from contract {:?} to origin {:?}. Transferred {:?}.", + amount, contract, origin, transferred, + ); + } }, } + if let ContractState::::Terminated { beneficiary } = state { + System::::dec_consumers(&contract); + // Whatever is left in the contract is sent to the termination beneficiary. + T::Currency::transfer( + &contract, + &beneficiary, + T::Currency::reducible_balance(&contract, Preservation::Expendable, Polite), + Preservation::Expendable, + )?; + } + Ok(()) } } @@ -593,9 +648,9 @@ mod tests { #[derive(Debug, PartialEq, Eq, Clone)] struct Charge { origin: AccountIdOf, - contract: DepositAccount, + contract: AccountIdOf, amount: DepositOf, - terminated: bool, + state: ContractState, } #[derive(Default, Debug, PartialEq, Eq, Clone)] @@ -627,16 +682,16 @@ mod tests { fn charge( origin: &AccountIdOf, - contract: &DepositAccount, + contract: &AccountIdOf, amount: &DepositOf, - terminated: bool, + state: &ContractState, ) -> Result<(), DispatchError> { TestExtTestValue::mutate(|ext| { ext.charges.push(Charge { origin: origin.clone(), contract: contract.clone(), amount: amount.clone(), - terminated, + state: state.clone(), }) }); Ok(()) @@ -664,7 +719,6 @@ mod tests { fn new_info(info: StorageInfo) -> ContractInfo { ContractInfo:: { trie_id: Default::default(), - deposit_account: DepositAccount([0u8; 32].into()), code_hash: Default::default(), storage_bytes: info.bytes, storage_items: info.items, @@ -700,7 +754,7 @@ mod tests { // an empty charge does not create a `Charge` entry let mut nested0 = meter.nested(BalanceOf::::zero()); nested0.charge(&Default::default()); - meter.absorb(nested0, DepositAccount(BOB), None); + meter.absorb(nested0, &BOB, None); assert_eq!( TestExtTestValue::get(), @@ -722,21 +776,21 @@ mod tests { charges: vec![ Charge { origin: ALICE, - contract: DepositAccount(CHARLIE), + contract: CHARLIE, amount: Deposit::Refund(10), - terminated: false, + state: ContractState::Alive, }, Charge { origin: ALICE, - contract: DepositAccount(CHARLIE), + contract: CHARLIE, amount: Deposit::Refund(20), - terminated: false, + state: ContractState::Alive, }, Charge { origin: ALICE, - contract: DepositAccount(BOB), + contract: BOB, amount: Deposit::Charge(2), - terminated: false, + state: ContractState::Alive, }, ], }, @@ -777,7 +831,7 @@ mod tests { }); let mut nested1 = nested0.nested(BalanceOf::::zero()); nested1.charge(&Diff { items_removed: 5, ..Default::default() }); - nested0.absorb(nested1, DepositAccount(CHARLIE), Some(&mut nested1_info)); + nested0.absorb(nested1, &CHARLIE, Some(&mut nested1_info)); let mut nested2_info = new_info(StorageInfo { bytes: 100, @@ -787,10 +841,10 @@ mod tests { }); let mut nested2 = nested0.nested(BalanceOf::::zero()); nested2.charge(&Diff { items_removed: 7, ..Default::default() }); - nested0.absorb(nested2, DepositAccount(CHARLIE), Some(&mut nested2_info)); + nested0.absorb(nested2, &CHARLIE, Some(&mut nested2_info)); nested0.enforce_limit(Some(&mut nested0_info)).unwrap(); - meter.absorb(nested0, DepositAccount(BOB), Some(&mut nested0_info)); + meter.absorb(nested0, &BOB, Some(&mut nested0_info)); assert_eq!(meter.try_into_deposit(&test_case.origin).unwrap(), test_case.deposit); @@ -813,15 +867,15 @@ mod tests { charges: vec![ Charge { origin: ALICE, - contract: DepositAccount(CHARLIE), + contract: CHARLIE, amount: Deposit::Refund(119), - terminated: true, + state: ContractState::Terminated { beneficiary: CHARLIE }, }, Charge { origin: ALICE, - contract: DepositAccount(BOB), + contract: BOB, amount: Deposit::Charge(12), - terminated: false, + state: ContractState::Alive, }, ], }, @@ -857,11 +911,11 @@ mod tests { let mut nested1 = nested0.nested(BalanceOf::::zero()); nested1.charge(&Diff { items_removed: 5, ..Default::default() }); nested1.charge(&Diff { bytes_added: 20, ..Default::default() }); - nested1.terminate(&nested1_info); + nested1.terminate(&nested1_info, CHARLIE); nested0.enforce_limit(Some(&mut nested1_info)).unwrap(); - nested0.absorb(nested1, DepositAccount(CHARLIE), None); + nested0.absorb(nested1, &CHARLIE, None); - meter.absorb(nested0, DepositAccount(BOB), None); + meter.absorb(nested0, &BOB, None); assert_eq!(meter.try_into_deposit(&test_case.origin).unwrap(), test_case.deposit); assert_eq!(TestExtTestValue::get(), test_case.expected) diff --git a/frame/contracts/src/tests.rs b/frame/contracts/src/tests.rs index 3132b8e39f7da..5c8fca43ab746 100644 --- a/frame/contracts/src/tests.rs +++ b/frame/contracts/src/tests.rs @@ -43,7 +43,7 @@ use frame_support::{ parameter_types, storage::child, traits::{ - fungible::{BalancedHold, Inspect, InspectHold, Mutate, MutateHold}, + fungible::{BalancedHold, Inspect, Mutate, MutateHold}, tokens::Preservation, ConstU32, ConstU64, Contains, OnIdle, OnInitialize, StorageVersion, }, @@ -60,7 +60,6 @@ use sp_runtime::{ traits::{BlakeTwo256, Convert, Hash, IdentityLookup}, AccountId32, BuildStorage, Perbill, TokenError, }; -use std::ops::Deref; type Block = frame_system::mocking::MockBlock; @@ -93,20 +92,20 @@ macro_rules! assert_refcount { pub mod test_utils { - use super::{DepositPerByte, DepositPerItem, Hash, SysConfig, Test}; + use super::{Contracts, DepositPerByte, DepositPerItem, Hash, SysConfig, Test}; use crate::{ exec::AccountIdOf, BalanceOf, CodeHash, CodeInfo, CodeInfoOf, Config, ContractInfo, ContractInfoOf, Nonce, PristineCode, }; use codec::{Encode, MaxEncodedLen}; - use frame_support::traits::{fungible::Mutate, Currency}; + use frame_support::traits::fungible::{InspectHold, Mutate}; pub fn place_contract(address: &AccountIdOf, code_hash: CodeHash) { let nonce = >::mutate(|counter| { *counter += 1; *counter }); - set_balance(address, ::Currency::minimum_balance() * 10); + set_balance(address, Contracts::min_balance() * 10); >::insert(code_hash, CodeInfo::new(address.clone())); let contract = >::new(&address, nonce, code_hash).unwrap(); >::insert(address, contract); @@ -117,6 +116,12 @@ pub mod test_utils { pub fn get_balance(who: &AccountIdOf) -> u64 { ::Currency::free_balance(who) } + pub fn get_balance_on_hold( + reason: &::RuntimeHoldReason, + who: &AccountIdOf, + ) -> u64 { + ::Currency::balance_on_hold(reason.into(), who) + } pub fn get_contract(addr: &AccountIdOf) -> ContractInfo { get_contract_checked(addr).unwrap() } @@ -126,6 +131,15 @@ pub mod test_utils { pub fn get_code_deposit(code_hash: &CodeHash) -> BalanceOf { crate::CodeInfoOf::::get(code_hash).unwrap().deposit() } + pub fn contract_info_storage_deposit( + addr: &::AccountId, + ) -> BalanceOf { + let contract_info = self::get_contract(&addr); + let info_size = contract_info.encoded_size() as u64; + DepositPerByte::get() + .saturating_mul(info_size) + .saturating_add(DepositPerItem::get()) + } pub fn hash(s: &S) -> <::Hashing as Hash>::Output { <::Hashing as Hash>::hash_of(s) } @@ -696,7 +710,7 @@ fn instantiate_and_call_and_deposit_event() { ExtBuilder::default().existential_deposit(1).build().execute_with(|| { let _ = ::Currency::set_balance(&ALICE, 1_000_000); - let min_balance = ::Currency::minimum_balance(); + let min_balance = Contracts::min_balance(); let value = 100; // We determine the storage deposit limit after uploading because it depends on ALICEs free @@ -728,36 +742,9 @@ fn instantiate_and_call_and_deposit_event() { .account_id; assert!(ContractInfoOf::::contains_key(&addr)); - let contract = get_contract(&addr); - let deposit_account = contract.deposit_account().deref(); - assert_eq!( System::events(), vec![ - EventRecord { - phase: Phase::Initialization, - event: RuntimeEvent::System(frame_system::Event::NewAccount { - account: deposit_account.clone(), - }), - topics: vec![], - }, - EventRecord { - phase: Phase::Initialization, - event: RuntimeEvent::Balances(pallet_balances::Event::Endowed { - account: deposit_account.clone(), - free_balance: 132, - }), - topics: vec![], - }, - EventRecord { - phase: Phase::Initialization, - event: RuntimeEvent::Balances(pallet_balances::Event::Transfer { - from: ALICE, - to: deposit_account.clone(), - amount: 132, - }), - topics: vec![], - }, EventRecord { phase: Phase::Initialization, event: RuntimeEvent::System(frame_system::Event::NewAccount { @@ -807,6 +794,17 @@ fn instantiate_and_call_and_deposit_event() { }), topics: vec![hash(&ALICE), hash(&addr)], }, + EventRecord { + phase: Phase::Initialization, + event: RuntimeEvent::Contracts( + pallet_contracts::Event::StorageDepositTransferredAndHeld { + from: ALICE, + to: addr.clone(), + amount: test_utils::contract_info_storage_deposit(&addr), + } + ), + topics: vec![hash(&ALICE), hash(&addr)], + }, ] ); }); @@ -864,7 +862,7 @@ fn deposit_event_max_value_limit() { fn run_out_of_fuel_engine() { let (wasm, _code_hash) = compile_module::("run_out_of_gas").unwrap(); ExtBuilder::default().existential_deposit(50).build().execute_with(|| { - let min_balance = ::Currency::minimum_balance(); + let min_balance = Contracts::min_balance(); let _ = ::Currency::set_balance(&ALICE, 1_000_000); let addr = Contracts::bare_instantiate( @@ -903,7 +901,7 @@ fn run_out_of_fuel_engine() { fn run_out_of_fuel_host() { let (code, _hash) = compile_module::("chain_extension").unwrap(); ExtBuilder::default().existential_deposit(50).build().execute_with(|| { - let min_balance = ::Currency::minimum_balance(); + let min_balance = Contracts::min_balance(); let _ = ::Currency::set_balance(&ALICE, 1000 * min_balance); let addr = Contracts::bare_instantiate( @@ -1169,7 +1167,7 @@ fn deploy_and_call_other_contract() { let (callee_wasm, callee_code_hash) = compile_module::("return_with_data").unwrap(); ExtBuilder::default().existential_deposit(1).build().execute_with(|| { - let min_balance = ::Currency::minimum_balance(); + let min_balance = Contracts::min_balance(); // Create let _ = ::Currency::set_balance(&ALICE, 1_000_000); @@ -1210,36 +1208,9 @@ fn deploy_and_call_other_contract() { callee_code_hash.as_ref().to_vec(), )); - let callee = get_contract(&callee_addr); - let deposit_account = callee.deposit_account().deref(); - assert_eq!( System::events(), vec![ - EventRecord { - phase: Phase::Initialization, - event: RuntimeEvent::System(frame_system::Event::NewAccount { - account: deposit_account.clone(), - }), - topics: vec![], - }, - EventRecord { - phase: Phase::Initialization, - event: RuntimeEvent::Balances(pallet_balances::Event::Endowed { - account: deposit_account.clone(), - free_balance: 132, - }), - topics: vec![], - }, - EventRecord { - phase: Phase::Initialization, - event: RuntimeEvent::Balances(pallet_balances::Event::Transfer { - from: ALICE, - to: deposit_account.clone(), - amount: 132, - }), - topics: vec![], - }, EventRecord { phase: Phase::Initialization, event: RuntimeEvent::System(frame_system::Event::NewAccount { @@ -1309,6 +1280,17 @@ fn deploy_and_call_other_contract() { }), topics: vec![hash(&Origin::::from_account_id(ALICE)), hash(&caller_addr)], }, + EventRecord { + phase: Phase::Initialization, + event: RuntimeEvent::Contracts( + pallet_contracts::Event::StorageDepositTransferredAndHeld { + from: ALICE, + to: callee_addr.clone(), + amount: test_utils::contract_info_storage_deposit(&callee_addr), + } + ), + topics: vec![hash(&ALICE), hash(&callee_addr)], + }, ] ); }); @@ -1357,7 +1339,7 @@ fn delegate_call() { } #[test] -fn transfer_allow_death_cannot_kill_account() { +fn transfer_expendable_cannot_kill_account() { let (wasm, _code_hash) = compile_module::("dummy").unwrap(); ExtBuilder::default().existential_deposit(200).build().execute_with(|| { let _ = ::Currency::set_balance(&ALICE, 1_000_000); @@ -1383,6 +1365,12 @@ fn transfer_allow_death_cannot_kill_account() { let total_balance = ::Currency::total_balance(&addr); + assert_eq!( + test_utils::get_balance_on_hold(&HoldReason::StorageDepositReserve.into(), &addr), + test_utils::contract_info_storage_deposit(&addr) + ); + + // Some ot the total balance is held, so it can't be transferred. assert_err!( <::Currency as Mutate>::transfer( &addr, @@ -1390,7 +1378,7 @@ fn transfer_allow_death_cannot_kill_account() { total_balance, Preservation::Expendable, ), - TokenError::Frozen, + TokenError::FundsUnavailable, ); assert_eq!(::Currency::total_balance(&addr), total_balance); @@ -1402,11 +1390,13 @@ fn cannot_self_destruct_through_draning() { let (wasm, _code_hash) = compile_module::("drain").unwrap(); ExtBuilder::default().existential_deposit(200).build().execute_with(|| { let _ = ::Currency::set_balance(&ALICE, 1_000_000); + let value = 1_000; + let min_balance = Contracts::min_balance(); // Instantiate the BOB contract. let addr = Contracts::bare_instantiate( ALICE, - 1_000, + value, GAS_LIMIT, None, Code::Upload(wasm), @@ -1436,7 +1426,7 @@ fn cannot_self_destruct_through_draning() { // Make sure the account wasn't remove by sending all free balance away. assert_eq!( ::Currency::total_balance(&addr), - 1_000 + ::Currency::minimum_balance(), + value + test_utils::contract_info_storage_deposit(&addr) + min_balance, ); }); } @@ -1446,7 +1436,7 @@ fn cannot_self_destruct_through_storage_refund_after_price_change() { let (wasm, _code_hash) = compile_module::("store_call").unwrap(); ExtBuilder::default().existential_deposit(200).build().execute_with(|| { let _ = ::Currency::set_balance(&ALICE, 1_000_000); - let min_balance = ::Currency::minimum_balance(); + let min_balance = Contracts::min_balance(); // Instantiate the BOB contract. let addr = Contracts::bare_instantiate( @@ -1464,10 +1454,12 @@ fn cannot_self_destruct_through_storage_refund_after_price_change() { .unwrap() .account_id; - // Check that the BOB contract has been instantiated and has the minimum balance - assert_eq!(get_contract(&addr).total_deposit(), min_balance); + let info_deposit = test_utils::contract_info_storage_deposit(&addr); + + // Check that the contract has been instantiated and has the minimum balance + assert_eq!(get_contract(&addr).total_deposit(), info_deposit); assert_eq!(get_contract(&addr).extra_deposit(), 0); - assert_eq!(::Currency::total_balance(&addr), min_balance); + assert_eq!(::Currency::total_balance(&addr), info_deposit + min_balance); // Create 100 bytes of storage with a price of per byte and a single storage item of price 2 assert_ok!(Contracts::call( @@ -1478,7 +1470,7 @@ fn cannot_self_destruct_through_storage_refund_after_price_change() { None, 100u32.to_le_bytes().to_vec() )); - assert_eq!(get_contract(&addr).total_deposit(), min_balance + 102); + assert_eq!(get_contract(&addr).total_deposit(), info_deposit + 102); // Increase the byte price and trigger a refund. This should not have any influence because // the removal is pro rata and exactly those 100 bytes should have been removed. @@ -1494,8 +1486,8 @@ fn cannot_self_destruct_through_storage_refund_after_price_change() { // Make sure the account wasn't removed by the refund assert_eq!( - ::Currency::total_balance(get_contract(&addr).deposit_account()), - get_contract(&addr).total_deposit(), + ::Currency::total_balance(&addr), + get_contract(&addr).total_deposit() + min_balance, ); assert_eq!(get_contract(&addr).extra_deposit(), 2); }); @@ -1551,6 +1543,7 @@ fn self_destruct_works() { ExtBuilder::default().existential_deposit(1_000).build().execute_with(|| { let _ = ::Currency::set_balance(&ALICE, 1_000_000); let _ = ::Currency::set_balance(&DJANGO, 1_000_000); + let min_balance = Contracts::min_balance(); // Instantiate the BOB contract. let addr = Contracts::bare_instantiate( @@ -1569,7 +1562,9 @@ fn self_destruct_works() { .account_id; // Check that the BOB contract has been instantiated. - let contract = get_contract(&addr); + let _ = get_contract(&addr); + + let info_deposit = test_utils::contract_info_storage_deposit(&addr); // Drop all previous events initialize_block(2); @@ -1587,29 +1582,22 @@ fn self_destruct_works() { assert!(get_contract_checked(&addr).is_none()); assert_eq!(::Currency::total_balance(&addr), 0); - // check that the beneficiary (django) got remaining balance - let ed = ::Currency::minimum_balance(); - assert_eq!(::Currency::free_balance(DJANGO), 1_000_000 + 100_000 + ed); + // Check that the beneficiary (django) got remaining balance. + assert_eq!( + ::Currency::free_balance(DJANGO), + 1_000_000 + 100_000 + min_balance + ); + + // Check that the Alice is missing Django's benefit. Within ALICE's total balance there's + // also the code upload deposit held. + assert_eq!( + ::Currency::total_balance(&ALICE), + 1_000_000 - (100_000 + min_balance) + ); pretty_assertions::assert_eq!( System::events(), vec![ - EventRecord { - phase: Phase::Initialization, - event: RuntimeEvent::System(frame_system::Event::KilledAccount { - account: addr.clone() - }), - topics: vec![], - }, - EventRecord { - phase: Phase::Initialization, - event: RuntimeEvent::Balances(pallet_balances::Event::Transfer { - from: addr.clone(), - to: DJANGO, - amount: 100_000 + ed, - }), - topics: vec![], - }, EventRecord { phase: Phase::Initialization, event: RuntimeEvent::Contracts(crate::Event::Terminated { @@ -1626,19 +1614,30 @@ fn self_destruct_works() { }), topics: vec![hash(&Origin::::from_account_id(ALICE)), hash(&addr)], }, + EventRecord { + phase: Phase::Initialization, + event: RuntimeEvent::Contracts( + pallet_contracts::Event::StorageDepositTransferredAndReleased { + from: addr.clone(), + to: ALICE, + amount: info_deposit, + } + ), + topics: vec![hash(&addr), hash(&ALICE)], + }, EventRecord { phase: Phase::Initialization, event: RuntimeEvent::System(frame_system::Event::KilledAccount { - account: contract.deposit_account().deref().clone(), + account: addr.clone() }), topics: vec![], }, EventRecord { phase: Phase::Initialization, event: RuntimeEvent::Balances(pallet_balances::Event::Transfer { - from: contract.deposit_account().deref().clone(), - to: ALICE, - amount: 1_000, + from: addr.clone(), + to: DJANGO, + amount: 100_000 + min_balance, }), topics: vec![], }, @@ -1785,7 +1784,7 @@ fn crypto_hashes() { fn transfer_return_code() { let (wasm, _code_hash) = compile_module::("transfer_return_code").unwrap(); ExtBuilder::default().existential_deposit(50).build().execute_with(|| { - let min_balance = ::Currency::minimum_balance(); + let min_balance = Contracts::min_balance(); let _ = ::Currency::set_balance(&ALICE, 1000 * min_balance); let addr = Contracts::bare_instantiate( @@ -1827,7 +1826,7 @@ fn call_return_code() { let (caller_code, _caller_hash) = compile_module::("call_return_code").unwrap(); let (callee_code, _callee_hash) = compile_module::("ok_trap_revert").unwrap(); ExtBuilder::default().existential_deposit(50).build().execute_with(|| { - let min_balance = ::Currency::minimum_balance(); + let min_balance = Contracts::min_balance(); let _ = ::Currency::set_balance(&ALICE, 1000 * min_balance); let _ = ::Currency::set_balance(&CHARLIE, 1000 * min_balance); @@ -1947,7 +1946,7 @@ fn instantiate_return_code() { let (caller_code, _caller_hash) = compile_module::("instantiate_return_code").unwrap(); let (callee_code, callee_hash) = compile_module::("ok_trap_revert").unwrap(); ExtBuilder::default().existential_deposit(50).build().execute_with(|| { - let min_balance = ::Currency::minimum_balance(); + let min_balance = Contracts::min_balance(); let _ = ::Currency::set_balance(&ALICE, 1000 * min_balance); let _ = ::Currency::set_balance(&CHARLIE, 1000 * min_balance); let callee_hash = callee_hash.as_ref().to_vec(); @@ -2049,7 +2048,7 @@ fn instantiate_return_code() { fn disabled_chain_extension_wont_deploy() { let (code, _hash) = compile_module::("chain_extension").unwrap(); ExtBuilder::default().existential_deposit(50).build().execute_with(|| { - let min_balance = ::Currency::minimum_balance(); + let min_balance = Contracts::min_balance(); let _ = ::Currency::set_balance(&ALICE, 1000 * min_balance); TestExtension::disable(); assert_err_ignore_postinfo!( @@ -2071,7 +2070,7 @@ fn disabled_chain_extension_wont_deploy() { fn disabled_chain_extension_errors_on_call() { let (code, _hash) = compile_module::("chain_extension").unwrap(); ExtBuilder::default().existential_deposit(50).build().execute_with(|| { - let min_balance = ::Currency::minimum_balance(); + let min_balance = Contracts::min_balance(); let _ = ::Currency::set_balance(&ALICE, 1000 * min_balance); let addr = Contracts::bare_instantiate( ALICE, @@ -2099,7 +2098,7 @@ fn disabled_chain_extension_errors_on_call() { fn chain_extension_works() { let (code, _hash) = compile_module::("chain_extension").unwrap(); ExtBuilder::default().existential_deposit(50).build().execute_with(|| { - let min_balance = ::Currency::minimum_balance(); + let min_balance = Contracts::min_balance(); let _ = ::Currency::set_balance(&ALICE, 1000 * min_balance); let addr = Contracts::bare_instantiate( ALICE, @@ -2246,7 +2245,7 @@ fn chain_extension_works() { fn chain_extension_temp_storage_works() { let (code, _hash) = compile_module::("chain_extension_temp_storage").unwrap(); ExtBuilder::default().existential_deposit(50).build().execute_with(|| { - let min_balance = ::Currency::minimum_balance(); + let min_balance = Contracts::min_balance(); let _ = ::Currency::set_balance(&ALICE, 1000 * min_balance); let addr = Contracts::bare_instantiate( ALICE, @@ -2293,7 +2292,7 @@ fn chain_extension_temp_storage_works() { fn lazy_removal_works() { let (code, _hash) = compile_module::("self_destruct").unwrap(); ExtBuilder::default().existential_deposit(50).build().execute_with(|| { - let min_balance = ::Currency::minimum_balance(); + let min_balance = Contracts::min_balance(); let _ = ::Currency::set_balance(&ALICE, 1000 * min_balance); let addr = Contracts::bare_instantiate( @@ -2345,7 +2344,7 @@ fn lazy_removal_works() { fn lazy_batch_removal_works() { let (code, _hash) = compile_module::("self_destruct").unwrap(); ExtBuilder::default().existential_deposit(50).build().execute_with(|| { - let min_balance = ::Currency::minimum_balance(); + let min_balance = Contracts::min_balance(); let _ = ::Currency::set_balance(&ALICE, 1000 * min_balance); let mut tries: Vec = vec![]; @@ -2413,7 +2412,7 @@ fn lazy_removal_partial_remove_works() { let mut ext = ExtBuilder::default().existential_deposit(50).build(); let trie = ext.execute_with(|| { - let min_balance = ::Currency::minimum_balance(); + let min_balance = Contracts::min_balance(); let _ = ::Currency::set_balance(&ALICE, 1000 * min_balance); let addr = Contracts::bare_instantiate( @@ -2495,7 +2494,7 @@ fn lazy_removal_partial_remove_works() { fn lazy_removal_does_no_run_on_low_remaining_weight() { let (code, _hash) = compile_module::("self_destruct").unwrap(); ExtBuilder::default().existential_deposit(50).build().execute_with(|| { - let min_balance = ::Currency::minimum_balance(); + let min_balance = Contracts::min_balance(); let _ = ::Currency::set_balance(&ALICE, 1000 * min_balance); let addr = Contracts::bare_instantiate( @@ -2567,7 +2566,7 @@ fn lazy_removal_does_not_use_all_weight() { let mut ext = ExtBuilder::default().existential_deposit(50).build(); let (trie, vals, weight_per_key) = ext.execute_with(|| { - let min_balance = ::Currency::minimum_balance(); + let min_balance = Contracts::min_balance(); let _ = ::Currency::set_balance(&ALICE, 1000 * min_balance); let addr = Contracts::bare_instantiate( @@ -2655,7 +2654,7 @@ fn deletion_queue_ring_buffer_overflow() { ext.commit_all().unwrap(); ext.execute_with(|| { - let min_balance = ::Currency::minimum_balance(); + let min_balance = Contracts::min_balance(); let _ = ::Currency::set_balance(&ALICE, 1000 * min_balance); let mut tries: Vec = vec![]; @@ -2716,7 +2715,7 @@ fn refcounter() { let (wasm, code_hash) = compile_module::("self_destruct").unwrap(); ExtBuilder::default().existential_deposit(50).build().execute_with(|| { let _ = ::Currency::set_balance(&ALICE, 1_000_000); - let min_balance = ::Currency::minimum_balance(); + let min_balance = Contracts::min_balance(); // Create two contracts with the same code and check that they do in fact share it. let addr0 = Contracts::bare_instantiate( @@ -2924,7 +2923,7 @@ fn gas_estimation_nested_call_fixed_limit() { let (caller_code, _caller_hash) = compile_module::("call_with_limit").unwrap(); let (callee_code, _callee_hash) = compile_module::("dummy").unwrap(); ExtBuilder::default().existential_deposit(50).build().execute_with(|| { - let min_balance = ::Currency::minimum_balance(); + let min_balance = Contracts::min_balance(); let _ = ::Currency::set_balance(&ALICE, 1000 * min_balance); let addr_caller = Contracts::bare_instantiate( @@ -3020,7 +3019,7 @@ fn gas_estimation_call_runtime() { let (caller_code, _caller_hash) = compile_module::("call_runtime").unwrap(); let (callee_code, _callee_hash) = compile_module::("dummy").unwrap(); ExtBuilder::default().existential_deposit(50).build().execute_with(|| { - let min_balance = ::Currency::minimum_balance(); + let min_balance = Contracts::min_balance(); let _ = ::Currency::set_balance(&ALICE, 1000 * min_balance); let _ = ::Currency::set_balance(&CHARLIE, 1000 * min_balance); @@ -3098,7 +3097,7 @@ fn call_runtime_reentrancy_guarded() { let (caller_code, _caller_hash) = compile_module::("call_runtime").unwrap(); let (callee_code, _callee_hash) = compile_module::("dummy").unwrap(); ExtBuilder::default().existential_deposit(50).build().execute_with(|| { - let min_balance = ::Currency::minimum_balance(); + let min_balance = Contracts::min_balance(); let _ = ::Currency::set_balance(&ALICE, 1000 * min_balance); let _ = ::Currency::set_balance(&CHARLIE, 1000 * min_balance); @@ -3229,7 +3228,7 @@ fn ecdsa_recover() { fn bare_instantiate_returns_events() { let (wasm, _code_hash) = compile_module::("transfer_return_code").unwrap(); ExtBuilder::default().existential_deposit(50).build().execute_with(|| { - let min_balance = ::Currency::minimum_balance(); + let min_balance = Contracts::min_balance(); let _ = ::Currency::set_balance(&ALICE, 1000 * min_balance); let result = Contracts::bare_instantiate( @@ -3254,7 +3253,7 @@ fn bare_instantiate_returns_events() { fn bare_instantiate_does_not_return_events() { let (wasm, _code_hash) = compile_module::("transfer_return_code").unwrap(); ExtBuilder::default().existential_deposit(50).build().execute_with(|| { - let min_balance = ::Currency::minimum_balance(); + let min_balance = Contracts::min_balance(); let _ = ::Currency::set_balance(&ALICE, 1000 * min_balance); let result = Contracts::bare_instantiate( @@ -3279,7 +3278,7 @@ fn bare_instantiate_does_not_return_events() { fn bare_call_returns_events() { let (wasm, _code_hash) = compile_module::("transfer_return_code").unwrap(); ExtBuilder::default().existential_deposit(50).build().execute_with(|| { - let min_balance = ::Currency::minimum_balance(); + let min_balance = Contracts::min_balance(); let _ = ::Currency::set_balance(&ALICE, 1000 * min_balance); let addr = Contracts::bare_instantiate( @@ -3320,7 +3319,7 @@ fn bare_call_returns_events() { fn bare_call_does_not_return_events() { let (wasm, _code_hash) = compile_module::("transfer_return_code").unwrap(); ExtBuilder::default().existential_deposit(50).build().execute_with(|| { - let min_balance = ::Currency::minimum_balance(); + let min_balance = Contracts::min_balance(); let _ = ::Currency::set_balance(&ALICE, 1000 * min_balance); let addr = Contracts::bare_instantiate( @@ -3733,7 +3732,7 @@ fn instantiate_with_zero_balance_works() { let (wasm, code_hash) = compile_module::("dummy").unwrap(); ExtBuilder::default().existential_deposit(200).build().execute_with(|| { let _ = ::Currency::set_balance(&ALICE, 1_000_000); - let min_balance = ::Currency::minimum_balance(); + let min_balance = Contracts::min_balance(); // Drop previous events initialize_block(2); @@ -3754,15 +3753,15 @@ fn instantiate_with_zero_balance_works() { .unwrap() .account_id; - // Check that the BOB contract has been instantiated. - let contract = get_contract(&addr); - let deposit_account = contract.deposit_account().deref(); // Ensure the contract was stored and get expected deposit amount to be reserved. let deposit_expected = expected_deposit(ensure_stored(code_hash)); // Make sure the account exists even though no free balance was send assert_eq!(::Currency::free_balance(&addr), min_balance); - assert_eq!(::Currency::total_balance(&addr), min_balance,); + assert_eq!( + ::Currency::total_balance(&addr), + min_balance + test_utils::contract_info_storage_deposit(&addr) + ); assert_eq!( System::events(), @@ -3776,30 +3775,6 @@ fn instantiate_with_zero_balance_works() { }), topics: vec![code_hash], }, - EventRecord { - phase: Phase::Initialization, - event: RuntimeEvent::System(frame_system::Event::NewAccount { - account: deposit_account.clone(), - }), - topics: vec![], - }, - EventRecord { - phase: Phase::Initialization, - event: RuntimeEvent::Balances(pallet_balances::Event::Endowed { - account: deposit_account.clone(), - free_balance: min_balance, - }), - topics: vec![], - }, - EventRecord { - phase: Phase::Initialization, - event: RuntimeEvent::Balances(pallet_balances::Event::Transfer { - from: ALICE, - to: deposit_account.clone(), - amount: min_balance, - }), - topics: vec![], - }, EventRecord { phase: Phase::Initialization, event: RuntimeEvent::System(frame_system::Event::NewAccount { @@ -3832,6 +3807,17 @@ fn instantiate_with_zero_balance_works() { }), topics: vec![hash(&ALICE), hash(&addr)], }, + EventRecord { + phase: Phase::Initialization, + event: RuntimeEvent::Contracts( + pallet_contracts::Event::StorageDepositTransferredAndHeld { + from: ALICE, + to: addr.clone(), + amount: test_utils::contract_info_storage_deposit(&addr), + } + ), + topics: vec![hash(&ALICE), hash(&addr)], + }, ] ); }); @@ -3842,7 +3828,8 @@ fn instantiate_with_below_existential_deposit_works() { let (wasm, code_hash) = compile_module::("dummy").unwrap(); ExtBuilder::default().existential_deposit(200).build().execute_with(|| { let _ = ::Currency::set_balance(&ALICE, 1_000_000); - let min_balance = ::Currency::minimum_balance(); + let min_balance = Contracts::min_balance(); + let value = 50; // Drop previous events initialize_block(2); @@ -3850,7 +3837,7 @@ fn instantiate_with_below_existential_deposit_works() { // Instantiate the BOB contract. let addr = Contracts::bare_instantiate( ALICE, - 50, + value, GAS_LIMIT, None, Code::Upload(wasm), @@ -3863,14 +3850,14 @@ fn instantiate_with_below_existential_deposit_works() { .unwrap() .account_id; - // Check that the BOB contract has been instantiated. - let contract = get_contract(&addr); - let deposit_account = contract.deposit_account().deref(); // Ensure the contract was stored and get expected deposit amount to be reserved. let deposit_expected = expected_deposit(ensure_stored(code_hash)); // Make sure the account exists even though not enough free balance was send - assert_eq!(::Currency::free_balance(&addr), min_balance + 50); - assert_eq!(::Currency::total_balance(&addr), min_balance + 50); + assert_eq!(::Currency::free_balance(&addr), min_balance + value); + assert_eq!( + ::Currency::total_balance(&addr), + min_balance + value + test_utils::contract_info_storage_deposit(&addr) + ); assert_eq!( System::events(), @@ -3884,30 +3871,6 @@ fn instantiate_with_below_existential_deposit_works() { }), topics: vec![code_hash], }, - EventRecord { - phase: Phase::Initialization, - event: RuntimeEvent::System(frame_system::Event::NewAccount { - account: deposit_account.clone(), - }), - topics: vec![], - }, - EventRecord { - phase: Phase::Initialization, - event: RuntimeEvent::Balances(pallet_balances::Event::Endowed { - account: deposit_account.clone(), - free_balance: min_balance, - }), - topics: vec![], - }, - EventRecord { - phase: Phase::Initialization, - event: RuntimeEvent::Balances(pallet_balances::Event::Transfer { - from: ALICE, - to: deposit_account.clone(), - amount: min_balance, - }), - topics: vec![], - }, EventRecord { phase: Phase::Initialization, event: RuntimeEvent::System(frame_system::Event::NewAccount { @@ -3949,6 +3912,17 @@ fn instantiate_with_below_existential_deposit_works() { }), topics: vec![hash(&ALICE), hash(&addr)], }, + EventRecord { + phase: Phase::Initialization, + event: RuntimeEvent::Contracts( + pallet_contracts::Event::StorageDepositTransferredAndHeld { + from: ALICE, + to: addr.clone(), + amount: test_utils::contract_info_storage_deposit(&addr), + } + ), + topics: vec![hash(&ALICE), hash(&addr)], + }, ] ); }); @@ -3959,7 +3933,6 @@ fn storage_deposit_works() { let (wasm, _code_hash) = compile_module::("multi_store").unwrap(); ExtBuilder::default().existential_deposit(200).build().execute_with(|| { let _ = ::Currency::set_balance(&ALICE, 1_000_000); - let mut deposit = ::Currency::minimum_balance(); let addr = Contracts::bare_instantiate( ALICE, @@ -3976,6 +3949,8 @@ fn storage_deposit_works() { .unwrap() .account_id; + let mut deposit = test_utils::contract_info_storage_deposit(&addr); + // Drop previous events initialize_block(2); @@ -4020,9 +3995,6 @@ fn storage_deposit_works() { deposit -= refunded0; assert_eq!(get_contract(&addr).total_deposit(), deposit); - let contract = get_contract(&addr); - let deposit_account = contract.deposit_account().deref(); - assert_eq!( System::events(), vec![ @@ -4045,12 +4017,14 @@ fn storage_deposit_works() { }, EventRecord { phase: Phase::Initialization, - event: RuntimeEvent::Balances(pallet_balances::Event::Transfer { - from: ALICE, - to: deposit_account.clone(), - amount: charged0, - }), - topics: vec![], + event: RuntimeEvent::Contracts( + pallet_contracts::Event::StorageDepositTransferredAndHeld { + from: ALICE, + to: addr.clone(), + amount: charged0, + } + ), + topics: vec![hash(&ALICE), hash(&addr)], }, EventRecord { phase: Phase::Initialization, @@ -4062,12 +4036,14 @@ fn storage_deposit_works() { }, EventRecord { phase: Phase::Initialization, - event: RuntimeEvent::Balances(pallet_balances::Event::Transfer { - from: ALICE, - to: deposit_account.clone(), - amount: charged1, - }), - topics: vec![], + event: RuntimeEvent::Contracts( + pallet_contracts::Event::StorageDepositTransferredAndHeld { + from: ALICE, + to: addr.clone(), + amount: charged1, + } + ), + topics: vec![hash(&ALICE), hash(&addr)], }, EventRecord { phase: Phase::Initialization, @@ -4079,12 +4055,14 @@ fn storage_deposit_works() { }, EventRecord { phase: Phase::Initialization, - event: RuntimeEvent::Balances(pallet_balances::Event::Transfer { - from: deposit_account.clone(), - to: ALICE, - amount: refunded0, - }), - topics: vec![], + event: RuntimeEvent::Contracts( + pallet_contracts::Event::StorageDepositTransferredAndReleased { + from: addr.clone(), + to: ALICE, + amount: refunded0, + } + ), + topics: vec![hash(&addr.clone()), hash(&ALICE)], }, ] ); @@ -4095,9 +4073,9 @@ fn storage_deposit_works() { fn storage_deposit_callee_works() { let (wasm_caller, _code_hash_caller) = compile_module::("call").unwrap(); let (wasm_callee, _code_hash_callee) = compile_module::("store_call").unwrap(); - const ED: u64 = 200; - ExtBuilder::default().existential_deposit(ED).build().execute_with(|| { + ExtBuilder::default().existential_deposit(200).build().execute_with(|| { let _ = ::Currency::set_balance(&ALICE, 1_000_000); + let min_balance = Contracts::min_balance(); // Create both contracts: Constructors do nothing. let addr_caller = Contracts::bare_instantiate( @@ -4139,10 +4117,13 @@ fn storage_deposit_callee_works() { )); let callee = get_contract(&addr_callee); - let deposit = ED + DepositPerByte::get() * 100 + DepositPerItem::get() * 1; + let deposit = DepositPerByte::get() * 100 + DepositPerItem::get() * 1; - assert_eq!(test_utils::get_balance(callee.deposit_account()), deposit); - assert_eq!(callee.total_deposit(), deposit); + assert_eq!(test_utils::get_balance(&addr_callee), min_balance); + assert_eq!( + callee.total_deposit(), + deposit + test_utils::contract_info_storage_deposit(&addr_callee) + ); }); } @@ -4238,11 +4219,10 @@ fn set_code_extrinsic() { #[test] fn slash_cannot_kill_account() { let (wasm, _code_hash) = compile_module::("dummy").unwrap(); - const ED: u64 = 200; - ExtBuilder::default().existential_deposit(ED).build().execute_with(|| { + ExtBuilder::default().existential_deposit(200).build().execute_with(|| { let value = 700; - let balance_held = 500; let _ = ::Currency::set_balance(&ALICE, 1_000_000); + let min_balance = Contracts::min_balance(); let addr = Contracts::bare_instantiate( ALICE, @@ -4262,28 +4242,29 @@ fn slash_cannot_kill_account() { // Drop previous events initialize_block(2); - // We need to hold some balances in order to have something to slash. As slashing can only - // affect balances held under certain HoldReason. - ::Currency::hold( - &HoldReason::CodeUploadDepositReserve.into(), - &addr, - balance_held, - ) - .unwrap(); + let info_deposit = test_utils::contract_info_storage_deposit(&addr); + + assert_eq!( + test_utils::get_balance_on_hold(&HoldReason::StorageDepositReserve.into(), &addr), + info_deposit + ); - assert_eq!(::Currency::total_balance_on_hold(&addr), balance_held); + assert_eq!( + ::Currency::total_balance(&addr), + info_deposit + value + min_balance + ); // Try to destroy the account of the contract by slashing the total balance. - // The account does not get destroyed because of the consumer reference. - // Slashing can for example happen if the contract takes part in staking. + // The account does not get destroyed because slashing only affects the balance held under + // certain `reason`. Slashing can for example happen if the contract takes part in staking. let _ = ::Currency::slash( - &HoldReason::CodeUploadDepositReserve.into(), + &HoldReason::StorageDepositReserve.into(), &addr, ::Currency::total_balance(&addr), ); // Slashing only removed the balance held. - assert_eq!(::Currency::total_balance(&addr), value + ED - balance_held,); + assert_eq!(::Currency::total_balance(&addr), value + min_balance); }); } @@ -4599,11 +4580,10 @@ fn set_code_hash() { #[test] fn storage_deposit_limit_is_enforced() { - let ed = 200; let (wasm, _code_hash) = compile_module::("store_call").unwrap(); - ExtBuilder::default().existential_deposit(ed).build().execute_with(|| { + ExtBuilder::default().existential_deposit(200).build().execute_with(|| { let _ = ::Currency::set_balance(&ALICE, 1_000_000); - let min_balance = ::Currency::minimum_balance(); + let min_balance = Contracts::min_balance(); // Setting insufficient storage_deposit should fail. assert_err!( @@ -4611,7 +4591,8 @@ fn storage_deposit_limit_is_enforced() { ALICE, 0, GAS_LIMIT, - Some((2 * ed + 3 - 1).into()), // expected deposit is 2 * ed + 3 for the call + Some((2 * min_balance + 3 - 1).into()), /* expected deposit is 2 * ed + 3 for + * the call */ Code::Upload(wasm.clone()), vec![], vec![], @@ -4638,9 +4619,10 @@ fn storage_deposit_limit_is_enforced() { .unwrap() .account_id; + let info_deposit = test_utils::contract_info_storage_deposit(&addr); // Check that the BOB contract has been instantiated and has the minimum balance - assert_eq!(get_contract(&addr).total_deposit(), min_balance); - assert_eq!(::Currency::total_balance(&addr), min_balance); + assert_eq!(get_contract(&addr).total_deposit(), info_deposit); + assert_eq!(::Currency::total_balance(&addr), info_deposit + min_balance); // Create 1 byte of storage with a price of per byte, // setting insufficient deposit limit, as it requires 3 Balance: @@ -4991,12 +4973,11 @@ fn deposit_limit_in_nested_instantiate() { #[test] fn deposit_limit_honors_liquidity_restrictions() { let (wasm, _code_hash) = compile_module::("store_call").unwrap(); - const ED: u64 = 200; - ExtBuilder::default().existential_deposit(ED).build().execute_with(|| { + ExtBuilder::default().existential_deposit(200).build().execute_with(|| { let bobs_balance = 1_000; let _ = ::Currency::set_balance(&ALICE, 1_000_000); let _ = ::Currency::set_balance(&BOB, bobs_balance); - let min_balance = ::Currency::minimum_balance(); + let min_balance = Contracts::min_balance(); // Instantiate the BOB contract. let addr = Contracts::bare_instantiate( @@ -5014,15 +4995,16 @@ fn deposit_limit_honors_liquidity_restrictions() { .unwrap() .account_id; + let info_deposit = test_utils::contract_info_storage_deposit(&addr); // Check that the contract has been instantiated and has the minimum balance - assert_eq!(get_contract(&addr).total_deposit(), min_balance); - assert_eq!(::Currency::total_balance(&addr), min_balance); + assert_eq!(get_contract(&addr).total_deposit(), info_deposit); + assert_eq!(::Currency::total_balance(&addr), info_deposit + min_balance); // check that the hold is honored ::Currency::hold( &HoldReason::CodeUploadDepositReserve.into(), &BOB, - bobs_balance - ED, + bobs_balance - min_balance, ) .unwrap(); assert_err_ignore_postinfo!( @@ -5036,7 +5018,7 @@ fn deposit_limit_honors_liquidity_restrictions() { ), >::StorageDepositNotEnoughFunds, ); - assert_eq!(::Currency::free_balance(&BOB), ED); + assert_eq!(::Currency::free_balance(&BOB), min_balance); }); } @@ -5046,7 +5028,7 @@ fn deposit_limit_honors_existential_deposit() { ExtBuilder::default().existential_deposit(200).build().execute_with(|| { let _ = ::Currency::set_balance(&ALICE, 1_000_000); let _ = ::Currency::set_balance(&BOB, 1_000); - let min_balance = ::Currency::minimum_balance(); + let min_balance = Contracts::min_balance(); // Instantiate the BOB contract. let addr = Contracts::bare_instantiate( @@ -5064,9 +5046,11 @@ fn deposit_limit_honors_existential_deposit() { .unwrap() .account_id; + let info_deposit = test_utils::contract_info_storage_deposit(&addr); + // Check that the contract has been instantiated and has the minimum balance - assert_eq!(get_contract(&addr).total_deposit(), min_balance); - assert_eq!(::Currency::total_balance(&addr), min_balance); + assert_eq!(get_contract(&addr).total_deposit(), info_deposit); + assert_eq!(::Currency::total_balance(&addr), min_balance + info_deposit); // check that the deposit can't bring the account below the existential deposit assert_err_ignore_postinfo!( @@ -5090,7 +5074,7 @@ fn deposit_limit_honors_min_leftover() { ExtBuilder::default().existential_deposit(200).build().execute_with(|| { let _ = ::Currency::set_balance(&ALICE, 1_000_000); let _ = ::Currency::set_balance(&BOB, 1_000); - let min_balance = ::Currency::minimum_balance(); + let min_balance = Contracts::min_balance(); // Instantiate the BOB contract. let addr = Contracts::bare_instantiate( @@ -5108,9 +5092,12 @@ fn deposit_limit_honors_min_leftover() { .unwrap() .account_id; - // Check that the contract has been instantiated and has the minimum balance - assert_eq!(get_contract(&addr).total_deposit(), min_balance); - assert_eq!(::Currency::total_balance(&addr), min_balance); + let info_deposit = test_utils::contract_info_storage_deposit(&addr); + + // Check that the contract has been instantiated and has the minimum balance and the storage + // deposit + assert_eq!(get_contract(&addr).total_deposit(), info_deposit); + assert_eq!(::Currency::total_balance(&addr), info_deposit + min_balance); // check that the minimum leftover (value send) is considered assert_err_ignore_postinfo!( @@ -5450,7 +5437,13 @@ fn add_remove_delegate_dependency_works() { let dependency_deposit = &CodeHashLockupDepositPercent::get().mul_ceil(deposit); assert_eq!(contract.delegate_dependencies().get(&code_hash), Some(dependency_deposit)); - assert_eq!(test_utils::get_balance(contract.deposit_account()), ED + dependency_deposit); + assert_eq!( + test_utils::get_balance_on_hold( + &HoldReason::StorageDepositReserve.into(), + &addr_caller + ), + dependency_deposit + contract.storage_base_deposit() - ED + ); // Removing the code should fail, since we have added a dependency. assert_err!( @@ -5483,7 +5476,13 @@ fn add_remove_delegate_dependency_works() { // Dependency should be removed, and deposit should be returned. let contract = test_utils::get_contract(&addr_caller); assert!(contract.delegate_dependencies().is_empty()); - assert_eq!(test_utils::get_balance(contract.deposit_account()), ED); + assert_eq!( + test_utils::get_balance_on_hold( + &HoldReason::StorageDepositReserve.into(), + &addr_caller + ), + contract.storage_base_deposit() - ED + ); // Removing an unexisting dependency should fail. assert_err!( @@ -5512,7 +5511,10 @@ fn add_remove_delegate_dependency_works() { // Call terminate should work, and return the deposit. let balance_before = test_utils::get_balance(&ALICE); assert_ok!(call(&addr_caller, &terminate_input).result); - assert_eq!(test_utils::get_balance(&ALICE), balance_before + 2 * ED + dependency_deposit); + assert_eq!( + test_utils::get_balance(&ALICE), + balance_before + contract.storage_base_deposit() + dependency_deposit + ); // Terminate should also remove the dependency, so we can remove the code. assert_ok!(Contracts::remove_code(RuntimeOrigin::signed(ALICE), code_hash)); @@ -5536,8 +5538,6 @@ fn native_dependency_deposit_works() { ExtBuilder::default().existential_deposit(ED).build().execute_with(|| { let _ = Balances::set_balance(&ALICE, 1_000_000); let lockup_deposit_percent = CodeHashLockupDepositPercent::get(); - let per_byte = DepositPerByte::get(); - let per_item = DepositPerItem::get(); // Upload the dummy contract, Contracts::upload_code( @@ -5577,14 +5577,12 @@ fn native_dependency_deposit_works() { ); let addr = res.result.unwrap().account_id; - let info = ContractInfoOf::::get(&addr).unwrap(); - let info_len = info.encoded_size() as u64; - let base_deposit = ED + per_byte * info_len + per_item * 1; + let base_deposit = ED + test_utils::contract_info_storage_deposit(&addr); let upload_deposit = test_utils::get_code_deposit(&code_hash); let extra_deposit = add_upload_deposit.then(|| upload_deposit).unwrap_or_default(); // Check initial storage_deposit - // The base deposit should be: ED + info_len * per_byte + 1 * per_item + 30% * deposit + // The base deposit should be: ED + contract_info_storage_deposit + 30% * deposit let deposit = extra_deposit + base_deposit + lockup_deposit_percent.mul_ceil(upload_deposit); @@ -5609,7 +5607,10 @@ fn native_dependency_deposit_works() { let code_deposit = test_utils::get_code_deposit(&dummy_code_hash); let deposit = base_deposit + lockup_deposit_percent.mul_ceil(code_deposit); assert_eq!(test_utils::get_contract(&addr).storage_base_deposit(), deposit); - assert_eq!(test_utils::get_balance(&info.deposit_account()), deposit - ED); + assert_eq!( + test_utils::get_balance_on_hold(&HoldReason::StorageDepositReserve.into(), &addr), + deposit - ED + ); }); } } diff --git a/frame/contracts/src/weights.rs b/frame/contracts/src/weights.rs index d8f873b0615be..34bea8ff0a30f 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-07-25, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-08-07, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` //! HOSTNAME: `runner-ynta1nyy-project-145-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz` //! EXECUTION: ``, WASM-EXECUTION: `Compiled`, CHAIN: `Some("dev")`, DB CACHE: `1024` @@ -57,6 +57,7 @@ pub trait WeightInfo { fn v12_migration_step(c: u32, ) -> Weight; fn v13_migration_step() -> Weight; fn v14_migration_step() -> Weight; + fn v15_migration_step() -> Weight; fn migration_noop() -> Weight; fn migrate() -> Weight; fn on_runtime_upgrade_noop() -> Weight; @@ -140,8 +141,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `142` // Estimated: `1627` - // Minimum execution time: 2_527_000 picoseconds. - Weight::from_parts(2_651_000, 1627) + // Minimum execution time: 2_410_000 picoseconds. + Weight::from_parts(2_581_000, 1627) .saturating_add(T::DbWeight::get().reads(1_u64)) } /// Storage: `Skipped::Metadata` (r:0 w:0) @@ -151,10 +152,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `451 + k * (69 ±0)` // Estimated: `441 + k * (70 ±0)` - // Minimum execution time: 13_291_000 picoseconds. - Weight::from_parts(13_825_000, 441) - // Standard Error: 1_137 - .saturating_add(Weight::from_parts(1_244_309, 0).saturating_mul(k.into())) + // Minimum execution time: 13_278_000 picoseconds. + Weight::from_parts(13_944_000, 441) + // Standard Error: 1_643 + .saturating_add(Weight::from_parts(1_194_404, 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)) @@ -168,25 +169,25 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `211 + c * (1 ±0)` // Estimated: `6149 + c * (1 ±0)` - // Minimum execution time: 8_359_000 picoseconds. - Weight::from_parts(9_179_121, 6149) + // Minimum execution time: 8_533_000 picoseconds. + Weight::from_parts(9_141_899, 6149) // Standard Error: 1 - .saturating_add(Weight::from_parts(1_312, 0).saturating_mul(c.into())) + .saturating_add(Weight::from_parts(1_327, 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:3 w:1) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Storage: `Contracts::ContractInfoOf` (r:2 w:1) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, 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: `709` - // Estimated: `9124` - // Minimum execution time: 42_457_000 picoseconds. - Weight::from_parts(44_556_000, 9124) - .saturating_add(T::DbWeight::get().reads(4_u64)) + // Measured: `510` + // Estimated: `6450` + // Minimum execution time: 16_998_000 picoseconds. + Weight::from_parts(17_776_000, 6450) + .saturating_add(T::DbWeight::get().reads(3_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } /// Storage: `Contracts::DeletionQueue` (r:1 w:1025) @@ -198,10 +199,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `171 + k * (1 ±0)` // Estimated: `3635 + k * (1 ±0)` - // Minimum execution time: 3_839_000 picoseconds. - Weight::from_parts(3_462_337, 3635) - // Standard Error: 1_384 - .saturating_add(Weight::from_parts(1_166_522, 0).saturating_mul(k.into())) + // Minimum execution time: 3_919_000 picoseconds. + Weight::from_parts(4_057_153, 3635) + // Standard Error: 1_252 + .saturating_add(Weight::from_parts(1_151_419, 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()))) @@ -220,38 +221,52 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `325 + c * (1 ±0)` // Estimated: `6263 + c * (1 ±0)` - // Minimum execution time: 17_001_000 picoseconds. - Weight::from_parts(17_095_380, 6263) + // Minimum execution time: 17_730_000 picoseconds. + Weight::from_parts(17_540_884, 6263) // Standard Error: 1 - .saturating_add(Weight::from_parts(411, 0).saturating_mul(c.into())) + .saturating_add(Weight::from_parts(417, 0).saturating_mul(c.into())) .saturating_add(T::DbWeight::get().reads(4_u64)) .saturating_add(T::DbWeight::get().writes(2_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(c.into())) } - /// Storage: `Contracts::ContractInfoOf` (r:3 w:1) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Storage: `Contracts::ContractInfoOf` (r:2 w:1) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) fn v13_migration_step() -> Weight { // Proof Size summary in bytes: - // Measured: `639` - // Estimated: `9054` - // Minimum execution time: 35_342_000 picoseconds. - Weight::from_parts(36_839_000, 9054) - .saturating_add(T::DbWeight::get().reads(3_u64)) + // Measured: `440` + // Estimated: `6380` + // Minimum execution time: 13_089_000 picoseconds. + Weight::from_parts(13_727_000, 6380) + .saturating_add(T::DbWeight::get().reads(2_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: `Contracts::CodeInfoOf` (r:2 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) - /// Storage: `System::Account` (r:1 w:0) + /// Storage: `System::Account` (r:1 w:1) /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`) + /// Storage: `Balances::Holds` (r:1 w:0) + /// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(85), added: 2560, mode: `Measured`) fn v14_migration_step() -> Weight { // Proof Size summary in bytes: - // Measured: `260` - // Estimated: `6200` - // Minimum execution time: 27_995_000 picoseconds. - Weight::from_parts(28_661_000, 6200) - .saturating_add(T::DbWeight::get().reads(3_u64)) + // Measured: `360` + // Estimated: `6300` + // Minimum execution time: 49_083_000 picoseconds. + Weight::from_parts(50_462_000, 6300) + .saturating_add(T::DbWeight::get().reads(4_u64)) + .saturating_add(T::DbWeight::get().writes(1_u64)) + } + /// Storage: `Contracts::ContractInfoOf` (r:2 w:1) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) + /// Storage: `System::Account` (r:2 w:1) + /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`) + fn v15_migration_step() -> Weight { + // Proof Size summary in bytes: + // Measured: `594` + // Estimated: `6534` + // Minimum execution time: 49_299_000 picoseconds. + Weight::from_parts(50_805_000, 6534) + .saturating_add(T::DbWeight::get().reads(4_u64)) + .saturating_add(T::DbWeight::get().writes(2_u64)) } /// Storage: `Contracts::MigrationInProgress` (r:1 w:1) /// Proof: `Contracts::MigrationInProgress` (`max_values`: Some(1), `max_size`: Some(1026), added: 1521, mode: `Measured`) @@ -259,8 +274,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `142` // Estimated: `1627` - // Minimum execution time: 3_272_000 picoseconds. - Weight::from_parts(3_553_000, 1627) + // Minimum execution time: 3_305_000 picoseconds. + Weight::from_parts(3_489_000, 1627) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -272,8 +287,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `166` // Estimated: `3631` - // Minimum execution time: 12_788_000 picoseconds. - Weight::from_parts(13_163_000, 3631) + // Minimum execution time: 12_657_000 picoseconds. + Weight::from_parts(13_100_000, 3631) .saturating_add(T::DbWeight::get().reads(2_u64)) .saturating_add(T::DbWeight::get().writes(2_u64)) } @@ -283,8 +298,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `142` // Estimated: `3607` - // Minimum execution time: 4_794_000 picoseconds. - Weight::from_parts(5_086_000, 3607) + // Minimum execution time: 4_784_000 picoseconds. + Weight::from_parts(4_994_000, 3607) .saturating_add(T::DbWeight::get().reads(1_u64)) } /// Storage: UNKNOWN KEY `0x4342193e496fab7ec59d615ed0dc55304e7b9012096b41c4eb3aaf947f6ea429` (r:1 w:0) @@ -295,8 +310,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `167` // Estimated: `3632` - // Minimum execution time: 6_616_000 picoseconds. - Weight::from_parts(7_034_000, 3632) + // Minimum execution time: 6_762_000 picoseconds. + Weight::from_parts(6_945_000, 3632) .saturating_add(T::DbWeight::get().reads(2_u64)) } /// Storage: UNKNOWN KEY `0x4342193e496fab7ec59d615ed0dc55304e7b9012096b41c4eb3aaf947f6ea429` (r:1 w:0) @@ -307,15 +322,15 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `142` // Estimated: `3607` - // Minimum execution time: 6_985_000 picoseconds. - Weight::from_parts(7_477_000, 3607) + // Minimum execution time: 6_999_000 picoseconds. + Weight::from_parts(7_372_000, 3607) .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(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1 w:0) @@ -329,12 +344,12 @@ impl WeightInfo for SubstrateWeight { /// The range of component `c` is `[0, 125952]`. fn call_with_code_per_byte(c: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `783` - // Estimated: `6732 + c * (1 ±0)` - // Minimum execution time: 306_088_000 picoseconds. - Weight::from_parts(268_361_911, 6732) - // Standard Error: 76 - .saturating_add(Weight::from_parts(38_334, 0).saturating_mul(c.into())) + // Measured: `759` + // Estimated: `6710 + c * (1 ±0)` + // Minimum execution time: 304_121_000 picoseconds. + Weight::from_parts(288_627_840, 6710) + // Standard Error: 83 + .saturating_add(Weight::from_parts(37_343, 0).saturating_mul(c.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(c.into())) @@ -343,15 +358,17 @@ impl WeightInfo for SubstrateWeight { /// Proof: `Contracts::MigrationInProgress` (`max_values`: Some(1), `max_size`: Some(1026), added: 1521, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:1) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) + /// Storage: `Balances::Holds` (r:2 w:2) + /// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(85), added: 2560, mode: `Measured`) /// Storage: `System::EventTopics` (r:3 w:3) /// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `Contracts::Nonce` (r:1 w:1) /// Proof: `Contracts::Nonce` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`) /// Storage: `Contracts::ContractInfoOf` (r:1 w:1) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Timestamp::Now` (r:1 w:0) /// Proof: `Timestamp::Now` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`) - /// Storage: `System::Account` (r:2 w:2) + /// Storage: `System::Account` (r:1 w:1) /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:0 w:1) /// Proof: `Contracts::PristineCode` (`max_values`: None, `max_size`: Some(125988), added: 128463, mode: `Measured`) @@ -360,18 +377,18 @@ impl WeightInfo for SubstrateWeight { /// The range of component `s` is `[0, 1048576]`. fn instantiate_with_code(c: u32, i: u32, s: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `303` - // Estimated: `8745` - // Minimum execution time: 4_224_657_000 picoseconds. - Weight::from_parts(451_557_864, 8745) - // Standard Error: 216 - .saturating_add(Weight::from_parts(111_761, 0).saturating_mul(c.into())) - // Standard Error: 26 - .saturating_add(Weight::from_parts(1_794, 0).saturating_mul(i.into())) - // Standard Error: 26 - .saturating_add(Weight::from_parts(2_013, 0).saturating_mul(s.into())) - .saturating_add(T::DbWeight::get().reads(10_u64)) - .saturating_add(T::DbWeight::get().writes(9_u64)) + // Measured: `290` + // Estimated: `8714` + // Minimum execution time: 4_101_589_000 picoseconds. + Weight::from_parts(694_193_047, 8714) + // Standard Error: 334 + .saturating_add(Weight::from_parts(108_847, 0).saturating_mul(c.into())) + // Standard Error: 40 + .saturating_add(Weight::from_parts(1_677, 0).saturating_mul(i.into())) + // Standard Error: 40 + .saturating_add(Weight::from_parts(1_783, 0).saturating_mul(s.into())) + .saturating_add(T::DbWeight::get().reads(11_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`) @@ -382,11 +399,13 @@ impl WeightInfo for SubstrateWeight { /// Storage: `Contracts::Nonce` (r:1 w:1) /// Proof: `Contracts::Nonce` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`) /// Storage: `Contracts::ContractInfoOf` (r:1 w:1) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Timestamp::Now` (r:1 w:0) /// Proof: `Timestamp::Now` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`) - /// Storage: `System::Account` (r:2 w:2) + /// Storage: `System::Account` (r:1 w:1) /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`) + /// Storage: `Balances::Holds` (r:1 w:1) + /// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(85), added: 2560, mode: `Measured`) /// Storage: `System::EventTopics` (r:2 w:2) /// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`) /// The range of component `i` is `[0, 1048576]`. @@ -394,20 +413,20 @@ impl WeightInfo for SubstrateWeight { fn instantiate(i: u32, s: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `527` - // Estimated: `6517` - // Minimum execution time: 2_029_313_000 picoseconds. - Weight::from_parts(353_077_600, 6517) - // Standard Error: 8 - .saturating_add(Weight::from_parts(1_781, 0).saturating_mul(i.into())) - // Standard Error: 8 - .saturating_add(Weight::from_parts(1_729, 0).saturating_mul(s.into())) + // Estimated: `6471` + // Minimum execution time: 2_011_580_000 picoseconds. + Weight::from_parts(397_415_227, 6471) + // Standard Error: 10 + .saturating_add(Weight::from_parts(1_689, 0).saturating_mul(i.into())) + // Standard Error: 10 + .saturating_add(Weight::from_parts(1_679, 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(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1 w:0) @@ -420,10 +439,10 @@ impl WeightInfo for SubstrateWeight { /// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`) fn call() -> Weight { // Proof Size summary in bytes: - // Measured: `817` - // Estimated: `6757` - // Minimum execution time: 204_086_000 picoseconds. - Weight::from_parts(216_738_000, 6757) + // Measured: `793` + // Estimated: `6733` + // Minimum execution time: 204_975_000 picoseconds. + Weight::from_parts(214_770_000, 6733) .saturating_add(T::DbWeight::get().reads(8_u64)) .saturating_add(T::DbWeight::get().writes(4_u64)) } @@ -431,6 +450,8 @@ impl WeightInfo for SubstrateWeight { /// Proof: `Contracts::MigrationInProgress` (`max_values`: Some(1), `max_size`: Some(1026), added: 1521, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:1) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) + /// Storage: `Balances::Holds` (r:1 w:1) + /// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(85), added: 2560, mode: `Measured`) /// Storage: `System::EventTopics` (r:1 w:1) /// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:0 w:1) @@ -440,44 +461,46 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `142` // Estimated: `3607` - // Minimum execution time: 269_337_000 picoseconds. - Weight::from_parts(220_186_006, 3607) - // Standard Error: 106 - .saturating_add(Weight::from_parts(74_291, 0).saturating_mul(c.into())) - .saturating_add(T::DbWeight::get().reads(3_u64)) - .saturating_add(T::DbWeight::get().writes(3_u64)) + // Minimum execution time: 269_545_000 picoseconds. + Weight::from_parts(256_054_650, 3607) + // Standard Error: 91 + .saturating_add(Weight::from_parts(72_743, 0).saturating_mul(c.into())) + .saturating_add(T::DbWeight::get().reads(4_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::CodeInfoOf` (r:1 w:1) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) + /// Storage: `Balances::Holds` (r:1 w:1) + /// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(85), added: 2560, mode: `Measured`) /// Storage: `System::EventTopics` (r:1 w:1) /// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:0 w:1) /// Proof: `Contracts::PristineCode` (`max_values`: None, `max_size`: Some(125988), added: 128463, mode: `Measured`) fn remove_code() -> Weight { // Proof Size summary in bytes: - // Measured: `259` - // Estimated: `3724` - // Minimum execution time: 35_127_000 picoseconds. - Weight::from_parts(36_180_000, 3724) - .saturating_add(T::DbWeight::get().reads(3_u64)) - .saturating_add(T::DbWeight::get().writes(3_u64)) + // Measured: `315` + // Estimated: `3780` + // Minimum execution time: 47_880_000 picoseconds. + Weight::from_parts(49_427_000, 3780) + .saturating_add(T::DbWeight::get().reads(4_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(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:2 w:2) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `System::EventTopics` (r:3 w:3) /// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`) fn set_code() -> Weight { // Proof Size summary in bytes: - // Measured: `576` - // Estimated: `8991` - // Minimum execution time: 37_550_000 picoseconds. - Weight::from_parts(39_149_000, 8991) + // Measured: `552` + // Estimated: `8967` + // Minimum execution time: 37_898_000 picoseconds. + Weight::from_parts(39_826_000, 8967) .saturating_add(T::DbWeight::get().reads(7_u64)) .saturating_add(T::DbWeight::get().writes(6_u64)) } @@ -486,7 +509,7 @@ impl WeightInfo for SubstrateWeight { /// 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) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1 w:0) @@ -498,12 +521,12 @@ impl WeightInfo for SubstrateWeight { /// The range of component `r` is `[0, 1600]`. fn seal_caller(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `857 + r * (6 ±0)` - // Estimated: `6798 + r * (6 ±0)` - // Minimum execution time: 269_991_000 picoseconds. - Weight::from_parts(293_993_592, 6798) - // Standard Error: 665 - .saturating_add(Weight::from_parts(343_796, 0).saturating_mul(r.into())) + // Measured: `833 + r * (6 ±0)` + // Estimated: `6773 + r * (6 ±0)` + // Minimum execution time: 260_916_000 picoseconds. + Weight::from_parts(295_521_846, 6773) + // Standard Error: 1_126 + .saturating_add(Weight::from_parts(348_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, 6).saturating_mul(r.into())) @@ -513,7 +536,7 @@ impl WeightInfo for SubstrateWeight { /// 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) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1 w:0) @@ -525,23 +548,23 @@ impl WeightInfo for SubstrateWeight { /// The range of component `r` is `[0, 1600]`. fn seal_is_contract(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `924 + r * (232 ±0)` - // Estimated: `6831 + r * (2707 ±0)` - // Minimum execution time: 274_151_000 picoseconds. - Weight::from_parts(83_529_206, 6831) - // Standard Error: 8_452 - .saturating_add(Weight::from_parts(3_534_024, 0).saturating_mul(r.into())) + // Measured: `889 + r * (209 ±0)` + // Estimated: `6793 + r * (2684 ±0)` + // Minimum execution time: 274_335_000 picoseconds. + Weight::from_parts(132_998_512, 6793) + // Standard Error: 7_396 + .saturating_add(Weight::from_parts(3_602_287, 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(3_u64)) - .saturating_add(Weight::from_parts(0, 2707).saturating_mul(r.into())) + .saturating_add(Weight::from_parts(0, 2684).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) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1 w:0) @@ -553,23 +576,23 @@ impl WeightInfo for SubstrateWeight { /// The range of component `r` is `[0, 1600]`. fn seal_code_hash(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `910 + r * (236 ±0)` - // Estimated: `6835 + r * (2711 ±0)` - // Minimum execution time: 276_689_000 picoseconds. - Weight::from_parts(110_268_281, 6835) - // Standard Error: 8_106 - .saturating_add(Weight::from_parts(4_376_136, 0).saturating_mul(r.into())) + // Measured: `888 + r * (213 ±0)` + // Estimated: `6797 + r * (2688 ±0)` + // Minimum execution time: 272_514_000 picoseconds. + Weight::from_parts(104_825_618, 6797) + // Standard Error: 10_038 + .saturating_add(Weight::from_parts(4_520_258, 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(3_u64)) - .saturating_add(Weight::from_parts(0, 2711).saturating_mul(r.into())) + .saturating_add(Weight::from_parts(0, 2688).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) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1 w:0) @@ -581,12 +604,12 @@ impl WeightInfo for SubstrateWeight { /// The range of component `r` is `[0, 1600]`. fn seal_own_code_hash(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `864 + r * (6 ±0)` - // Estimated: `6806 + r * (6 ±0)` - // Minimum execution time: 274_079_000 picoseconds. - Weight::from_parts(282_258_090, 6806) - // Standard Error: 1_343 - .saturating_add(Weight::from_parts(464_680, 0).saturating_mul(r.into())) + // Measured: `840 + r * (6 ±0)` + // Estimated: `6782 + r * (6 ±0)` + // Minimum execution time: 264_593_000 picoseconds. + Weight::from_parts(294_139_363, 6782) + // Standard Error: 907 + .saturating_add(Weight::from_parts(432_964, 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())) @@ -596,7 +619,7 @@ impl WeightInfo for SubstrateWeight { /// 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) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1 w:0) @@ -608,12 +631,12 @@ impl WeightInfo for SubstrateWeight { /// The range of component `r` is `[0, 1600]`. fn seal_caller_is_origin(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `854 + r * (3 ±0)` - // Estimated: `6799 + r * (3 ±0)` - // Minimum execution time: 270_960_000 picoseconds. - Weight::from_parts(281_985_584, 6799) - // Standard Error: 378 - .saturating_add(Weight::from_parts(184_462, 0).saturating_mul(r.into())) + // Measured: `830 + r * (3 ±0)` + // Estimated: `6771 + r * (3 ±0)` + // Minimum execution time: 260_412_000 picoseconds. + Weight::from_parts(284_371_703, 6771) + // Standard Error: 433 + .saturating_add(Weight::from_parts(182_952, 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, 3).saturating_mul(r.into())) @@ -621,7 +644,7 @@ impl WeightInfo for SubstrateWeight { /// 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(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1 w:0) @@ -633,12 +656,12 @@ impl WeightInfo for SubstrateWeight { /// The range of component `r` is `[0, 1600]`. fn seal_caller_is_root(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `744 + r * (3 ±0)` - // Estimated: `6684 + r * (3 ±0)` - // Minimum execution time: 244_835_000 picoseconds. - Weight::from_parts(270_660_753, 6684) - // Standard Error: 390 - .saturating_add(Weight::from_parts(164_232, 0).saturating_mul(r.into())) + // Measured: `720 + r * (3 ±0)` + // Estimated: `6660 + r * (3 ±0)` + // Minimum execution time: 255_112_000 picoseconds. + Weight::from_parts(273_052_488, 6660) + // Standard Error: 376 + .saturating_add(Weight::from_parts(166_644, 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())) @@ -648,7 +671,7 @@ impl WeightInfo for SubstrateWeight { /// 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) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1 w:0) @@ -660,12 +683,12 @@ impl WeightInfo for SubstrateWeight { /// The range of component `r` is `[0, 1600]`. fn seal_address(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `858 + r * (6 ±0)` - // Estimated: `6800 + r * (6 ±0)` - // Minimum execution time: 273_269_000 picoseconds. - Weight::from_parts(274_468_168, 6800) - // Standard Error: 2_246 - .saturating_add(Weight::from_parts(386_838, 0).saturating_mul(r.into())) + // Measured: `834 + r * (6 ±0)` + // Estimated: `6774 + r * (6 ±0)` + // Minimum execution time: 270_426_000 picoseconds. + Weight::from_parts(289_240_775, 6774) + // Standard Error: 748 + .saturating_add(Weight::from_parts(344_791, 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())) @@ -675,7 +698,7 @@ impl WeightInfo for SubstrateWeight { /// 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) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1 w:0) @@ -687,12 +710,12 @@ impl WeightInfo for SubstrateWeight { /// The range of component `r` is `[0, 1600]`. fn seal_gas_left(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `854 + r * (6 ±0)` - // Estimated: `6795 + r * (6 ±0)` - // Minimum execution time: 275_244_000 picoseconds. - Weight::from_parts(281_299_739, 6795) - // Standard Error: 2_890 - .saturating_add(Weight::from_parts(600_498, 0).saturating_mul(r.into())) + // Measured: `830 + r * (6 ±0)` + // Estimated: `6773 + r * (6 ±0)` + // Minimum execution time: 260_217_000 picoseconds. + Weight::from_parts(288_660_978, 6773) + // Standard Error: 1_199 + .saturating_add(Weight::from_parts(550_304, 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())) @@ -702,7 +725,7 @@ impl WeightInfo for SubstrateWeight { /// 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) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1 w:0) @@ -714,12 +737,12 @@ impl WeightInfo for SubstrateWeight { /// The range of component `r` is `[0, 1600]`. fn seal_balance(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `998 + r * (6 ±0)` - // Estimated: `6922 + r * (6 ±0)` - // Minimum execution time: 271_540_000 picoseconds. - Weight::from_parts(298_456_935, 6922) - // Standard Error: 2_881 - .saturating_add(Weight::from_parts(1_719_337, 0).saturating_mul(r.into())) + // Measured: `974 + r * (6 ±0)` + // Estimated: `6898 + r * (6 ±0)` + // Minimum execution time: 273_473_000 picoseconds. + Weight::from_parts(298_889_279, 6898) + // Standard Error: 4_604 + .saturating_add(Weight::from_parts(1_630_175, 0).saturating_mul(r.into())) .saturating_add(T::DbWeight::get().reads(9_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) .saturating_add(Weight::from_parts(0, 6).saturating_mul(r.into())) @@ -729,7 +752,7 @@ impl WeightInfo for SubstrateWeight { /// 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) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1 w:0) @@ -741,12 +764,12 @@ impl WeightInfo for SubstrateWeight { /// The range of component `r` is `[0, 1600]`. fn seal_value_transferred(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `868 + r * (6 ±0)` - // Estimated: `6817 + r * (6 ±0)` - // Minimum execution time: 274_832_000 picoseconds. - Weight::from_parts(286_078_648, 6817) - // Standard Error: 695 - .saturating_add(Weight::from_parts(345_045, 0).saturating_mul(r.into())) + // Measured: `844 + r * (6 ±0)` + // Estimated: `6790 + r * (6 ±0)` + // Minimum execution time: 262_033_000 picoseconds. + Weight::from_parts(284_293_851, 6790) + // Standard Error: 591 + .saturating_add(Weight::from_parts(369_240, 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())) @@ -756,7 +779,7 @@ impl WeightInfo for SubstrateWeight { /// 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) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1 w:0) @@ -768,12 +791,12 @@ impl WeightInfo for SubstrateWeight { /// The range of component `r` is `[0, 1600]`. fn seal_minimum_balance(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `866 + r * (6 ±0)` - // Estimated: `6815 + r * (6 ±0)` - // Minimum execution time: 267_337_000 picoseconds. - Weight::from_parts(283_693_170, 6815) - // Standard Error: 580 - .saturating_add(Weight::from_parts(345_350, 0).saturating_mul(r.into())) + // Measured: `842 + r * (6 ±0)` + // Estimated: `6783 + r * (6 ±0)` + // Minimum execution time: 274_568_000 picoseconds. + Weight::from_parts(294_688_466, 6783) + // Standard Error: 768 + .saturating_add(Weight::from_parts(349_584, 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())) @@ -783,7 +806,7 @@ impl WeightInfo for SubstrateWeight { /// 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) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1 w:0) @@ -795,12 +818,12 @@ impl WeightInfo for SubstrateWeight { /// The range of component `r` is `[0, 1600]`. fn seal_block_number(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `863 + r * (6 ±0)` - // Estimated: `6813 + r * (6 ±0)` - // Minimum execution time: 276_313_000 picoseconds. - Weight::from_parts(287_689_703, 6813) - // Standard Error: 1_251 - .saturating_add(Weight::from_parts(342_536, 0).saturating_mul(r.into())) + // Measured: `839 + r * (6 ±0)` + // Estimated: `6786 + r * (6 ±0)` + // Minimum execution time: 264_061_000 picoseconds. + Weight::from_parts(287_964_188, 6786) + // Standard Error: 490 + .saturating_add(Weight::from_parts(356_273, 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())) @@ -810,7 +833,7 @@ impl WeightInfo for SubstrateWeight { /// 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) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1 w:0) @@ -822,12 +845,12 @@ impl WeightInfo for SubstrateWeight { /// The range of component `r` is `[0, 1600]`. fn seal_now(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `854 + r * (6 ±0)` - // Estimated: `6799 + r * (6 ±0)` - // Minimum execution time: 274_196_000 picoseconds. - Weight::from_parts(288_641_687, 6799) - // Standard Error: 530 - .saturating_add(Weight::from_parts(336_194, 0).saturating_mul(r.into())) + // Measured: `830 + r * (6 ±0)` + // Estimated: `6771 + r * (6 ±0)` + // Minimum execution time: 275_707_000 picoseconds. + Weight::from_parts(290_797_828, 6771) + // Standard Error: 967 + .saturating_add(Weight::from_parts(352_839, 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())) @@ -837,7 +860,7 @@ impl WeightInfo for SubstrateWeight { /// 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) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1 w:0) @@ -851,12 +874,12 @@ impl WeightInfo for SubstrateWeight { /// The range of component `r` is `[0, 1600]`. fn seal_weight_to_fee(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `928 + r * (14 ±0)` - // Estimated: `6861 + r * (14 ±0)` - // Minimum execution time: 254_997_000 picoseconds. - Weight::from_parts(292_260_891, 6861) - // Standard Error: 1_019 - .saturating_add(Weight::from_parts(1_447_021, 0).saturating_mul(r.into())) + // Measured: `904 + r * (14 ±0)` + // Estimated: `6839 + r * (14 ±0)` + // Minimum execution time: 272_492_000 picoseconds. + Weight::from_parts(295_010_878, 6839) + // Standard Error: 2_549 + .saturating_add(Weight::from_parts(1_426_715, 0).saturating_mul(r.into())) .saturating_add(T::DbWeight::get().reads(9_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) .saturating_add(Weight::from_parts(0, 14).saturating_mul(r.into())) @@ -866,7 +889,7 @@ impl WeightInfo for SubstrateWeight { /// 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) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1 w:0) @@ -878,12 +901,12 @@ impl WeightInfo for SubstrateWeight { /// The range of component `r` is `[0, 1600]`. fn seal_input(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `856 + r * (6 ±0)` - // Estimated: `6800 + r * (6 ±0)` - // Minimum execution time: 272_720_000 picoseconds. - Weight::from_parts(287_125_181, 6800) - // Standard Error: 491 - .saturating_add(Weight::from_parts(294_488, 0).saturating_mul(r.into())) + // Measured: `832 + r * (6 ±0)` + // Estimated: `6774 + r * (6 ±0)` + // Minimum execution time: 257_981_000 picoseconds. + Weight::from_parts(285_824_773, 6774) + // Standard Error: 704 + .saturating_add(Weight::from_parts(301_327, 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())) @@ -893,7 +916,7 @@ impl WeightInfo for SubstrateWeight { /// 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) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1 w:0) @@ -905,12 +928,12 @@ impl WeightInfo for SubstrateWeight { /// The range of component `n` is `[0, 1048576]`. fn seal_input_per_byte(n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `860` - // Estimated: `6800` - // Minimum execution time: 280_665_000 picoseconds. - Weight::from_parts(233_022_448, 6800) - // Standard Error: 23 - .saturating_add(Weight::from_parts(996, 0).saturating_mul(n.into())) + // Measured: `836` + // Estimated: `6776` + // Minimum execution time: 259_470_000 picoseconds. + Weight::from_parts(232_759_442, 6776) + // Standard Error: 24 + .saturating_add(Weight::from_parts(981, 0).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads(8_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) } @@ -919,7 +942,7 @@ impl WeightInfo for SubstrateWeight { /// 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) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1 w:0) @@ -931,12 +954,12 @@ impl WeightInfo for SubstrateWeight { /// The range of component `r` is `[0, 1]`. fn seal_return(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `844 + r * (45 ±0)` - // Estimated: `6784 + r * (45 ±0)` - // Minimum execution time: 250_335_000 picoseconds. - Weight::from_parts(278_774_071, 6784) - // Standard Error: 873_509 - .saturating_add(Weight::from_parts(4_562_628, 0).saturating_mul(r.into())) + // Measured: `820 + r * (45 ±0)` + // Estimated: `6760 + r * (45 ±0)` + // Minimum execution time: 252_740_000 picoseconds. + Weight::from_parts(278_155_436, 6760) + // Standard Error: 882_420 + .saturating_add(Weight::from_parts(755_063, 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, 45).saturating_mul(r.into())) @@ -946,7 +969,7 @@ impl WeightInfo for SubstrateWeight { /// 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) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1 w:0) @@ -958,21 +981,21 @@ impl WeightInfo for SubstrateWeight { /// The range of component `n` is `[0, 1048576]`. fn seal_return_per_byte(n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `854` - // Estimated: `6807` - // Minimum execution time: 278_402_000 picoseconds. - Weight::from_parts(285_491_021, 6807) - // Standard Error: 0 - .saturating_add(Weight::from_parts(312, 0).saturating_mul(n.into())) + // Measured: `830` + // Estimated: `6777` + // Minimum execution time: 257_318_000 picoseconds. + Weight::from_parts(285_765_697, 6777) + // Standard Error: 1 + .saturating_add(Weight::from_parts(322, 0).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads(8_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) + /// Storage: `System::Account` (r:3 w:3) /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`) /// Storage: `Contracts::ContractInfoOf` (r:1 w:1) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:2 w:2) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1 w:0) @@ -981,31 +1004,33 @@ impl WeightInfo for SubstrateWeight { /// Proof: `Timestamp::Now` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`) /// Storage: `Contracts::DeletionQueueCounter` (r:1 w:1) /// Proof: `Contracts::DeletionQueueCounter` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`) - /// Storage: `System::EventTopics` (r:3 w:3) + /// Storage: `System::EventTopics` (r:4 w:4) /// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `Balances::Holds` (r:1 w:1) + /// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(85), added: 2560, mode: `Measured`) /// Storage: `Contracts::DeletionQueue` (r:0 w:1) /// Proof: `Contracts::DeletionQueue` (`max_values`: None, `max_size`: Some(142), added: 2617, mode: `Measured`) /// The range of component `r` is `[0, 1]`. fn seal_terminate(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `2963 + r * (400 ±0)` - // Estimated: `8903 + r * (7825 ±0)` - // Minimum execution time: 281_030_000 picoseconds. - Weight::from_parts(305_435_226, 8903) - // Standard Error: 816_824 - .saturating_add(Weight::from_parts(131_691_873, 0).saturating_mul(r.into())) + // Measured: `2939 + r * (316 ±0)` + // Estimated: `8879 + r * (5266 ±0)` + // Minimum execution time: 280_392_000 picoseconds. + Weight::from_parts(310_023_381, 8879) + // Standard Error: 1_008_026 + .saturating_add(Weight::from_parts(130_208_818, 0).saturating_mul(r.into())) .saturating_add(T::DbWeight::get().reads(8_u64)) - .saturating_add(T::DbWeight::get().reads((6_u64).saturating_mul(r.into()))) + .saturating_add(T::DbWeight::get().reads((7_u64).saturating_mul(r.into()))) .saturating_add(T::DbWeight::get().writes(3_u64)) - .saturating_add(T::DbWeight::get().writes((9_u64).saturating_mul(r.into()))) - .saturating_add(Weight::from_parts(0, 7825).saturating_mul(r.into())) + .saturating_add(T::DbWeight::get().writes((10_u64).saturating_mul(r.into()))) + .saturating_add(Weight::from_parts(0, 5266).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) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1 w:0) @@ -1019,12 +1044,12 @@ impl WeightInfo for SubstrateWeight { /// The range of component `r` is `[0, 1600]`. fn seal_random(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `935 + r * (10 ±0)` - // Estimated: `6876 + r * (10 ±0)` - // Minimum execution time: 261_369_000 picoseconds. - Weight::from_parts(300_458_315, 6876) - // Standard Error: 3_506 - .saturating_add(Weight::from_parts(1_971_733, 0).saturating_mul(r.into())) + // Measured: `911 + r * (10 ±0)` + // Estimated: `6852 + r * (10 ±0)` + // Minimum execution time: 270_547_000 picoseconds. + Weight::from_parts(295_931_189, 6852) + // Standard Error: 3_280 + .saturating_add(Weight::from_parts(1_941_248, 0).saturating_mul(r.into())) .saturating_add(T::DbWeight::get().reads(9_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) .saturating_add(Weight::from_parts(0, 10).saturating_mul(r.into())) @@ -1034,7 +1059,7 @@ impl WeightInfo for SubstrateWeight { /// 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) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1 w:0) @@ -1046,12 +1071,12 @@ impl WeightInfo for SubstrateWeight { /// The range of component `r` is `[0, 1600]`. fn seal_deposit_event(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `854 + r * (10 ±0)` - // Estimated: `6799 + r * (10 ±0)` - // Minimum execution time: 262_894_000 picoseconds. - Weight::from_parts(285_321_838, 6799) - // Standard Error: 6_585 - .saturating_add(Weight::from_parts(3_998_744, 0).saturating_mul(r.into())) + // Measured: `830 + r * (10 ±0)` + // Estimated: `6772 + r * (10 ±0)` + // Minimum execution time: 255_730_000 picoseconds. + Weight::from_parts(301_859_471, 6772) + // Standard Error: 5_401 + .saturating_add(Weight::from_parts(3_887_632, 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())) @@ -1061,7 +1086,7 @@ impl WeightInfo for SubstrateWeight { /// 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) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1 w:0) @@ -1074,14 +1099,14 @@ impl WeightInfo for SubstrateWeight { /// The range of component `n` is `[0, 16384]`. fn seal_deposit_event_per_topic_and_byte(t: u32, n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `873 + t * (32 ±0)` - // Estimated: `6820 + t * (2508 ±0)` - // Minimum execution time: 275_909_000 picoseconds. - Weight::from_parts(289_251_568, 6820) - // Standard Error: 94_431 - .saturating_add(Weight::from_parts(3_007_409, 0).saturating_mul(t.into())) - // Standard Error: 26 - .saturating_add(Weight::from_parts(815, 0).saturating_mul(n.into())) + // Measured: `847 + t * (32 ±0)` + // Estimated: `6792 + t * (2508 ±0)` + // Minimum execution time: 276_643_000 picoseconds. + Weight::from_parts(294_275_838, 6792) + // Standard Error: 106_745 + .saturating_add(Weight::from_parts(2_831_489, 0).saturating_mul(t.into())) + // Standard Error: 29 + .saturating_add(Weight::from_parts(624, 0).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads(8_u64)) .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(t.into()))) .saturating_add(T::DbWeight::get().writes(3_u64)) @@ -1093,7 +1118,7 @@ impl WeightInfo for SubstrateWeight { /// 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) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1 w:0) @@ -1105,12 +1130,12 @@ impl WeightInfo for SubstrateWeight { /// The range of component `r` is `[0, 1600]`. fn seal_debug_message(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `853 + r * (7 ±0)` - // Estimated: `6797 + r * (7 ±0)` - // Minimum execution time: 168_482_000 picoseconds. - Weight::from_parts(178_065_606, 6797) - // Standard Error: 371 - .saturating_add(Weight::from_parts(242_851, 0).saturating_mul(r.into())) + // Measured: `829 + r * (7 ±0)` + // Estimated: `6774 + r * (7 ±0)` + // Minimum execution time: 169_012_000 picoseconds. + Weight::from_parts(179_567_029, 6774) + // Standard Error: 534 + .saturating_add(Weight::from_parts(249_500, 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, 7).saturating_mul(r.into())) @@ -1120,7 +1145,7 @@ impl WeightInfo for SubstrateWeight { /// 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) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `MaxEncodedLen`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `MaxEncodedLen`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `MaxEncodedLen`) /// Storage: `Contracts::PristineCode` (r:1 w:0) @@ -1132,12 +1157,12 @@ impl WeightInfo for SubstrateWeight { /// The range of component `i` is `[0, 1048576]`. fn seal_debug_message_per_byte(i: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `125804` - // Estimated: `131746` - // Minimum execution time: 407_401_000 picoseconds. - Weight::from_parts(426_585_443, 131746) - // Standard Error: 22 - .saturating_add(Weight::from_parts(986, 0).saturating_mul(i.into())) + // Measured: `125780` + // Estimated: `131722` + // Minimum execution time: 408_647_000 picoseconds. + Weight::from_parts(387_678_006, 131722) + // Standard Error: 12 + .saturating_add(Weight::from_parts(1_045, 0).saturating_mul(i.into())) .saturating_add(T::DbWeight::get().reads(8_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) } @@ -1146,12 +1171,12 @@ impl WeightInfo for SubstrateWeight { /// The range of component `r` is `[0, 800]`. fn seal_set_storage(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `921 + r * (292 ±0)` - // Estimated: `919 + r * (293 ±0)` - // Minimum execution time: 275_800_000 picoseconds. - Weight::from_parts(161_230_700, 919) - // Standard Error: 12_908 - .saturating_add(Weight::from_parts(6_965_844, 0).saturating_mul(r.into())) + // Measured: `891 + r * (292 ±0)` + // Estimated: `892 + r * (293 ±0)` + // Minimum execution time: 279_315_000 picoseconds. + Weight::from_parts(171_270_899, 892) + // Standard Error: 15_492 + .saturating_add(Weight::from_parts(6_776_878, 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(3_u64)) @@ -1163,26 +1188,26 @@ impl WeightInfo for SubstrateWeight { /// The range of component `n` is `[0, 16384]`. fn seal_set_storage_per_new_byte(n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `1380` - // Estimated: `1356` - // Minimum execution time: 289_258_000 picoseconds. - Weight::from_parts(334_318_402, 1356) - // Standard Error: 59 - .saturating_add(Weight::from_parts(808, 0).saturating_mul(n.into())) - .saturating_add(T::DbWeight::get().reads(10_u64)) - .saturating_add(T::DbWeight::get().writes(6_u64)) + // Measured: `1413` + // Estimated: `1396` + // Minimum execution time: 289_666_000 picoseconds. + Weight::from_parts(348_062_625, 1396) + // Standard Error: 79 + .saturating_add(Weight::from_parts(532, 0).saturating_mul(n.into())) + .saturating_add(T::DbWeight::get().reads(12_u64)) + .saturating_add(T::DbWeight::get().writes(8_u64)) } /// Storage: `Skipped::Metadata` (r:0 w:0) /// Proof: `Skipped::Metadata` (`max_values`: None, `max_size`: None, mode: `Measured`) /// The range of component `n` is `[0, 16384]`. fn seal_set_storage_per_old_byte(n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `1243 + n * (1 ±0)` - // Estimated: `1243 + n * (1 ±0)` - // Minimum execution time: 277_874_000 picoseconds. - Weight::from_parts(303_956_600, 1243) - // Standard Error: 33 - .saturating_add(Weight::from_parts(58, 0).saturating_mul(n.into())) + // Measured: `1219 + n * (1 ±0)` + // Estimated: `1219 + n * (1 ±0)` + // Minimum execution time: 273_840_000 picoseconds. + Weight::from_parts(297_024_621, 1219) + // Standard Error: 55 + .saturating_add(Weight::from_parts(945, 0).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads(9_u64)) .saturating_add(T::DbWeight::get().writes(4_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) @@ -1192,12 +1217,12 @@ impl WeightInfo for SubstrateWeight { /// The range of component `r` is `[0, 800]`. fn seal_clear_storage(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `917 + r * (288 ±0)` - // Estimated: `921 + r * (289 ±0)` - // Minimum execution time: 255_230_000 picoseconds. - Weight::from_parts(163_226_984, 921) - // Standard Error: 12_691 - .saturating_add(Weight::from_parts(6_808_905, 0).saturating_mul(r.into())) + // Measured: `887 + r * (288 ±0)` + // Estimated: `893 + r * (289 ±0)` + // Minimum execution time: 279_110_000 picoseconds. + Weight::from_parts(177_898_012, 893) + // Standard Error: 16_287 + .saturating_add(Weight::from_parts(6_640_103, 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(3_u64)) @@ -1209,12 +1234,10 @@ impl WeightInfo for SubstrateWeight { /// The range of component `n` is `[0, 16384]`. fn seal_clear_storage_per_byte(n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `1239 + n * (1 ±0)` - // Estimated: `1239 + n * (1 ±0)` - // Minimum execution time: 275_780_000 picoseconds. - Weight::from_parts(301_967_262, 1239) - // Standard Error: 34 - .saturating_add(Weight::from_parts(128, 0).saturating_mul(n.into())) + // Measured: `1215 + n * (1 ±0)` + // Estimated: `1215 + n * (1 ±0)` + // Minimum execution time: 276_566_000 picoseconds. + Weight::from_parts(304_992_376, 1215) .saturating_add(T::DbWeight::get().reads(9_u64)) .saturating_add(T::DbWeight::get().writes(4_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) @@ -1224,12 +1247,12 @@ impl WeightInfo for SubstrateWeight { /// The range of component `r` is `[0, 800]`. fn seal_get_storage(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `911 + r * (296 ±0)` - // Estimated: `916 + r * (297 ±0)` - // Minimum execution time: 279_295_000 picoseconds. - Weight::from_parts(208_289_066, 916) - // Standard Error: 8_330 - .saturating_add(Weight::from_parts(5_600_713, 0).saturating_mul(r.into())) + // Measured: `887 + r * (296 ±0)` + // Estimated: `889 + r * (297 ±0)` + // Minimum execution time: 266_285_000 picoseconds. + Weight::from_parts(200_488_939, 889) + // Standard Error: 11_193 + .saturating_add(Weight::from_parts(5_467_725, 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(3_u64)) @@ -1240,12 +1263,12 @@ impl WeightInfo for SubstrateWeight { /// The range of component `n` is `[0, 16384]`. fn seal_get_storage_per_byte(n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `1255 + n * (1 ±0)` - // Estimated: `1255 + n * (1 ±0)` - // Minimum execution time: 276_745_000 picoseconds. - Weight::from_parts(298_824_233, 1255) - // Standard Error: 36 - .saturating_add(Weight::from_parts(717, 0).saturating_mul(n.into())) + // Measured: `1231 + n * (1 ±0)` + // Estimated: `1231 + n * (1 ±0)` + // Minimum execution time: 278_625_000 picoseconds. + Weight::from_parts(304_319_493, 1231) + // Standard Error: 39 + .saturating_add(Weight::from_parts(415, 0).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads(9_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) @@ -1255,12 +1278,12 @@ impl WeightInfo for SubstrateWeight { /// The range of component `r` is `[0, 800]`. fn seal_contains_storage(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `932 + r * (288 ±0)` - // Estimated: `933 + r * (289 ±0)` - // Minimum execution time: 275_137_000 picoseconds. - Weight::from_parts(196_695_898, 933) - // Standard Error: 9_207 - .saturating_add(Weight::from_parts(5_466_071, 0).saturating_mul(r.into())) + // Measured: `898 + r * (288 ±0)` + // Estimated: `895 + r * (289 ±0)` + // Minimum execution time: 271_851_000 picoseconds. + Weight::from_parts(202_164_395, 895) + // Standard Error: 11_115 + .saturating_add(Weight::from_parts(5_273_320, 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(3_u64)) @@ -1271,12 +1294,12 @@ impl WeightInfo for SubstrateWeight { /// The range of component `n` is `[0, 16384]`. fn seal_contains_storage_per_byte(n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `1242 + n * (1 ±0)` - // Estimated: `1242 + n * (1 ±0)` - // Minimum execution time: 269_315_000 picoseconds. - Weight::from_parts(296_795_271, 1242) - // Standard Error: 39 - .saturating_add(Weight::from_parts(242, 0).saturating_mul(n.into())) + // Measured: `1218 + n * (1 ±0)` + // Estimated: `1218 + n * (1 ±0)` + // Minimum execution time: 274_200_000 picoseconds. + Weight::from_parts(299_524_586, 1218) + // Standard Error: 33 + .saturating_add(Weight::from_parts(272, 0).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads(9_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) @@ -1286,12 +1309,12 @@ impl WeightInfo for SubstrateWeight { /// The range of component `r` is `[0, 800]`. fn seal_take_storage(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `905 + r * (296 ±0)` - // Estimated: `912 + r * (297 ±0)` - // Minimum execution time: 256_406_000 picoseconds. - Weight::from_parts(156_850_288, 912) - // Standard Error: 12_496 - .saturating_add(Weight::from_parts(7_055_305, 0).saturating_mul(r.into())) + // Measured: `880 + r * (296 ±0)` + // Estimated: `885 + r * (297 ±0)` + // Minimum execution time: 258_535_000 picoseconds. + Weight::from_parts(190_468_808, 885) + // Standard Error: 11_940 + .saturating_add(Weight::from_parts(6_737_079, 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(3_u64)) @@ -1303,12 +1326,12 @@ impl WeightInfo for SubstrateWeight { /// The range of component `n` is `[0, 16384]`. fn seal_take_storage_per_byte(n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `1256 + n * (1 ±0)` - // Estimated: `1256 + n * (1 ±0)` - // Minimum execution time: 280_297_000 picoseconds. - Weight::from_parts(302_241_752, 1256) - // Standard Error: 34 - .saturating_add(Weight::from_parts(748, 0).saturating_mul(n.into())) + // Measured: `1232 + n * (1 ±0)` + // Estimated: `1232 + n * (1 ±0)` + // Minimum execution time: 280_536_000 picoseconds. + Weight::from_parts(304_479_477, 1232) + // Standard Error: 37 + .saturating_add(Weight::from_parts(534, 0).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads(9_u64)) .saturating_add(T::DbWeight::get().writes(4_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) @@ -1318,7 +1341,7 @@ impl WeightInfo for SubstrateWeight { /// 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) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1 w:0) @@ -1330,12 +1353,12 @@ impl WeightInfo for SubstrateWeight { /// The range of component `r` is `[0, 1600]`. fn seal_transfer(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `1449 + r * (45 ±0)` - // Estimated: `7346 + r * (2520 ±0)` - // Minimum execution time: 274_834_000 picoseconds. - Weight::from_parts(176_977_557, 7346) - // Standard Error: 32_386 - .saturating_add(Weight::from_parts(39_393_162, 0).saturating_mul(r.into())) + // Measured: `1382 + r * (45 ±0)` + // Estimated: `7274 + r * (2520 ±0)` + // Minimum execution time: 260_373_000 picoseconds. + Weight::from_parts(278_290_000, 7274) + // Standard Error: 25_683 + .saturating_add(Weight::from_parts(39_264_864, 0).saturating_mul(r.into())) .saturating_add(T::DbWeight::get().reads(9_u64)) .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(r.into()))) .saturating_add(T::DbWeight::get().writes(4_u64)) @@ -1347,7 +1370,7 @@ impl WeightInfo for SubstrateWeight { /// 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) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:2 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:2 w:0) @@ -1359,24 +1382,24 @@ impl WeightInfo for SubstrateWeight { /// The range of component `r` is `[0, 800]`. fn seal_call(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `1304 + r * (268 ±0)` - // Estimated: `9485 + r * (2744 ±0)` - // Minimum execution time: 279_802_000 picoseconds. - Weight::from_parts(287_995_000, 9485) - // Standard Error: 99_110 - .saturating_add(Weight::from_parts(245_521_843, 0).saturating_mul(r.into())) + // Measured: `1227 + r * (245 ±0)` + // Estimated: `9407 + r * (2721 ±0)` + // Minimum execution time: 277_621_000 picoseconds. + Weight::from_parts(281_775_000, 9407) + // Standard Error: 110_802 + .saturating_add(Weight::from_parts(245_363_533, 0).saturating_mul(r.into())) .saturating_add(T::DbWeight::get().reads(11_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, 2744).saturating_mul(r.into())) + .saturating_add(Weight::from_parts(0, 2721).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) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:736 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:736 w:0) @@ -1389,11 +1412,11 @@ impl WeightInfo for SubstrateWeight { fn seal_delegate_call(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0 + r * (576 ±0)` - // Estimated: `6803 + r * (2637 ±3)` - // Minimum execution time: 273_435_000 picoseconds. - Weight::from_parts(276_865_000, 6803) - // Standard Error: 148_051 - .saturating_add(Weight::from_parts(244_660_274, 0).saturating_mul(r.into())) + // Estimated: `6779 + r * (2637 ±3)` + // Minimum execution time: 267_314_000 picoseconds. + Weight::from_parts(279_888_000, 6779) + // Standard Error: 144_378 + .saturating_add(Weight::from_parts(244_606_414, 0).saturating_mul(r.into())) .saturating_add(T::DbWeight::get().reads(8_u64)) .saturating_add(T::DbWeight::get().reads((3_u64).saturating_mul(r.into()))) .saturating_add(T::DbWeight::get().writes(3_u64)) @@ -1405,7 +1428,7 @@ impl WeightInfo for SubstrateWeight { /// 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) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:2 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:2 w:0) @@ -1418,26 +1441,26 @@ impl WeightInfo for SubstrateWeight { /// The range of component `c` is `[0, 1048576]`. fn seal_call_per_transfer_clone_byte(t: u32, c: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `1322 + t * (310 ±0)` - // Estimated: `12212 + t * (5260 ±0)` - // Minimum execution time: 477_593_000 picoseconds. - Weight::from_parts(69_887_451, 12212) - // Standard Error: 11_764_606 - .saturating_add(Weight::from_parts(373_361_977, 0).saturating_mul(t.into())) + // Measured: `1274 + t * (277 ±0)` + // Estimated: `12164 + t * (5227 ±0)` + // Minimum execution time: 477_589_000 picoseconds. + Weight::from_parts(70_712_793, 12164) + // Standard Error: 11_713_135 + .saturating_add(Weight::from_parts(375_371_698, 0).saturating_mul(t.into())) // Standard Error: 17 - .saturating_add(Weight::from_parts(1_000, 0).saturating_mul(c.into())) + .saturating_add(Weight::from_parts(991, 0).saturating_mul(c.into())) .saturating_add(T::DbWeight::get().reads(13_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, 5260).saturating_mul(t.into())) + .saturating_add(Weight::from_parts(0, 5227).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) + /// Storage: `System::Account` (r:802 w:802) /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`) /// Storage: `Contracts::ContractInfoOf` (r:801 w:801) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:801 w:800) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:801 w:0) @@ -1446,29 +1469,31 @@ impl WeightInfo for SubstrateWeight { /// Proof: `Timestamp::Now` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`) /// Storage: `Contracts::Nonce` (r:1 w:1) /// Proof: `Contracts::Nonce` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`) - /// Storage: `System::EventTopics` (r:802 w:802) + /// Storage: `Balances::Holds` (r:800 w:800) + /// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(85), added: 2560, mode: `Measured`) + /// Storage: `System::EventTopics` (r:803 w:803) /// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`) /// The range of component `r` is `[1, 800]`. fn seal_instantiate(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `1380 + r * (255 ±0)` - // Estimated: `7204 + r * (5206 ±0)` - // Minimum execution time: 652_387_000 picoseconds. - Weight::from_parts(658_670_000, 7204) - // Standard Error: 363_054 - .saturating_add(Weight::from_parts(395_547_049, 0).saturating_mul(r.into())) - .saturating_add(T::DbWeight::get().reads(10_u64)) + // Measured: `1245 + r * (255 ±0)` + // Estimated: `9587 + r * (2731 ±0)` + // Minimum execution time: 662_502_000 picoseconds. + Weight::from_parts(671_726_000, 9587) + // Standard Error: 351_643 + .saturating_add(Weight::from_parts(390_457_971, 0).saturating_mul(r.into())) + .saturating_add(T::DbWeight::get().reads(11_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(7_u64)) .saturating_add(T::DbWeight::get().writes((5_u64).saturating_mul(r.into()))) - .saturating_add(Weight::from_parts(0, 5206).saturating_mul(r.into())) + .saturating_add(Weight::from_parts(0, 2731).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) + /// Storage: `System::Account` (r:3 w:3) /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`) /// Storage: `Contracts::ContractInfoOf` (r:2 w:2) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:2 w:1) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:2 w:0) @@ -1477,35 +1502,37 @@ impl WeightInfo for SubstrateWeight { /// Proof: `Timestamp::Now` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`) /// Storage: `Contracts::Nonce` (r:1 w:1) /// Proof: `Contracts::Nonce` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`) - /// Storage: `System::EventTopics` (r:3 w:3) + /// Storage: `Balances::Holds` (r:1 w:1) + /// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(85), added: 2560, mode: `Measured`) + /// Storage: `System::EventTopics` (r:4 w:4) /// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`) /// The range of component `t` is `[0, 1]`. /// The range of component `i` is `[0, 983040]`. /// The range of component `s` is `[0, 983040]`. fn seal_instantiate_per_transfer_input_salt_byte(t: u32, i: u32, s: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `1233 + t * (156 ±0)` - // Estimated: `9663 + t * (2578 ±2)` - // Minimum execution time: 2_299_620_000 picoseconds. - Weight::from_parts(1_274_859_063, 9663) - // Standard Error: 12_129_871 - .saturating_add(Weight::from_parts(16_608_792, 0).saturating_mul(t.into())) - // Standard Error: 19 - .saturating_add(Weight::from_parts(1_014, 0).saturating_mul(i.into())) - // Standard Error: 19 - .saturating_add(Weight::from_parts(1_180, 0).saturating_mul(s.into())) - .saturating_add(T::DbWeight::get().reads(15_u64)) + // Measured: `1270 + t * (104 ±0)` + // Estimated: `12178 + t * (2549 ±1)` + // Minimum execution time: 2_675_525_000 picoseconds. + Weight::from_parts(851_421_242, 12178) + // Standard Error: 7_094_722 + .saturating_add(Weight::from_parts(112_457_697, 0).saturating_mul(t.into())) + // Standard Error: 11 + .saturating_add(Weight::from_parts(1_867, 0).saturating_mul(i.into())) + // Standard Error: 11 + .saturating_add(Weight::from_parts(1_931, 0).saturating_mul(s.into())) + .saturating_add(T::DbWeight::get().reads(16_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(11_u64)) .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(t.into()))) - .saturating_add(Weight::from_parts(0, 2578).saturating_mul(t.into())) + .saturating_add(Weight::from_parts(0, 2549).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) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1 w:0) @@ -1517,12 +1544,12 @@ impl WeightInfo for SubstrateWeight { /// The range of component `r` is `[0, 1600]`. fn seal_hash_sha2_256(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `853 + r * (8 ±0)` - // Estimated: `6794 + r * (8 ±0)` - // Minimum execution time: 267_959_000 picoseconds. - Weight::from_parts(282_967_946, 6794) - // Standard Error: 624 - .saturating_add(Weight::from_parts(402_344, 0).saturating_mul(r.into())) + // Measured: `829 + r * (8 ±0)` + // Estimated: `6768 + r * (8 ±0)` + // Minimum execution time: 270_818_000 picoseconds. + Weight::from_parts(286_520_166, 6768) + // Standard Error: 575 + .saturating_add(Weight::from_parts(402_286, 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, 8).saturating_mul(r.into())) @@ -1532,7 +1559,7 @@ impl WeightInfo for SubstrateWeight { /// 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) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1 w:0) @@ -1544,12 +1571,12 @@ impl WeightInfo for SubstrateWeight { /// The range of component `n` is `[0, 1048576]`. fn seal_hash_sha2_256_per_byte(n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `861` - // Estimated: `6801` - // Minimum execution time: 274_585_000 picoseconds. - Weight::from_parts(272_480_647, 6801) + // Measured: `837` + // Estimated: `6775` + // Minimum execution time: 257_134_000 picoseconds. + Weight::from_parts(268_214_648, 6775) // Standard Error: 1 - .saturating_add(Weight::from_parts(1_089, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(1_098, 0).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads(8_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) } @@ -1558,7 +1585,7 @@ impl WeightInfo for SubstrateWeight { /// 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) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1 w:0) @@ -1570,12 +1597,12 @@ impl WeightInfo for SubstrateWeight { /// The range of component `r` is `[0, 1600]`. fn seal_hash_keccak_256(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `855 + r * (8 ±0)` - // Estimated: `6797 + r * (8 ±0)` - // Minimum execution time: 268_346_000 picoseconds. - Weight::from_parts(284_168_231, 6797) - // Standard Error: 620 - .saturating_add(Weight::from_parts(805_038, 0).saturating_mul(r.into())) + // Measured: `831 + r * (8 ±0)` + // Estimated: `6773 + r * (8 ±0)` + // Minimum execution time: 259_222_000 picoseconds. + Weight::from_parts(283_273_283, 6773) + // Standard Error: 967 + .saturating_add(Weight::from_parts(817_596, 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, 8).saturating_mul(r.into())) @@ -1585,7 +1612,7 @@ impl WeightInfo for SubstrateWeight { /// 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) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1 w:0) @@ -1597,12 +1624,12 @@ impl WeightInfo for SubstrateWeight { /// The range of component `n` is `[0, 1048576]`. fn seal_hash_keccak_256_per_byte(n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `863` - // Estimated: `6805` - // Minimum execution time: 273_073_000 picoseconds. - Weight::from_parts(280_346_065, 6805) + // Measured: `839` + // Estimated: `6781` + // Minimum execution time: 260_040_000 picoseconds. + Weight::from_parts(283_869_860, 6781) // Standard Error: 1 - .saturating_add(Weight::from_parts(3_357, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(3_349, 0).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads(8_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) } @@ -1611,7 +1638,7 @@ impl WeightInfo for SubstrateWeight { /// 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) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1 w:0) @@ -1623,12 +1650,12 @@ impl WeightInfo for SubstrateWeight { /// The range of component `r` is `[0, 1600]`. fn seal_hash_blake2_256(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `855 + r * (8 ±0)` - // Estimated: `6800 + r * (8 ±0)` - // Minimum execution time: 263_072_000 picoseconds. - Weight::from_parts(284_487_433, 6800) - // Standard Error: 668 - .saturating_add(Weight::from_parts(458_763, 0).saturating_mul(r.into())) + // Measured: `831 + r * (8 ±0)` + // Estimated: `6775 + r * (8 ±0)` + // Minimum execution time: 260_698_000 picoseconds. + Weight::from_parts(282_900_345, 6775) + // Standard Error: 805 + .saturating_add(Weight::from_parts(469_457, 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, 8).saturating_mul(r.into())) @@ -1638,7 +1665,7 @@ impl WeightInfo for SubstrateWeight { /// 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) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1 w:0) @@ -1650,12 +1677,12 @@ impl WeightInfo for SubstrateWeight { /// The range of component `n` is `[0, 1048576]`. fn seal_hash_blake2_256_per_byte(n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `863` - // Estimated: `6809` - // Minimum execution time: 271_488_000 picoseconds. - Weight::from_parts(273_877_727, 6809) + // Measured: `839` + // Estimated: `6780` + // Minimum execution time: 256_967_000 picoseconds. + Weight::from_parts(273_024_512, 6780) // Standard Error: 1 - .saturating_add(Weight::from_parts(1_202, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(1_204, 0).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads(8_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) } @@ -1664,7 +1691,7 @@ impl WeightInfo for SubstrateWeight { /// 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) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1 w:0) @@ -1676,12 +1703,12 @@ impl WeightInfo for SubstrateWeight { /// The range of component `r` is `[0, 1600]`. fn seal_hash_blake2_128(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `855 + r * (8 ±0)` - // Estimated: `6801 + r * (8 ±0)` - // Minimum execution time: 271_365_000 picoseconds. - Weight::from_parts(285_100_883, 6801) - // Standard Error: 651 - .saturating_add(Weight::from_parts(462_754, 0).saturating_mul(r.into())) + // Measured: `831 + r * (8 ±0)` + // Estimated: `6772 + r * (8 ±0)` + // Minimum execution time: 272_039_000 picoseconds. + Weight::from_parts(289_853_116, 6772) + // Standard Error: 559 + .saturating_add(Weight::from_parts(459_383, 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, 8).saturating_mul(r.into())) @@ -1691,7 +1718,7 @@ impl WeightInfo for SubstrateWeight { /// 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) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1 w:0) @@ -1703,12 +1730,12 @@ impl WeightInfo for SubstrateWeight { /// The range of component `n` is `[0, 1048576]`. fn seal_hash_blake2_128_per_byte(n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `863` - // Estimated: `6803` - // Minimum execution time: 272_341_000 picoseconds. - Weight::from_parts(275_388_470, 6803) + // Measured: `839` + // Estimated: `6778` + // Minimum execution time: 253_913_000 picoseconds. + Weight::from_parts(274_682_010, 6778) // Standard Error: 1 - .saturating_add(Weight::from_parts(1_192, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(1_204, 0).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads(8_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) } @@ -1717,7 +1744,7 @@ impl WeightInfo for SubstrateWeight { /// 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) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1 w:0) @@ -1729,12 +1756,12 @@ impl WeightInfo for SubstrateWeight { /// The range of component `n` is `[0, 125697]`. fn seal_sr25519_verify_per_byte(n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `988 + n * (1 ±0)` - // Estimated: `6925 + n * (1 ±0)` - // Minimum execution time: 341_302_000 picoseconds. - Weight::from_parts(354_111_630, 6925) - // Standard Error: 8 - .saturating_add(Weight::from_parts(5_913, 0).saturating_mul(n.into())) + // Measured: `964 + n * (1 ±0)` + // Estimated: `6901 + n * (1 ±0)` + // Minimum execution time: 343_955_000 picoseconds. + Weight::from_parts(350_777_388, 6901) + // Standard Error: 14 + .saturating_add(Weight::from_parts(5_915, 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())) @@ -1744,7 +1771,7 @@ impl WeightInfo for SubstrateWeight { /// 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) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1 w:0) @@ -1756,12 +1783,12 @@ 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: `804 + r * (112 ±0)` - // Estimated: `6742 + r * (112 ±0)` - // Minimum execution time: 275_325_000 picoseconds. - Weight::from_parts(333_041_903, 6742) - // Standard Error: 11_171 - .saturating_add(Weight::from_parts(56_605_218, 0).saturating_mul(r.into())) + // Measured: `774 + r * (112 ±0)` + // Estimated: `6715 + r * (112 ±0)` + // Minimum execution time: 268_698_000 picoseconds. + Weight::from_parts(336_398_814, 6715) + // Standard Error: 16_627 + .saturating_add(Weight::from_parts(56_155_384, 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, 112).saturating_mul(r.into())) @@ -1771,7 +1798,7 @@ impl WeightInfo for SubstrateWeight { /// 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) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1 w:0) @@ -1783,12 +1810,12 @@ impl WeightInfo for SubstrateWeight { /// The range of component `r` is `[0, 160]`. fn seal_ecdsa_recover(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `898 + r * (76 ±0)` - // Estimated: `6793 + r * (77 ±0)` - // Minimum execution time: 274_165_000 picoseconds. - Weight::from_parts(347_487_800, 6793) - // Standard Error: 15_398 - .saturating_add(Weight::from_parts(46_072_020, 0).saturating_mul(r.into())) + // Measured: `874 + r * (76 ±0)` + // Estimated: `6768 + r * (77 ±0)` + // Minimum execution time: 258_906_000 picoseconds. + Weight::from_parts(340_672_829, 6768) + // Standard Error: 18_295 + .saturating_add(Weight::from_parts(46_106_884, 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, 77).saturating_mul(r.into())) @@ -1798,7 +1825,7 @@ impl WeightInfo for SubstrateWeight { /// 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) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1 w:0) @@ -1810,12 +1837,12 @@ impl WeightInfo for SubstrateWeight { /// The range of component `r` is `[0, 160]`. fn seal_ecdsa_to_eth_address(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `868 + r * (42 ±0)` - // Estimated: `6807 + r * (42 ±0)` - // Minimum execution time: 270_855_000 picoseconds. - Weight::from_parts(320_777_105, 6807) - // Standard Error: 11_106 - .saturating_add(Weight::from_parts(12_053_053, 0).saturating_mul(r.into())) + // Measured: `844 + r * (42 ±0)` + // Estimated: `6783 + r * (42 ±0)` + // Minimum execution time: 275_105_000 picoseconds. + Weight::from_parts(313_700_348, 6783) + // Standard Error: 11_960 + .saturating_add(Weight::from_parts(12_050_300, 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, 42).saturating_mul(r.into())) @@ -1825,7 +1852,7 @@ impl WeightInfo for SubstrateWeight { /// 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) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1536 w:1536) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1536 w:0) @@ -1838,11 +1865,11 @@ impl WeightInfo for SubstrateWeight { fn seal_set_code_hash(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0 + r * (965 ±0)` - // Estimated: `6798 + r * (3090 ±10)` - // Minimum execution time: 257_732_000 picoseconds. - Weight::from_parts(280_982_000, 6798) - // Standard Error: 68_194 - .saturating_add(Weight::from_parts(27_413_991, 0).saturating_mul(r.into())) + // Estimated: `6774 + r * (3090 ±7)` + // Minimum execution time: 259_178_000 picoseconds. + Weight::from_parts(275_643_000, 6774) + // Standard Error: 54_044 + .saturating_add(Weight::from_parts(26_026_930, 0).saturating_mul(r.into())) .saturating_add(T::DbWeight::get().reads(8_u64)) .saturating_add(T::DbWeight::get().reads((3_u64).saturating_mul(r.into()))) .saturating_add(T::DbWeight::get().writes(3_u64)) @@ -1854,7 +1881,7 @@ impl WeightInfo for SubstrateWeight { /// 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) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:33 w:32) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1 w:0) @@ -1866,12 +1893,12 @@ impl WeightInfo for SubstrateWeight { /// The range of component `r` is `[0, 32]`. fn add_delegate_dependency(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `918 + r * (132 ±0)` - // Estimated: `6870 + r * (2606 ±0)` - // Minimum execution time: 278_285_000 picoseconds. - Weight::from_parts(298_012_554, 6870) - // Standard Error: 24_160 - .saturating_add(Weight::from_parts(6_363_118, 0).saturating_mul(r.into())) + // Measured: `895 + r * (131 ±0)` + // Estimated: `6845 + r * (2606 ±0)` + // Minimum execution time: 263_386_000 picoseconds. + Weight::from_parts(295_443_439, 6845) + // Standard Error: 24_422 + .saturating_add(Weight::from_parts(6_429_537, 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(3_u64)) @@ -1883,7 +1910,7 @@ impl WeightInfo for SubstrateWeight { /// 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) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `MaxEncodedLen`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `MaxEncodedLen`) /// Storage: `Contracts::CodeInfoOf` (r:33 w:32) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `MaxEncodedLen`) /// Storage: `Contracts::PristineCode` (r:1 w:0) @@ -1895,12 +1922,12 @@ impl WeightInfo for SubstrateWeight { /// The range of component `r` is `[0, 32]`. fn remove_delegate_dependency(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `965 + r * (183 ±0)` + // Measured: `936 + r * (183 ±0)` // Estimated: `129453 + r * (2568 ±0)` - // Minimum execution time: 258_198_000 picoseconds. - Weight::from_parts(290_090_206, 129453) - // Standard Error: 19_792 - .saturating_add(Weight::from_parts(6_004_811, 0).saturating_mul(r.into())) + // Minimum execution time: 261_371_000 picoseconds. + Weight::from_parts(297_493_194, 129453) + // Standard Error: 23_734 + .saturating_add(Weight::from_parts(5_673_169, 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(3_u64)) @@ -1912,7 +1939,7 @@ impl WeightInfo for SubstrateWeight { /// 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) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1 w:0) @@ -1924,12 +1951,12 @@ impl WeightInfo for SubstrateWeight { /// The range of component `r` is `[0, 1600]`. fn seal_reentrance_count(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `849 + r * (3 ±0)` - // Estimated: `6799 + r * (3 ±0)` - // Minimum execution time: 263_315_000 picoseconds. - Weight::from_parts(284_093_748, 6799) - // Standard Error: 371 - .saturating_add(Weight::from_parts(176_949, 0).saturating_mul(r.into())) + // Measured: `825 + r * (3 ±0)` + // Estimated: `6771 + r * (3 ±0)` + // Minimum execution time: 275_558_000 picoseconds. + Weight::from_parts(287_220_765, 6771) + // Standard Error: 437 + .saturating_add(Weight::from_parts(184_125, 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, 3).saturating_mul(r.into())) @@ -1939,7 +1966,7 @@ impl WeightInfo for SubstrateWeight { /// 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) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1 w:0) @@ -1951,12 +1978,12 @@ impl WeightInfo for SubstrateWeight { /// The range of component `r` is `[0, 1600]`. fn seal_account_reentrance_count(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `2082 + r * (39 ±0)` - // Estimated: `7886 + r * (40 ±0)` - // Minimum execution time: 274_583_000 picoseconds. - Weight::from_parts(352_081_486, 7886) - // Standard Error: 1_799 - .saturating_add(Weight::from_parts(313_433, 0).saturating_mul(r.into())) + // Measured: `2076 + r * (39 ±0)` + // Estimated: `7866 + r * (40 ±0)` + // Minimum execution time: 265_752_000 picoseconds. + Weight::from_parts(331_187_665, 7866) + // Standard Error: 1_950 + .saturating_add(Weight::from_parts(312_262, 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, 40).saturating_mul(r.into())) @@ -1966,7 +1993,7 @@ impl WeightInfo for SubstrateWeight { /// 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) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1 w:0) @@ -1980,12 +2007,12 @@ impl WeightInfo for SubstrateWeight { /// The range of component `r` is `[0, 1600]`. fn seal_instantiation_nonce(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `852 + r * (3 ±0)` - // Estimated: `6799 + r * (3 ±0)` - // Minimum execution time: 267_291_000 picoseconds. - Weight::from_parts(287_500_540, 6799) - // Standard Error: 393 - .saturating_add(Weight::from_parts(152_587, 0).saturating_mul(r.into())) + // Measured: `828 + r * (3 ±0)` + // Estimated: `6768 + r * (3 ±0)` + // Minimum execution time: 257_114_000 picoseconds. + Weight::from_parts(286_686_654, 6768) + // Standard Error: 426 + .saturating_add(Weight::from_parts(162_295, 0).saturating_mul(r.into())) .saturating_add(T::DbWeight::get().reads(9_u64)) .saturating_add(T::DbWeight::get().writes(4_u64)) .saturating_add(Weight::from_parts(0, 3).saturating_mul(r.into())) @@ -1995,10 +2022,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_440_000 picoseconds. - Weight::from_parts(1_656_631, 0) - // Standard Error: 13 - .saturating_add(Weight::from_parts(10_486, 0).saturating_mul(r.into())) + // Minimum execution time: 1_388_000 picoseconds. + Weight::from_parts(1_680_408, 0) + // Standard Error: 21 + .saturating_add(Weight::from_parts(10_564, 0).saturating_mul(r.into())) } } @@ -2010,8 +2037,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `142` // Estimated: `1627` - // Minimum execution time: 2_527_000 picoseconds. - Weight::from_parts(2_651_000, 1627) + // Minimum execution time: 2_410_000 picoseconds. + Weight::from_parts(2_581_000, 1627) .saturating_add(RocksDbWeight::get().reads(1_u64)) } /// Storage: `Skipped::Metadata` (r:0 w:0) @@ -2021,10 +2048,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `451 + k * (69 ±0)` // Estimated: `441 + k * (70 ±0)` - // Minimum execution time: 13_291_000 picoseconds. - Weight::from_parts(13_825_000, 441) - // Standard Error: 1_137 - .saturating_add(Weight::from_parts(1_244_309, 0).saturating_mul(k.into())) + // Minimum execution time: 13_278_000 picoseconds. + Weight::from_parts(13_944_000, 441) + // Standard Error: 1_643 + .saturating_add(Weight::from_parts(1_194_404, 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)) @@ -2038,25 +2065,25 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `211 + c * (1 ±0)` // Estimated: `6149 + c * (1 ±0)` - // Minimum execution time: 8_359_000 picoseconds. - Weight::from_parts(9_179_121, 6149) + // Minimum execution time: 8_533_000 picoseconds. + Weight::from_parts(9_141_899, 6149) // Standard Error: 1 - .saturating_add(Weight::from_parts(1_312, 0).saturating_mul(c.into())) + .saturating_add(Weight::from_parts(1_327, 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:3 w:1) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Storage: `Contracts::ContractInfoOf` (r:2 w:1) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, 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: `709` - // Estimated: `9124` - // Minimum execution time: 42_457_000 picoseconds. - Weight::from_parts(44_556_000, 9124) - .saturating_add(RocksDbWeight::get().reads(4_u64)) + // Measured: `510` + // Estimated: `6450` + // Minimum execution time: 16_998_000 picoseconds. + Weight::from_parts(17_776_000, 6450) + .saturating_add(RocksDbWeight::get().reads(3_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } /// Storage: `Contracts::DeletionQueue` (r:1 w:1025) @@ -2068,10 +2095,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `171 + k * (1 ±0)` // Estimated: `3635 + k * (1 ±0)` - // Minimum execution time: 3_839_000 picoseconds. - Weight::from_parts(3_462_337, 3635) - // Standard Error: 1_384 - .saturating_add(Weight::from_parts(1_166_522, 0).saturating_mul(k.into())) + // Minimum execution time: 3_919_000 picoseconds. + Weight::from_parts(4_057_153, 3635) + // Standard Error: 1_252 + .saturating_add(Weight::from_parts(1_151_419, 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()))) @@ -2090,38 +2117,52 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `325 + c * (1 ±0)` // Estimated: `6263 + c * (1 ±0)` - // Minimum execution time: 17_001_000 picoseconds. - Weight::from_parts(17_095_380, 6263) + // Minimum execution time: 17_730_000 picoseconds. + Weight::from_parts(17_540_884, 6263) // Standard Error: 1 - .saturating_add(Weight::from_parts(411, 0).saturating_mul(c.into())) + .saturating_add(Weight::from_parts(417, 0).saturating_mul(c.into())) .saturating_add(RocksDbWeight::get().reads(4_u64)) .saturating_add(RocksDbWeight::get().writes(2_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(c.into())) } - /// Storage: `Contracts::ContractInfoOf` (r:3 w:1) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Storage: `Contracts::ContractInfoOf` (r:2 w:1) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) fn v13_migration_step() -> Weight { // Proof Size summary in bytes: - // Measured: `639` - // Estimated: `9054` - // Minimum execution time: 35_342_000 picoseconds. - Weight::from_parts(36_839_000, 9054) - .saturating_add(RocksDbWeight::get().reads(3_u64)) + // Measured: `440` + // Estimated: `6380` + // Minimum execution time: 13_089_000 picoseconds. + Weight::from_parts(13_727_000, 6380) + .saturating_add(RocksDbWeight::get().reads(2_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: `Contracts::CodeInfoOf` (r:2 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) - /// Storage: `System::Account` (r:1 w:0) + /// Storage: `System::Account` (r:1 w:1) /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`) + /// Storage: `Balances::Holds` (r:1 w:0) + /// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(85), added: 2560, mode: `Measured`) fn v14_migration_step() -> Weight { // Proof Size summary in bytes: - // Measured: `260` - // Estimated: `6200` - // Minimum execution time: 27_995_000 picoseconds. - Weight::from_parts(28_661_000, 6200) - .saturating_add(RocksDbWeight::get().reads(3_u64)) + // Measured: `360` + // Estimated: `6300` + // Minimum execution time: 49_083_000 picoseconds. + Weight::from_parts(50_462_000, 6300) + .saturating_add(RocksDbWeight::get().reads(4_u64)) + .saturating_add(RocksDbWeight::get().writes(1_u64)) + } + /// Storage: `Contracts::ContractInfoOf` (r:2 w:1) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) + /// Storage: `System::Account` (r:2 w:1) + /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`) + fn v15_migration_step() -> Weight { + // Proof Size summary in bytes: + // Measured: `594` + // Estimated: `6534` + // Minimum execution time: 49_299_000 picoseconds. + Weight::from_parts(50_805_000, 6534) + .saturating_add(RocksDbWeight::get().reads(4_u64)) + .saturating_add(RocksDbWeight::get().writes(2_u64)) } /// Storage: `Contracts::MigrationInProgress` (r:1 w:1) /// Proof: `Contracts::MigrationInProgress` (`max_values`: Some(1), `max_size`: Some(1026), added: 1521, mode: `Measured`) @@ -2129,8 +2170,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `142` // Estimated: `1627` - // Minimum execution time: 3_272_000 picoseconds. - Weight::from_parts(3_553_000, 1627) + // Minimum execution time: 3_305_000 picoseconds. + Weight::from_parts(3_489_000, 1627) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -2142,8 +2183,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `166` // Estimated: `3631` - // Minimum execution time: 12_788_000 picoseconds. - Weight::from_parts(13_163_000, 3631) + // Minimum execution time: 12_657_000 picoseconds. + Weight::from_parts(13_100_000, 3631) .saturating_add(RocksDbWeight::get().reads(2_u64)) .saturating_add(RocksDbWeight::get().writes(2_u64)) } @@ -2153,8 +2194,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `142` // Estimated: `3607` - // Minimum execution time: 4_794_000 picoseconds. - Weight::from_parts(5_086_000, 3607) + // Minimum execution time: 4_784_000 picoseconds. + Weight::from_parts(4_994_000, 3607) .saturating_add(RocksDbWeight::get().reads(1_u64)) } /// Storage: UNKNOWN KEY `0x4342193e496fab7ec59d615ed0dc55304e7b9012096b41c4eb3aaf947f6ea429` (r:1 w:0) @@ -2165,8 +2206,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `167` // Estimated: `3632` - // Minimum execution time: 6_616_000 picoseconds. - Weight::from_parts(7_034_000, 3632) + // Minimum execution time: 6_762_000 picoseconds. + Weight::from_parts(6_945_000, 3632) .saturating_add(RocksDbWeight::get().reads(2_u64)) } /// Storage: UNKNOWN KEY `0x4342193e496fab7ec59d615ed0dc55304e7b9012096b41c4eb3aaf947f6ea429` (r:1 w:0) @@ -2177,15 +2218,15 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `142` // Estimated: `3607` - // Minimum execution time: 6_985_000 picoseconds. - Weight::from_parts(7_477_000, 3607) + // Minimum execution time: 6_999_000 picoseconds. + Weight::from_parts(7_372_000, 3607) .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(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1 w:0) @@ -2199,12 +2240,12 @@ impl WeightInfo for () { /// The range of component `c` is `[0, 125952]`. fn call_with_code_per_byte(c: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `783` - // Estimated: `6732 + c * (1 ±0)` - // Minimum execution time: 306_088_000 picoseconds. - Weight::from_parts(268_361_911, 6732) - // Standard Error: 76 - .saturating_add(Weight::from_parts(38_334, 0).saturating_mul(c.into())) + // Measured: `759` + // Estimated: `6710 + c * (1 ±0)` + // Minimum execution time: 304_121_000 picoseconds. + Weight::from_parts(288_627_840, 6710) + // Standard Error: 83 + .saturating_add(Weight::from_parts(37_343, 0).saturating_mul(c.into())) .saturating_add(RocksDbWeight::get().reads(8_u64)) .saturating_add(RocksDbWeight::get().writes(4_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(c.into())) @@ -2213,15 +2254,17 @@ impl WeightInfo for () { /// Proof: `Contracts::MigrationInProgress` (`max_values`: Some(1), `max_size`: Some(1026), added: 1521, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:1) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) + /// Storage: `Balances::Holds` (r:2 w:2) + /// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(85), added: 2560, mode: `Measured`) /// Storage: `System::EventTopics` (r:3 w:3) /// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `Contracts::Nonce` (r:1 w:1) /// Proof: `Contracts::Nonce` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`) /// Storage: `Contracts::ContractInfoOf` (r:1 w:1) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Timestamp::Now` (r:1 w:0) /// Proof: `Timestamp::Now` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`) - /// Storage: `System::Account` (r:2 w:2) + /// Storage: `System::Account` (r:1 w:1) /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:0 w:1) /// Proof: `Contracts::PristineCode` (`max_values`: None, `max_size`: Some(125988), added: 128463, mode: `Measured`) @@ -2230,18 +2273,18 @@ impl WeightInfo for () { /// The range of component `s` is `[0, 1048576]`. fn instantiate_with_code(c: u32, i: u32, s: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `303` - // Estimated: `8745` - // Minimum execution time: 4_224_657_000 picoseconds. - Weight::from_parts(451_557_864, 8745) - // Standard Error: 216 - .saturating_add(Weight::from_parts(111_761, 0).saturating_mul(c.into())) - // Standard Error: 26 - .saturating_add(Weight::from_parts(1_794, 0).saturating_mul(i.into())) - // Standard Error: 26 - .saturating_add(Weight::from_parts(2_013, 0).saturating_mul(s.into())) - .saturating_add(RocksDbWeight::get().reads(10_u64)) - .saturating_add(RocksDbWeight::get().writes(9_u64)) + // Measured: `290` + // Estimated: `8714` + // Minimum execution time: 4_101_589_000 picoseconds. + Weight::from_parts(694_193_047, 8714) + // Standard Error: 334 + .saturating_add(Weight::from_parts(108_847, 0).saturating_mul(c.into())) + // Standard Error: 40 + .saturating_add(Weight::from_parts(1_677, 0).saturating_mul(i.into())) + // Standard Error: 40 + .saturating_add(Weight::from_parts(1_783, 0).saturating_mul(s.into())) + .saturating_add(RocksDbWeight::get().reads(11_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`) @@ -2252,11 +2295,13 @@ impl WeightInfo for () { /// Storage: `Contracts::Nonce` (r:1 w:1) /// Proof: `Contracts::Nonce` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`) /// Storage: `Contracts::ContractInfoOf` (r:1 w:1) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Timestamp::Now` (r:1 w:0) /// Proof: `Timestamp::Now` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`) - /// Storage: `System::Account` (r:2 w:2) + /// Storage: `System::Account` (r:1 w:1) /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`) + /// Storage: `Balances::Holds` (r:1 w:1) + /// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(85), added: 2560, mode: `Measured`) /// Storage: `System::EventTopics` (r:2 w:2) /// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`) /// The range of component `i` is `[0, 1048576]`. @@ -2264,20 +2309,20 @@ impl WeightInfo for () { fn instantiate(i: u32, s: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `527` - // Estimated: `6517` - // Minimum execution time: 2_029_313_000 picoseconds. - Weight::from_parts(353_077_600, 6517) - // Standard Error: 8 - .saturating_add(Weight::from_parts(1_781, 0).saturating_mul(i.into())) - // Standard Error: 8 - .saturating_add(Weight::from_parts(1_729, 0).saturating_mul(s.into())) + // Estimated: `6471` + // Minimum execution time: 2_011_580_000 picoseconds. + Weight::from_parts(397_415_227, 6471) + // Standard Error: 10 + .saturating_add(Weight::from_parts(1_689, 0).saturating_mul(i.into())) + // Standard Error: 10 + .saturating_add(Weight::from_parts(1_679, 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(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1 w:0) @@ -2290,10 +2335,10 @@ impl WeightInfo for () { /// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`) fn call() -> Weight { // Proof Size summary in bytes: - // Measured: `817` - // Estimated: `6757` - // Minimum execution time: 204_086_000 picoseconds. - Weight::from_parts(216_738_000, 6757) + // Measured: `793` + // Estimated: `6733` + // Minimum execution time: 204_975_000 picoseconds. + Weight::from_parts(214_770_000, 6733) .saturating_add(RocksDbWeight::get().reads(8_u64)) .saturating_add(RocksDbWeight::get().writes(4_u64)) } @@ -2301,6 +2346,8 @@ impl WeightInfo for () { /// Proof: `Contracts::MigrationInProgress` (`max_values`: Some(1), `max_size`: Some(1026), added: 1521, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:1) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) + /// Storage: `Balances::Holds` (r:1 w:1) + /// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(85), added: 2560, mode: `Measured`) /// Storage: `System::EventTopics` (r:1 w:1) /// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:0 w:1) @@ -2310,44 +2357,46 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `142` // Estimated: `3607` - // Minimum execution time: 269_337_000 picoseconds. - Weight::from_parts(220_186_006, 3607) - // Standard Error: 106 - .saturating_add(Weight::from_parts(74_291, 0).saturating_mul(c.into())) - .saturating_add(RocksDbWeight::get().reads(3_u64)) - .saturating_add(RocksDbWeight::get().writes(3_u64)) + // Minimum execution time: 269_545_000 picoseconds. + Weight::from_parts(256_054_650, 3607) + // Standard Error: 91 + .saturating_add(Weight::from_parts(72_743, 0).saturating_mul(c.into())) + .saturating_add(RocksDbWeight::get().reads(4_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::CodeInfoOf` (r:1 w:1) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) + /// Storage: `Balances::Holds` (r:1 w:1) + /// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(85), added: 2560, mode: `Measured`) /// Storage: `System::EventTopics` (r:1 w:1) /// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:0 w:1) /// Proof: `Contracts::PristineCode` (`max_values`: None, `max_size`: Some(125988), added: 128463, mode: `Measured`) fn remove_code() -> Weight { // Proof Size summary in bytes: - // Measured: `259` - // Estimated: `3724` - // Minimum execution time: 35_127_000 picoseconds. - Weight::from_parts(36_180_000, 3724) - .saturating_add(RocksDbWeight::get().reads(3_u64)) - .saturating_add(RocksDbWeight::get().writes(3_u64)) + // Measured: `315` + // Estimated: `3780` + // Minimum execution time: 47_880_000 picoseconds. + Weight::from_parts(49_427_000, 3780) + .saturating_add(RocksDbWeight::get().reads(4_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(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:2 w:2) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `System::EventTopics` (r:3 w:3) /// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`) fn set_code() -> Weight { // Proof Size summary in bytes: - // Measured: `576` - // Estimated: `8991` - // Minimum execution time: 37_550_000 picoseconds. - Weight::from_parts(39_149_000, 8991) + // Measured: `552` + // Estimated: `8967` + // Minimum execution time: 37_898_000 picoseconds. + Weight::from_parts(39_826_000, 8967) .saturating_add(RocksDbWeight::get().reads(7_u64)) .saturating_add(RocksDbWeight::get().writes(6_u64)) } @@ -2356,7 +2405,7 @@ impl WeightInfo for () { /// 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) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1 w:0) @@ -2368,12 +2417,12 @@ impl WeightInfo for () { /// The range of component `r` is `[0, 1600]`. fn seal_caller(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `857 + r * (6 ±0)` - // Estimated: `6798 + r * (6 ±0)` - // Minimum execution time: 269_991_000 picoseconds. - Weight::from_parts(293_993_592, 6798) - // Standard Error: 665 - .saturating_add(Weight::from_parts(343_796, 0).saturating_mul(r.into())) + // Measured: `833 + r * (6 ±0)` + // Estimated: `6773 + r * (6 ±0)` + // Minimum execution time: 260_916_000 picoseconds. + Weight::from_parts(295_521_846, 6773) + // Standard Error: 1_126 + .saturating_add(Weight::from_parts(348_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, 6).saturating_mul(r.into())) @@ -2383,7 +2432,7 @@ impl WeightInfo for () { /// 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) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1 w:0) @@ -2395,23 +2444,23 @@ impl WeightInfo for () { /// The range of component `r` is `[0, 1600]`. fn seal_is_contract(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `924 + r * (232 ±0)` - // Estimated: `6831 + r * (2707 ±0)` - // Minimum execution time: 274_151_000 picoseconds. - Weight::from_parts(83_529_206, 6831) - // Standard Error: 8_452 - .saturating_add(Weight::from_parts(3_534_024, 0).saturating_mul(r.into())) + // Measured: `889 + r * (209 ±0)` + // Estimated: `6793 + r * (2684 ±0)` + // Minimum execution time: 274_335_000 picoseconds. + Weight::from_parts(132_998_512, 6793) + // Standard Error: 7_396 + .saturating_add(Weight::from_parts(3_602_287, 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(3_u64)) - .saturating_add(Weight::from_parts(0, 2707).saturating_mul(r.into())) + .saturating_add(Weight::from_parts(0, 2684).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) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1 w:0) @@ -2423,23 +2472,23 @@ impl WeightInfo for () { /// The range of component `r` is `[0, 1600]`. fn seal_code_hash(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `910 + r * (236 ±0)` - // Estimated: `6835 + r * (2711 ±0)` - // Minimum execution time: 276_689_000 picoseconds. - Weight::from_parts(110_268_281, 6835) - // Standard Error: 8_106 - .saturating_add(Weight::from_parts(4_376_136, 0).saturating_mul(r.into())) + // Measured: `888 + r * (213 ±0)` + // Estimated: `6797 + r * (2688 ±0)` + // Minimum execution time: 272_514_000 picoseconds. + Weight::from_parts(104_825_618, 6797) + // Standard Error: 10_038 + .saturating_add(Weight::from_parts(4_520_258, 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(3_u64)) - .saturating_add(Weight::from_parts(0, 2711).saturating_mul(r.into())) + .saturating_add(Weight::from_parts(0, 2688).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) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1 w:0) @@ -2451,12 +2500,12 @@ impl WeightInfo for () { /// The range of component `r` is `[0, 1600]`. fn seal_own_code_hash(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `864 + r * (6 ±0)` - // Estimated: `6806 + r * (6 ±0)` - // Minimum execution time: 274_079_000 picoseconds. - Weight::from_parts(282_258_090, 6806) - // Standard Error: 1_343 - .saturating_add(Weight::from_parts(464_680, 0).saturating_mul(r.into())) + // Measured: `840 + r * (6 ±0)` + // Estimated: `6782 + r * (6 ±0)` + // Minimum execution time: 264_593_000 picoseconds. + Weight::from_parts(294_139_363, 6782) + // Standard Error: 907 + .saturating_add(Weight::from_parts(432_964, 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())) @@ -2466,7 +2515,7 @@ impl WeightInfo for () { /// 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) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1 w:0) @@ -2478,12 +2527,12 @@ impl WeightInfo for () { /// The range of component `r` is `[0, 1600]`. fn seal_caller_is_origin(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `854 + r * (3 ±0)` - // Estimated: `6799 + r * (3 ±0)` - // Minimum execution time: 270_960_000 picoseconds. - Weight::from_parts(281_985_584, 6799) - // Standard Error: 378 - .saturating_add(Weight::from_parts(184_462, 0).saturating_mul(r.into())) + // Measured: `830 + r * (3 ±0)` + // Estimated: `6771 + r * (3 ±0)` + // Minimum execution time: 260_412_000 picoseconds. + Weight::from_parts(284_371_703, 6771) + // Standard Error: 433 + .saturating_add(Weight::from_parts(182_952, 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, 3).saturating_mul(r.into())) @@ -2491,7 +2540,7 @@ impl WeightInfo for () { /// 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(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1 w:0) @@ -2503,12 +2552,12 @@ impl WeightInfo for () { /// The range of component `r` is `[0, 1600]`. fn seal_caller_is_root(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `744 + r * (3 ±0)` - // Estimated: `6684 + r * (3 ±0)` - // Minimum execution time: 244_835_000 picoseconds. - Weight::from_parts(270_660_753, 6684) - // Standard Error: 390 - .saturating_add(Weight::from_parts(164_232, 0).saturating_mul(r.into())) + // Measured: `720 + r * (3 ±0)` + // Estimated: `6660 + r * (3 ±0)` + // Minimum execution time: 255_112_000 picoseconds. + Weight::from_parts(273_052_488, 6660) + // Standard Error: 376 + .saturating_add(Weight::from_parts(166_644, 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())) @@ -2518,7 +2567,7 @@ impl WeightInfo for () { /// 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) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1 w:0) @@ -2530,12 +2579,12 @@ impl WeightInfo for () { /// The range of component `r` is `[0, 1600]`. fn seal_address(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `858 + r * (6 ±0)` - // Estimated: `6800 + r * (6 ±0)` - // Minimum execution time: 273_269_000 picoseconds. - Weight::from_parts(274_468_168, 6800) - // Standard Error: 2_246 - .saturating_add(Weight::from_parts(386_838, 0).saturating_mul(r.into())) + // Measured: `834 + r * (6 ±0)` + // Estimated: `6774 + r * (6 ±0)` + // Minimum execution time: 270_426_000 picoseconds. + Weight::from_parts(289_240_775, 6774) + // Standard Error: 748 + .saturating_add(Weight::from_parts(344_791, 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())) @@ -2545,7 +2594,7 @@ impl WeightInfo for () { /// 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) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1 w:0) @@ -2557,12 +2606,12 @@ impl WeightInfo for () { /// The range of component `r` is `[0, 1600]`. fn seal_gas_left(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `854 + r * (6 ±0)` - // Estimated: `6795 + r * (6 ±0)` - // Minimum execution time: 275_244_000 picoseconds. - Weight::from_parts(281_299_739, 6795) - // Standard Error: 2_890 - .saturating_add(Weight::from_parts(600_498, 0).saturating_mul(r.into())) + // Measured: `830 + r * (6 ±0)` + // Estimated: `6773 + r * (6 ±0)` + // Minimum execution time: 260_217_000 picoseconds. + Weight::from_parts(288_660_978, 6773) + // Standard Error: 1_199 + .saturating_add(Weight::from_parts(550_304, 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())) @@ -2572,7 +2621,7 @@ impl WeightInfo for () { /// 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) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1 w:0) @@ -2584,12 +2633,12 @@ impl WeightInfo for () { /// The range of component `r` is `[0, 1600]`. fn seal_balance(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `998 + r * (6 ±0)` - // Estimated: `6922 + r * (6 ±0)` - // Minimum execution time: 271_540_000 picoseconds. - Weight::from_parts(298_456_935, 6922) - // Standard Error: 2_881 - .saturating_add(Weight::from_parts(1_719_337, 0).saturating_mul(r.into())) + // Measured: `974 + r * (6 ±0)` + // Estimated: `6898 + r * (6 ±0)` + // Minimum execution time: 273_473_000 picoseconds. + Weight::from_parts(298_889_279, 6898) + // Standard Error: 4_604 + .saturating_add(Weight::from_parts(1_630_175, 0).saturating_mul(r.into())) .saturating_add(RocksDbWeight::get().reads(9_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) .saturating_add(Weight::from_parts(0, 6).saturating_mul(r.into())) @@ -2599,7 +2648,7 @@ impl WeightInfo for () { /// 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) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1 w:0) @@ -2611,12 +2660,12 @@ impl WeightInfo for () { /// The range of component `r` is `[0, 1600]`. fn seal_value_transferred(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `868 + r * (6 ±0)` - // Estimated: `6817 + r * (6 ±0)` - // Minimum execution time: 274_832_000 picoseconds. - Weight::from_parts(286_078_648, 6817) - // Standard Error: 695 - .saturating_add(Weight::from_parts(345_045, 0).saturating_mul(r.into())) + // Measured: `844 + r * (6 ±0)` + // Estimated: `6790 + r * (6 ±0)` + // Minimum execution time: 262_033_000 picoseconds. + Weight::from_parts(284_293_851, 6790) + // Standard Error: 591 + .saturating_add(Weight::from_parts(369_240, 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())) @@ -2626,7 +2675,7 @@ impl WeightInfo for () { /// 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) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1 w:0) @@ -2638,12 +2687,12 @@ impl WeightInfo for () { /// The range of component `r` is `[0, 1600]`. fn seal_minimum_balance(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `866 + r * (6 ±0)` - // Estimated: `6815 + r * (6 ±0)` - // Minimum execution time: 267_337_000 picoseconds. - Weight::from_parts(283_693_170, 6815) - // Standard Error: 580 - .saturating_add(Weight::from_parts(345_350, 0).saturating_mul(r.into())) + // Measured: `842 + r * (6 ±0)` + // Estimated: `6783 + r * (6 ±0)` + // Minimum execution time: 274_568_000 picoseconds. + Weight::from_parts(294_688_466, 6783) + // Standard Error: 768 + .saturating_add(Weight::from_parts(349_584, 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())) @@ -2653,7 +2702,7 @@ impl WeightInfo for () { /// 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) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1 w:0) @@ -2665,12 +2714,12 @@ impl WeightInfo for () { /// The range of component `r` is `[0, 1600]`. fn seal_block_number(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `863 + r * (6 ±0)` - // Estimated: `6813 + r * (6 ±0)` - // Minimum execution time: 276_313_000 picoseconds. - Weight::from_parts(287_689_703, 6813) - // Standard Error: 1_251 - .saturating_add(Weight::from_parts(342_536, 0).saturating_mul(r.into())) + // Measured: `839 + r * (6 ±0)` + // Estimated: `6786 + r * (6 ±0)` + // Minimum execution time: 264_061_000 picoseconds. + Weight::from_parts(287_964_188, 6786) + // Standard Error: 490 + .saturating_add(Weight::from_parts(356_273, 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())) @@ -2680,7 +2729,7 @@ impl WeightInfo for () { /// 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) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1 w:0) @@ -2692,12 +2741,12 @@ impl WeightInfo for () { /// The range of component `r` is `[0, 1600]`. fn seal_now(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `854 + r * (6 ±0)` - // Estimated: `6799 + r * (6 ±0)` - // Minimum execution time: 274_196_000 picoseconds. - Weight::from_parts(288_641_687, 6799) - // Standard Error: 530 - .saturating_add(Weight::from_parts(336_194, 0).saturating_mul(r.into())) + // Measured: `830 + r * (6 ±0)` + // Estimated: `6771 + r * (6 ±0)` + // Minimum execution time: 275_707_000 picoseconds. + Weight::from_parts(290_797_828, 6771) + // Standard Error: 967 + .saturating_add(Weight::from_parts(352_839, 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())) @@ -2707,7 +2756,7 @@ impl WeightInfo for () { /// 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) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1 w:0) @@ -2721,12 +2770,12 @@ impl WeightInfo for () { /// The range of component `r` is `[0, 1600]`. fn seal_weight_to_fee(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `928 + r * (14 ±0)` - // Estimated: `6861 + r * (14 ±0)` - // Minimum execution time: 254_997_000 picoseconds. - Weight::from_parts(292_260_891, 6861) - // Standard Error: 1_019 - .saturating_add(Weight::from_parts(1_447_021, 0).saturating_mul(r.into())) + // Measured: `904 + r * (14 ±0)` + // Estimated: `6839 + r * (14 ±0)` + // Minimum execution time: 272_492_000 picoseconds. + Weight::from_parts(295_010_878, 6839) + // Standard Error: 2_549 + .saturating_add(Weight::from_parts(1_426_715, 0).saturating_mul(r.into())) .saturating_add(RocksDbWeight::get().reads(9_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) .saturating_add(Weight::from_parts(0, 14).saturating_mul(r.into())) @@ -2736,7 +2785,7 @@ impl WeightInfo for () { /// 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) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1 w:0) @@ -2748,12 +2797,12 @@ impl WeightInfo for () { /// The range of component `r` is `[0, 1600]`. fn seal_input(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `856 + r * (6 ±0)` - // Estimated: `6800 + r * (6 ±0)` - // Minimum execution time: 272_720_000 picoseconds. - Weight::from_parts(287_125_181, 6800) - // Standard Error: 491 - .saturating_add(Weight::from_parts(294_488, 0).saturating_mul(r.into())) + // Measured: `832 + r * (6 ±0)` + // Estimated: `6774 + r * (6 ±0)` + // Minimum execution time: 257_981_000 picoseconds. + Weight::from_parts(285_824_773, 6774) + // Standard Error: 704 + .saturating_add(Weight::from_parts(301_327, 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())) @@ -2763,7 +2812,7 @@ impl WeightInfo for () { /// 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) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1 w:0) @@ -2775,12 +2824,12 @@ impl WeightInfo for () { /// The range of component `n` is `[0, 1048576]`. fn seal_input_per_byte(n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `860` - // Estimated: `6800` - // Minimum execution time: 280_665_000 picoseconds. - Weight::from_parts(233_022_448, 6800) - // Standard Error: 23 - .saturating_add(Weight::from_parts(996, 0).saturating_mul(n.into())) + // Measured: `836` + // Estimated: `6776` + // Minimum execution time: 259_470_000 picoseconds. + Weight::from_parts(232_759_442, 6776) + // Standard Error: 24 + .saturating_add(Weight::from_parts(981, 0).saturating_mul(n.into())) .saturating_add(RocksDbWeight::get().reads(8_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) } @@ -2789,7 +2838,7 @@ impl WeightInfo for () { /// 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) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1 w:0) @@ -2801,12 +2850,12 @@ impl WeightInfo for () { /// The range of component `r` is `[0, 1]`. fn seal_return(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `844 + r * (45 ±0)` - // Estimated: `6784 + r * (45 ±0)` - // Minimum execution time: 250_335_000 picoseconds. - Weight::from_parts(278_774_071, 6784) - // Standard Error: 873_509 - .saturating_add(Weight::from_parts(4_562_628, 0).saturating_mul(r.into())) + // Measured: `820 + r * (45 ±0)` + // Estimated: `6760 + r * (45 ±0)` + // Minimum execution time: 252_740_000 picoseconds. + Weight::from_parts(278_155_436, 6760) + // Standard Error: 882_420 + .saturating_add(Weight::from_parts(755_063, 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, 45).saturating_mul(r.into())) @@ -2816,7 +2865,7 @@ impl WeightInfo for () { /// 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) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1 w:0) @@ -2828,21 +2877,21 @@ impl WeightInfo for () { /// The range of component `n` is `[0, 1048576]`. fn seal_return_per_byte(n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `854` - // Estimated: `6807` - // Minimum execution time: 278_402_000 picoseconds. - Weight::from_parts(285_491_021, 6807) - // Standard Error: 0 - .saturating_add(Weight::from_parts(312, 0).saturating_mul(n.into())) + // Measured: `830` + // Estimated: `6777` + // Minimum execution time: 257_318_000 picoseconds. + Weight::from_parts(285_765_697, 6777) + // Standard Error: 1 + .saturating_add(Weight::from_parts(322, 0).saturating_mul(n.into())) .saturating_add(RocksDbWeight::get().reads(8_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) + /// Storage: `System::Account` (r:3 w:3) /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`) /// Storage: `Contracts::ContractInfoOf` (r:1 w:1) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:2 w:2) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1 w:0) @@ -2851,31 +2900,33 @@ impl WeightInfo for () { /// Proof: `Timestamp::Now` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`) /// Storage: `Contracts::DeletionQueueCounter` (r:1 w:1) /// Proof: `Contracts::DeletionQueueCounter` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`) - /// Storage: `System::EventTopics` (r:3 w:3) + /// Storage: `System::EventTopics` (r:4 w:4) /// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `Balances::Holds` (r:1 w:1) + /// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(85), added: 2560, mode: `Measured`) /// Storage: `Contracts::DeletionQueue` (r:0 w:1) /// Proof: `Contracts::DeletionQueue` (`max_values`: None, `max_size`: Some(142), added: 2617, mode: `Measured`) /// The range of component `r` is `[0, 1]`. fn seal_terminate(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `2963 + r * (400 ±0)` - // Estimated: `8903 + r * (7825 ±0)` - // Minimum execution time: 281_030_000 picoseconds. - Weight::from_parts(305_435_226, 8903) - // Standard Error: 816_824 - .saturating_add(Weight::from_parts(131_691_873, 0).saturating_mul(r.into())) + // Measured: `2939 + r * (316 ±0)` + // Estimated: `8879 + r * (5266 ±0)` + // Minimum execution time: 280_392_000 picoseconds. + Weight::from_parts(310_023_381, 8879) + // Standard Error: 1_008_026 + .saturating_add(Weight::from_parts(130_208_818, 0).saturating_mul(r.into())) .saturating_add(RocksDbWeight::get().reads(8_u64)) - .saturating_add(RocksDbWeight::get().reads((6_u64).saturating_mul(r.into()))) + .saturating_add(RocksDbWeight::get().reads((7_u64).saturating_mul(r.into()))) .saturating_add(RocksDbWeight::get().writes(3_u64)) - .saturating_add(RocksDbWeight::get().writes((9_u64).saturating_mul(r.into()))) - .saturating_add(Weight::from_parts(0, 7825).saturating_mul(r.into())) + .saturating_add(RocksDbWeight::get().writes((10_u64).saturating_mul(r.into()))) + .saturating_add(Weight::from_parts(0, 5266).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) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1 w:0) @@ -2889,12 +2940,12 @@ impl WeightInfo for () { /// The range of component `r` is `[0, 1600]`. fn seal_random(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `935 + r * (10 ±0)` - // Estimated: `6876 + r * (10 ±0)` - // Minimum execution time: 261_369_000 picoseconds. - Weight::from_parts(300_458_315, 6876) - // Standard Error: 3_506 - .saturating_add(Weight::from_parts(1_971_733, 0).saturating_mul(r.into())) + // Measured: `911 + r * (10 ±0)` + // Estimated: `6852 + r * (10 ±0)` + // Minimum execution time: 270_547_000 picoseconds. + Weight::from_parts(295_931_189, 6852) + // Standard Error: 3_280 + .saturating_add(Weight::from_parts(1_941_248, 0).saturating_mul(r.into())) .saturating_add(RocksDbWeight::get().reads(9_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) .saturating_add(Weight::from_parts(0, 10).saturating_mul(r.into())) @@ -2904,7 +2955,7 @@ impl WeightInfo for () { /// 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) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1 w:0) @@ -2916,12 +2967,12 @@ impl WeightInfo for () { /// The range of component `r` is `[0, 1600]`. fn seal_deposit_event(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `854 + r * (10 ±0)` - // Estimated: `6799 + r * (10 ±0)` - // Minimum execution time: 262_894_000 picoseconds. - Weight::from_parts(285_321_838, 6799) - // Standard Error: 6_585 - .saturating_add(Weight::from_parts(3_998_744, 0).saturating_mul(r.into())) + // Measured: `830 + r * (10 ±0)` + // Estimated: `6772 + r * (10 ±0)` + // Minimum execution time: 255_730_000 picoseconds. + Weight::from_parts(301_859_471, 6772) + // Standard Error: 5_401 + .saturating_add(Weight::from_parts(3_887_632, 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())) @@ -2931,7 +2982,7 @@ impl WeightInfo for () { /// 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) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1 w:0) @@ -2944,14 +2995,14 @@ impl WeightInfo for () { /// The range of component `n` is `[0, 16384]`. fn seal_deposit_event_per_topic_and_byte(t: u32, n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `873 + t * (32 ±0)` - // Estimated: `6820 + t * (2508 ±0)` - // Minimum execution time: 275_909_000 picoseconds. - Weight::from_parts(289_251_568, 6820) - // Standard Error: 94_431 - .saturating_add(Weight::from_parts(3_007_409, 0).saturating_mul(t.into())) - // Standard Error: 26 - .saturating_add(Weight::from_parts(815, 0).saturating_mul(n.into())) + // Measured: `847 + t * (32 ±0)` + // Estimated: `6792 + t * (2508 ±0)` + // Minimum execution time: 276_643_000 picoseconds. + Weight::from_parts(294_275_838, 6792) + // Standard Error: 106_745 + .saturating_add(Weight::from_parts(2_831_489, 0).saturating_mul(t.into())) + // Standard Error: 29 + .saturating_add(Weight::from_parts(624, 0).saturating_mul(n.into())) .saturating_add(RocksDbWeight::get().reads(8_u64)) .saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(t.into()))) .saturating_add(RocksDbWeight::get().writes(3_u64)) @@ -2963,7 +3014,7 @@ impl WeightInfo for () { /// 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) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1 w:0) @@ -2975,12 +3026,12 @@ impl WeightInfo for () { /// The range of component `r` is `[0, 1600]`. fn seal_debug_message(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `853 + r * (7 ±0)` - // Estimated: `6797 + r * (7 ±0)` - // Minimum execution time: 168_482_000 picoseconds. - Weight::from_parts(178_065_606, 6797) - // Standard Error: 371 - .saturating_add(Weight::from_parts(242_851, 0).saturating_mul(r.into())) + // Measured: `829 + r * (7 ±0)` + // Estimated: `6774 + r * (7 ±0)` + // Minimum execution time: 169_012_000 picoseconds. + Weight::from_parts(179_567_029, 6774) + // Standard Error: 534 + .saturating_add(Weight::from_parts(249_500, 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, 7).saturating_mul(r.into())) @@ -2990,7 +3041,7 @@ impl WeightInfo for () { /// 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) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `MaxEncodedLen`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `MaxEncodedLen`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `MaxEncodedLen`) /// Storage: `Contracts::PristineCode` (r:1 w:0) @@ -3002,12 +3053,12 @@ impl WeightInfo for () { /// The range of component `i` is `[0, 1048576]`. fn seal_debug_message_per_byte(i: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `125804` - // Estimated: `131746` - // Minimum execution time: 407_401_000 picoseconds. - Weight::from_parts(426_585_443, 131746) - // Standard Error: 22 - .saturating_add(Weight::from_parts(986, 0).saturating_mul(i.into())) + // Measured: `125780` + // Estimated: `131722` + // Minimum execution time: 408_647_000 picoseconds. + Weight::from_parts(387_678_006, 131722) + // Standard Error: 12 + .saturating_add(Weight::from_parts(1_045, 0).saturating_mul(i.into())) .saturating_add(RocksDbWeight::get().reads(8_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) } @@ -3016,12 +3067,12 @@ impl WeightInfo for () { /// The range of component `r` is `[0, 800]`. fn seal_set_storage(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `921 + r * (292 ±0)` - // Estimated: `919 + r * (293 ±0)` - // Minimum execution time: 275_800_000 picoseconds. - Weight::from_parts(161_230_700, 919) - // Standard Error: 12_908 - .saturating_add(Weight::from_parts(6_965_844, 0).saturating_mul(r.into())) + // Measured: `891 + r * (292 ±0)` + // Estimated: `892 + r * (293 ±0)` + // Minimum execution time: 279_315_000 picoseconds. + Weight::from_parts(171_270_899, 892) + // Standard Error: 15_492 + .saturating_add(Weight::from_parts(6_776_878, 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(3_u64)) @@ -3033,26 +3084,26 @@ impl WeightInfo for () { /// The range of component `n` is `[0, 16384]`. fn seal_set_storage_per_new_byte(n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `1380` - // Estimated: `1356` - // Minimum execution time: 289_258_000 picoseconds. - Weight::from_parts(334_318_402, 1356) - // Standard Error: 59 - .saturating_add(Weight::from_parts(808, 0).saturating_mul(n.into())) - .saturating_add(RocksDbWeight::get().reads(10_u64)) - .saturating_add(RocksDbWeight::get().writes(6_u64)) + // Measured: `1413` + // Estimated: `1396` + // Minimum execution time: 289_666_000 picoseconds. + Weight::from_parts(348_062_625, 1396) + // Standard Error: 79 + .saturating_add(Weight::from_parts(532, 0).saturating_mul(n.into())) + .saturating_add(RocksDbWeight::get().reads(12_u64)) + .saturating_add(RocksDbWeight::get().writes(8_u64)) } /// Storage: `Skipped::Metadata` (r:0 w:0) /// Proof: `Skipped::Metadata` (`max_values`: None, `max_size`: None, mode: `Measured`) /// The range of component `n` is `[0, 16384]`. fn seal_set_storage_per_old_byte(n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `1243 + n * (1 ±0)` - // Estimated: `1243 + n * (1 ±0)` - // Minimum execution time: 277_874_000 picoseconds. - Weight::from_parts(303_956_600, 1243) - // Standard Error: 33 - .saturating_add(Weight::from_parts(58, 0).saturating_mul(n.into())) + // Measured: `1219 + n * (1 ±0)` + // Estimated: `1219 + n * (1 ±0)` + // Minimum execution time: 273_840_000 picoseconds. + Weight::from_parts(297_024_621, 1219) + // Standard Error: 55 + .saturating_add(Weight::from_parts(945, 0).saturating_mul(n.into())) .saturating_add(RocksDbWeight::get().reads(9_u64)) .saturating_add(RocksDbWeight::get().writes(4_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) @@ -3062,12 +3113,12 @@ impl WeightInfo for () { /// The range of component `r` is `[0, 800]`. fn seal_clear_storage(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `917 + r * (288 ±0)` - // Estimated: `921 + r * (289 ±0)` - // Minimum execution time: 255_230_000 picoseconds. - Weight::from_parts(163_226_984, 921) - // Standard Error: 12_691 - .saturating_add(Weight::from_parts(6_808_905, 0).saturating_mul(r.into())) + // Measured: `887 + r * (288 ±0)` + // Estimated: `893 + r * (289 ±0)` + // Minimum execution time: 279_110_000 picoseconds. + Weight::from_parts(177_898_012, 893) + // Standard Error: 16_287 + .saturating_add(Weight::from_parts(6_640_103, 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(3_u64)) @@ -3079,12 +3130,10 @@ impl WeightInfo for () { /// The range of component `n` is `[0, 16384]`. fn seal_clear_storage_per_byte(n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `1239 + n * (1 ±0)` - // Estimated: `1239 + n * (1 ±0)` - // Minimum execution time: 275_780_000 picoseconds. - Weight::from_parts(301_967_262, 1239) - // Standard Error: 34 - .saturating_add(Weight::from_parts(128, 0).saturating_mul(n.into())) + // Measured: `1215 + n * (1 ±0)` + // Estimated: `1215 + n * (1 ±0)` + // Minimum execution time: 276_566_000 picoseconds. + Weight::from_parts(304_992_376, 1215) .saturating_add(RocksDbWeight::get().reads(9_u64)) .saturating_add(RocksDbWeight::get().writes(4_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) @@ -3094,12 +3143,12 @@ impl WeightInfo for () { /// The range of component `r` is `[0, 800]`. fn seal_get_storage(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `911 + r * (296 ±0)` - // Estimated: `916 + r * (297 ±0)` - // Minimum execution time: 279_295_000 picoseconds. - Weight::from_parts(208_289_066, 916) - // Standard Error: 8_330 - .saturating_add(Weight::from_parts(5_600_713, 0).saturating_mul(r.into())) + // Measured: `887 + r * (296 ±0)` + // Estimated: `889 + r * (297 ±0)` + // Minimum execution time: 266_285_000 picoseconds. + Weight::from_parts(200_488_939, 889) + // Standard Error: 11_193 + .saturating_add(Weight::from_parts(5_467_725, 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(3_u64)) @@ -3110,12 +3159,12 @@ impl WeightInfo for () { /// The range of component `n` is `[0, 16384]`. fn seal_get_storage_per_byte(n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `1255 + n * (1 ±0)` - // Estimated: `1255 + n * (1 ±0)` - // Minimum execution time: 276_745_000 picoseconds. - Weight::from_parts(298_824_233, 1255) - // Standard Error: 36 - .saturating_add(Weight::from_parts(717, 0).saturating_mul(n.into())) + // Measured: `1231 + n * (1 ±0)` + // Estimated: `1231 + n * (1 ±0)` + // Minimum execution time: 278_625_000 picoseconds. + Weight::from_parts(304_319_493, 1231) + // Standard Error: 39 + .saturating_add(Weight::from_parts(415, 0).saturating_mul(n.into())) .saturating_add(RocksDbWeight::get().reads(9_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) @@ -3125,12 +3174,12 @@ impl WeightInfo for () { /// The range of component `r` is `[0, 800]`. fn seal_contains_storage(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `932 + r * (288 ±0)` - // Estimated: `933 + r * (289 ±0)` - // Minimum execution time: 275_137_000 picoseconds. - Weight::from_parts(196_695_898, 933) - // Standard Error: 9_207 - .saturating_add(Weight::from_parts(5_466_071, 0).saturating_mul(r.into())) + // Measured: `898 + r * (288 ±0)` + // Estimated: `895 + r * (289 ±0)` + // Minimum execution time: 271_851_000 picoseconds. + Weight::from_parts(202_164_395, 895) + // Standard Error: 11_115 + .saturating_add(Weight::from_parts(5_273_320, 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(3_u64)) @@ -3141,12 +3190,12 @@ impl WeightInfo for () { /// The range of component `n` is `[0, 16384]`. fn seal_contains_storage_per_byte(n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `1242 + n * (1 ±0)` - // Estimated: `1242 + n * (1 ±0)` - // Minimum execution time: 269_315_000 picoseconds. - Weight::from_parts(296_795_271, 1242) - // Standard Error: 39 - .saturating_add(Weight::from_parts(242, 0).saturating_mul(n.into())) + // Measured: `1218 + n * (1 ±0)` + // Estimated: `1218 + n * (1 ±0)` + // Minimum execution time: 274_200_000 picoseconds. + Weight::from_parts(299_524_586, 1218) + // Standard Error: 33 + .saturating_add(Weight::from_parts(272, 0).saturating_mul(n.into())) .saturating_add(RocksDbWeight::get().reads(9_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) @@ -3156,12 +3205,12 @@ impl WeightInfo for () { /// The range of component `r` is `[0, 800]`. fn seal_take_storage(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `905 + r * (296 ±0)` - // Estimated: `912 + r * (297 ±0)` - // Minimum execution time: 256_406_000 picoseconds. - Weight::from_parts(156_850_288, 912) - // Standard Error: 12_496 - .saturating_add(Weight::from_parts(7_055_305, 0).saturating_mul(r.into())) + // Measured: `880 + r * (296 ±0)` + // Estimated: `885 + r * (297 ±0)` + // Minimum execution time: 258_535_000 picoseconds. + Weight::from_parts(190_468_808, 885) + // Standard Error: 11_940 + .saturating_add(Weight::from_parts(6_737_079, 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(3_u64)) @@ -3173,12 +3222,12 @@ impl WeightInfo for () { /// The range of component `n` is `[0, 16384]`. fn seal_take_storage_per_byte(n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `1256 + n * (1 ±0)` - // Estimated: `1256 + n * (1 ±0)` - // Minimum execution time: 280_297_000 picoseconds. - Weight::from_parts(302_241_752, 1256) - // Standard Error: 34 - .saturating_add(Weight::from_parts(748, 0).saturating_mul(n.into())) + // Measured: `1232 + n * (1 ±0)` + // Estimated: `1232 + n * (1 ±0)` + // Minimum execution time: 280_536_000 picoseconds. + Weight::from_parts(304_479_477, 1232) + // Standard Error: 37 + .saturating_add(Weight::from_parts(534, 0).saturating_mul(n.into())) .saturating_add(RocksDbWeight::get().reads(9_u64)) .saturating_add(RocksDbWeight::get().writes(4_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) @@ -3188,7 +3237,7 @@ impl WeightInfo for () { /// 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) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1 w:0) @@ -3200,12 +3249,12 @@ impl WeightInfo for () { /// The range of component `r` is `[0, 1600]`. fn seal_transfer(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `1449 + r * (45 ±0)` - // Estimated: `7346 + r * (2520 ±0)` - // Minimum execution time: 274_834_000 picoseconds. - Weight::from_parts(176_977_557, 7346) - // Standard Error: 32_386 - .saturating_add(Weight::from_parts(39_393_162, 0).saturating_mul(r.into())) + // Measured: `1382 + r * (45 ±0)` + // Estimated: `7274 + r * (2520 ±0)` + // Minimum execution time: 260_373_000 picoseconds. + Weight::from_parts(278_290_000, 7274) + // Standard Error: 25_683 + .saturating_add(Weight::from_parts(39_264_864, 0).saturating_mul(r.into())) .saturating_add(RocksDbWeight::get().reads(9_u64)) .saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(r.into()))) .saturating_add(RocksDbWeight::get().writes(4_u64)) @@ -3217,7 +3266,7 @@ impl WeightInfo for () { /// 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) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:2 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:2 w:0) @@ -3229,24 +3278,24 @@ impl WeightInfo for () { /// The range of component `r` is `[0, 800]`. fn seal_call(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `1304 + r * (268 ±0)` - // Estimated: `9485 + r * (2744 ±0)` - // Minimum execution time: 279_802_000 picoseconds. - Weight::from_parts(287_995_000, 9485) - // Standard Error: 99_110 - .saturating_add(Weight::from_parts(245_521_843, 0).saturating_mul(r.into())) + // Measured: `1227 + r * (245 ±0)` + // Estimated: `9407 + r * (2721 ±0)` + // Minimum execution time: 277_621_000 picoseconds. + Weight::from_parts(281_775_000, 9407) + // Standard Error: 110_802 + .saturating_add(Weight::from_parts(245_363_533, 0).saturating_mul(r.into())) .saturating_add(RocksDbWeight::get().reads(11_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, 2744).saturating_mul(r.into())) + .saturating_add(Weight::from_parts(0, 2721).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) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:736 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:736 w:0) @@ -3259,11 +3308,11 @@ impl WeightInfo for () { fn seal_delegate_call(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0 + r * (576 ±0)` - // Estimated: `6803 + r * (2637 ±3)` - // Minimum execution time: 273_435_000 picoseconds. - Weight::from_parts(276_865_000, 6803) - // Standard Error: 148_051 - .saturating_add(Weight::from_parts(244_660_274, 0).saturating_mul(r.into())) + // Estimated: `6779 + r * (2637 ±3)` + // Minimum execution time: 267_314_000 picoseconds. + Weight::from_parts(279_888_000, 6779) + // Standard Error: 144_378 + .saturating_add(Weight::from_parts(244_606_414, 0).saturating_mul(r.into())) .saturating_add(RocksDbWeight::get().reads(8_u64)) .saturating_add(RocksDbWeight::get().reads((3_u64).saturating_mul(r.into()))) .saturating_add(RocksDbWeight::get().writes(3_u64)) @@ -3275,7 +3324,7 @@ impl WeightInfo for () { /// 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) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:2 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:2 w:0) @@ -3288,26 +3337,26 @@ impl WeightInfo for () { /// The range of component `c` is `[0, 1048576]`. fn seal_call_per_transfer_clone_byte(t: u32, c: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `1322 + t * (310 ±0)` - // Estimated: `12212 + t * (5260 ±0)` - // Minimum execution time: 477_593_000 picoseconds. - Weight::from_parts(69_887_451, 12212) - // Standard Error: 11_764_606 - .saturating_add(Weight::from_parts(373_361_977, 0).saturating_mul(t.into())) + // Measured: `1274 + t * (277 ±0)` + // Estimated: `12164 + t * (5227 ±0)` + // Minimum execution time: 477_589_000 picoseconds. + Weight::from_parts(70_712_793, 12164) + // Standard Error: 11_713_135 + .saturating_add(Weight::from_parts(375_371_698, 0).saturating_mul(t.into())) // Standard Error: 17 - .saturating_add(Weight::from_parts(1_000, 0).saturating_mul(c.into())) + .saturating_add(Weight::from_parts(991, 0).saturating_mul(c.into())) .saturating_add(RocksDbWeight::get().reads(13_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, 5260).saturating_mul(t.into())) + .saturating_add(Weight::from_parts(0, 5227).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) + /// Storage: `System::Account` (r:802 w:802) /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`) /// Storage: `Contracts::ContractInfoOf` (r:801 w:801) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:801 w:800) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:801 w:0) @@ -3316,29 +3365,31 @@ impl WeightInfo for () { /// Proof: `Timestamp::Now` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`) /// Storage: `Contracts::Nonce` (r:1 w:1) /// Proof: `Contracts::Nonce` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`) - /// Storage: `System::EventTopics` (r:802 w:802) + /// Storage: `Balances::Holds` (r:800 w:800) + /// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(85), added: 2560, mode: `Measured`) + /// Storage: `System::EventTopics` (r:803 w:803) /// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`) /// The range of component `r` is `[1, 800]`. fn seal_instantiate(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `1380 + r * (255 ±0)` - // Estimated: `7204 + r * (5206 ±0)` - // Minimum execution time: 652_387_000 picoseconds. - Weight::from_parts(658_670_000, 7204) - // Standard Error: 363_054 - .saturating_add(Weight::from_parts(395_547_049, 0).saturating_mul(r.into())) - .saturating_add(RocksDbWeight::get().reads(10_u64)) + // Measured: `1245 + r * (255 ±0)` + // Estimated: `9587 + r * (2731 ±0)` + // Minimum execution time: 662_502_000 picoseconds. + Weight::from_parts(671_726_000, 9587) + // Standard Error: 351_643 + .saturating_add(Weight::from_parts(390_457_971, 0).saturating_mul(r.into())) + .saturating_add(RocksDbWeight::get().reads(11_u64)) .saturating_add(RocksDbWeight::get().reads((6_u64).saturating_mul(r.into()))) - .saturating_add(RocksDbWeight::get().writes(6_u64)) + .saturating_add(RocksDbWeight::get().writes(7_u64)) .saturating_add(RocksDbWeight::get().writes((5_u64).saturating_mul(r.into()))) - .saturating_add(Weight::from_parts(0, 5206).saturating_mul(r.into())) + .saturating_add(Weight::from_parts(0, 2731).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) + /// Storage: `System::Account` (r:3 w:3) /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`) /// Storage: `Contracts::ContractInfoOf` (r:2 w:2) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:2 w:1) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:2 w:0) @@ -3347,35 +3398,37 @@ impl WeightInfo for () { /// Proof: `Timestamp::Now` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`) /// Storage: `Contracts::Nonce` (r:1 w:1) /// Proof: `Contracts::Nonce` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`) - /// Storage: `System::EventTopics` (r:3 w:3) + /// Storage: `Balances::Holds` (r:1 w:1) + /// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(85), added: 2560, mode: `Measured`) + /// Storage: `System::EventTopics` (r:4 w:4) /// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`) /// The range of component `t` is `[0, 1]`. /// The range of component `i` is `[0, 983040]`. /// The range of component `s` is `[0, 983040]`. fn seal_instantiate_per_transfer_input_salt_byte(t: u32, i: u32, s: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `1233 + t * (156 ±0)` - // Estimated: `9663 + t * (2578 ±2)` - // Minimum execution time: 2_299_620_000 picoseconds. - Weight::from_parts(1_274_859_063, 9663) - // Standard Error: 12_129_871 - .saturating_add(Weight::from_parts(16_608_792, 0).saturating_mul(t.into())) - // Standard Error: 19 - .saturating_add(Weight::from_parts(1_014, 0).saturating_mul(i.into())) - // Standard Error: 19 - .saturating_add(Weight::from_parts(1_180, 0).saturating_mul(s.into())) - .saturating_add(RocksDbWeight::get().reads(15_u64)) + // Measured: `1270 + t * (104 ±0)` + // Estimated: `12178 + t * (2549 ±1)` + // Minimum execution time: 2_675_525_000 picoseconds. + Weight::from_parts(851_421_242, 12178) + // Standard Error: 7_094_722 + .saturating_add(Weight::from_parts(112_457_697, 0).saturating_mul(t.into())) + // Standard Error: 11 + .saturating_add(Weight::from_parts(1_867, 0).saturating_mul(i.into())) + // Standard Error: 11 + .saturating_add(Weight::from_parts(1_931, 0).saturating_mul(s.into())) + .saturating_add(RocksDbWeight::get().reads(16_u64)) .saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(t.into()))) - .saturating_add(RocksDbWeight::get().writes(10_u64)) + .saturating_add(RocksDbWeight::get().writes(11_u64)) .saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(t.into()))) - .saturating_add(Weight::from_parts(0, 2578).saturating_mul(t.into())) + .saturating_add(Weight::from_parts(0, 2549).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) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1 w:0) @@ -3387,12 +3440,12 @@ impl WeightInfo for () { /// The range of component `r` is `[0, 1600]`. fn seal_hash_sha2_256(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `853 + r * (8 ±0)` - // Estimated: `6794 + r * (8 ±0)` - // Minimum execution time: 267_959_000 picoseconds. - Weight::from_parts(282_967_946, 6794) - // Standard Error: 624 - .saturating_add(Weight::from_parts(402_344, 0).saturating_mul(r.into())) + // Measured: `829 + r * (8 ±0)` + // Estimated: `6768 + r * (8 ±0)` + // Minimum execution time: 270_818_000 picoseconds. + Weight::from_parts(286_520_166, 6768) + // Standard Error: 575 + .saturating_add(Weight::from_parts(402_286, 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, 8).saturating_mul(r.into())) @@ -3402,7 +3455,7 @@ impl WeightInfo for () { /// 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) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1 w:0) @@ -3414,12 +3467,12 @@ impl WeightInfo for () { /// The range of component `n` is `[0, 1048576]`. fn seal_hash_sha2_256_per_byte(n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `861` - // Estimated: `6801` - // Minimum execution time: 274_585_000 picoseconds. - Weight::from_parts(272_480_647, 6801) + // Measured: `837` + // Estimated: `6775` + // Minimum execution time: 257_134_000 picoseconds. + Weight::from_parts(268_214_648, 6775) // Standard Error: 1 - .saturating_add(Weight::from_parts(1_089, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(1_098, 0).saturating_mul(n.into())) .saturating_add(RocksDbWeight::get().reads(8_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) } @@ -3428,7 +3481,7 @@ impl WeightInfo for () { /// 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) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1 w:0) @@ -3440,12 +3493,12 @@ impl WeightInfo for () { /// The range of component `r` is `[0, 1600]`. fn seal_hash_keccak_256(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `855 + r * (8 ±0)` - // Estimated: `6797 + r * (8 ±0)` - // Minimum execution time: 268_346_000 picoseconds. - Weight::from_parts(284_168_231, 6797) - // Standard Error: 620 - .saturating_add(Weight::from_parts(805_038, 0).saturating_mul(r.into())) + // Measured: `831 + r * (8 ±0)` + // Estimated: `6773 + r * (8 ±0)` + // Minimum execution time: 259_222_000 picoseconds. + Weight::from_parts(283_273_283, 6773) + // Standard Error: 967 + .saturating_add(Weight::from_parts(817_596, 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, 8).saturating_mul(r.into())) @@ -3455,7 +3508,7 @@ impl WeightInfo for () { /// 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) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1 w:0) @@ -3467,12 +3520,12 @@ impl WeightInfo for () { /// The range of component `n` is `[0, 1048576]`. fn seal_hash_keccak_256_per_byte(n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `863` - // Estimated: `6805` - // Minimum execution time: 273_073_000 picoseconds. - Weight::from_parts(280_346_065, 6805) + // Measured: `839` + // Estimated: `6781` + // Minimum execution time: 260_040_000 picoseconds. + Weight::from_parts(283_869_860, 6781) // Standard Error: 1 - .saturating_add(Weight::from_parts(3_357, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(3_349, 0).saturating_mul(n.into())) .saturating_add(RocksDbWeight::get().reads(8_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) } @@ -3481,7 +3534,7 @@ impl WeightInfo for () { /// 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) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1 w:0) @@ -3493,12 +3546,12 @@ impl WeightInfo for () { /// The range of component `r` is `[0, 1600]`. fn seal_hash_blake2_256(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `855 + r * (8 ±0)` - // Estimated: `6800 + r * (8 ±0)` - // Minimum execution time: 263_072_000 picoseconds. - Weight::from_parts(284_487_433, 6800) - // Standard Error: 668 - .saturating_add(Weight::from_parts(458_763, 0).saturating_mul(r.into())) + // Measured: `831 + r * (8 ±0)` + // Estimated: `6775 + r * (8 ±0)` + // Minimum execution time: 260_698_000 picoseconds. + Weight::from_parts(282_900_345, 6775) + // Standard Error: 805 + .saturating_add(Weight::from_parts(469_457, 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, 8).saturating_mul(r.into())) @@ -3508,7 +3561,7 @@ impl WeightInfo for () { /// 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) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1 w:0) @@ -3520,12 +3573,12 @@ impl WeightInfo for () { /// The range of component `n` is `[0, 1048576]`. fn seal_hash_blake2_256_per_byte(n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `863` - // Estimated: `6809` - // Minimum execution time: 271_488_000 picoseconds. - Weight::from_parts(273_877_727, 6809) + // Measured: `839` + // Estimated: `6780` + // Minimum execution time: 256_967_000 picoseconds. + Weight::from_parts(273_024_512, 6780) // Standard Error: 1 - .saturating_add(Weight::from_parts(1_202, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(1_204, 0).saturating_mul(n.into())) .saturating_add(RocksDbWeight::get().reads(8_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) } @@ -3534,7 +3587,7 @@ impl WeightInfo for () { /// 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) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1 w:0) @@ -3546,12 +3599,12 @@ impl WeightInfo for () { /// The range of component `r` is `[0, 1600]`. fn seal_hash_blake2_128(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `855 + r * (8 ±0)` - // Estimated: `6801 + r * (8 ±0)` - // Minimum execution time: 271_365_000 picoseconds. - Weight::from_parts(285_100_883, 6801) - // Standard Error: 651 - .saturating_add(Weight::from_parts(462_754, 0).saturating_mul(r.into())) + // Measured: `831 + r * (8 ±0)` + // Estimated: `6772 + r * (8 ±0)` + // Minimum execution time: 272_039_000 picoseconds. + Weight::from_parts(289_853_116, 6772) + // Standard Error: 559 + .saturating_add(Weight::from_parts(459_383, 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, 8).saturating_mul(r.into())) @@ -3561,7 +3614,7 @@ impl WeightInfo for () { /// 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) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1 w:0) @@ -3573,12 +3626,12 @@ impl WeightInfo for () { /// The range of component `n` is `[0, 1048576]`. fn seal_hash_blake2_128_per_byte(n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `863` - // Estimated: `6803` - // Minimum execution time: 272_341_000 picoseconds. - Weight::from_parts(275_388_470, 6803) + // Measured: `839` + // Estimated: `6778` + // Minimum execution time: 253_913_000 picoseconds. + Weight::from_parts(274_682_010, 6778) // Standard Error: 1 - .saturating_add(Weight::from_parts(1_192, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(1_204, 0).saturating_mul(n.into())) .saturating_add(RocksDbWeight::get().reads(8_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) } @@ -3587,7 +3640,7 @@ impl WeightInfo for () { /// 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) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1 w:0) @@ -3599,12 +3652,12 @@ impl WeightInfo for () { /// The range of component `n` is `[0, 125697]`. fn seal_sr25519_verify_per_byte(n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `988 + n * (1 ±0)` - // Estimated: `6925 + n * (1 ±0)` - // Minimum execution time: 341_302_000 picoseconds. - Weight::from_parts(354_111_630, 6925) - // Standard Error: 8 - .saturating_add(Weight::from_parts(5_913, 0).saturating_mul(n.into())) + // Measured: `964 + n * (1 ±0)` + // Estimated: `6901 + n * (1 ±0)` + // Minimum execution time: 343_955_000 picoseconds. + Weight::from_parts(350_777_388, 6901) + // Standard Error: 14 + .saturating_add(Weight::from_parts(5_915, 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())) @@ -3614,7 +3667,7 @@ impl WeightInfo for () { /// 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) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1 w:0) @@ -3626,12 +3679,12 @@ impl WeightInfo for () { /// The range of component `r` is `[0, 160]`. fn seal_sr25519_verify(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `804 + r * (112 ±0)` - // Estimated: `6742 + r * (112 ±0)` - // Minimum execution time: 275_325_000 picoseconds. - Weight::from_parts(333_041_903, 6742) - // Standard Error: 11_171 - .saturating_add(Weight::from_parts(56_605_218, 0).saturating_mul(r.into())) + // Measured: `774 + r * (112 ±0)` + // Estimated: `6715 + r * (112 ±0)` + // Minimum execution time: 268_698_000 picoseconds. + Weight::from_parts(336_398_814, 6715) + // Standard Error: 16_627 + .saturating_add(Weight::from_parts(56_155_384, 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, 112).saturating_mul(r.into())) @@ -3641,7 +3694,7 @@ impl WeightInfo for () { /// 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) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1 w:0) @@ -3653,12 +3706,12 @@ impl WeightInfo for () { /// The range of component `r` is `[0, 160]`. fn seal_ecdsa_recover(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `898 + r * (76 ±0)` - // Estimated: `6793 + r * (77 ±0)` - // Minimum execution time: 274_165_000 picoseconds. - Weight::from_parts(347_487_800, 6793) - // Standard Error: 15_398 - .saturating_add(Weight::from_parts(46_072_020, 0).saturating_mul(r.into())) + // Measured: `874 + r * (76 ±0)` + // Estimated: `6768 + r * (77 ±0)` + // Minimum execution time: 258_906_000 picoseconds. + Weight::from_parts(340_672_829, 6768) + // Standard Error: 18_295 + .saturating_add(Weight::from_parts(46_106_884, 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, 77).saturating_mul(r.into())) @@ -3668,7 +3721,7 @@ impl WeightInfo for () { /// 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) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1 w:0) @@ -3680,12 +3733,12 @@ impl WeightInfo for () { /// The range of component `r` is `[0, 160]`. fn seal_ecdsa_to_eth_address(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `868 + r * (42 ±0)` - // Estimated: `6807 + r * (42 ±0)` - // Minimum execution time: 270_855_000 picoseconds. - Weight::from_parts(320_777_105, 6807) - // Standard Error: 11_106 - .saturating_add(Weight::from_parts(12_053_053, 0).saturating_mul(r.into())) + // Measured: `844 + r * (42 ±0)` + // Estimated: `6783 + r * (42 ±0)` + // Minimum execution time: 275_105_000 picoseconds. + Weight::from_parts(313_700_348, 6783) + // Standard Error: 11_960 + .saturating_add(Weight::from_parts(12_050_300, 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, 42).saturating_mul(r.into())) @@ -3695,7 +3748,7 @@ impl WeightInfo for () { /// 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) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1536 w:1536) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1536 w:0) @@ -3708,11 +3761,11 @@ impl WeightInfo for () { fn seal_set_code_hash(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0 + r * (965 ±0)` - // Estimated: `6798 + r * (3090 ±10)` - // Minimum execution time: 257_732_000 picoseconds. - Weight::from_parts(280_982_000, 6798) - // Standard Error: 68_194 - .saturating_add(Weight::from_parts(27_413_991, 0).saturating_mul(r.into())) + // Estimated: `6774 + r * (3090 ±7)` + // Minimum execution time: 259_178_000 picoseconds. + Weight::from_parts(275_643_000, 6774) + // Standard Error: 54_044 + .saturating_add(Weight::from_parts(26_026_930, 0).saturating_mul(r.into())) .saturating_add(RocksDbWeight::get().reads(8_u64)) .saturating_add(RocksDbWeight::get().reads((3_u64).saturating_mul(r.into()))) .saturating_add(RocksDbWeight::get().writes(3_u64)) @@ -3724,7 +3777,7 @@ impl WeightInfo for () { /// 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) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:33 w:32) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1 w:0) @@ -3736,12 +3789,12 @@ impl WeightInfo for () { /// The range of component `r` is `[0, 32]`. fn add_delegate_dependency(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `918 + r * (132 ±0)` - // Estimated: `6870 + r * (2606 ±0)` - // Minimum execution time: 278_285_000 picoseconds. - Weight::from_parts(298_012_554, 6870) - // Standard Error: 24_160 - .saturating_add(Weight::from_parts(6_363_118, 0).saturating_mul(r.into())) + // Measured: `895 + r * (131 ±0)` + // Estimated: `6845 + r * (2606 ±0)` + // Minimum execution time: 263_386_000 picoseconds. + Weight::from_parts(295_443_439, 6845) + // Standard Error: 24_422 + .saturating_add(Weight::from_parts(6_429_537, 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(3_u64)) @@ -3753,7 +3806,7 @@ impl WeightInfo for () { /// 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) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `MaxEncodedLen`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `MaxEncodedLen`) /// Storage: `Contracts::CodeInfoOf` (r:33 w:32) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `MaxEncodedLen`) /// Storage: `Contracts::PristineCode` (r:1 w:0) @@ -3765,12 +3818,12 @@ impl WeightInfo for () { /// The range of component `r` is `[0, 32]`. fn remove_delegate_dependency(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `965 + r * (183 ±0)` + // Measured: `936 + r * (183 ±0)` // Estimated: `129453 + r * (2568 ±0)` - // Minimum execution time: 258_198_000 picoseconds. - Weight::from_parts(290_090_206, 129453) - // Standard Error: 19_792 - .saturating_add(Weight::from_parts(6_004_811, 0).saturating_mul(r.into())) + // Minimum execution time: 261_371_000 picoseconds. + Weight::from_parts(297_493_194, 129453) + // Standard Error: 23_734 + .saturating_add(Weight::from_parts(5_673_169, 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(3_u64)) @@ -3782,7 +3835,7 @@ impl WeightInfo for () { /// 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) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1 w:0) @@ -3794,12 +3847,12 @@ impl WeightInfo for () { /// The range of component `r` is `[0, 1600]`. fn seal_reentrance_count(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `849 + r * (3 ±0)` - // Estimated: `6799 + r * (3 ±0)` - // Minimum execution time: 263_315_000 picoseconds. - Weight::from_parts(284_093_748, 6799) - // Standard Error: 371 - .saturating_add(Weight::from_parts(176_949, 0).saturating_mul(r.into())) + // Measured: `825 + r * (3 ±0)` + // Estimated: `6771 + r * (3 ±0)` + // Minimum execution time: 275_558_000 picoseconds. + Weight::from_parts(287_220_765, 6771) + // Standard Error: 437 + .saturating_add(Weight::from_parts(184_125, 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, 3).saturating_mul(r.into())) @@ -3809,7 +3862,7 @@ impl WeightInfo for () { /// 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) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1 w:0) @@ -3821,12 +3874,12 @@ impl WeightInfo for () { /// The range of component `r` is `[0, 1600]`. fn seal_account_reentrance_count(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `2082 + r * (39 ±0)` - // Estimated: `7886 + r * (40 ±0)` - // Minimum execution time: 274_583_000 picoseconds. - Weight::from_parts(352_081_486, 7886) - // Standard Error: 1_799 - .saturating_add(Weight::from_parts(313_433, 0).saturating_mul(r.into())) + // Measured: `2076 + r * (39 ±0)` + // Estimated: `7866 + r * (40 ±0)` + // Minimum execution time: 265_752_000 picoseconds. + Weight::from_parts(331_187_665, 7866) + // Standard Error: 1_950 + .saturating_add(Weight::from_parts(312_262, 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, 40).saturating_mul(r.into())) @@ -3836,7 +3889,7 @@ impl WeightInfo for () { /// 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) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1819), added: 4294, mode: `Measured`) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1 w:0) @@ -3850,12 +3903,12 @@ impl WeightInfo for () { /// The range of component `r` is `[0, 1600]`. fn seal_instantiation_nonce(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `852 + r * (3 ±0)` - // Estimated: `6799 + r * (3 ±0)` - // Minimum execution time: 267_291_000 picoseconds. - Weight::from_parts(287_500_540, 6799) - // Standard Error: 393 - .saturating_add(Weight::from_parts(152_587, 0).saturating_mul(r.into())) + // Measured: `828 + r * (3 ±0)` + // Estimated: `6768 + r * (3 ±0)` + // Minimum execution time: 257_114_000 picoseconds. + Weight::from_parts(286_686_654, 6768) + // Standard Error: 426 + .saturating_add(Weight::from_parts(162_295, 0).saturating_mul(r.into())) .saturating_add(RocksDbWeight::get().reads(9_u64)) .saturating_add(RocksDbWeight::get().writes(4_u64)) .saturating_add(Weight::from_parts(0, 3).saturating_mul(r.into())) @@ -3865,9 +3918,9 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_440_000 picoseconds. - Weight::from_parts(1_656_631, 0) - // Standard Error: 13 - .saturating_add(Weight::from_parts(10_486, 0).saturating_mul(r.into())) + // Minimum execution time: 1_388_000 picoseconds. + Weight::from_parts(1_680_408, 0) + // Standard Error: 21 + .saturating_add(Weight::from_parts(10_564, 0).saturating_mul(r.into())) } } diff --git a/frame/support/src/traits/tokens/fungible/hold.rs b/frame/support/src/traits/tokens/fungible/hold.rs index 2605d1797ed2e..3a0ff62e0965a 100644 --- a/frame/support/src/traits/tokens/fungible/hold.rs +++ b/frame/support/src/traits/tokens/fungible/hold.rs @@ -269,7 +269,7 @@ pub trait Mutate: /// Transfer held funds into a destination account. /// - /// If `on_hold` is `true`, then the destination account must already exist and the assets + /// If `mode` is `OnHold`, then the destination account must already exist and the assets /// transferred will still be on hold in the destination account. If not, then the destination /// account need not already exist, but must be creatable. /// diff --git a/frame/support/src/traits/tokens/fungibles/hold.rs b/frame/support/src/traits/tokens/fungibles/hold.rs index 2adc00bb4d05a..55f9d51c65564 100644 --- a/frame/support/src/traits/tokens/fungibles/hold.rs +++ b/frame/support/src/traits/tokens/fungibles/hold.rs @@ -332,7 +332,7 @@ pub trait Mutate: /// Transfer held funds into a destination account. /// - /// If `on_hold` is `true`, then the destination account must already exist and the assets + /// If `mode` is `OnHold`, then the destination account must already exist and the assets /// transferred will still be on hold in the destination account. If not, then the destination /// account need not already exist, but must be creatable. ///