diff --git a/frame/contracts/fixtures/caller_contract.wat b/frame/contracts/fixtures/caller_contract.wat index 9c7cdf62abfc9..f9caf49f29ca8 100644 --- a/frame/contracts/fixtures/caller_contract.wat +++ b/frame/contracts/fixtures/caller_contract.wat @@ -16,27 +16,11 @@ ) ) - (func $current_balance (param $sp i32) (result i64) - (i32.store - (i32.sub (get_local $sp) (i32.const 16)) - (i32.const 8) - ) - (call $seal_balance - (i32.sub (get_local $sp) (i32.const 8)) - (i32.sub (get_local $sp) (i32.const 16)) - ) - (call $assert - (i32.eq (i32.load (i32.sub (get_local $sp) (i32.const 16))) (i32.const 8)) - ) - (i64.load (i32.sub (get_local $sp) (i32.const 8))) - ) - (func (export "deploy")) (func (export "call") (local $sp i32) (local $exit_code i32) - (local $balance i64) ;; Length of the buffer (i32.store (i32.const 20) (i32.const 32)) @@ -54,9 +38,6 @@ ;; Read current balance into local variable. (set_local $sp (i32.const 1024)) - (set_local $balance - (call $current_balance (get_local $sp)) - ) ;; Fail to deploy the contract since it returns a non-zero exit status. (set_local $exit_code @@ -82,11 +63,6 @@ (i32.eq (get_local $exit_code) (i32.const 2)) ;; ReturnCode::CalleeReverted ) - ;; Check that balance has not changed. - (call $assert - (i64.eq (get_local $balance) (call $current_balance (get_local $sp))) - ) - ;; Fail to deploy the contract due to insufficient gas. (set_local $exit_code (call $seal_instantiate @@ -112,11 +88,6 @@ (i32.eq (get_local $exit_code) (i32.const 1)) ;; ReturnCode::CalleeTrapped ) - ;; Check that balance has not changed. - (call $assert - (i64.eq (get_local $balance) (call $current_balance (get_local $sp))) - ) - ;; Length of the output buffer (i32.store (i32.sub (get_local $sp) (i32.const 4)) @@ -153,14 +124,6 @@ (i32.eq (i32.load (i32.sub (get_local $sp) (i32.const 4))) (i32.const 32)) ) - ;; Check that balance has been deducted. - (set_local $balance - (i64.sub (get_local $balance) (i64.load (i32.const 0))) - ) - (call $assert - (i64.eq (get_local $balance) (call $current_balance (get_local $sp))) - ) - ;; Zero out destination buffer of output (i32.store (i32.sub (get_local $sp) (i32.const 4)) @@ -204,11 +167,6 @@ ) ) - ;; Check that balance has not changed. - (call $assert - (i64.eq (get_local $balance) (call $current_balance (get_local $sp))) - ) - ;; Fail to call the contract due to insufficient gas. (set_local $exit_code (call $seal_call @@ -229,11 +187,6 @@ (i32.eq (get_local $exit_code) (i32.const 1)) ;; ReturnCode::CalleeTrapped ) - ;; Check that balance has not changed. - (call $assert - (i64.eq (get_local $balance) (call $current_balance (get_local $sp))) - ) - ;; Zero out destination buffer of output (i32.store (i32.sub (get_local $sp) (i32.const 4)) @@ -276,14 +229,6 @@ (i32.const 0x77665544) ) ) - - ;; Check that balance has been deducted. - (set_local $balance - (i64.sub (get_local $balance) (i64.load (i32.const 0))) - ) - (call $assert - (i64.eq (get_local $balance) (call $current_balance (get_local $sp))) - ) ) (data (i32.const 0) "\00\80") ;; The value to transfer on instantiation and calls. diff --git a/frame/contracts/fixtures/drain.wat b/frame/contracts/fixtures/drain.wat index 94c6518422667..9f126898fac81 100644 --- a/frame/contracts/fixtures/drain.wat +++ b/frame/contracts/fixtures/drain.wat @@ -34,8 +34,7 @@ ) ;; Try to self-destruct by sending full balance to the 0 address. - ;; All the *free* balance will be send away, which is a valid thing to do - ;; because the storage deposits will keep the account alive. + ;; The call will fail because a contract transfer has a keep alive requirement (call $assert (i32.eq (call $seal_transfer @@ -44,7 +43,7 @@ (i32.const 0) ;; Pointer to the buffer with value to transfer (i32.const 8) ;; Length of the buffer with value to transfer ) - (i32.const 0) ;; ReturnCode::Success + (i32.const 5) ;; ReturnCode::TransferFailed ) ) ) diff --git a/frame/contracts/primitives/src/lib.rs b/frame/contracts/primitives/src/lib.rs index 1811ae09c0572..f5b8da249517e 100644 --- a/frame/contracts/primitives/src/lib.rs +++ b/frame/contracts/primitives/src/lib.rs @@ -47,10 +47,12 @@ pub struct ContractResult { /// Additionally, any `seal_call` or `seal_instantiate` makes use of pre-charging /// when a non-zero `gas_limit` argument is supplied. pub gas_required: Weight, - /// How much balance was deposited and reserved during execution in order to pay for storage. + /// How much balance was paid by the origin into the contract's deposit account in order to + /// pay for storage. /// - /// The storage deposit is never actually charged from the caller in case of [`Self::result`] - /// is `Err`. This is because on error all storage changes are rolled back. + /// The storage deposit is never actually charged from the origin in case of [`Self::result`] + /// is `Err`. This is because on error all storage changes are rolled back including the + /// payment of the deposit. pub storage_deposit: StorageDeposit, /// An optional debug message. This message is only filled when explicitly requested /// by the code that calls into the contract. Otherwise it is empty. @@ -159,12 +161,12 @@ pub enum StorageDeposit { /// The transaction reduced storage consumption. /// /// This means that the specified amount of balance was transferred from the involved - /// contracts to the call origin. + /// deposit accounts to the origin. Refund(Balance), - /// The transaction increased overall storage usage. + /// The transaction increased storage consumption. /// - /// This means that the specified amount of balance was transferred from the call origin - /// to the contracts involved. + /// This means that the specified amount of balance was transferred from the origin + /// to the involved deposit accounts. Charge(Balance), } diff --git a/frame/contracts/src/address.rs b/frame/contracts/src/address.rs new file mode 100644 index 0000000000000..4b1bb1f48b91c --- /dev/null +++ b/frame/contracts/src/address.rs @@ -0,0 +1,81 @@ +// This file is part of Substrate. + +// Copyright (C) 2018-2022 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. + +//! Functions that deal with address derivation. + +use crate::{CodeHash, Config}; +use codec::{Decode, Encode}; +use sp_runtime::traits::{Hash, TrailingZeroInput}; + +/// Provides the contract address generation method. +/// +/// See [`DefaultAddressGenerator`] for the default implementation. +/// +/// # Note for implementors +/// +/// 1. Make sure that there are no collisions, different inputs never lead to the same output. +/// 2. Make sure that the same inputs lead to the same output. +pub trait AddressGenerator { + /// The address of a contract based on the given instantiate parameters. + /// + /// Changing the formular for an already deployed chain is fine as long as no collisons + /// with the old formular. Changes only affect existing contracts. + fn contract_address( + deploying_address: &T::AccountId, + code_hash: &CodeHash, + 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. +/// +/// This is the default address generator used by contract instantiation. Its result +/// is only dependent on its inputs. It can therefore be used to reliably predict the +/// address of a contract. This is akin to the formula of eth's CREATE2 opcode. There +/// is no CREATE equivalent because CREATE2 is strictly more powerful. +/// Formula: +/// `hash("contract_addr_v1" ++ deploying_address ++ code_hash ++ input_data ++ salt)` +pub struct DefaultAddressGenerator; + +impl AddressGenerator for DefaultAddressGenerator { + /// Formula: `hash("contract_addr_v1" ++ deploying_address ++ code_hash ++ input_data ++ salt)` + fn contract_address( + deploying_address: &T::AccountId, + code_hash: &CodeHash, + input_data: &[u8], + salt: &[u8], + ) -> T::AccountId { + let entropy = (b"contract_addr_v1", deploying_address, code_hash, input_data, salt) + .using_encoded(T::Hashing::hash); + 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 55d315d5c7be1..ed41cece17301 100644 --- a/frame/contracts/src/benchmarking/mod.rs +++ b/frame/contracts/src/benchmarking/mod.rs @@ -32,7 +32,6 @@ use self::{ use crate::{ exec::{AccountIdOf, FixSizedKey, VarSizedKey}, schedule::{API_BENCHMARK_BATCH_SIZE, INSTR_BENCHMARK_BATCH_SIZE}, - storage::Storage, wasm::CallFlags, Pallet as Contracts, *, }; @@ -133,14 +132,8 @@ where fn store(&self, items: &Vec<(FixSizedKey, Vec)>) -> Result<(), &'static str> { let info = self.info()?; for item in items { - Storage::::write( - &info.trie_id, - &item.0 as &FixSizedKey, - Some(item.1.clone()), - None, - false, - ) - .map_err(|_| "Failed to write storage to restoration dest")?; + info.write(&item.0 as &FixSizedKey, Some(item.1.clone()), None, false) + .map_err(|_| "Failed to write storage to restoration dest")?; } >::insert(&self.account_id, info); Ok(()) @@ -207,7 +200,7 @@ benchmarks! { // The base weight consumed on processing contracts deletion queue. #[pov_mode = Measured] on_process_deletion_queue_batch {}: { - Storage::::process_deletion_queue_batch(Weight::MAX) + ContractInfo::::process_deletion_queue_batch(Weight::MAX) } #[skip_meta] @@ -215,9 +208,9 @@ benchmarks! { on_initialize_per_trie_key { let k in 0..1024; let instance = Contract::::with_storage(WasmModule::dummy(), k, T::Schedule::get().limits.payload_len)?; - Storage::::queue_trie_for_deletion(&instance.info()?)?; + instance.info()?.queue_trie_for_deletion()?; }: { - Storage::::process_deletion_queue_batch(Weight::MAX) + ContractInfo::::process_deletion_queue_batch(Weight::MAX) } #[pov_mode = Measured] @@ -225,11 +218,11 @@ benchmarks! { let q in 0..1024.min(T::DeletionQueueDepth::get()); for i in 0 .. q { let instance = Contract::::with_index(i, WasmModule::dummy(), vec![])?; - Storage::::queue_trie_for_deletion(&instance.info()?)?; + instance.info()?.queue_trie_for_deletion()?; ContractInfoOf::::remove(instance.account_id); } }: { - Storage::::process_deletion_queue_batch(Weight::MAX) + ContractInfo::::process_deletion_queue_batch(Weight::MAX) } // This benchmarks the additional weight that is charged when a contract is executed the @@ -293,18 +286,16 @@ benchmarks! { let addr = Contracts::::contract_address(&caller, &hash, &input, &salt); }: _(origin, value, Weight::MAX, None, code, input, salt) verify { - // the contract itself does not trigger any reserves - let deposit = T::Currency::reserved_balance(&addr); + let deposit_account = Contract::::address_info(&addr)?.deposit_account().clone(); + let deposit = T::Currency::free_balance(&deposit_account); // uploading the code reserves some balance in the callers account let code_deposit = T::Currency::reserved_balance(&caller); assert_eq!( T::Currency::free_balance(&caller), - caller_funding::() - value - deposit - code_deposit, + caller_funding::() - value - deposit - code_deposit - Pallet::::min_balance(), ); // contract has the full value - assert_eq!(T::Currency::free_balance(&addr), value); - // instantiate should leave a contract - Contract::::address_info(&addr)?; + assert_eq!(T::Currency::free_balance(&addr), value + Pallet::::min_balance()); } // Instantiate uses a dummy contract constructor to measure the overhead of the instantiate. @@ -325,14 +316,15 @@ benchmarks! { Contracts::::store_code_raw(code, caller.clone())?; }: _(origin, value, Weight::MAX, None, hash, input, salt) verify { - // the contract itself does not trigger any reserves - let deposit = T::Currency::reserved_balance(&addr); + let deposit_account = Contract::::address_info(&addr)?.deposit_account().clone(); + let deposit = T::Currency::free_balance(&deposit_account); // value was removed from the caller - assert_eq!(T::Currency::free_balance(&caller), caller_funding::() - value - deposit); + assert_eq!( + T::Currency::free_balance(&caller), + caller_funding::() - value - deposit - Pallet::::min_balance(), + ); // contract has the full value - assert_eq!(T::Currency::free_balance(&addr), value); - // instantiate should leave a contract - Contract::::address_info(&addr)?; + assert_eq!(T::Currency::free_balance(&addr), value + Pallet::::min_balance()); } // We just call a dummy contract to measure the overhead of the call extrinsic. @@ -348,18 +340,19 @@ 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::free_balance(&instance.account_id); + let before_deposit = T::Currency::free_balance(&deposit_account); }: _(origin, callee, value, Weight::MAX, None, data) verify { - // the contract itself does not trigger any reserves - let deposit = T::Currency::reserved_balance(&instance.account_id); + let deposit = T::Currency::free_balance(&deposit_account); // value and value transfered via call should be removed from the caller assert_eq!( T::Currency::free_balance(&instance.caller), - caller_funding::() - instance.value - value - deposit, + caller_funding::() - instance.value - value - deposit - Pallet::::min_balance(), ); // contract should have received the value assert_eq!(T::Currency::free_balance(&instance.account_id), before + value); @@ -798,14 +791,16 @@ 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::free_balance(&instance.account_id), Pallet::::min_balance()); - assert_ne!(T::Currency::reserved_balance(&instance.account_id), 0u32.into()); + assert_eq!(T::Currency::free_balance(&instance.account_id), Pallet::::min_balance() * 2u32.into()); + assert_ne!(T::Currency::free_balance(&deposit_account), 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(&beneficiary), Pallet::::min_balance()); + assert_eq!(T::Currency::total_balance(&deposit_account), 0u32.into()); + assert_eq!(T::Currency::total_balance(&beneficiary), Pallet::::min_balance() * 2u32.into()); } } @@ -1039,8 +1034,7 @@ benchmarks! { let instance = Contract::::new(code, vec![])?; let info = instance.info()?; for key in keys { - Storage::::write( - &info.trie_id, + info.write( &VarSizedKey::::try_from(key).map_err(|e| "Key has wrong length")?, Some(vec![]), None, @@ -1088,8 +1082,7 @@ benchmarks! { let instance = Contract::::new(code, vec![])?; let info = instance.info()?; for key in keys { - Storage::::write( - &info.trie_id, + info.write( &VarSizedKey::::try_from(key).map_err(|e| "Key has wrong length")?, Some(vec![]), None, @@ -1137,8 +1130,7 @@ benchmarks! { let instance = Contract::::new(code, vec![])?; let info = instance.info()?; for key in keys { - Storage::::write( - &info.trie_id, + info.write( &VarSizedKey::::try_from(key).map_err(|e| "Key has wrong length")?, Some(vec![42u8; (n * 2048) as usize]), // value_len increments by 2kb up to max payload_len None, @@ -1188,8 +1180,7 @@ benchmarks! { let instance = Contract::::new(code, vec![])?; let info = instance.info()?; for key in keys { - Storage::::write( - &info.trie_id, + info.write( &VarSizedKey::::try_from(key).map_err(|e| "Key has wrong length")?, Some(vec![]), None, @@ -1236,8 +1227,7 @@ benchmarks! { let instance = Contract::::new(code, vec![])?; let info = instance.info()?; for key in keys { - Storage::::write( - &info.trie_id, + info.write( &VarSizedKey::::try_from(key).map_err(|e| "Key has wrong length")?, Some(vec![42u8; (n * 2048) as usize]), // value_len increments by 2kb up to max payload_len None, @@ -1291,8 +1281,7 @@ benchmarks! { let instance = Contract::::new(code, vec![])?; let info = instance.info()?; for key in keys { - Storage::::write( - &info.trie_id, + info.write( &VarSizedKey::::try_from(key).map_err(|e| "Key has wrong length")?, Some(vec![]), None, @@ -1346,8 +1335,7 @@ benchmarks! { let instance = Contract::::new(code, vec![])?; let info = instance.info()?; for key in keys { - Storage::::write( - &info.trie_id, + info.write( &VarSizedKey::::try_from(key).map_err(|e| "Key has wrong length")?, Some(vec![42u8; (n * 2048) as usize]), // value_len increments by 2kb up to max payload_len None, @@ -1396,8 +1384,7 @@ benchmarks! { let instance = Contract::::new(code, vec![])?; let info = instance.info()?; for key in keys { - Storage::::write( - &info.trie_id, + info.write( &VarSizedKey::::try_from(key).map_err(|e| "Key has wrong length")?, Some(vec![]), None, @@ -1444,8 +1431,7 @@ benchmarks! { let instance = Contract::::new(code, vec![])?; let info = instance.info()?; for key in keys { - Storage::::write( - &info.trie_id, + info.write( &VarSizedKey::::try_from(key).map_err(|e| "Key has wrong length")?, Some(vec![42u8; (n * 2048) as usize]), // value_len increments by 2kb up to max payload_len None, @@ -1499,8 +1485,7 @@ benchmarks! { let instance = Contract::::new(code, vec![])?; let info = instance.info()?; for key in keys { - Storage::::write( - &info.trie_id, + info.write( &VarSizedKey::::try_from(key).map_err(|e| "Key has wrong length")?, Some(vec![]), None, @@ -1554,8 +1539,7 @@ benchmarks! { let instance = Contract::::new(code, vec![])?; let info = instance.info()?; for key in keys { - Storage::::write( - &info.trie_id, + info.write( &VarSizedKey::::try_from(key).map_err(|e| "Key has wrong length")?, Some(vec![42u8; (n * 2048) as usize]), // value_len increments by 2kb up to max payload_len None, @@ -1884,7 +1868,7 @@ benchmarks! { .. Default::default() }); let instance = Contract::::new(code, vec![])?; - instance.set_balance(value * (r * API_BENCHMARK_BATCH_SIZE + 1).into()); + instance.set_balance((value + Pallet::::min_balance()) * (r * API_BENCHMARK_BATCH_SIZE + 1).into()); let origin = RawOrigin::Signed(instance.caller.clone()); let callee = instance.addr.clone(); let addresses = hashes @@ -1997,7 +1981,7 @@ benchmarks! { .. Default::default() }); let instance = Contract::::new(code, vec![])?; - instance.set_balance(value * (API_BENCHMARK_BATCH_SIZE + 1).into()); + instance.set_balance((value + Pallet::::min_balance()) * (API_BENCHMARK_BATCH_SIZE + 1).into()); let origin = RawOrigin::Signed(instance.caller.clone()); }: call(origin, instance.addr, 0u32.into(), Weight::MAX, None, vec![]) @@ -3113,8 +3097,8 @@ benchmarks! { { let weight_limit = T::DeletionWeightLimit::get(); let max_queue_depth = T::DeletionQueueDepth::get() as usize; - let empty_queue_throughput = Storage::::deletion_budget(0, weight_limit); - let full_queue_throughput = Storage::::deletion_budget(max_queue_depth, weight_limit); + let empty_queue_throughput = ContractInfo::::deletion_budget(0, weight_limit); + let full_queue_throughput = ContractInfo::::deletion_budget(max_queue_depth, weight_limit); println!("{:#?}", Schedule::::default()); println!("###############################################"); println!("Lazy deletion weight per key: {}", empty_queue_throughput.0); diff --git a/frame/contracts/src/exec.rs b/frame/contracts/src/exec.rs index 9b033a76cf0ff..92930cc791397 100644 --- a/frame/contracts/src/exec.rs +++ b/frame/contracts/src/exec.rs @@ -17,9 +17,9 @@ use crate::{ gas::GasMeter, - storage::{self, Storage, WriteOutcome}, + storage::{self, DepositAccount, WriteOutcome}, BalanceOf, CodeHash, Config, ContractInfo, ContractInfoOf, DebugBufferVec, Determinism, Error, - Event, Nonce, Pallet as Contracts, Schedule, + Event, Nonce, Pallet as Contracts, Schedule, System, }; use frame_support::{ crypto::ecdsa::ECDSAExt, @@ -492,7 +492,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, + Terminated(DepositAccount), } impl CachedContract { @@ -513,6 +513,15 @@ 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 { @@ -591,7 +600,9 @@ impl CachedContract { /// Terminate and return the contract info. fn terminate(&mut self, account_id: &T::AccountId) -> ContractInfo { self.load(account_id); - get_cached_or_panic_after_load!(mem::replace(self, Self::Terminated)) + 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))) } } @@ -751,9 +762,7 @@ where input_data, salt, ); - let trie_id = Storage::::generate_trie_id(&account_id, nonce); - let contract = - Storage::::new_contract(&account_id, trie_id, *executable.code_hash())?; + let contract = ContractInfo::new(&account_id, nonce, *executable.code_hash())?; ( account_id, contract, @@ -873,7 +882,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()) } @@ -962,11 +971,21 @@ where // Record the storage meter changes of the nested call into the parent meter. // If the dropped frame's contract wasn't terminated we update the deposit counter - // in its contract info. The load is necessary to to pull it from storage in case + // 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, account_id, contract.as_mut()); + prev.nested_storage + .absorb(frame.nested_storage, deposit_account, contract.as_mut()); // In case the contract wasn't terminated we need to persist changes made to it. if let Some(contract) = contract { @@ -1001,10 +1020,14 @@ 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), - &self.first_frame.account_id, + deposit_account, contract.as_deref_mut(), ); if let Some(contract) = contract { @@ -1182,19 +1205,21 @@ where } fn terminate(&mut self, beneficiary: &AccountIdOf) -> Result<(), DispatchError> { + use frame_support::traits::fungible::Inspect; if self.is_recursive() { return Err(Error::::TerminatedWhileReentrant.into()) } let frame = self.top_frame_mut(); let info = frame.terminate(); frame.nested_storage.terminate(&info); - Storage::::queue_trie_for_deletion(&info)?; - >::transfer( - ExistenceRequirement::AllowDeath, + System::::dec_consumers(&frame.account_id); + T::Currency::transfer( &frame.account_id, beneficiary, - T::Currency::free_balance(&frame.account_id), + T::Currency::reducible_balance(&frame.account_id, false), + ExistenceRequirement::AllowDeath, )?; + info.queue_trie_for_deletion()?; ContractInfoOf::::remove(&frame.account_id); E::remove_user(info.code_hash); Contracts::::deposit_event( @@ -1212,19 +1237,19 @@ where } fn get_storage(&mut self, key: &FixSizedKey) -> Option> { - Storage::::read(&self.top_frame_mut().contract_info().trie_id, key) + self.top_frame_mut().contract_info().read(key) } fn get_storage_transparent(&mut self, key: &VarSizedKey) -> Option> { - Storage::::read(&self.top_frame_mut().contract_info().trie_id, key) + self.top_frame_mut().contract_info().read(key) } fn get_storage_size(&mut self, key: &FixSizedKey) -> Option { - Storage::::size(&self.top_frame_mut().contract_info().trie_id, key) + self.top_frame_mut().contract_info().size(key) } fn get_storage_size_transparent(&mut self, key: &VarSizedKey) -> Option { - Storage::::size(&self.top_frame_mut().contract_info().trie_id, key) + self.top_frame_mut().contract_info().size(key) } fn set_storage( @@ -1234,8 +1259,7 @@ where take_old: bool, ) -> Result { let frame = self.top_frame_mut(); - Storage::::write( - &frame.contract_info.get(&frame.account_id).trie_id, + frame.contract_info.get(&frame.account_id).write( key, value, Some(&mut frame.nested_storage), @@ -1250,8 +1274,7 @@ where take_old: bool, ) -> Result { let frame = self.top_frame_mut(); - Storage::::write( - &frame.contract_info.get(&frame.account_id).trie_id, + frame.contract_info.get(&frame.account_id).write( key, value, Some(&mut frame.nested_storage), @@ -1438,7 +1461,6 @@ mod tests { use crate::{ exec::ExportedFunction::*, gas::GasMeter, - storage::Storage, tests::{ test_utils::{get_balance, hash, place_contract, set_balance}, ExtBuilder, RuntimeCall, RuntimeEvent as MetaEvent, Test, TestFilter, ALICE, BOB, @@ -1891,9 +1913,8 @@ mod tests { let mut gas_meter = GasMeter::::new(GAS_LIMIT); let executable = MockExecutable::from_storage(input_data_ch, &schedule, &mut gas_meter).unwrap(); - set_balance(&ALICE, min_balance * 1000); - let mut storage_meter = - storage::meter::Meter::new(&ALICE, Some(min_balance * 100), min_balance).unwrap(); + set_balance(&ALICE, min_balance * 10_000); + let mut storage_meter = storage::meter::Meter::new(&ALICE, None, min_balance).unwrap(); let result = MockStack::run_instantiate( ALICE, @@ -2231,7 +2252,7 @@ mod tests { // Check that the newly created account has the expected code hash and // there are instantiation event. assert_eq!( - Storage::::code_hash(&instantiated_contract_address).unwrap(), + ContractInfo::::load_code_hash(&instantiated_contract_address).unwrap(), dummy_ch ); assert_eq!( @@ -2273,7 +2294,7 @@ mod tests { ); // Check that the account has not been created. - assert!(Storage::::code_hash(&instantiated_contract_address).is_none()); + assert!(ContractInfo::::load_code_hash(&instantiated_contract_address).is_none()); assert!(events().is_empty()); }); } @@ -2332,7 +2353,7 @@ mod tests { // Check that the newly created account has the expected code hash and // there are instantiation event. assert_eq!( - Storage::::code_hash(&instantiated_contract_address).unwrap(), + ContractInfo::::load_code_hash(&instantiated_contract_address).unwrap(), dummy_ch ); assert_eq!( @@ -2374,7 +2395,7 @@ mod tests { set_balance(&ALICE, 1000); set_balance(&BOB, 100); place_contract(&BOB, instantiator_ch); - let mut storage_meter = storage::meter::Meter::new(&ALICE, Some(100), 0).unwrap(); + let mut storage_meter = storage::meter::Meter::new(&ALICE, Some(200), 0).unwrap(); assert_matches!( MockStack::run_call( @@ -2409,8 +2430,8 @@ mod tests { let mut gas_meter = GasMeter::::new(GAS_LIMIT); let executable = MockExecutable::from_storage(terminate_ch, &schedule, &mut gas_meter).unwrap(); - set_balance(&ALICE, 1000); - let mut storage_meter = storage::meter::Meter::new(&ALICE, Some(100), 100).unwrap(); + set_balance(&ALICE, 10_000); + let mut storage_meter = storage::meter::Meter::new(&ALICE, None, 100).unwrap(); assert_eq!( MockStack::run_instantiate( @@ -2494,9 +2515,8 @@ mod tests { let min_balance = ::Currency::minimum_balance(); let mut gas_meter = GasMeter::::new(GAS_LIMIT); let executable = MockExecutable::from_storage(code, &schedule, &mut gas_meter).unwrap(); - set_balance(&ALICE, min_balance * 1000); - let mut storage_meter = - storage::meter::Meter::new(&ALICE, Some(min_balance * 100), min_balance).unwrap(); + set_balance(&ALICE, min_balance * 10_000); + let mut storage_meter = storage::meter::Meter::new(&ALICE, None, min_balance).unwrap(); let result = MockStack::run_instantiate( ALICE, @@ -2902,10 +2922,9 @@ mod tests { MockExecutable::from_storage(succ_fail_code, &schedule, &mut gas_meter).unwrap(); let succ_succ_executable = MockExecutable::from_storage(succ_succ_code, &schedule, &mut gas_meter).unwrap(); - set_balance(&ALICE, min_balance * 1000); + set_balance(&ALICE, min_balance * 10_000); let mut storage_meter = - storage::meter::Meter::new(&ALICE, Some(min_balance * 500), min_balance * 100) - .unwrap(); + storage::meter::Meter::new(&ALICE, None, min_balance * 100).unwrap(); MockStack::run_instantiate( ALICE, diff --git a/frame/contracts/src/lib.rs b/frame/contracts/src/lib.rs index e131a2685bad9..a5f35a9cb5f3b 100644 --- a/frame/contracts/src/lib.rs +++ b/frame/contracts/src/lib.rs @@ -85,6 +85,7 @@ #[macro_use] mod gas; +mod address; mod benchmarking; mod exec; mod migration; @@ -101,11 +102,11 @@ mod tests; use crate::{ exec::{AccountIdOf, ExecError, Executable, Stack as ExecStack}, gas::GasMeter, - storage::{meter::Meter as StorageMeter, ContractInfo, DeletedContract, Storage}, + storage::{meter::Meter as StorageMeter, ContractInfo, DeletedContract}, wasm::{OwnerInfo, PrefabWasmModule, TryInstantiate}, weights::WeightInfo, }; -use codec::{Codec, Decode, Encode, HasCompact}; +use codec::{Codec, Encode, HasCompact}; use frame_support::{ dispatch::{Dispatchable, GetDispatchInfo, Pays, PostDispatchInfo}, ensure, @@ -124,10 +125,11 @@ use pallet_contracts_primitives::{ }; use scale_info::TypeInfo; use smallvec::Array; -use sp_runtime::traits::{Convert, Hash, Saturating, StaticLookup, TrailingZeroInput}; +use sp_runtime::traits::{Convert, Hash, Saturating, StaticLookup}; use sp_std::{fmt::Debug, marker::PhantomData, prelude::*}; pub use crate::{ + address::{AddressGenerator, DefaultAddressGenerator}, exec::{Frame, VarSizedKey as StorageKey}, migration::Migration, pallet::*, @@ -155,49 +157,6 @@ type DebugBufferVec = BoundedVec::MaxDebugBufferLen>; /// that this value makes sense for a memory location or length. const SENTINEL: u32 = u32::MAX; -/// Provides the contract address generation method. -/// -/// See [`DefaultAddressGenerator`] for the default implementation. -pub trait AddressGenerator { - /// Generate the address of a contract based on the given instantiate parameters. - /// - /// # Note for implementors - /// 1. Make sure that there are no collisions, different inputs never lead to the same output. - /// 2. Make sure that the same inputs lead to the same output. - /// 3. Changing the implementation through a runtime upgrade without a proper storage migration - /// would lead to catastrophic misbehavior. - fn generate_address( - deploying_address: &T::AccountId, - code_hash: &CodeHash, - input_data: &[u8], - salt: &[u8], - ) -> T::AccountId; -} - -/// Default address generator. -/// -/// This is the default address generator used by contract instantiation. Its result -/// is only dependant on its inputs. It can therefore be used to reliably predict the -/// address of a contract. This is akin to the formula of eth's CREATE2 opcode. There -/// is no CREATE equivalent because CREATE2 is strictly more powerful. -/// Formula: -/// `hash("contract_addr_v1" ++ deploying_address ++ code_hash ++ input_data ++ salt)` -pub struct DefaultAddressGenerator; - -impl AddressGenerator for DefaultAddressGenerator { - fn generate_address( - deploying_address: &T::AccountId, - code_hash: &CodeHash, - input_data: &[u8], - salt: &[u8], - ) -> T::AccountId { - let entropy = (b"contract_addr_v1", deploying_address, code_hash, input_data, salt) - .using_encoded(T::Hashing::hash); - Decode::decode(&mut TrailingZeroInput::new(entropy.as_ref())) - .expect("infinite length input; no invalid inputs for type; qed") - } -} - #[frame_support::pallet] pub mod pallet { use super::*; @@ -365,7 +324,7 @@ pub mod pallet { #[pallet::hooks] impl Hooks> for Pallet { fn on_idle(_block: T::BlockNumber, remaining_weight: Weight) -> Weight { - Storage::::process_deletion_queue_batch(remaining_weight) + ContractInfo::::process_deletion_queue_batch(remaining_weight) .saturating_add(T::WeightInfo::on_process_deletion_queue_batch()) } @@ -381,7 +340,7 @@ pub mod pallet { .max_block .saturating_sub(System::::block_weight().total()) .min(T::DeletionWeightLimit::get()); - Storage::::process_deletion_queue_batch(weight_limit) + ContractInfo::::process_deletion_queue_batch(weight_limit) .saturating_add(T::WeightInfo::on_process_deletion_queue_batch()) } else { T::WeightInfo::on_process_deletion_queue_batch() @@ -1129,8 +1088,7 @@ impl Pallet { let contract_info = ContractInfoOf::::get(&address).ok_or(ContractAccessError::DoesntExist)?; - let maybe_value = Storage::::read( - &contract_info.trie_id, + let maybe_value = contract_info.read( &StorageKey::::try_from(key).map_err(|_| ContractAccessError::KeyDecodingFailed)?, ); Ok(maybe_value) @@ -1146,12 +1104,12 @@ impl Pallet { input_data: &[u8], salt: &[u8], ) -> T::AccountId { - T::AddressGenerator::generate_address(deploying_address, code_hash, input_data, salt) + T::AddressGenerator::contract_address(deploying_address, code_hash, input_data, salt) } /// Returns the code hash of the contract specified by `account` ID. pub fn code_hash(account: &AccountIdOf) -> Option> { - Storage::::code_hash(account) + ContractInfo::::load_code_hash(account) } /// Store code for benchmarks which does not check nor instrument the code. diff --git a/frame/contracts/src/storage.rs b/frame/contracts/src/storage.rs index bf030a2bd8c81..35db33c4ca0b2 100644 --- a/frame/contracts/src/storage.rs +++ b/frame/contracts/src/storage.rs @@ -22,13 +22,15 @@ pub mod meter; use crate::{ exec::{AccountIdOf, StorageKey}, weights::WeightInfo, - BalanceOf, CodeHash, Config, ContractInfoOf, DeletionQueue, Error, TrieId, SENTINEL, + AddressGenerator, BalanceOf, CodeHash, Config, ContractInfoOf, DeletionQueue, Error, Pallet, + TrieId, SENTINEL, }; use codec::{Decode, Encode, MaxEncodedLen}; use frame_support::{ dispatch::{DispatchError, DispatchResult}, storage::child::{self, ChildInfo}, weights::Weight, + RuntimeDebugNoBound, }; use scale_info::TypeInfo; use sp_io::KillStorageResult; @@ -36,7 +38,7 @@ use sp_runtime::{ traits::{Hash, Saturating, Zero}, RuntimeDebug, }; -use sp_std::{marker::PhantomData, prelude::*}; +use sp_std::{ops::Deref, prelude::*}; /// Information for managing an account and its sub trie abstraction. /// This is the required info to cache for an account. @@ -45,28 +47,68 @@ use sp_std::{marker::PhantomData, prelude::*}; 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. - pub storage_bytes: u32, + storage_bytes: u32, /// How many items of storage are accumulated in this contract's child trie. - pub storage_items: u32, + storage_items: u32, /// This records to how much deposit the accumulated `storage_bytes` amount to. pub storage_byte_deposit: BalanceOf, /// This records to how much deposit the accumulated `storage_items` amount to. - pub storage_item_deposit: BalanceOf, + storage_item_deposit: BalanceOf, /// This records how much deposit is put down in order to pay for the contract itself. /// /// We need to store this information separately so it is not used when calculating any refunds /// since the base deposit can only ever be refunded on contract termination. - pub storage_base_deposit: BalanceOf, + storage_base_deposit: BalanceOf, } impl ContractInfo { + /// Constructs a new contract info **without** writing it to storage. + /// + /// This returns an `Err` if an contract with the supplied `account` already exists + /// in storage. + pub fn new( + account: &AccountIdOf, + nonce: u64, + code_hash: CodeHash, + ) -> Result { + if >::contains_key(account) { + return Err(Error::::DuplicateContract.into()) + } + + let trie_id = { + let buf = (account, nonce).using_encoded(T::Hashing::hash); + buf.as_ref() + .to_vec() + .try_into() + .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, + storage_byte_deposit: Zero::zero(), + storage_item_deposit: Zero::zero(), + storage_base_deposit: Zero::zero(), + }; + + Ok(contract) + } + /// Associated child trie unique id is built from the hash part of the trie id. - #[cfg(test)] pub fn child_trie_info(&self) -> ChildInfo { - child_trie_info(&self.trie_id[..]) + ChildInfo::new_default(self.trie_id.as_ref()) } /// The deposit paying for the accumulated storage generated within the contract's child trie. @@ -76,79 +118,30 @@ impl ContractInfo { /// Same as [`Self::extra_deposit`] but including the base deposit. pub fn total_deposit(&self) -> BalanceOf { - self.extra_deposit().saturating_add(self.storage_base_deposit) + self.extra_deposit() + .saturating_add(self.storage_base_deposit) + .saturating_sub(Pallet::::min_balance()) } -} - -/// Associated child trie unique id is built from the hash part of the trie id. -fn child_trie_info(trie_id: &[u8]) -> ChildInfo { - ChildInfo::new_default(trie_id) -} - -#[derive(Encode, Decode, TypeInfo, MaxEncodedLen)] -pub struct DeletedContract { - pub(crate) trie_id: TrieId, -} -/// Information about what happended to the pre-existing value when calling [`Storage::write`]. -#[cfg_attr(test, derive(Debug, PartialEq))] -pub enum WriteOutcome { - /// No value existed at the specified key. - New, - /// A value of the returned length was overwritten. - Overwritten(u32), - /// The returned value was taken out of storage before being overwritten. - /// - /// This is only returned when specifically requested because it causes additional work - /// depending on the size of the pre-existing value. When not requested [`Self::Overwritten`] - /// is returned instead. - Taken(Vec), -} - -impl WriteOutcome { - /// Extracts the size of the overwritten value or `0` if there - /// was no value in storage. - pub fn old_len(&self) -> u32 { - match self { - Self::New => 0, - Self::Overwritten(len) => *len, - Self::Taken(value) => value.len() as u32, - } + /// Return the account that storage deposits should be deposited into. + pub fn deposit_account(&self) -> &DepositAccount { + &self.deposit_account } - /// Extracts the size of the overwritten value or `SENTINEL` if there - /// was no value in storage. - /// - /// # Note - /// - /// We cannot use `0` as sentinel value because there could be a zero sized - /// storage entry which is different from a non existing one. - pub fn old_len_with_sentinel(&self) -> u32 { - match self { - Self::New => SENTINEL, - Self::Overwritten(len) => *len, - Self::Taken(value) => value.len() as u32, - } - } -} - -pub struct Storage(PhantomData); - -impl Storage { /// Reads a storage kv pair of a contract. /// /// The read is performed from the `trie_id` only. The `address` is not necessary. If the /// contract doesn't store under the given `key` `None` is returned. - pub fn read>(trie_id: &TrieId, key: &K) -> Option> { - child::get_raw(&child_trie_info(trie_id), key.hash().as_slice()) + pub fn read>(&self, key: &K) -> Option> { + child::get_raw(&self.child_trie_info(), key.hash().as_slice()) } /// Returns `Some(len)` (in bytes) if a storage item exists at `key`. /// /// Returns `None` if the `key` wasn't previously set by `set_storage` or /// was deleted. - pub fn size>(trie_id: &TrieId, key: &K) -> Option { - child::len(&child_trie_info(trie_id), key.hash().as_slice()) + pub fn size>(&self, key: &K) -> Option { + child::len(&self.child_trie_info(), key.hash().as_slice()) } /// Update a storage entry into a contract's kv storage. @@ -159,13 +152,13 @@ impl Storage { /// This function also records how much storage was created or removed if a `storage_meter` /// is supplied. It should only be absent for testing or benchmarking code. pub fn write>( - trie_id: &TrieId, + &self, key: &K, new_value: Option>, storage_meter: Option<&mut meter::NestedMeter>, take: bool, ) -> Result { - let child_trie_info = &child_trie_info(trie_id); + let child_trie_info = &self.child_trie_info(); let hashed_key = key.hash(); let (old_len, old_value) = if take { let val = child::get_raw(child_trie_info, &hashed_key); @@ -208,37 +201,11 @@ impl Storage { }) } - /// Creates a new contract descriptor in the storage with the given code hash at the given - /// address. - /// - /// Returns `Err` if there is already a contract at the given address. - pub fn new_contract( - account: &AccountIdOf, - trie_id: TrieId, - code_hash: CodeHash, - ) -> Result, DispatchError> { - if >::contains_key(account) { - return Err(Error::::DuplicateContract.into()) - } - - let contract = ContractInfo:: { - code_hash, - trie_id, - storage_bytes: 0, - storage_items: 0, - storage_byte_deposit: Zero::zero(), - storage_item_deposit: Zero::zero(), - storage_base_deposit: Zero::zero(), - }; - - Ok(contract) - } - /// Push a contract's trie to the deletion queue for lazy removal. /// /// You must make sure that the contract is also removed when queuing the trie for deletion. - pub fn queue_trie_for_deletion(contract: &ContractInfo) -> DispatchResult { - >::try_append(DeletedContract { trie_id: contract.trie_id.clone() }) + pub fn queue_trie_for_deletion(&self) -> DispatchResult { + >::try_append(DeletedContract { trie_id: self.trie_id.clone() }) .map_err(|_| >::DeletionQueueFull.into()) } @@ -289,7 +256,10 @@ impl Storage { // Cannot panic due to loop condition let trie = &mut queue[0]; #[allow(deprecated)] - let outcome = child::kill_storage(&child_trie_info(&trie.trie_id), Some(remaining_key_budget)); + let outcome = child::kill_storage( + &ChildInfo::new_default(&trie.trie_id), + Some(remaining_key_budget), + ); let keys_removed = match outcome { // This happens when our budget wasn't large enough to remove all keys. KillStorageResult::SomeRemaining(c) => c, @@ -307,17 +277,8 @@ impl Storage { weight_limit.saturating_sub(weight_per_key.saturating_mul(u64::from(remaining_key_budget))) } - /// Generates a unique trie id by returning `hash(account_id ++ nonce)`. - pub fn generate_trie_id(account_id: &AccountIdOf, nonce: u64) -> TrieId { - let buf = (account_id, nonce).using_encoded(T::Hashing::hash); - buf.as_ref() - .to_vec() - .try_into() - .expect("Runtime uses a reasonable hash size. Hence sizeof(T::Hash) <= 128; qed") - } - /// Returns the code hash of the contract specified by `account` ID. - pub fn code_hash(account: &AccountIdOf) -> Option> { + pub fn load_code_hash(account: &AccountIdOf) -> Option> { >::get(account).map(|i| i.code_hash) } @@ -332,3 +293,62 @@ impl Storage { >::put(bounded); } } + +#[derive(Encode, Decode, TypeInfo, MaxEncodedLen)] +pub struct DeletedContract { + pub(crate) trie_id: TrieId, +} + +/// Information about what happended to the pre-existing value when calling [`ContractInfo::write`]. +#[cfg_attr(test, derive(Debug, PartialEq))] +pub enum WriteOutcome { + /// No value existed at the specified key. + New, + /// A value of the returned length was overwritten. + Overwritten(u32), + /// The returned value was taken out of storage before being overwritten. + /// + /// This is only returned when specifically requested because it causes additional work + /// depending on the size of the pre-existing value. When not requested [`Self::Overwritten`] + /// is returned instead. + Taken(Vec), +} + +impl WriteOutcome { + /// Extracts the size of the overwritten value or `0` if there + /// was no value in storage. + pub fn old_len(&self) -> u32 { + match self { + Self::New => 0, + Self::Overwritten(len) => *len, + Self::Taken(value) => value.len() as u32, + } + } + + /// Extracts the size of the overwritten value or `SENTINEL` if there + /// was no value in storage. + /// + /// # Note + /// + /// We cannot use `0` as sentinel value because there could be a zero sized + /// storage entry which is different from a non existing one. + pub fn old_len_with_sentinel(&self) -> u32 { + match self { + Self::New => SENTINEL, + Self::Overwritten(len) => *len, + Self::Taken(value) => value.len() as u32, + } + } +} + +#[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 + } +} diff --git a/frame/contracts/src/storage/meter.rs b/frame/contracts/src/storage/meter.rs index 94bca741af661..5102edb78a09f 100644 --- a/frame/contracts/src/storage/meter.rs +++ b/frame/contracts/src/storage/meter.rs @@ -17,22 +17,19 @@ //! This module contains functions to meter the storage deposit. -use crate::{storage::ContractInfo, BalanceOf, Config, Error, Inspect, Pallet}; +use crate::{ + storage::{ContractInfo, DepositAccount}, + BalanceOf, Config, Error, Inspect, Pallet, System, +}; use codec::Encode; use frame_support::{ dispatch::DispatchError, ensure, - traits::{ - tokens::{BalanceStatus, WithdrawConsequence}, - Currency, ExistenceRequirement, Get, ReservableCurrency, - }, + traits::{tokens::WithdrawConsequence, Currency, ExistenceRequirement, Get}, DefaultNoBound, RuntimeDebugNoBound, }; use pallet_contracts_primitives::StorageDeposit as Deposit; -use sp_runtime::{ - traits::{Saturating, Zero}, - FixedPointNumber, FixedU128, -}; +use sp_runtime::{traits::Saturating, FixedPointNumber, FixedU128}; use sp_std::{marker::PhantomData, vec::Vec}; /// Deposit that uses the native currency's balance type. @@ -72,14 +69,14 @@ 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 `contract` or the other way + /// The balance transfer can either flow from `origin` to `deposit_account` or the other way /// around depending on whether `amount` constitutes a `Charge` or a `Refund`. - /// It is guaranteed that that this succeeds because no more balance than returned by + /// 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. fn charge( origin: &T::AccountId, - contract: &T::AccountId, + deposit_account: &DepositAccount, amount: &DepositOf, terminated: bool, ); @@ -216,7 +213,7 @@ impl Diff { /// essentially makes the order of storage changes irrelevant with regard to the deposit system. #[derive(RuntimeDebugNoBound, Clone)] struct Charge { - contract: T::AccountId, + deposit_account: DepositAccount, amount: DepositOf, terminated: bool, } @@ -270,8 +267,8 @@ 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 `contract` based on the overall - /// storage consumption of the call. It also updates the supplied contract info. + /// This does the actual balance transfer from/to `origin` and `deposit_account` 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 /// any changes it recorded. @@ -280,12 +277,12 @@ where /// /// - `absorbed`: The child storage meter that should be absorbed. /// - `origin`: The origin that spawned the original root meter. - /// - `contract`: The contract that this sub call belongs to. + /// - `deposit_account`: The contract's deposit 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, - contract: &T::AccountId, + deposit_account: DepositAccount, info: Option<&mut ContractInfo>, ) { let own_deposit = absorbed.own_contribution.update_contract(info); @@ -296,7 +293,7 @@ where if !own_deposit.is_zero() { self.charges.extend_from_slice(&absorbed.charges); self.charges.push(Charge { - contract: contract.clone(), + deposit_account, amount: own_deposit, terminated: absorbed.is_terminated(), }); @@ -345,10 +342,10 @@ where /// execution did finish. pub fn into_deposit(self, origin: &T::AccountId) -> DepositOf { for charge in self.charges.iter().filter(|c| matches!(c.amount, Deposit::Refund(_))) { - E::charge(origin, &charge.contract, &charge.amount, charge.terminated); + E::charge(origin, &charge.deposit_account, &charge.amount, charge.terminated); } for charge in self.charges.iter().filter(|c| matches!(c.amount, Deposit::Charge(_))) { - E::charge(origin, &charge.contract, &charge.amount, charge.terminated); + E::charge(origin, &charge.deposit_account, &charge.amount, charge.terminated); } self.total_deposit } @@ -360,9 +357,8 @@ where T: Config, E: Ext, { - /// Try to charge the `diff` from the meter. Fails if this would exceed the original limit. + /// Charge `diff` from the meter. pub fn charge(&mut self, diff: &Diff) { - debug_assert!(self.is_alive()); match &mut self.own_contribution { Contribution::Alive(own) => *own = own.saturating_add(diff), _ => panic!("Charge is never called after termination; qed"), @@ -379,13 +375,16 @@ where info: &mut ContractInfo, ) -> Result, DispatchError> { debug_assert!(self.is_alive()); + + let ed = Pallet::::min_balance(); let mut deposit = Diff { bytes_added: info.encoded_size() as u32, items_added: 1, ..Default::default() } .update_contract::(None); - // Instantiate needs to transfer the minimum balance at least in order to pull the - // contract's account into existence. - deposit = deposit.max(Deposit::Charge(Pallet::::min_balance())); + // 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. + deposit = deposit.max(Deposit::Charge(ed)).saturating_add(&Deposit::Charge(ed)); if deposit.charge_or_zero() > self.limit { return Err(>::StorageDepositLimitExhausted.into()) } @@ -394,11 +393,22 @@ where // contract execution does conclude and hence would lead to a double charge. self.total_deposit = deposit.clone(); info.storage_base_deposit = deposit.charge_or_zero(); - if !deposit.is_zero() { - // We need to charge immediately so that the account is created before the `value` - // is transferred from the caller to the contract. - E::charge(origin, contract, &deposit, false); - } + + // Usually, 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, + info.deposit_account(), + &deposit.saturating_sub(&Deposit::Charge(ed)), + false, + ); + System::::inc_consumers(info.deposit_account())?; + + // We also need to make sure that the contract's account itself exists. + T::Currency::transfer(origin, contract, ed, ExistenceRequirement::KeepAlive)?; + System::::inc_consumers(contract)?; + Ok(deposit) } @@ -443,7 +453,12 @@ impl Ext for ReservingExt { limit: Option>, min_leftover: BalanceOf, ) -> Result, DispatchError> { - let max = T::Currency::reducible_balance(origin, true).saturating_sub(min_leftover); + // We are sending the `min_leftover` and the `min_balance` from the origin + // account as part of a contract call. Hence origin needs to have those left over + // as free balance after accounting for all deposits. + let max = T::Currency::reducible_balance(origin, true) + .saturating_sub(min_leftover) + .saturating_sub(Pallet::::min_balance()); let limit = limit.unwrap_or(max); ensure!( limit <= max && @@ -455,67 +470,67 @@ impl Ext for ReservingExt { fn charge( origin: &T::AccountId, - contract: &T::AccountId, + deposit_account: &DepositAccount, amount: &DepositOf, terminated: bool, ) { - // There is nothing we can do when this fails as this constitutes a bug in the runtime: - // Either the runtime does not hold up the invariant of never deleting a contract's account - // or it does not honor reserved balances. We need to settle for emitting an error log - // in this case. + // There is nothing we can do when this fails as this constitutes a bug in the runtime. + // We need to settle for emitting an error log in this case. + // + // # Note + // + // This is infallible because it is called in a part of the execution where we cannot + // simply roll back. It might make sense to do some refactoring to move the deposit + // collection to the fallible part of execution. match amount { Deposit::Charge(amount) => { - // This will never fail because a contract's account is required to exist - // at all times. The pallet enforces this invariant by depositing at least the - // existential deposit when instantiating and never refunds it unless the contract - // is removed. This means the receiver always exists except when instantiating a - // contract. In this case we made sure that at least the existential deposit is - // sent. The sender always has enough balance because we checked that it had enough - // balance when instantiating the storage meter. + // This will never fail because a deposit account is required to exist + // at all times. The pallet enforces this invariant by holding a consumer reference + // on the deposit account as long as the contract exists. + // + // The sender always has enough balance because we checked that it had enough + // balance when instantiating the storage meter. There is no way for the sender + // which is a plain account to send away this balance in the meantime. let result = T::Currency::transfer( origin, - contract, + deposit_account, *amount, ExistenceRequirement::KeepAlive, - ) - .and_then(|_| T::Currency::reserve(contract, *amount)); + ); if let Err(err) = result { log::error!( target: "runtime::contracts", - "Failed to transfer storage deposit {:?} from origin {:?} to contract {:?}: {:?}", - amount, origin, contract, err, + "Failed to transfer storage deposit {:?} from origin {:?} to deposit account {:?}: {:?}", + amount, origin, deposit_account, err, ); if cfg!(debug_assertions) { panic!("Unable to collect storage deposit. This is a bug."); } } }, - // For `Refund(_)` no error happen because the initial value transfer from the - // origin to the contract has a keep alive existence requirement and when reserving we - // make sure to leave at least the ed in the free balance. Therefore the receiver always - // exists because there is no way for it to be removed in between. The sender always has - // enough reserved balance because we track it in the `ContractInfo` and never send more - // back than we have. + // The receiver always exists because the initial value transfer from the + // origin to the contract has a keep alive existence requirement. When taking a deposit + // we make sure to leave at least the ed in the free balance. + // + // The sender always has enough balance because we track it in the `ContractInfo` and + // never send more back than we have. Noone has access to the deposit account. Hence no + // other interaction with this account takes place. Deposit::Refund(amount) => { - let amount = if terminated { - *amount - } else { - // This is necessary when the `storage_deposit` tracked inside the account - // info is out of sync with the actual balance. That can only happen due to - // slashing. We make sure to never dust the contract's account through a - // refund because we consider this unexpected behaviour. - *amount.min( - &T::Currency::reserved_balance(contract) - .saturating_sub(Pallet::::min_balance()), - ) - }; - let result = - T::Currency::repatriate_reserved(contract, origin, amount, BalanceStatus::Free); - if matches!(result, Ok(val) if !val.is_zero()) || matches!(result, Err(_)) { + if terminated { + System::::dec_consumers(&deposit_account); + } + let result = T::Currency::transfer( + deposit_account, + origin, + *amount, + // We can safely use `AllowDeath` because our own consumer prevents an removal. + ExistenceRequirement::AllowDeath, + ); + if matches!(result, Err(_)) { log::error!( target: "runtime::contracts", - "Failed to repatriate storage deposit {:?} from contract {:?} to origin {:?}: {:?}", - amount, contract, origin, result, + "Failed to refund storage deposit {:?} from deposit account {:?} to origin {:?}: {:?}", + amount, deposit_account, origin, result, ); if cfg!(debug_assertions) { panic!("Unable to refund storage deposit. This is a bug."); @@ -558,7 +573,7 @@ mod tests { #[derive(Debug, PartialEq, Eq, Clone)] struct Charge { origin: AccountIdOf, - contract: AccountIdOf, + contract: DepositAccount, amount: DepositOf, terminated: bool, } @@ -592,7 +607,7 @@ mod tests { fn charge( origin: &AccountIdOf, - contract: &AccountIdOf, + contract: &DepositAccount, amount: &DepositOf, terminated: bool, ) { @@ -620,12 +635,10 @@ mod tests { } fn new_info(info: StorageInfo) -> ContractInfo { - use crate::storage::Storage; - use sp_runtime::traits::Hash; - ContractInfo:: { - trie_id: >::generate_trie_id(&ALICE, 42), - code_hash: ::Hashing::hash(b"42"), + trie_id: Default::default(), + deposit_account: DepositAccount([0u8; 32].into()), + code_hash: Default::default(), storage_bytes: info.bytes, storage_items: info.items, storage_byte_deposit: info.bytes_deposit, @@ -659,7 +672,7 @@ mod tests { // an empty charge does not create a `Charge` entry let mut nested0 = meter.nested(); nested0.charge(&Default::default()); - meter.absorb(nested0, &BOB, None); + meter.absorb(nested0, DepositAccount(BOB), None); assert_eq!( TestExtTestValue::get(), @@ -692,16 +705,16 @@ mod tests { new_info(StorageInfo { bytes: 100, items: 10, bytes_deposit: 100, items_deposit: 20 }); let mut nested1 = nested0.nested(); nested1.charge(&Diff { items_removed: 5, ..Default::default() }); - nested0.absorb(nested1, &CHARLIE, Some(&mut nested1_info)); + nested0.absorb(nested1, DepositAccount(CHARLIE), Some(&mut nested1_info)); let mut nested2_info = new_info(StorageInfo { bytes: 100, items: 7, bytes_deposit: 100, items_deposit: 20 }); let mut nested2 = nested0.nested(); nested2.charge(&Diff { items_removed: 7, ..Default::default() }); - nested0.absorb(nested2, &CHARLIE, Some(&mut nested2_info)); + nested0.absorb(nested2, DepositAccount(CHARLIE), Some(&mut nested2_info)); nested0.enforce_limit(Some(&mut nested0_info)).unwrap(); - meter.absorb(nested0, &BOB, Some(&mut nested0_info)); + meter.absorb(nested0, DepositAccount(BOB), Some(&mut nested0_info)); meter.into_deposit(&ALICE); @@ -716,19 +729,19 @@ mod tests { charges: vec![ Charge { origin: ALICE, - contract: CHARLIE, + contract: DepositAccount(CHARLIE), amount: Deposit::Refund(10), terminated: false }, Charge { origin: ALICE, - contract: CHARLIE, + contract: DepositAccount(CHARLIE), amount: Deposit::Refund(20), terminated: false }, Charge { origin: ALICE, - contract: BOB, + contract: DepositAccount(BOB), amount: Deposit::Charge(2), terminated: false } @@ -760,9 +773,9 @@ mod tests { nested1.charge(&Diff { bytes_added: 20, ..Default::default() }); nested1.terminate(&nested1_info); nested0.enforce_limit(Some(&mut nested1_info)).unwrap(); - nested0.absorb(nested1, &CHARLIE, None); + nested0.absorb(nested1, DepositAccount(CHARLIE), None); - meter.absorb(nested0, &BOB, None); + meter.absorb(nested0, DepositAccount(BOB), None); meter.into_deposit(&ALICE); assert_eq!( @@ -772,13 +785,13 @@ mod tests { charges: vec![ Charge { origin: ALICE, - contract: CHARLIE, - amount: Deposit::Refund(120), + contract: DepositAccount(CHARLIE), + amount: Deposit::Refund(119), terminated: true }, Charge { origin: ALICE, - contract: BOB, + contract: DepositAccount(BOB), amount: Deposit::Charge(12), terminated: false } diff --git a/frame/contracts/src/tests.rs b/frame/contracts/src/tests.rs index cab426ad132cb..879268a68dca9 100644 --- a/frame/contracts/src/tests.rs +++ b/frame/contracts/src/tests.rs @@ -22,12 +22,11 @@ use crate::{ Result as ExtensionResult, RetVal, ReturnFlags, SysConfig, }, exec::{FixSizedKey, Frame}, - storage::Storage, tests::test_utils::{get_contract, get_contract_checked}, wasm::{Determinism, PrefabWasmModule, ReturnCode as RuntimeReturnCode}, weights::WeightInfo, - BalanceOf, Code, CodeStorage, Config, ContractInfoOf, DefaultAddressGenerator, DeletionQueue, - Error, Pallet, Schedule, + BalanceOf, Code, CodeStorage, Config, ContractInfo, ContractInfoOf, DefaultAddressGenerator, + DeletionQueue, Error, Pallet, Schedule, }; use assert_matches::assert_matches; use codec::Encode; @@ -37,8 +36,8 @@ use frame_support::{ parameter_types, storage::child, traits::{ - BalanceStatus, ConstU32, ConstU64, Contains, Currency, Get, LockableCurrency, OnIdle, - OnInitialize, ReservableCurrency, WithdrawReasons, + ConstU32, ConstU64, Contains, Currency, ExistenceRequirement, Get, LockableCurrency, + OnIdle, OnInitialize, ReservableCurrency, WithdrawReasons, }, weights::{constants::WEIGHT_REF_TIME_PER_SECOND, Weight}, }; @@ -51,7 +50,7 @@ use sp_runtime::{ traits::{BlakeTwo256, Convert, Hash, IdentityLookup}, AccountId32, }; -use std::sync::Arc; +use std::{ops::Deref, sync::Arc}; use crate as pallet_contracts; @@ -76,9 +75,7 @@ frame_support::construct_runtime!( #[macro_use] pub mod test_utils { use super::{Balances, Hash, SysConfig, Test}; - use crate::{ - exec::AccountIdOf, storage::Storage, CodeHash, Config, ContractInfo, ContractInfoOf, Nonce, - }; + use crate::{exec::AccountIdOf, CodeHash, Config, ContractInfo, ContractInfoOf, Nonce}; use codec::Encode; use frame_support::traits::Currency; @@ -87,9 +84,8 @@ pub mod test_utils { *counter += 1; *counter }); - let trie_id = Storage::::generate_trie_id(address, nonce); set_balance(address, ::Currency::minimum_balance() * 10); - let contract = Storage::::new_contract(&address, trie_id, code_hash).unwrap(); + let contract = >::new(&address, nonce, code_hash).unwrap(); >::insert(address, contract); } pub fn set_balance(who: &AccountIdOf, amount: u64) { @@ -518,7 +514,7 @@ fn calling_plain_account_fails() { fn instantiate_and_call_and_deposit_event() { let (wasm, code_hash) = compile_module::("event_and_return_on_deploy").unwrap(); - ExtBuilder::default().existential_deposit(500).build().execute_with(|| { + ExtBuilder::default().existential_deposit(1).build().execute_with(|| { let _ = Balances::deposit_creating(&ALICE, 1_000_000); let min_balance = ::Currency::minimum_balance(); let value = 100; @@ -551,21 +547,24 @@ 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: addr.clone() + account: deposit_account.clone(), }), topics: vec![], }, EventRecord { phase: Phase::Initialization, event: RuntimeEvent::Balances(pallet_balances::Event::Endowed { - account: addr.clone(), - free_balance: min_balance, + account: deposit_account.clone(), + free_balance: 131, }), topics: vec![], }, @@ -573,15 +572,31 @@ fn instantiate_and_call_and_deposit_event() { phase: Phase::Initialization, event: RuntimeEvent::Balances(pallet_balances::Event::Transfer { from: ALICE, - to: addr.clone(), - amount: min_balance, + to: deposit_account.clone(), + amount: 131, }), topics: vec![], }, EventRecord { phase: Phase::Initialization, - event: RuntimeEvent::Balances(pallet_balances::Event::Reserved { - who: addr.clone(), + event: RuntimeEvent::System(frame_system::Event::NewAccount { + account: addr.clone() + }), + topics: vec![], + }, + EventRecord { + phase: Phase::Initialization, + event: RuntimeEvent::Balances(pallet_balances::Event::Endowed { + account: addr.clone(), + free_balance: min_balance, + }), + topics: vec![], + }, + EventRecord { + phase: Phase::Initialization, + event: RuntimeEvent::Balances(pallet_balances::Event::Transfer { + from: ALICE, + to: addr.clone(), amount: min_balance, }), topics: vec![], @@ -823,7 +838,7 @@ fn deploy_and_call_other_contract() { let (caller_wasm, _caller_code_hash) = compile_module::("caller_contract").unwrap(); let (callee_wasm, callee_code_hash) = compile_module::("return_with_data").unwrap(); - ExtBuilder::default().existential_deposit(500).build().execute_with(|| { + ExtBuilder::default().existential_deposit(1).build().execute_with(|| { let min_balance = ::Currency::minimum_balance(); // Create @@ -841,18 +856,7 @@ fn deploy_and_call_other_contract() { .result .unwrap() .account_id; - Contracts::bare_instantiate( - ALICE, - 100_000, - GAS_LIMIT, - None, - Code::Upload(callee_wasm), - 0u32.to_le_bytes().encode(), - vec![42], - false, - ) - .result - .unwrap(); + Contracts::bare_upload_code(ALICE, callee_wasm, None, Determinism::Deterministic).unwrap(); let callee_addr = Contracts::contract_address( &caller_addr, @@ -875,21 +879,24 @@ 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: callee_addr.clone() + account: deposit_account.clone(), }), topics: vec![], }, EventRecord { phase: Phase::Initialization, event: RuntimeEvent::Balances(pallet_balances::Event::Endowed { - account: callee_addr.clone(), - free_balance: min_balance, + account: deposit_account.clone(), + free_balance: 131, }), topics: vec![], }, @@ -897,15 +904,31 @@ fn deploy_and_call_other_contract() { phase: Phase::Initialization, event: RuntimeEvent::Balances(pallet_balances::Event::Transfer { from: ALICE, - to: callee_addr.clone(), - amount: min_balance, + to: deposit_account.clone(), + amount: 131, }), topics: vec![], }, EventRecord { phase: Phase::Initialization, - event: RuntimeEvent::Balances(pallet_balances::Event::Reserved { - who: callee_addr.clone(), + event: RuntimeEvent::System(frame_system::Event::NewAccount { + account: callee_addr.clone() + }), + topics: vec![], + }, + EventRecord { + phase: Phase::Initialization, + event: RuntimeEvent::Balances(pallet_balances::Event::Endowed { + account: callee_addr.clone(), + free_balance: min_balance, + }), + topics: vec![], + }, + EventRecord { + phase: Phase::Initialization, + event: RuntimeEvent::Balances(pallet_balances::Event::Transfer { + from: ALICE, + to: callee_addr.clone(), amount: min_balance, }), topics: vec![], @@ -915,7 +938,7 @@ fn deploy_and_call_other_contract() { event: RuntimeEvent::Balances(pallet_balances::Event::Transfer { from: caller_addr.clone(), to: callee_addr.clone(), - amount: 32768, // hard coded in wasm + amount: 32768 // hardcoded in wasm }), topics: vec![], }, @@ -999,8 +1022,8 @@ fn delegate_call() { } #[test] -fn cannot_self_destruct_through_draning() { - let (wasm, _code_hash) = compile_module::("drain").unwrap(); +fn transfer_allow_death_cannot_kill_account() { + let (wasm, _code_hash) = compile_module::("dummy").unwrap(); ExtBuilder::default().existential_deposit(200).build().execute_with(|| { let _ = Balances::deposit_creating(&ALICE, 1_000_000); @@ -1022,36 +1045,32 @@ fn cannot_self_destruct_through_draning() { // Check that the BOB contract has been instantiated. get_contract(&addr); - // Call BOB which makes it send all funds to the zero address - // The contract code asserts that the transfer was successful - assert_ok!(Contracts::call( - RuntimeOrigin::signed(ALICE), - addr.clone(), - 0, - GAS_LIMIT, - None, - vec![] - )); + let total_balance = ::Currency::total_balance(&addr); - // Make sure the account wasn't remove by sending all free balance away. - assert_eq!( - ::Currency::total_balance(&addr), - ::Currency::minimum_balance(), + assert_err!( + <::Currency as Currency>::transfer( + &addr, + &ALICE, + total_balance, + ExistenceRequirement::AllowDeath, + ), + pallet_balances::Error::::KeepAlive, ); + + assert_eq!(::Currency::total_balance(&addr), total_balance); }); } #[test] -fn cannot_self_destruct_through_storage_refund_after_price_change() { - let (wasm, _code_hash) = compile_module::("store").unwrap(); +fn cannot_self_destruct_through_draning() { + let (wasm, _code_hash) = compile_module::("drain").unwrap(); ExtBuilder::default().existential_deposit(200).build().execute_with(|| { let _ = Balances::deposit_creating(&ALICE, 1_000_000); - let min_balance = ::Currency::minimum_balance(); // Instantiate the BOB contract. let addr = Contracts::bare_instantiate( ALICE, - 0, + 1_000, GAS_LIMIT, None, Code::Upload(wasm), @@ -1063,50 +1082,36 @@ 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); - assert_eq!(get_contract(&addr).extra_deposit(), 0); - assert_eq!(::Currency::total_balance(&addr), 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( - RuntimeOrigin::signed(ALICE), - addr.clone(), - 0, - GAS_LIMIT, - None, - 100u32.to_le_bytes().to_vec() - )); - assert_eq!(get_contract(&addr).total_deposit(), min_balance + 102); + // Check that the BOB contract has been instantiated. + get_contract(&addr); - // 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. - DEPOSIT_PER_BYTE.with(|c| *c.borrow_mut() = 500); + // Call BOB which makes it send all funds to the zero address + // The contract code asserts that the transfer fails with the correct error code assert_ok!(Contracts::call( RuntimeOrigin::signed(ALICE), addr.clone(), 0, GAS_LIMIT, None, - 0u32.to_le_bytes().to_vec() + vec![] )); - // Make sure the account wasn't removed by the refund + // Make sure the account wasn't remove by sending all free balance away. assert_eq!( ::Currency::total_balance(&addr), - get_contract(&addr).total_deposit(), + 1_000 + ::Currency::minimum_balance(), ); - assert_eq!(get_contract(&addr).extra_deposit(), 2,); }); } #[test] -fn cannot_self_destruct_by_refund_after_slash() { +fn cannot_self_destruct_through_storage_refund_after_price_change() { let (wasm, _code_hash) = compile_module::("store").unwrap(); - ExtBuilder::default().existential_deposit(500).build().execute_with(|| { + ExtBuilder::default().existential_deposit(200).build().execute_with(|| { let _ = Balances::deposit_creating(&ALICE, 1_000_000); let min_balance = ::Currency::minimum_balance(); + // Instantiate the BOB contract. let addr = Contracts::bare_instantiate( ALICE, 0, @@ -1121,68 +1126,40 @@ fn cannot_self_destruct_by_refund_after_slash() { .unwrap() .account_id; - // create 100 more reserved balance + // Check that the BOB contract has been instantiated and has the minimum balance + assert_eq!(get_contract(&addr).total_deposit(), min_balance); + assert_eq!(get_contract(&addr).extra_deposit(), 0); + assert_eq!(::Currency::total_balance(&addr), 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( RuntimeOrigin::signed(ALICE), addr.clone(), 0, GAS_LIMIT, None, - 98u32.encode(), + 100u32.to_le_bytes().to_vec() )); + assert_eq!(get_contract(&addr).total_deposit(), min_balance + 102); - // Drop previous events - initialize_block(2); - - // slash parts of the 100 so that the next refund ould remove the account - // because it the value it stored for `storage_deposit` becomes out of sync - let _ = ::Currency::slash(&addr, 90); - assert_eq!(::Currency::total_balance(&addr), min_balance + 10); - - // trigger a refund of 50 which would bring the contract below min when actually refunded + // 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. + DEPOSIT_PER_BYTE.with(|c| *c.borrow_mut() = 500); assert_ok!(Contracts::call( RuntimeOrigin::signed(ALICE), addr.clone(), 0, GAS_LIMIT, None, - 48u32.encode(), + 0u32.to_le_bytes().to_vec() )); - // Make sure the account kept the minimum balance and was not destroyed - assert_eq!(::Currency::total_balance(&addr), min_balance); - + // Make sure the account wasn't removed by the refund assert_eq!( - System::events(), - vec![ - EventRecord { - phase: Phase::Initialization, - event: RuntimeEvent::Balances(pallet_balances::Event::Slashed { - who: addr.clone(), - amount: 90, - }), - topics: vec![], - }, - EventRecord { - phase: Phase::Initialization, - event: RuntimeEvent::Contracts(crate::Event::Called { - caller: ALICE, - contract: addr.clone(), - }), - topics: vec![hash(&ALICE), hash(&addr)], - }, - EventRecord { - phase: Phase::Initialization, - event: RuntimeEvent::Balances(pallet_balances::Event::ReserveRepatriated { - from: addr.clone(), - to: ALICE, - amount: 10, - destination_status: BalanceStatus::Free, - }), - topics: vec![], - }, - ] + ::Currency::total_balance(get_contract(&addr).deposit_account()), + get_contract(&addr).total_deposit(), ); + assert_eq!(get_contract(&addr).extra_deposit(), 2); }); } @@ -1252,7 +1229,7 @@ fn self_destruct_works() { .account_id; // Check that the BOB contract has been instantiated. - get_contract(&addr); + let contract = get_contract(&addr); // Drop all previous events initialize_block(2); @@ -1271,17 +1248,25 @@ fn self_destruct_works() { assert_eq!(Balances::total_balance(&addr), 0); // check that the beneficiary (django) got remaining balance - assert_eq!(Balances::free_balance(DJANGO), 1_000_000 + 100_000); + let ed = ::Currency::minimum_balance(); + assert_eq!(Balances::free_balance(DJANGO), 1_000_000 + 100_000 + ed); 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, + amount: 100_000 + ed, }), topics: vec![], }, @@ -1304,17 +1289,16 @@ fn self_destruct_works() { EventRecord { phase: Phase::Initialization, event: RuntimeEvent::System(frame_system::Event::KilledAccount { - account: addr.clone() + account: contract.deposit_account().deref().clone(), }), topics: vec![], }, EventRecord { phase: Phase::Initialization, - event: RuntimeEvent::Balances(pallet_balances::Event::ReserveRepatriated { - from: addr.clone(), + event: RuntimeEvent::Balances(pallet_balances::Event::Transfer { + from: contract.deposit_account().deref().clone(), to: ALICE, amount: 1_000, - destination_status: BalanceStatus::Free, }), topics: vec![], }, @@ -2055,7 +2039,7 @@ fn lazy_removal_on_full_queue_works_on_initialize() { ExtBuilder::default().existential_deposit(50).build().execute_with(|| { // Fill the deletion queue with dummy values, so that on_initialize attempts // to clear the queue - Storage::::fill_queue_with_dummies(); + ContractInfo::::fill_queue_with_dummies(); let queue_len_initial = >::decode_len().unwrap_or(0); @@ -2132,7 +2116,7 @@ fn lazy_removal_partial_remove_works() { // We create a contract with some extra keys above the weight limit let extra_keys = 7u32; let weight_limit = Weight::from_ref_time(5_000_000_000); - let (_, max_keys) = Storage::::deletion_budget(1, weight_limit); + let (_, max_keys) = ContractInfo::::deletion_budget(1, weight_limit); let vals: Vec<_> = (0..max_keys + extra_keys) .map(|i| (blake2_256(&i.encode()), (i as u32), (i as u32).encode())) .collect(); @@ -2161,14 +2145,7 @@ fn lazy_removal_partial_remove_works() { // Put value into the contracts child trie for val in &vals { - Storage::::write( - &info.trie_id, - &val.0 as &FixSizedKey, - Some(val.2.clone()), - None, - false, - ) - .unwrap(); + info.write(&val.0 as &FixSizedKey, Some(val.2.clone()), None, false).unwrap(); } >::insert(&addr, info.clone()); @@ -2201,7 +2178,7 @@ fn lazy_removal_partial_remove_works() { ext.execute_with(|| { // Run the lazy removal - let weight_used = Storage::::process_deletion_queue_batch(weight_limit); + let weight_used = ContractInfo::::process_deletion_queue_batch(weight_limit); // Weight should be exhausted because we could not even delete all keys assert_eq!(weight_used, weight_limit); @@ -2235,7 +2212,7 @@ fn lazy_removal_does_no_run_on_full_queue_and_full_block() { // Fill the deletion queue with dummy values, so that on_initialize attempts // to clear the queue - Storage::::fill_queue_with_dummies(); + ContractInfo::::fill_queue_with_dummies(); // Check that on_initialize() tries to perform lazy removal but removes nothing // as no more weight is left for that. @@ -2344,7 +2321,7 @@ fn lazy_removal_does_not_use_all_weight() { .account_id; let info = get_contract(&addr); - let (weight_per_key, max_keys) = Storage::::deletion_budget(1, weight_limit); + let (weight_per_key, max_keys) = ContractInfo::::deletion_budget(1, weight_limit); // We create a contract with one less storage item than we can remove within the limit let vals: Vec<_> = (0..max_keys - 1) @@ -2353,14 +2330,7 @@ fn lazy_removal_does_not_use_all_weight() { // Put value into the contracts child trie for val in &vals { - Storage::::write( - &info.trie_id, - &val.0 as &FixSizedKey, - Some(val.2.clone()), - None, - false, - ) - .unwrap(); + info.write(&val.0 as &FixSizedKey, Some(val.2.clone()), None, false).unwrap(); } >::insert(&addr, info.clone()); @@ -2393,7 +2363,7 @@ fn lazy_removal_does_not_use_all_weight() { ext.execute_with(|| { // Run the lazy removal - let weight_used = Storage::::process_deletion_queue_batch(weight_limit); + let weight_used = ContractInfo::::process_deletion_queue_batch(weight_limit); // We have one less key in our trie than our weight limit suffices for assert_eq!(weight_used, weight_limit - weight_per_key); @@ -2427,7 +2397,7 @@ fn deletion_queue_full() { .account_id; // fill the deletion queue up until its limit - Storage::::fill_queue_with_dummies(); + ContractInfo::::fill_queue_with_dummies(); // Terminate the contract should fail assert_err_ignore_postinfo!( @@ -3196,14 +3166,12 @@ fn instantiate_with_zero_balance_works() { .account_id; // Check that the BOB contract has been instantiated. - get_contract(&addr); + let contract = get_contract(&addr); + let deposit_account = contract.deposit_account().deref(); // Make sure the account exists even though no free balance was send - assert_eq!(::Currency::free_balance(&addr), 0,); - assert_eq!( - ::Currency::total_balance(&addr), - ::Currency::minimum_balance(), - ); + assert_eq!(::Currency::free_balance(&addr), min_balance); + assert_eq!(::Currency::total_balance(&addr), min_balance,); assert_eq!( System::events(), @@ -3211,14 +3179,14 @@ fn instantiate_with_zero_balance_works() { EventRecord { phase: Phase::Initialization, event: RuntimeEvent::System(frame_system::Event::NewAccount { - account: addr.clone() + account: deposit_account.clone(), }), topics: vec![], }, EventRecord { phase: Phase::Initialization, event: RuntimeEvent::Balances(pallet_balances::Event::Endowed { - account: addr.clone(), + account: deposit_account.clone(), free_balance: min_balance, }), topics: vec![], @@ -3227,15 +3195,31 @@ fn instantiate_with_zero_balance_works() { phase: Phase::Initialization, event: RuntimeEvent::Balances(pallet_balances::Event::Transfer { from: ALICE, - to: addr.clone(), + to: deposit_account.clone(), amount: min_balance, }), topics: vec![], }, EventRecord { phase: Phase::Initialization, - event: RuntimeEvent::Balances(pallet_balances::Event::Reserved { - who: addr.clone(), + event: RuntimeEvent::System(frame_system::Event::NewAccount { + account: addr.clone(), + }), + topics: vec![], + }, + EventRecord { + phase: Phase::Initialization, + event: RuntimeEvent::Balances(pallet_balances::Event::Endowed { + account: addr.clone(), + free_balance: min_balance, + }), + topics: vec![], + }, + EventRecord { + phase: Phase::Initialization, + event: RuntimeEvent::Balances(pallet_balances::Event::Transfer { + from: ALICE, + to: addr.clone(), amount: min_balance, }), topics: vec![], @@ -3292,14 +3276,12 @@ fn instantiate_with_below_existential_deposit_works() { .account_id; // Check that the BOB contract has been instantiated. - get_contract(&addr); + let contract = get_contract(&addr); + let deposit_account = contract.deposit_account().deref(); - // Make sure the account exists even though no free balance was send - assert_eq!(::Currency::free_balance(&addr), 50,); - assert_eq!( - ::Currency::total_balance(&addr), - ::Currency::minimum_balance() + 50, - ); + // 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!( System::events(), @@ -3307,14 +3289,14 @@ fn instantiate_with_below_existential_deposit_works() { EventRecord { phase: Phase::Initialization, event: RuntimeEvent::System(frame_system::Event::NewAccount { - account: addr.clone() + account: deposit_account.clone(), }), topics: vec![], }, EventRecord { phase: Phase::Initialization, event: RuntimeEvent::Balances(pallet_balances::Event::Endowed { - account: addr.clone(), + account: deposit_account.clone(), free_balance: min_balance, }), topics: vec![], @@ -3323,15 +3305,31 @@ fn instantiate_with_below_existential_deposit_works() { phase: Phase::Initialization, event: RuntimeEvent::Balances(pallet_balances::Event::Transfer { from: ALICE, - to: addr.clone(), + to: deposit_account.clone(), amount: min_balance, }), topics: vec![], }, EventRecord { phase: Phase::Initialization, - event: RuntimeEvent::Balances(pallet_balances::Event::Reserved { - who: addr.clone(), + event: RuntimeEvent::System(frame_system::Event::NewAccount { + account: addr.clone() + }), + topics: vec![], + }, + EventRecord { + phase: Phase::Initialization, + event: RuntimeEvent::Balances(pallet_balances::Event::Endowed { + account: addr.clone(), + free_balance: min_balance, + }), + topics: vec![], + }, + EventRecord { + phase: Phase::Initialization, + event: RuntimeEvent::Balances(pallet_balances::Event::Transfer { + from: ALICE, + to: addr.clone(), amount: min_balance, }), topics: vec![], @@ -3436,6 +3434,9 @@ 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![ @@ -3460,15 +3461,7 @@ fn storage_deposit_works() { phase: Phase::Initialization, event: RuntimeEvent::Balances(pallet_balances::Event::Transfer { from: ALICE, - to: addr.clone(), - amount: charged0, - }), - topics: vec![], - }, - EventRecord { - phase: Phase::Initialization, - event: RuntimeEvent::Balances(pallet_balances::Event::Reserved { - who: addr.clone(), + to: deposit_account.clone(), amount: charged0, }), topics: vec![], @@ -3485,15 +3478,7 @@ fn storage_deposit_works() { phase: Phase::Initialization, event: RuntimeEvent::Balances(pallet_balances::Event::Transfer { from: ALICE, - to: addr.clone(), - amount: charged1, - }), - topics: vec![], - }, - EventRecord { - phase: Phase::Initialization, - event: RuntimeEvent::Balances(pallet_balances::Event::Reserved { - who: addr.clone(), + to: deposit_account.clone(), amount: charged1, }), topics: vec![], @@ -3508,11 +3493,10 @@ fn storage_deposit_works() { }, EventRecord { phase: Phase::Initialization, - event: RuntimeEvent::Balances(pallet_balances::Event::ReserveRepatriated { - from: addr.clone(), + event: RuntimeEvent::Balances(pallet_balances::Event::Transfer { + from: deposit_account.clone(), to: ALICE, amount: refunded0, - destination_status: BalanceStatus::Free, }), topics: vec![], }, @@ -3610,11 +3594,10 @@ fn set_code_extrinsic() { } #[test] -fn call_after_killed_account_needs_funding() { +fn slash_cannot_kill_account() { let (wasm, _code_hash) = compile_module::("dummy").unwrap(); ExtBuilder::default().existential_deposit(200).build().execute_with(|| { let _ = Balances::deposit_creating(&ALICE, 1_000_000); - let min_balance = ::Currency::minimum_balance(); let addr = Contracts::bare_instantiate( ALICE, @@ -3633,107 +3616,24 @@ fn call_after_killed_account_needs_funding() { // Drop previous events initialize_block(2); - // Destroy the account of the contract by slashing. - // Slashing can actually happen if the contract takes part in staking. - // It is a corner case and we accept the destruction of the account. + // Try to destroy the account of the contract by slashing. + // The account does not get destroyed because of the consumer reference. + // Slashing can for example happen if the contract takes part in staking. let _ = ::Currency::slash( &addr, ::Currency::total_balance(&addr), ); - // Sending below the minimum balance will fail the call because it needs to create the - // account in order to send balance there. - assert_err_ignore_postinfo!( - Contracts::call( - RuntimeOrigin::signed(ALICE), - addr.clone(), - min_balance - 1, - GAS_LIMIT, - None, - vec![], - ), - >::TransferFailed - ); - - // Sending zero should work as it does not do a transfer - assert_ok!(Contracts::call( - RuntimeOrigin::signed(ALICE), - addr.clone(), - 0, - GAS_LIMIT, - None, - vec![], - )); - - // Sending minimum balance should work - assert_ok!(Contracts::call( - RuntimeOrigin::signed(ALICE), - addr.clone(), - min_balance, - GAS_LIMIT, - None, - vec![], - )); - 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::Slashed { - who: addr.clone(), - amount: min_balance + 700 - }), - topics: vec![], - }, - EventRecord { - phase: Phase::Initialization, - event: RuntimeEvent::Contracts(crate::Event::Called { - caller: ALICE, - contract: addr.clone(), - }), - topics: vec![hash(&ALICE), hash(&addr)], - }, - EventRecord { - phase: Phase::Initialization, - event: RuntimeEvent::System(frame_system::Event::NewAccount { - account: addr.clone() - }), - topics: vec![], - }, - EventRecord { - phase: Phase::Initialization, - event: RuntimeEvent::Balances(pallet_balances::Event::Endowed { - account: addr.clone(), - free_balance: min_balance - }), - topics: vec![], - }, - EventRecord { - phase: Phase::Initialization, - event: RuntimeEvent::Balances(pallet_balances::Event::Transfer { - from: ALICE, - to: addr.clone(), - amount: min_balance - }), - topics: vec![], - }, - EventRecord { - phase: Phase::Initialization, - event: RuntimeEvent::Contracts(crate::Event::Called { - caller: ALICE, - contract: addr.clone(), - }), - topics: vec![hash(&ALICE), hash(&addr)], - }, - ] + vec![EventRecord { + phase: Phase::Initialization, + event: RuntimeEvent::Balances(pallet_balances::Event::Slashed { + who: addr.clone(), + amount: 700, // slash didn't remove the minimum balance + }), + topics: vec![], + },] ); }); } diff --git a/frame/contracts/src/weights.rs b/frame/contracts/src/weights.rs index 057a9257d4268..d032615843656 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-02-15, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-02-16, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` //! HOSTNAME: `bm3`, CPU: `Intel(R) Core(TM) i7-7700K CPU @ 4.20GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("dev"), DB CACHE: 1024 @@ -178,8 +178,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `109` // Estimated: `604` - // Minimum execution time: 2_507 nanoseconds. - Weight::from_ref_time(2_650_000) + // Minimum execution time: 2_591 nanoseconds. + Weight::from_ref_time(2_817_000) .saturating_add(Weight::from_proof_size(604)) .saturating_add(T::DbWeight::get().reads(1_u64)) } @@ -190,11 +190,11 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `481 + k * (69 ±0)` // Estimated: `471 + k * (70 ±0)` - // Minimum execution time: 9_953 nanoseconds. - Weight::from_ref_time(6_467_352) + // Minimum execution time: 10_190 nanoseconds. + Weight::from_ref_time(6_642_117) .saturating_add(Weight::from_proof_size(471)) - // Standard Error: 1_074 - .saturating_add(Weight::from_ref_time(943_946).saturating_mul(k.into())) + // Standard Error: 992 + .saturating_add(Weight::from_ref_time(919_828).saturating_mul(k.into())) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(k.into()))) @@ -207,11 +207,11 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `281 + q * (33 ±0)` // Estimated: `763 + q * (33 ±0)` - // Minimum execution time: 2_545 nanoseconds. - Weight::from_ref_time(10_080_106) + // Minimum execution time: 2_598 nanoseconds. + Weight::from_ref_time(10_288_252) .saturating_add(Weight::from_proof_size(763)) - // Standard Error: 2_929 - .saturating_add(Weight::from_ref_time(1_078_265).saturating_mul(q.into())) + // Standard Error: 2_886 + .saturating_add(Weight::from_ref_time(1_092_420).saturating_mul(q.into())) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) .saturating_add(Weight::from_proof_size(33).saturating_mul(q.into())) @@ -225,17 +225,17 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `270 + c * (1 ±0)` // Estimated: `3025 + c * (2 ±0)` - // Minimum execution time: 34_613 nanoseconds. - Weight::from_ref_time(27_355_774) + // Minimum execution time: 34_338 nanoseconds. + Weight::from_ref_time(32_159_677) .saturating_add(Weight::from_proof_size(3025)) - // Standard Error: 81 - .saturating_add(Weight::from_ref_time(51_954).saturating_mul(c.into())) + // Standard Error: 53 + .saturating_add(Weight::from_ref_time(51_034).saturating_mul(c.into())) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) .saturating_add(Weight::from_proof_size(2).saturating_mul(c.into())) } /// Storage: Contracts ContractInfoOf (r:1 w:1) - /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:1 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) /// Storage: Timestamp Now (r:1 w:0) @@ -247,13 +247,13 @@ 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: `771` - // Estimated: `16780 + c * (5 ±0)` - // Minimum execution time: 386_104 nanoseconds. - Weight::from_ref_time(396_718_823) - .saturating_add(Weight::from_proof_size(16780)) + // Measured: `803` + // Estimated: `16930 + c * (5 ±0)` + // Minimum execution time: 385_587 nanoseconds. + Weight::from_ref_time(395_545_811) + .saturating_add(Weight::from_proof_size(16930)) // Standard Error: 27 - .saturating_add(Weight::from_ref_time(31_370).saturating_mul(c.into())) + .saturating_add(Weight::from_ref_time(31_342).saturating_mul(c.into())) .saturating_add(T::DbWeight::get().reads(6_u64)) .saturating_add(T::DbWeight::get().writes(4_u64)) .saturating_add(Weight::from_proof_size(5).saturating_mul(c.into())) @@ -263,10 +263,10 @@ 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(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, 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:1 w:1) + /// Storage: System Account (r:2 w:2) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: System EventTopics (r:3 w:3) /// Proof Skipped: System EventTopics (max_values: None, max_size: None, mode: Measured) @@ -279,29 +279,29 @@ 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: `257` - // Estimated: `17752` - // Minimum execution time: 3_786_500 nanoseconds. - Weight::from_ref_time(672_511_565) - .saturating_add(Weight::from_proof_size(17752)) - // Standard Error: 281 - .saturating_add(Weight::from_ref_time(94_538).saturating_mul(c.into())) + // Measured: `270` + // Estimated: `20267` + // Minimum execution time: 3_799_742 nanoseconds. + Weight::from_ref_time(670_115_588) + .saturating_add(Weight::from_proof_size(20267)) + // Standard Error: 287 + .saturating_add(Weight::from_ref_time(93_885).saturating_mul(c.into())) // Standard Error: 16 - .saturating_add(Weight::from_ref_time(1_364).saturating_mul(i.into())) + .saturating_add(Weight::from_ref_time(1_367).saturating_mul(i.into())) // Standard Error: 16 - .saturating_add(Weight::from_ref_time(1_768).saturating_mul(s.into())) - .saturating_add(T::DbWeight::get().reads(8_u64)) - .saturating_add(T::DbWeight::get().writes(9_u64)) + .saturating_add(Weight::from_ref_time(1_781).saturating_mul(s.into())) + .saturating_add(T::DbWeight::get().reads(9_u64)) + .saturating_add(T::DbWeight::get().writes(10_u64)) } /// Storage: Contracts CodeStorage (r:1 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) /// Storage: Contracts Nonce (r:1 w:1) /// 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(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, 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:1 w:1) + /// Storage: System Account (r:2 w:2) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts OwnerInfoOf (r:1 w:1) /// Proof: Contracts OwnerInfoOf (max_values: None, max_size: Some(88), added: 2563, mode: Measured) @@ -311,20 +311,20 @@ impl WeightInfo for SubstrateWeight { /// The range of component `s` is `[0, 1048576]`. fn instantiate(i: u32, s: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `533` - // Estimated: `19543` - // Minimum execution time: 1_927_365 nanoseconds. - Weight::from_ref_time(189_843_928) - .saturating_add(Weight::from_proof_size(19543)) + // Measured: `546` + // Estimated: `22039` + // Minimum execution time: 1_949_008 nanoseconds. + Weight::from_ref_time(214_033_418) + .saturating_add(Weight::from_proof_size(22039)) // Standard Error: 8 - .saturating_add(Weight::from_ref_time(1_677).saturating_mul(i.into())) + .saturating_add(Weight::from_ref_time(1_666).saturating_mul(i.into())) // Standard Error: 8 - .saturating_add(Weight::from_ref_time(1_803).saturating_mul(s.into())) - .saturating_add(T::DbWeight::get().reads(8_u64)) - .saturating_add(T::DbWeight::get().writes(6_u64)) + .saturating_add(Weight::from_ref_time(1_801).saturating_mul(s.into())) + .saturating_add(T::DbWeight::get().reads(9_u64)) + .saturating_add(T::DbWeight::get().writes(7_u64)) } /// Storage: Contracts ContractInfoOf (r:1 w:1) - /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:1 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) /// Storage: Timestamp Now (r:1 w:0) @@ -335,11 +335,11 @@ impl WeightInfo for SubstrateWeight { /// Proof Skipped: System EventTopics (max_values: None, max_size: None, mode: Measured) fn call() -> Weight { // Proof Size summary in bytes: - // Measured: `823` - // Estimated: `16985` - // Minimum execution time: 146_354 nanoseconds. - Weight::from_ref_time(147_693_000) - .saturating_add(Weight::from_proof_size(16985)) + // Measured: `855` + // Estimated: `17145` + // Minimum execution time: 146_654 nanoseconds. + Weight::from_ref_time(147_528_000) + .saturating_add(Weight::from_proof_size(17145)) .saturating_add(T::DbWeight::get().reads(6_u64)) .saturating_add(T::DbWeight::get().writes(4_u64)) } @@ -356,11 +356,11 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `109` // Estimated: `5386` - // Minimum execution time: 388_107 nanoseconds. - Weight::from_ref_time(383_172_702) + // Minimum execution time: 387_889 nanoseconds. + Weight::from_ref_time(391_379_335) .saturating_add(Weight::from_proof_size(5386)) - // Standard Error: 73 - .saturating_add(Weight::from_ref_time(95_037).saturating_mul(c.into())) + // Standard Error: 89 + .saturating_add(Weight::from_ref_time(94_810).saturating_mul(c.into())) .saturating_add(T::DbWeight::get().reads(2_u64)) .saturating_add(T::DbWeight::get().writes(4_u64)) } @@ -376,32 +376,32 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `287` // Estimated: `6098` - // Minimum execution time: 26_278 nanoseconds. - Weight::from_ref_time(26_682_000) + // Minimum execution time: 26_014 nanoseconds. + Weight::from_ref_time(26_510_000) .saturating_add(Weight::from_proof_size(6098)) .saturating_add(T::DbWeight::get().reads(2_u64)) .saturating_add(T::DbWeight::get().writes(4_u64)) } /// Storage: Contracts ContractInfoOf (r:1 w:1) - /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts OwnerInfoOf (r:2 w:2) /// Proof: Contracts OwnerInfoOf (max_values: None, max_size: Some(88), added: 2563, mode: Measured) /// Storage: System EventTopics (r:3 w:3) /// Proof Skipped: System EventTopics (max_values: None, max_size: None, mode: Measured) fn set_code() -> Weight { // Proof Size summary in bytes: - // Measured: `634` - // Estimated: `16752` - // Minimum execution time: 30_223 nanoseconds. - Weight::from_ref_time(30_737_000) - .saturating_add(Weight::from_proof_size(16752)) + // Measured: `666` + // Estimated: `16848` + // Minimum execution time: 30_177 nanoseconds. + Weight::from_ref_time(30_639_000) + .saturating_add(Weight::from_proof_size(16848)) .saturating_add(T::DbWeight::get().reads(6_u64)) .saturating_add(T::DbWeight::get().writes(6_u64)) } /// 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(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:1 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) /// Storage: Timestamp Now (r:1 w:0) @@ -411,13 +411,13 @@ impl WeightInfo for SubstrateWeight { /// The range of component `r` is `[0, 20]`. fn seal_caller(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `845 + r * (480 ±0)` - // Estimated: `17120 + r * (2400 ±0)` - // Minimum execution time: 374_780 nanoseconds. - Weight::from_ref_time(379_468_453) - .saturating_add(Weight::from_proof_size(17120)) - // Standard Error: 45_809 - .saturating_add(Weight::from_ref_time(17_553_577).saturating_mul(r.into())) + // Measured: `877 + r * (480 ±0)` + // Estimated: `17295 + r * (2400 ±0)` + // Minimum execution time: 373_786 nanoseconds. + Weight::from_ref_time(377_332_691) + .saturating_add(Weight::from_proof_size(17295)) + // Standard Error: 51_211 + .saturating_add(Weight::from_ref_time(17_715_615).saturating_mul(r.into())) .saturating_add(T::DbWeight::get().reads(6_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) .saturating_add(Weight::from_proof_size(2400).saturating_mul(r.into())) @@ -425,7 +425,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(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:1 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) /// Storage: Timestamp Now (r:1 w:0) @@ -435,22 +435,22 @@ impl WeightInfo for SubstrateWeight { /// The range of component `r` is `[0, 20]`. fn seal_is_contract(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `882 + r * (19218 ±0)` - // Estimated: `17110 + r * (294100 ±0)` - // Minimum execution time: 374_399 nanoseconds. - Weight::from_ref_time(228_569_211) - .saturating_add(Weight::from_proof_size(17110)) - // Standard Error: 492_562 - .saturating_add(Weight::from_ref_time(251_682_897).saturating_mul(r.into())) + // Measured: `917 + r * (21778 ±0)` + // Estimated: `17295 + r * (306895 ±0)` + // Minimum execution time: 374_009 nanoseconds. + Weight::from_ref_time(238_991_986) + .saturating_add(Weight::from_proof_size(17295)) + // Standard Error: 464_711 + .saturating_add(Weight::from_ref_time(249_099_538).saturating_mul(r.into())) .saturating_add(T::DbWeight::get().reads(6_u64)) .saturating_add(T::DbWeight::get().reads((80_u64).saturating_mul(r.into()))) .saturating_add(T::DbWeight::get().writes(3_u64)) - .saturating_add(Weight::from_proof_size(294100).saturating_mul(r.into())) + .saturating_add(Weight::from_proof_size(306895).saturating_mul(r.into())) } /// 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(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:1 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) /// Storage: Timestamp Now (r:1 w:0) @@ -460,22 +460,22 @@ impl WeightInfo for SubstrateWeight { /// The range of component `r` is `[0, 20]`. fn seal_code_hash(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `889 + r * (19539 ±0)` - // Estimated: `17170 + r * (295700 ±0)` - // Minimum execution time: 375_980 nanoseconds. - Weight::from_ref_time(232_604_331) - .saturating_add(Weight::from_proof_size(17170)) - // Standard Error: 491_912 - .saturating_add(Weight::from_ref_time(299_479_335).saturating_mul(r.into())) + // Measured: `921 + r * (22099 ±0)` + // Estimated: `17340 + r * (308500 ±0)` + // Minimum execution time: 375_058 nanoseconds. + Weight::from_ref_time(238_765_068) + .saturating_add(Weight::from_proof_size(17340)) + // Standard Error: 662_617 + .saturating_add(Weight::from_ref_time(302_175_089).saturating_mul(r.into())) .saturating_add(T::DbWeight::get().reads(6_u64)) .saturating_add(T::DbWeight::get().reads((80_u64).saturating_mul(r.into()))) .saturating_add(T::DbWeight::get().writes(3_u64)) - .saturating_add(Weight::from_proof_size(295700).saturating_mul(r.into())) + .saturating_add(Weight::from_proof_size(308500).saturating_mul(r.into())) } /// 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(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:1 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) /// Storage: Timestamp Now (r:1 w:0) @@ -485,13 +485,13 @@ impl WeightInfo for SubstrateWeight { /// The range of component `r` is `[0, 20]`. fn seal_own_code_hash(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `852 + r * (480 ±0)` - // Estimated: `17155 + r * (2400 ±0)` - // Minimum execution time: 375_075 nanoseconds. - Weight::from_ref_time(381_217_372) - .saturating_add(Weight::from_proof_size(17155)) - // Standard Error: 63_950 - .saturating_add(Weight::from_ref_time(21_872_316).saturating_mul(r.into())) + // Measured: `884 + r * (480 ±0)` + // Estimated: `17330 + r * (2400 ±0)` + // Minimum execution time: 374_747 nanoseconds. + Weight::from_ref_time(376_482_380) + .saturating_add(Weight::from_proof_size(17330)) + // Standard Error: 61_919 + .saturating_add(Weight::from_ref_time(22_376_795).saturating_mul(r.into())) .saturating_add(T::DbWeight::get().reads(6_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) .saturating_add(Weight::from_proof_size(2400).saturating_mul(r.into())) @@ -499,7 +499,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(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:1 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) /// Storage: Timestamp Now (r:1 w:0) @@ -509,13 +509,13 @@ impl WeightInfo for SubstrateWeight { /// The range of component `r` is `[0, 20]`. fn seal_caller_is_origin(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `842 + r * (240 ±0)` - // Estimated: `17080 + r * (1200 ±0)` - // Minimum execution time: 373_260 nanoseconds. - Weight::from_ref_time(377_987_666) - .saturating_add(Weight::from_proof_size(17080)) - // Standard Error: 35_603 - .saturating_add(Weight::from_ref_time(11_274_165).saturating_mul(r.into())) + // Measured: `874 + r * (240 ±0)` + // Estimated: `17265 + r * (1200 ±0)` + // Minimum execution time: 372_287 nanoseconds. + Weight::from_ref_time(376_250_858) + .saturating_add(Weight::from_proof_size(17265)) + // Standard Error: 40_119 + .saturating_add(Weight::from_ref_time(11_359_647).saturating_mul(r.into())) .saturating_add(T::DbWeight::get().reads(6_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) .saturating_add(Weight::from_proof_size(1200).saturating_mul(r.into())) @@ -523,7 +523,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(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:1 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) /// Storage: Timestamp Now (r:1 w:0) @@ -533,13 +533,13 @@ impl WeightInfo for SubstrateWeight { /// The range of component `r` is `[0, 20]`. fn seal_address(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `846 + r * (480 ±0)` - // Estimated: `17100 + r * (2400 ±0)` - // Minimum execution time: 374_605 nanoseconds. - Weight::from_ref_time(379_395_443) - .saturating_add(Weight::from_proof_size(17100)) - // Standard Error: 49_646 - .saturating_add(Weight::from_ref_time(17_487_585).saturating_mul(r.into())) + // Measured: `878 + r * (480 ±0)` + // Estimated: `17260 + r * (2400 ±0)` + // Minimum execution time: 374_445 nanoseconds. + Weight::from_ref_time(377_243_521) + .saturating_add(Weight::from_proof_size(17260)) + // Standard Error: 53_032 + .saturating_add(Weight::from_ref_time(17_684_246).saturating_mul(r.into())) .saturating_add(T::DbWeight::get().reads(6_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) .saturating_add(Weight::from_proof_size(2400).saturating_mul(r.into())) @@ -547,7 +547,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(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:1 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) /// Storage: Timestamp Now (r:1 w:0) @@ -557,21 +557,21 @@ impl WeightInfo for SubstrateWeight { /// The range of component `r` is `[0, 20]`. fn seal_gas_left(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `847 + r * (480 ±0)` - // Estimated: `17105 + r * (2400 ±0)` - // Minimum execution time: 374_620 nanoseconds. - Weight::from_ref_time(379_623_792) - .saturating_add(Weight::from_proof_size(17105)) - // Standard Error: 49_990 - .saturating_add(Weight::from_ref_time(17_226_706).saturating_mul(r.into())) + // Measured: `879 + r * (480 ±0)` + // Estimated: `17250 + r * (2405 ±0)` + // Minimum execution time: 374_029 nanoseconds. + Weight::from_ref_time(380_415_186) + .saturating_add(Weight::from_proof_size(17250)) + // Standard Error: 60_562 + .saturating_add(Weight::from_ref_time(17_152_599).saturating_mul(r.into())) .saturating_add(T::DbWeight::get().reads(6_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) - .saturating_add(Weight::from_proof_size(2400).saturating_mul(r.into())) + .saturating_add(Weight::from_proof_size(2405).saturating_mul(r.into())) } /// 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(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:1 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) /// Storage: Timestamp Now (r:1 w:0) @@ -581,13 +581,13 @@ impl WeightInfo for SubstrateWeight { /// The range of component `r` is `[0, 20]`. fn seal_balance(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `1017 + r * (480 ±0)` - // Estimated: `19673 + r * (2456 ±4)` - // Minimum execution time: 374_002 nanoseconds. - Weight::from_ref_time(384_615_649) - .saturating_add(Weight::from_proof_size(19673)) - // Standard Error: 85_633 - .saturating_add(Weight::from_ref_time(95_227_118).saturating_mul(r.into())) + // Measured: `1049 + r * (480 ±0)` + // Estimated: `19849 + r * (2456 ±0)` + // Minimum execution time: 373_999 nanoseconds. + Weight::from_ref_time(381_757_033) + .saturating_add(Weight::from_proof_size(19849)) + // Standard Error: 97_983 + .saturating_add(Weight::from_ref_time(98_290_984).saturating_mul(r.into())) .saturating_add(T::DbWeight::get().reads(7_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) .saturating_add(Weight::from_proof_size(2456).saturating_mul(r.into())) @@ -595,7 +595,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(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:1 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) /// Storage: Timestamp Now (r:1 w:0) @@ -605,13 +605,13 @@ impl WeightInfo for SubstrateWeight { /// The range of component `r` is `[0, 20]`. fn seal_value_transferred(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `856 + r * (480 ±0)` - // Estimated: `17200 + r * (2400 ±0)` - // Minimum execution time: 375_307 nanoseconds. - Weight::from_ref_time(378_389_705) - .saturating_add(Weight::from_proof_size(17200)) - // Standard Error: 42_265 - .saturating_add(Weight::from_ref_time(17_316_680).saturating_mul(r.into())) + // Measured: `888 + r * (480 ±0)` + // Estimated: `17360 + r * (2400 ±0)` + // Minimum execution time: 374_197 nanoseconds. + Weight::from_ref_time(377_755_896) + .saturating_add(Weight::from_proof_size(17360)) + // Standard Error: 60_542 + .saturating_add(Weight::from_ref_time(17_442_065).saturating_mul(r.into())) .saturating_add(T::DbWeight::get().reads(6_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) .saturating_add(Weight::from_proof_size(2400).saturating_mul(r.into())) @@ -619,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(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:1 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) /// Storage: Timestamp Now (r:1 w:0) @@ -629,13 +629,13 @@ impl WeightInfo for SubstrateWeight { /// The range of component `r` is `[0, 20]`. fn seal_minimum_balance(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `854 + r * (480 ±0)` - // Estimated: `17140 + r * (2400 ±0)` - // Minimum execution time: 374_878 nanoseconds. - Weight::from_ref_time(379_364_066) - .saturating_add(Weight::from_proof_size(17140)) - // Standard Error: 49_158 - .saturating_add(Weight::from_ref_time(17_111_145).saturating_mul(r.into())) + // Measured: `886 + r * (480 ±0)` + // Estimated: `17290 + r * (2400 ±0)` + // Minimum execution time: 373_888 nanoseconds. + Weight::from_ref_time(377_825_771) + .saturating_add(Weight::from_proof_size(17290)) + // Standard Error: 38_026 + .saturating_add(Weight::from_ref_time(17_147_903).saturating_mul(r.into())) .saturating_add(T::DbWeight::get().reads(6_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) .saturating_add(Weight::from_proof_size(2400).saturating_mul(r.into())) @@ -643,7 +643,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(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:1 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) /// Storage: Timestamp Now (r:1 w:0) @@ -653,13 +653,13 @@ impl WeightInfo for SubstrateWeight { /// The range of component `r` is `[0, 20]`. fn seal_block_number(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `851 + r * (480 ±0)` - // Estimated: `17125 + r * (2400 ±0)` - // Minimum execution time: 374_981 nanoseconds. - Weight::from_ref_time(381_539_022) - .saturating_add(Weight::from_proof_size(17125)) - // Standard Error: 61_419 - .saturating_add(Weight::from_ref_time(17_062_381).saturating_mul(r.into())) + // Measured: `883 + r * (480 ±0)` + // Estimated: `17315 + r * (2400 ±0)` + // Minimum execution time: 373_904 nanoseconds. + Weight::from_ref_time(378_652_372) + .saturating_add(Weight::from_proof_size(17315)) + // Standard Error: 43_833 + .saturating_add(Weight::from_ref_time(16_936_781).saturating_mul(r.into())) .saturating_add(T::DbWeight::get().reads(6_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) .saturating_add(Weight::from_proof_size(2400).saturating_mul(r.into())) @@ -667,7 +667,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(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:1 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) /// Storage: Timestamp Now (r:1 w:0) @@ -677,13 +677,13 @@ impl WeightInfo for SubstrateWeight { /// The range of component `r` is `[0, 20]`. fn seal_now(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `842 + r * (480 ±0)` - // Estimated: `17100 + r * (2400 ±0)` - // Minimum execution time: 374_798 nanoseconds. - Weight::from_ref_time(372_659_915) - .saturating_add(Weight::from_proof_size(17100)) - // Standard Error: 151_499 - .saturating_add(Weight::from_ref_time(18_192_683).saturating_mul(r.into())) + // Measured: `874 + r * (480 ±0)` + // Estimated: `17245 + r * (2400 ±0)` + // Minimum execution time: 373_473 nanoseconds. + Weight::from_ref_time(376_386_312) + .saturating_add(Weight::from_proof_size(17245)) + // Standard Error: 46_945 + .saturating_add(Weight::from_ref_time(17_336_462).saturating_mul(r.into())) .saturating_add(T::DbWeight::get().reads(6_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) .saturating_add(Weight::from_proof_size(2400).saturating_mul(r.into())) @@ -691,7 +691,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(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:1 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) /// Storage: Timestamp Now (r:1 w:0) @@ -703,13 +703,13 @@ impl WeightInfo for SubstrateWeight { /// The range of component `r` is `[0, 20]`. fn seal_weight_to_fee(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `919 + r * (800 ±0)` - // Estimated: `18835 + r * (4805 ±0)` - // Minimum execution time: 374_841 nanoseconds. - Weight::from_ref_time(385_475_889) - .saturating_add(Weight::from_proof_size(18835)) - // Standard Error: 106_207 - .saturating_add(Weight::from_ref_time(88_099_987).saturating_mul(r.into())) + // Measured: `951 + r * (800 ±0)` + // Estimated: `19046 + r * (4805 ±0)` + // Minimum execution time: 373_661 nanoseconds. + Weight::from_ref_time(385_824_015) + .saturating_add(Weight::from_proof_size(19046)) + // Standard Error: 75_964 + .saturating_add(Weight::from_ref_time(88_530_074).saturating_mul(r.into())) .saturating_add(T::DbWeight::get().reads(7_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) .saturating_add(Weight::from_proof_size(4805).saturating_mul(r.into())) @@ -717,7 +717,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(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:1 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) /// Storage: Timestamp Now (r:1 w:0) @@ -727,13 +727,13 @@ impl WeightInfo for SubstrateWeight { /// The range of component `r` is `[0, 20]`. fn seal_gas(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `809 + r * (320 ±0)` - // Estimated: `16955 + r * (1600 ±0)` - // Minimum execution time: 134_436 nanoseconds. - Weight::from_ref_time(137_789_498) - .saturating_add(Weight::from_proof_size(16955)) - // Standard Error: 10_622 - .saturating_add(Weight::from_ref_time(8_144_024).saturating_mul(r.into())) + // Measured: `841 + r * (320 ±0)` + // Estimated: `17120 + r * (1600 ±0)` + // Minimum execution time: 133_849 nanoseconds. + Weight::from_ref_time(137_283_391) + .saturating_add(Weight::from_proof_size(17120)) + // Standard Error: 13_312 + .saturating_add(Weight::from_ref_time(8_055_328).saturating_mul(r.into())) .saturating_add(T::DbWeight::get().reads(6_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) .saturating_add(Weight::from_proof_size(1600).saturating_mul(r.into())) @@ -741,7 +741,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(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:1 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) /// Storage: Timestamp Now (r:1 w:0) @@ -751,13 +751,13 @@ impl WeightInfo for SubstrateWeight { /// The range of component `r` is `[0, 20]`. fn seal_input(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `844 + r * (480 ±0)` - // Estimated: `17085 + r * (2400 ±0)` - // Minimum execution time: 374_480 nanoseconds. - Weight::from_ref_time(379_723_392) - .saturating_add(Weight::from_proof_size(17085)) - // Standard Error: 50_240 - .saturating_add(Weight::from_ref_time(15_358_041).saturating_mul(r.into())) + // Measured: `876 + r * (480 ±0)` + // Estimated: `17245 + r * (2400 ±0)` + // Minimum execution time: 373_468 nanoseconds. + Weight::from_ref_time(376_121_093) + .saturating_add(Weight::from_proof_size(17245)) + // Standard Error: 61_857 + .saturating_add(Weight::from_ref_time(15_868_414).saturating_mul(r.into())) .saturating_add(T::DbWeight::get().reads(6_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) .saturating_add(Weight::from_proof_size(2400).saturating_mul(r.into())) @@ -765,7 +765,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(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:1 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) /// Storage: Timestamp Now (r:1 w:0) @@ -775,20 +775,20 @@ impl WeightInfo for SubstrateWeight { /// The range of component `n` is `[0, 1024]`. fn seal_input_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `1324` - // Estimated: `19490` - // Minimum execution time: 392_282 nanoseconds. - Weight::from_ref_time(418_943_323) - .saturating_add(Weight::from_proof_size(19490)) - // Standard Error: 4_673 - .saturating_add(Weight::from_ref_time(9_664_301).saturating_mul(n.into())) + // Measured: `1356` + // Estimated: `19650` + // Minimum execution time: 390_668 nanoseconds. + Weight::from_ref_time(419_608_449) + .saturating_add(Weight::from_proof_size(19650)) + // Standard Error: 4_890 + .saturating_add(Weight::from_ref_time(9_672_288).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads(6_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) } /// 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(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:1 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) /// Storage: Timestamp Now (r:1 w:0) @@ -798,11 +798,13 @@ impl WeightInfo for SubstrateWeight { /// The range of component `r` is `[0, 1]`. fn seal_return(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `832 + r * (45 ±0)` - // Estimated: `17030 + r * (225 ±0)` - // Minimum execution time: 372_207 nanoseconds. - Weight::from_ref_time(376_232_444) - .saturating_add(Weight::from_proof_size(17030)) + // Measured: `864 + r * (45 ±0)` + // Estimated: `17190 + r * (225 ±0)` + // Minimum execution time: 371_309 nanoseconds. + Weight::from_ref_time(373_625_402) + .saturating_add(Weight::from_proof_size(17190)) + // Standard Error: 419_605 + .saturating_add(Weight::from_ref_time(1_737_397).saturating_mul(r.into())) .saturating_add(T::DbWeight::get().reads(6_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) .saturating_add(Weight::from_proof_size(225).saturating_mul(r.into())) @@ -810,7 +812,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(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:1 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) /// Storage: Timestamp Now (r:1 w:0) @@ -820,20 +822,20 @@ impl WeightInfo for SubstrateWeight { /// The range of component `n` is `[0, 1024]`. fn seal_return_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `842` - // Estimated: `17125` - // Minimum execution time: 374_743 nanoseconds. - Weight::from_ref_time(377_365_053) - .saturating_add(Weight::from_proof_size(17125)) - // Standard Error: 1_073 - .saturating_add(Weight::from_ref_time(231_251).saturating_mul(n.into())) + // Measured: `874` + // Estimated: `17285` + // Minimum execution time: 374_094 nanoseconds. + Weight::from_ref_time(375_965_200) + .saturating_add(Weight::from_proof_size(17285)) + // Standard Error: 1_127 + .saturating_add(Weight::from_ref_time(232_645).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads(6_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) } - /// Storage: System Account (r:3 w:3) + /// Storage: System Account (r:4 w:4) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:1 w:1) - /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:1 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) /// Storage: Timestamp Now (r:1 w:0) @@ -847,23 +849,23 @@ impl WeightInfo for SubstrateWeight { /// The range of component `r` is `[0, 1]`. fn seal_terminate(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `874 + r * (280 ±0)` - // Estimated: `19880 + r * (11465 ±0)` - // Minimum execution time: 374_873 nanoseconds. - Weight::from_ref_time(378_422_289) - .saturating_add(Weight::from_proof_size(19880)) - // Standard Error: 979_734 - .saturating_add(Weight::from_ref_time(57_035_310).saturating_mul(r.into())) + // Measured: `906 + r * (452 ±0)` + // Estimated: `20242 + r * (15004 ±0)` + // Minimum execution time: 373_123 nanoseconds. + Weight::from_ref_time(374_924_634) + .saturating_add(Weight::from_proof_size(20242)) + // Standard Error: 378_010 + .saturating_add(Weight::from_ref_time(70_441_665).saturating_mul(r.into())) .saturating_add(T::DbWeight::get().reads(6_u64)) - .saturating_add(T::DbWeight::get().reads((5_u64).saturating_mul(r.into()))) + .saturating_add(T::DbWeight::get().reads((6_u64).saturating_mul(r.into()))) .saturating_add(T::DbWeight::get().writes(3_u64)) - .saturating_add(T::DbWeight::get().writes((6_u64).saturating_mul(r.into()))) - .saturating_add(Weight::from_proof_size(11465).saturating_mul(r.into())) + .saturating_add(T::DbWeight::get().writes((7_u64).saturating_mul(r.into()))) + .saturating_add(Weight::from_proof_size(15004).saturating_mul(r.into())) } /// 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(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:1 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) /// Storage: Timestamp Now (r:1 w:0) @@ -875,13 +877,13 @@ impl WeightInfo for SubstrateWeight { /// The range of component `r` is `[0, 20]`. fn seal_random(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `889 + r * (800 ±0)` - // Estimated: `18643 + r * (4805 ±0)` - // Minimum execution time: 375_001 nanoseconds. - Weight::from_ref_time(382_558_599) - .saturating_add(Weight::from_proof_size(18643)) - // Standard Error: 94_918 - .saturating_add(Weight::from_ref_time(112_973_277).saturating_mul(r.into())) + // Measured: `921 + r * (800 ±0)` + // Estimated: `18835 + r * (4805 ±0)` + // Minimum execution time: 373_291 nanoseconds. + Weight::from_ref_time(385_684_344) + .saturating_add(Weight::from_proof_size(18835)) + // Standard Error: 99_025 + .saturating_add(Weight::from_ref_time(111_308_793).saturating_mul(r.into())) .saturating_add(T::DbWeight::get().reads(7_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) .saturating_add(Weight::from_proof_size(4805).saturating_mul(r.into())) @@ -889,7 +891,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(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:1 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) /// Storage: Timestamp Now (r:1 w:0) @@ -899,13 +901,13 @@ impl WeightInfo for SubstrateWeight { /// The range of component `r` is `[0, 20]`. fn seal_deposit_event(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `842 + r * (800 ±0)` - // Estimated: `17075 + r * (4000 ±0)` - // Minimum execution time: 372_547 nanoseconds. - Weight::from_ref_time(383_278_916) - .saturating_add(Weight::from_proof_size(17075)) - // Standard Error: 128_339 - .saturating_add(Weight::from_ref_time(229_356_088).saturating_mul(r.into())) + // Measured: `874 + r * (800 ±0)` + // Estimated: `17250 + r * (4000 ±0)` + // Minimum execution time: 371_900 nanoseconds. + Weight::from_ref_time(384_166_626) + .saturating_add(Weight::from_proof_size(17250)) + // Standard Error: 205_255 + .saturating_add(Weight::from_ref_time(229_214_157).saturating_mul(r.into())) .saturating_add(T::DbWeight::get().reads(6_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) .saturating_add(Weight::from_proof_size(4000).saturating_mul(r.into())) @@ -913,7 +915,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(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:1 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) /// Storage: Timestamp Now (r:1 w:0) @@ -924,15 +926,15 @@ impl WeightInfo for SubstrateWeight { /// The range of component `n` is `[0, 16]`. fn seal_deposit_event_per_topic_and_kb(t: u32, n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `1778 + t * (2608 ±0) + n * (8 ±0)` - // Estimated: `21675 + t * (211030 ±0) + n * (50 ±0)` - // Minimum execution time: 1_290_432 nanoseconds. - Weight::from_ref_time(595_859_216) - .saturating_add(Weight::from_proof_size(21675)) - // Standard Error: 602_943 - .saturating_add(Weight::from_ref_time(178_128_149).saturating_mul(t.into())) - // Standard Error: 165_597 - .saturating_add(Weight::from_ref_time(71_475_468).saturating_mul(n.into())) + // Measured: `1821 + t * (2608 ±0) + n * (7 ±0)` + // Estimated: `21870 + t * (211030 ±0) + n * (50 ±0)` + // Minimum execution time: 1_289_873 nanoseconds. + Weight::from_ref_time(581_702_206) + .saturating_add(Weight::from_proof_size(21870)) + // Standard Error: 665_638 + .saturating_add(Weight::from_ref_time(181_470_553).saturating_mul(t.into())) + // Standard Error: 182_816 + .saturating_add(Weight::from_ref_time(71_635_250).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads(6_u64)) .saturating_add(T::DbWeight::get().reads((80_u64).saturating_mul(t.into()))) .saturating_add(T::DbWeight::get().writes(3_u64)) @@ -943,7 +945,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(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:1 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) /// Storage: Timestamp Now (r:1 w:0) @@ -953,13 +955,13 @@ impl WeightInfo for SubstrateWeight { /// The range of component `r` is `[0, 20]`. fn seal_debug_message(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `841 + r * (560 ±0)` - // Estimated: `17065 + r * (2800 ±0)` - // Minimum execution time: 149_020 nanoseconds. - Weight::from_ref_time(152_893_012) - .saturating_add(Weight::from_proof_size(17065)) - // Standard Error: 31_804 - .saturating_add(Weight::from_ref_time(14_497_512).saturating_mul(r.into())) + // Measured: `873 + r * (560 ±0)` + // Estimated: `17240 + r * (2800 ±0)` + // Minimum execution time: 148_635 nanoseconds. + Weight::from_ref_time(154_095_712) + .saturating_add(Weight::from_proof_size(17240)) + // Standard Error: 77_790 + .saturating_add(Weight::from_ref_time(14_837_085).saturating_mul(r.into())) .saturating_add(T::DbWeight::get().reads(6_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) .saturating_add(Weight::from_proof_size(2800).saturating_mul(r.into())) @@ -967,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: MaxEncodedLen) /// Storage: Contracts ContractInfoOf (r:1 w:1) - /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: MaxEncodedLen) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: MaxEncodedLen) /// Storage: Contracts CodeStorage (r:1 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: MaxEncodedLen) /// Storage: Timestamp Now (r:1 w:0) @@ -977,13 +979,13 @@ impl WeightInfo for SubstrateWeight { /// The range of component `i` is `[0, 1024]`. fn seal_debug_message_per_kb(i: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `125792` - // Estimated: `265059` - // Minimum execution time: 502_589 nanoseconds. - Weight::from_ref_time(506_695_307) - .saturating_add(Weight::from_proof_size(265059)) - // Standard Error: 2_148 - .saturating_add(Weight::from_ref_time(814_647).saturating_mul(i.into())) + // Measured: `125824` + // Estimated: `265128` + // Minimum execution time: 501_014 nanoseconds. + Weight::from_ref_time(505_634_218) + .saturating_add(Weight::from_proof_size(265128)) + // Standard Error: 2_441 + .saturating_add(Weight::from_ref_time(819_257).saturating_mul(i.into())) .saturating_add(T::DbWeight::get().reads(6_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) } @@ -992,85 +994,85 @@ impl WeightInfo for SubstrateWeight { /// The range of component `r` is `[0, 10]`. fn seal_set_storage(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `883 + r * (23417 ±0)` - // Estimated: `883 + r * (23417 ±0)` - // Minimum execution time: 375_473 nanoseconds. - Weight::from_ref_time(291_125_810) - .saturating_add(Weight::from_proof_size(883)) - // Standard Error: 824_971 - .saturating_add(Weight::from_ref_time(477_999_695).saturating_mul(r.into())) + // Measured: `911 + r * (23420 ±0)` + // Estimated: `911 + r * (23418 ±0)` + // Minimum execution time: 375_301 nanoseconds. + Weight::from_ref_time(291_498_841) + .saturating_add(Weight::from_proof_size(911)) + // Standard Error: 809_989 + .saturating_add(Weight::from_ref_time(464_550_291).saturating_mul(r.into())) .saturating_add(T::DbWeight::get().reads(6_u64)) .saturating_add(T::DbWeight::get().reads((80_u64).saturating_mul(r.into()))) .saturating_add(T::DbWeight::get().writes(3_u64)) .saturating_add(T::DbWeight::get().writes((80_u64).saturating_mul(r.into()))) - .saturating_add(Weight::from_proof_size(23417).saturating_mul(r.into())) + .saturating_add(Weight::from_proof_size(23418).saturating_mul(r.into())) } /// Storage: Skipped Metadata (r:0 w:0) /// Proof Skipped: Skipped Metadata (max_values: None, max_size: None, mode: Measured) /// The range of component `n` is `[0, 8]`. fn seal_set_storage_per_new_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `12583 + n * (11969 ±0)` - // Estimated: `8500 + n * (12813 ±61)` - // Minimum execution time: 515_962 nanoseconds. - Weight::from_ref_time(697_904_030) - .saturating_add(Weight::from_proof_size(8500)) - // Standard Error: 1_684_000 - .saturating_add(Weight::from_ref_time(98_411_710).saturating_mul(n.into())) + // Measured: `12672 + n * (11945 ±0)` + // Estimated: `8529 + n * (12814 ±61)` + // Minimum execution time: 506_318 nanoseconds. + Weight::from_ref_time(676_935_313) + .saturating_add(Weight::from_proof_size(8529)) + // Standard Error: 1_589_291 + .saturating_add(Weight::from_ref_time(97_839_399).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads(52_u64)) .saturating_add(T::DbWeight::get().reads((7_u64).saturating_mul(n.into()))) .saturating_add(T::DbWeight::get().writes(50_u64)) .saturating_add(T::DbWeight::get().writes((7_u64).saturating_mul(n.into()))) - .saturating_add(Weight::from_proof_size(12813).saturating_mul(n.into())) + .saturating_add(Weight::from_proof_size(12814).saturating_mul(n.into())) } /// Storage: Skipped Metadata (r:0 w:0) /// Proof Skipped: Skipped Metadata (max_values: None, max_size: None, mode: Measured) /// The range of component `n` is `[0, 8]`. fn seal_set_storage_per_old_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `15138 + n * (175775 ±0)` - // Estimated: `9898 + n * (176855 ±74)` - // Minimum execution time: 515_828 nanoseconds. - Weight::from_ref_time(661_240_495) - .saturating_add(Weight::from_proof_size(9898)) - // Standard Error: 1_338_661 - .saturating_add(Weight::from_ref_time(65_767_819).saturating_mul(n.into())) + // Measured: `15170 + n * (175775 ±0)` + // Estimated: `9914 + n * (176858 ±74)` + // Minimum execution time: 506_148 nanoseconds. + Weight::from_ref_time(648_278_778) + .saturating_add(Weight::from_proof_size(9914)) + // Standard Error: 1_343_586 + .saturating_add(Weight::from_ref_time(65_789_595).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads(51_u64)) .saturating_add(T::DbWeight::get().reads((7_u64).saturating_mul(n.into()))) .saturating_add(T::DbWeight::get().writes(49_u64)) .saturating_add(T::DbWeight::get().writes((7_u64).saturating_mul(n.into()))) - .saturating_add(Weight::from_proof_size(176855).saturating_mul(n.into())) + .saturating_add(Weight::from_proof_size(176858).saturating_mul(n.into())) } /// Storage: Skipped Metadata (r:0 w:0) /// Proof Skipped: Skipped Metadata (max_values: None, max_size: None, mode: Measured) /// The range of component `r` is `[0, 10]`. fn seal_clear_storage(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `876 + r * (23098 ±0)` - // Estimated: `881 + r * (23097 ±0)` - // Minimum execution time: 375_528 nanoseconds. - Weight::from_ref_time(296_453_612) - .saturating_add(Weight::from_proof_size(881)) - // Standard Error: 809_232 - .saturating_add(Weight::from_ref_time(465_365_815).saturating_mul(r.into())) + // Measured: `903 + r * (23099 ±0)` + // Estimated: `908 + r * (23099 ±0)` + // Minimum execution time: 374_344 nanoseconds. + Weight::from_ref_time(293_272_061) + .saturating_add(Weight::from_proof_size(908)) + // Standard Error: 810_412 + .saturating_add(Weight::from_ref_time(453_315_956).saturating_mul(r.into())) .saturating_add(T::DbWeight::get().reads(6_u64)) .saturating_add(T::DbWeight::get().reads((80_u64).saturating_mul(r.into()))) .saturating_add(T::DbWeight::get().writes(3_u64)) .saturating_add(T::DbWeight::get().writes((80_u64).saturating_mul(r.into()))) - .saturating_add(Weight::from_proof_size(23097).saturating_mul(r.into())) + .saturating_add(Weight::from_proof_size(23099).saturating_mul(r.into())) } /// Storage: Skipped Metadata (r:0 w:0) /// Proof Skipped: Skipped Metadata (max_values: None, max_size: None, mode: Measured) /// The range of component `n` is `[0, 8]`. fn seal_clear_storage_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `14863 + n * (175768 ±0)` - // Estimated: `9519 + n * (176867 ±75)` - // Minimum execution time: 480_427 nanoseconds. - Weight::from_ref_time(640_337_570) - .saturating_add(Weight::from_proof_size(9519)) - // Standard Error: 1_497_141 - .saturating_add(Weight::from_ref_time(67_963_696).saturating_mul(n.into())) + // Measured: `14895 + n * (175768 ±0)` + // Estimated: `9551 + n * (176867 ±75)` + // Minimum execution time: 478_564 nanoseconds. + Weight::from_ref_time(630_839_142) + .saturating_add(Weight::from_proof_size(9551)) + // Standard Error: 1_427_520 + .saturating_add(Weight::from_ref_time(66_813_592).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads(51_u64)) .saturating_add(T::DbWeight::get().reads((7_u64).saturating_mul(n.into()))) .saturating_add(T::DbWeight::get().writes(48_u64)) @@ -1082,30 +1084,30 @@ impl WeightInfo for SubstrateWeight { /// The range of component `r` is `[0, 10]`. fn seal_get_storage(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `878 + r * (23740 ±0)` - // Estimated: `880 + r * (23739 ±0)` - // Minimum execution time: 375_725 nanoseconds. - Weight::from_ref_time(307_839_394) - .saturating_add(Weight::from_proof_size(880)) - // Standard Error: 710_694 - .saturating_add(Weight::from_ref_time(381_738_407).saturating_mul(r.into())) + // Measured: `896 + r * (23744 ±0)` + // Estimated: `909 + r * (23740 ±0)` + // Minimum execution time: 374_479 nanoseconds. + Weight::from_ref_time(311_839_315) + .saturating_add(Weight::from_proof_size(909)) + // Standard Error: 666_553 + .saturating_add(Weight::from_ref_time(371_213_042).saturating_mul(r.into())) .saturating_add(T::DbWeight::get().reads(6_u64)) .saturating_add(T::DbWeight::get().reads((80_u64).saturating_mul(r.into()))) .saturating_add(T::DbWeight::get().writes(3_u64)) - .saturating_add(Weight::from_proof_size(23739).saturating_mul(r.into())) + .saturating_add(Weight::from_proof_size(23740).saturating_mul(r.into())) } /// Storage: Skipped Metadata (r:0 w:0) /// Proof Skipped: Skipped Metadata (max_values: None, max_size: None, mode: Measured) /// The range of component `n` is `[0, 8]`. fn seal_get_storage_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `15469 + n * (175775 ±0)` - // Estimated: `10010 + n * (176900 ±76)` - // Minimum execution time: 461_871 nanoseconds. - Weight::from_ref_time(605_755_493) - .saturating_add(Weight::from_proof_size(10010)) - // Standard Error: 1_375_044 - .saturating_add(Weight::from_ref_time(161_332_330).saturating_mul(n.into())) + // Measured: `15501 + n * (175775 ±0)` + // Estimated: `10042 + n * (176900 ±76)` + // Minimum execution time: 460_639 nanoseconds. + Weight::from_ref_time(591_187_094) + .saturating_add(Weight::from_proof_size(10042)) + // Standard Error: 1_233_792 + .saturating_add(Weight::from_ref_time(160_874_477).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads(51_u64)) .saturating_add(T::DbWeight::get().reads((7_u64).saturating_mul(n.into()))) .saturating_add(T::DbWeight::get().writes(3_u64)) @@ -1116,47 +1118,47 @@ impl WeightInfo for SubstrateWeight { /// The range of component `r` is `[0, 10]`. fn seal_contains_storage(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `871 + r * (23100 ±0)` - // Estimated: `873 + r * (23099 ±0)` - // Minimum execution time: 375_325 nanoseconds. - Weight::from_ref_time(305_508_307) - .saturating_add(Weight::from_proof_size(873)) - // Standard Error: 715_627 - .saturating_add(Weight::from_ref_time(369_985_438).saturating_mul(r.into())) + // Measured: `914 + r * (23098 ±0)` + // Estimated: `920 + r * (23098 ±0)` + // Minimum execution time: 374_272 nanoseconds. + Weight::from_ref_time(311_446_269) + .saturating_add(Weight::from_proof_size(920)) + // Standard Error: 630_307 + .saturating_add(Weight::from_ref_time(357_134_931).saturating_mul(r.into())) .saturating_add(T::DbWeight::get().reads(6_u64)) .saturating_add(T::DbWeight::get().reads((80_u64).saturating_mul(r.into()))) .saturating_add(T::DbWeight::get().writes(3_u64)) - .saturating_add(Weight::from_proof_size(23099).saturating_mul(r.into())) + .saturating_add(Weight::from_proof_size(23098).saturating_mul(r.into())) } /// Storage: Skipped Metadata (r:0 w:0) /// Proof Skipped: Skipped Metadata (max_values: None, max_size: None, mode: Measured) /// The range of component `n` is `[0, 8]`. fn seal_contains_storage_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `14814 + n * (175782 ±0)` - // Estimated: `9502 + n * (176872 ±75)` - // Minimum execution time: 457_128 nanoseconds. - Weight::from_ref_time(582_799_799) - .saturating_add(Weight::from_proof_size(9502)) - // Standard Error: 1_151_126 - .saturating_add(Weight::from_ref_time(63_425_277).saturating_mul(n.into())) + // Measured: `14839 + n * (175789 ±0)` + // Estimated: `9532 + n * (176874 ±75)` + // Minimum execution time: 456_013 nanoseconds. + Weight::from_ref_time(575_116_352) + .saturating_add(Weight::from_proof_size(9532)) + // Standard Error: 1_122_298 + .saturating_add(Weight::from_ref_time(61_786_107).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads(51_u64)) .saturating_add(T::DbWeight::get().reads((7_u64).saturating_mul(n.into()))) .saturating_add(T::DbWeight::get().writes(3_u64)) - .saturating_add(Weight::from_proof_size(176872).saturating_mul(n.into())) + .saturating_add(Weight::from_proof_size(176874).saturating_mul(n.into())) } /// Storage: Skipped Metadata (r:0 w:0) /// Proof Skipped: Skipped Metadata (max_values: None, max_size: None, mode: Measured) /// The range of component `r` is `[0, 10]`. fn seal_take_storage(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `879 + r * (23740 ±0)` - // Estimated: `881 + r * (23739 ±0)` - // Minimum execution time: 375_918 nanoseconds. - Weight::from_ref_time(293_217_646) - .saturating_add(Weight::from_proof_size(881)) - // Standard Error: 840_266 - .saturating_add(Weight::from_ref_time(478_374_701).saturating_mul(r.into())) + // Measured: `911 + r * (23740 ±0)` + // Estimated: `913 + r * (23739 ±0)` + // Minimum execution time: 374_621 nanoseconds. + Weight::from_ref_time(299_689_489) + .saturating_add(Weight::from_proof_size(913)) + // Standard Error: 757_735 + .saturating_add(Weight::from_ref_time(465_213_246).saturating_mul(r.into())) .saturating_add(T::DbWeight::get().reads(6_u64)) .saturating_add(T::DbWeight::get().reads((80_u64).saturating_mul(r.into()))) .saturating_add(T::DbWeight::get().writes(3_u64)) @@ -1168,13 +1170,13 @@ impl WeightInfo for SubstrateWeight { /// The range of component `n` is `[0, 8]`. fn seal_take_storage_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `15470 + n * (175775 ±0)` - // Estimated: `10010 + n * (176898 ±76)` - // Minimum execution time: 484_207 nanoseconds. - Weight::from_ref_time(664_065_436) - .saturating_add(Weight::from_proof_size(10010)) - // Standard Error: 1_655_442 - .saturating_add(Weight::from_ref_time(166_258_757).saturating_mul(n.into())) + // Measured: `15502 + n * (175775 ±0)` + // Estimated: `10042 + n * (176898 ±76)` + // Minimum execution time: 481_980 nanoseconds. + Weight::from_ref_time(647_289_053) + .saturating_add(Weight::from_proof_size(10042)) + // Standard Error: 1_556_155 + .saturating_add(Weight::from_ref_time(166_592_657).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads(51_u64)) .saturating_add(T::DbWeight::get().reads((7_u64).saturating_mul(n.into()))) .saturating_add(T::DbWeight::get().writes(48_u64)) @@ -1184,7 +1186,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(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:1 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) /// Storage: Timestamp Now (r:1 w:0) @@ -1194,23 +1196,23 @@ impl WeightInfo for SubstrateWeight { /// The range of component `r` is `[0, 20]`. fn seal_transfer(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `1393 + r * (3602 ±0)` - // Estimated: `21258 + r * (216091 ±0)` - // Minimum execution time: 377_152 nanoseconds. - Weight::from_ref_time(317_470_910) - .saturating_add(Weight::from_proof_size(21258)) - // Standard Error: 994_076 - .saturating_add(Weight::from_ref_time(1_409_416_087).saturating_mul(r.into())) + // Measured: `1457 + r * (3604 ±0)` + // Estimated: `21583 + r * (216101 ±0)` + // Minimum execution time: 374_962 nanoseconds. + Weight::from_ref_time(313_416_386) + .saturating_add(Weight::from_proof_size(21583)) + // Standard Error: 710_675 + .saturating_add(Weight::from_ref_time(1_396_551_156).saturating_mul(r.into())) .saturating_add(T::DbWeight::get().reads(7_u64)) .saturating_add(T::DbWeight::get().reads((80_u64).saturating_mul(r.into()))) .saturating_add(T::DbWeight::get().writes(4_u64)) .saturating_add(T::DbWeight::get().writes((80_u64).saturating_mul(r.into()))) - .saturating_add(Weight::from_proof_size(216091).saturating_mul(r.into())) + .saturating_add(Weight::from_proof_size(216101).saturating_mul(r.into())) } /// 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:1601) - /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:2 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) /// Storage: Timestamp Now (r:1 w:0) @@ -1220,23 +1222,23 @@ impl WeightInfo for SubstrateWeight { /// The range of component `r` is `[0, 20]`. fn seal_call(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `1551 + r * (20511 ±0)` - // Estimated: `21848 + r * (498651 ±1)` - // Minimum execution time: 376_257 nanoseconds. - Weight::from_ref_time(377_035_000) - .saturating_add(Weight::from_proof_size(21848)) - // Standard Error: 7_966_778 - .saturating_add(Weight::from_ref_time(28_873_495_129).saturating_mul(r.into())) + // Measured: `1609 + r * (23073 ±0)` + // Estimated: `22098 + r * (511456 ±1)` + // Minimum execution time: 375_916 nanoseconds. + Weight::from_ref_time(376_468_000) + .saturating_add(Weight::from_proof_size(22098)) + // Standard Error: 7_246_855 + .saturating_add(Weight::from_ref_time(28_982_425_139).saturating_mul(r.into())) .saturating_add(T::DbWeight::get().reads(7_u64)) .saturating_add(T::DbWeight::get().reads((160_u64).saturating_mul(r.into()))) .saturating_add(T::DbWeight::get().writes(3_u64)) .saturating_add(T::DbWeight::get().writes((160_u64).saturating_mul(r.into()))) - .saturating_add(Weight::from_proof_size(498651).saturating_mul(r.into())) + .saturating_add(Weight::from_proof_size(511456).saturating_mul(r.into())) } /// 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(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:1536 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) /// Storage: Timestamp Now (r:1 w:0) @@ -1247,22 +1249,22 @@ impl WeightInfo for SubstrateWeight { fn seal_delegate_call(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0 + r * (71670 ±0)` - // Estimated: `17125 + r * (659927 ±822)` - // Minimum execution time: 376_544 nanoseconds. - Weight::from_ref_time(377_490_000) - .saturating_add(Weight::from_proof_size(17125)) - // Standard Error: 8_608_050 - .saturating_add(Weight::from_ref_time(28_568_714_410).saturating_mul(r.into())) + // Estimated: `17285 + r * (659930 ±563)` + // Minimum execution time: 375_412 nanoseconds. + Weight::from_ref_time(376_493_000) + .saturating_add(Weight::from_proof_size(17285)) + // Standard Error: 8_239_575 + .saturating_add(Weight::from_ref_time(28_716_347_183).saturating_mul(r.into())) .saturating_add(T::DbWeight::get().reads(6_u64)) .saturating_add(T::DbWeight::get().reads((150_u64).saturating_mul(r.into()))) .saturating_add(T::DbWeight::get().writes(3_u64)) .saturating_add(T::DbWeight::get().writes((75_u64).saturating_mul(r.into()))) - .saturating_add(Weight::from_proof_size(659927).saturating_mul(r.into())) + .saturating_add(Weight::from_proof_size(659930).saturating_mul(r.into())) } /// Storage: System Account (r:82 w:81) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:81 w:81) - /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:2 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) /// Storage: Timestamp Now (r:1 w:0) @@ -1273,25 +1275,25 @@ impl WeightInfo for SubstrateWeight { /// The range of component `c` is `[0, 1024]`. fn seal_call_per_transfer_clone_kb(t: u32, c: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `21611 + t * (15369 ±0)` - // Estimated: `519400 + t * (277320 ±0)` - // Minimum execution time: 10_322_052 nanoseconds. - Weight::from_ref_time(9_248_652_894) - .saturating_add(Weight::from_proof_size(519400)) - // Standard Error: 9_039_638 - .saturating_add(Weight::from_ref_time(1_393_054_441).saturating_mul(t.into())) - // Standard Error: 13_554 - .saturating_add(Weight::from_ref_time(9_819_606).saturating_mul(c.into())) + // Measured: `24269 + t * (16910 ±0)` + // Estimated: `532690 + t * (285025 ±0)` + // Minimum execution time: 10_443_315 nanoseconds. + Weight::from_ref_time(9_342_574_069) + .saturating_add(Weight::from_proof_size(532690)) + // Standard Error: 7_237_279 + .saturating_add(Weight::from_ref_time(1_390_221_936).saturating_mul(t.into())) + // Standard Error: 10_851 + .saturating_add(Weight::from_ref_time(9_842_151).saturating_mul(c.into())) .saturating_add(T::DbWeight::get().reads(167_u64)) .saturating_add(T::DbWeight::get().reads((81_u64).saturating_mul(t.into()))) .saturating_add(T::DbWeight::get().writes(163_u64)) .saturating_add(T::DbWeight::get().writes((81_u64).saturating_mul(t.into()))) - .saturating_add(Weight::from_proof_size(277320).saturating_mul(t.into())) + .saturating_add(Weight::from_proof_size(285025).saturating_mul(t.into())) } - /// Storage: System Account (r:1602 w:1602) + /// Storage: System Account (r:3202 w:3202) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:1601 w:1601) - /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:1601 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) /// Storage: Timestamp Now (r:1 w:0) @@ -1305,23 +1307,23 @@ impl WeightInfo for SubstrateWeight { /// The range of component `r` is `[0, 20]`. fn seal_instantiate(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `1613 + r * (25576 ±0)` - // Estimated: `25698 + r * (1169112 ±1)` - // Minimum execution time: 376_639 nanoseconds. - Weight::from_ref_time(377_892_000) - .saturating_add(Weight::from_proof_size(25698)) - // Standard Error: 21_259_255 - .saturating_add(Weight::from_ref_time(34_131_174_956).saturating_mul(r.into())) + // Measured: `1775 + r * (25568 ±0)` + // Estimated: `26563 + r * (1367114 ±2)` + // Minimum execution time: 376_418 nanoseconds. + Weight::from_ref_time(377_292_000) + .saturating_add(Weight::from_proof_size(26563)) + // Standard Error: 32_312_545 + .saturating_add(Weight::from_ref_time(35_904_826_312).saturating_mul(r.into())) .saturating_add(T::DbWeight::get().reads(8_u64)) - .saturating_add(T::DbWeight::get().reads((400_u64).saturating_mul(r.into()))) + .saturating_add(T::DbWeight::get().reads((480_u64).saturating_mul(r.into()))) .saturating_add(T::DbWeight::get().writes(5_u64)) - .saturating_add(T::DbWeight::get().writes((320_u64).saturating_mul(r.into()))) - .saturating_add(Weight::from_proof_size(1169112).saturating_mul(r.into())) + .saturating_add(T::DbWeight::get().writes((400_u64).saturating_mul(r.into()))) + .saturating_add(Weight::from_proof_size(1367114).saturating_mul(r.into())) } - /// Storage: System Account (r:82 w:82) + /// Storage: System Account (r:162 w:162) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:81 w:81) - /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:2 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) /// Storage: Timestamp Now (r:1 w:0) @@ -1337,27 +1339,27 @@ impl WeightInfo for SubstrateWeight { /// The range of component `s` is `[0, 960]`. fn seal_instantiate_per_transfer_input_salt_kb(t: u32, i: u32, s: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `5666 + t * (17 ±0)` - // Estimated: `651914 + t * (2762 ±3)` - // Minimum execution time: 130_366_376 nanoseconds. - Weight::from_ref_time(9_844_607_874) - .saturating_add(Weight::from_proof_size(651914)) - // Standard Error: 100_211_149 - .saturating_add(Weight::from_ref_time(390_481_449).saturating_mul(t.into())) - // Standard Error: 163_416 - .saturating_add(Weight::from_ref_time(126_154_200).saturating_mul(i.into())) - // Standard Error: 163_416 - .saturating_add(Weight::from_ref_time(126_430_874).saturating_mul(s.into())) - .saturating_add(T::DbWeight::get().reads(249_u64)) + // Measured: `5785 + t * (33 ±0)` + // Estimated: `850985 + t * (2671 ±3)` + // Minimum execution time: 132_157_340 nanoseconds. + Weight::from_ref_time(11_329_968_948) + .saturating_add(Weight::from_proof_size(850985)) + // Standard Error: 99_102_968 + .saturating_add(Weight::from_ref_time(84_719_458).saturating_mul(t.into())) + // Standard Error: 161_609 + .saturating_add(Weight::from_ref_time(126_156_627).saturating_mul(i.into())) + // Standard Error: 161_609 + .saturating_add(Weight::from_ref_time(126_628_313).saturating_mul(s.into())) + .saturating_add(T::DbWeight::get().reads(329_u64)) .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(t.into()))) - .saturating_add(T::DbWeight::get().writes(246_u64)) + .saturating_add(T::DbWeight::get().writes(326_u64)) .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(t.into()))) - .saturating_add(Weight::from_proof_size(2762).saturating_mul(t.into())) + .saturating_add(Weight::from_proof_size(2671).saturating_mul(t.into())) } /// 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(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:1 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) /// Storage: Timestamp Now (r:1 w:0) @@ -1367,13 +1369,13 @@ impl WeightInfo for SubstrateWeight { /// The range of component `r` is `[0, 1]`. fn seal_hash_sha2_256(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `839 + r * (642 ±0)` - // Estimated: `17065 + r * (3210 ±0)` - // Minimum execution time: 373_848 nanoseconds. - Weight::from_ref_time(375_974_597) - .saturating_add(Weight::from_proof_size(17065)) - // Standard Error: 558_923 - .saturating_add(Weight::from_ref_time(42_648_202).saturating_mul(r.into())) + // Measured: `871 + r * (642 ±0)` + // Estimated: `17225 + r * (3210 ±0)` + // Minimum execution time: 373_559 nanoseconds. + Weight::from_ref_time(375_166_904) + .saturating_add(Weight::from_proof_size(17225)) + // Standard Error: 125_024 + .saturating_add(Weight::from_ref_time(42_291_595).saturating_mul(r.into())) .saturating_add(T::DbWeight::get().reads(6_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) .saturating_add(Weight::from_proof_size(3210).saturating_mul(r.into())) @@ -1381,7 +1383,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(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:1 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) /// Storage: Timestamp Now (r:1 w:0) @@ -1391,20 +1393,20 @@ impl WeightInfo for SubstrateWeight { /// The range of component `n` is `[0, 1024]`. fn seal_hash_sha2_256_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `1641` - // Estimated: `21000` - // Minimum execution time: 417_281 nanoseconds. - Weight::from_ref_time(418_086_000) - .saturating_add(Weight::from_proof_size(21000)) - // Standard Error: 43_883 - .saturating_add(Weight::from_ref_time(324_497_460).saturating_mul(n.into())) + // Measured: `1673` + // Estimated: `21160` + // Minimum execution time: 416_233 nanoseconds. + Weight::from_ref_time(416_785_000) + .saturating_add(Weight::from_proof_size(21160)) + // Standard Error: 56_223 + .saturating_add(Weight::from_ref_time(324_513_835).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads(6_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) } /// 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(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:1 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) /// Storage: Timestamp Now (r:1 w:0) @@ -1414,13 +1416,13 @@ impl WeightInfo for SubstrateWeight { /// The range of component `r` is `[0, 1]`. fn seal_hash_keccak_256(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `841 + r * (642 ±0)` - // Estimated: `17075 + r * (3210 ±0)` - // Minimum execution time: 372_362 nanoseconds. - Weight::from_ref_time(374_975_677) - .saturating_add(Weight::from_proof_size(17075)) - // Standard Error: 307_932 - .saturating_add(Weight::from_ref_time(57_607_522).saturating_mul(r.into())) + // Measured: `873 + r * (642 ±0)` + // Estimated: `17235 + r * (3210 ±0)` + // Minimum execution time: 371_735 nanoseconds. + Weight::from_ref_time(375_979_430) + .saturating_add(Weight::from_proof_size(17235)) + // Standard Error: 968_037 + .saturating_add(Weight::from_ref_time(57_780_769).saturating_mul(r.into())) .saturating_add(T::DbWeight::get().reads(6_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) .saturating_add(Weight::from_proof_size(3210).saturating_mul(r.into())) @@ -1428,7 +1430,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(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:1 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) /// Storage: Timestamp Now (r:1 w:0) @@ -1438,20 +1440,20 @@ impl WeightInfo for SubstrateWeight { /// The range of component `n` is `[0, 1024]`. fn seal_hash_keccak_256_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `1643` - // Estimated: `21040` - // Minimum execution time: 431_034 nanoseconds. - Weight::from_ref_time(431_571_000) - .saturating_add(Weight::from_proof_size(21040)) - // Standard Error: 80_071 - .saturating_add(Weight::from_ref_time(261_645_325).saturating_mul(n.into())) + // Measured: `1675` + // Estimated: `21205` + // Minimum execution time: 428_196 nanoseconds. + Weight::from_ref_time(429_438_000) + .saturating_add(Weight::from_proof_size(21205)) + // Standard Error: 57_860 + .saturating_add(Weight::from_ref_time(260_917_896).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads(6_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) } /// 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(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:1 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) /// Storage: Timestamp Now (r:1 w:0) @@ -1461,13 +1463,13 @@ impl WeightInfo for SubstrateWeight { /// The range of component `r` is `[0, 1]`. fn seal_hash_blake2_256(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `841 + r * (642 ±0)` - // Estimated: `17075 + r * (3210 ±0)` - // Minimum execution time: 372_069 nanoseconds. - Weight::from_ref_time(374_200_608) - .saturating_add(Weight::from_proof_size(17075)) - // Standard Error: 171_799 - .saturating_add(Weight::from_ref_time(32_843_391).saturating_mul(r.into())) + // Measured: `873 + r * (642 ±0)` + // Estimated: `17235 + r * (3210 ±0)` + // Minimum execution time: 371_412 nanoseconds. + Weight::from_ref_time(373_635_818) + .saturating_add(Weight::from_proof_size(17235)) + // Standard Error: 222_973 + .saturating_add(Weight::from_ref_time(33_347_181).saturating_mul(r.into())) .saturating_add(T::DbWeight::get().reads(6_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) .saturating_add(Weight::from_proof_size(3210).saturating_mul(r.into())) @@ -1475,7 +1477,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(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:1 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) /// Storage: Timestamp Now (r:1 w:0) @@ -1485,20 +1487,20 @@ impl WeightInfo for SubstrateWeight { /// The range of component `n` is `[0, 1024]`. fn seal_hash_blake2_256_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `1643` - // Estimated: `21010` - // Minimum execution time: 406_143 nanoseconds. - Weight::from_ref_time(406_744_000) - .saturating_add(Weight::from_proof_size(21010)) - // Standard Error: 48_038 - .saturating_add(Weight::from_ref_time(103_286_295).saturating_mul(n.into())) + // Measured: `1675` + // Estimated: `21180` + // Minimum execution time: 405_858 nanoseconds. + Weight::from_ref_time(406_498_000) + .saturating_add(Weight::from_proof_size(21180)) + // Standard Error: 48_388 + .saturating_add(Weight::from_ref_time(103_283_157).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads(6_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) } /// 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(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:1 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) /// Storage: Timestamp Now (r:1 w:0) @@ -1508,13 +1510,13 @@ impl WeightInfo for SubstrateWeight { /// The range of component `r` is `[0, 1]`. fn seal_hash_blake2_128(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `841 + r * (679 ±0)` - // Estimated: `17075 + r * (3395 ±0)` - // Minimum execution time: 372_201 nanoseconds. - Weight::from_ref_time(374_049_708) - .saturating_add(Weight::from_proof_size(17075)) - // Standard Error: 387_179 - .saturating_add(Weight::from_ref_time(38_857_191).saturating_mul(r.into())) + // Measured: `873 + r * (679 ±0)` + // Estimated: `17235 + r * (3395 ±0)` + // Minimum execution time: 371_746 nanoseconds. + Weight::from_ref_time(373_538_171) + .saturating_add(Weight::from_proof_size(17235)) + // Standard Error: 387_332 + .saturating_add(Weight::from_ref_time(35_933_528).saturating_mul(r.into())) .saturating_add(T::DbWeight::get().reads(6_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) .saturating_add(Weight::from_proof_size(3395).saturating_mul(r.into())) @@ -1522,7 +1524,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(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:1 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) /// Storage: Timestamp Now (r:1 w:0) @@ -1532,20 +1534,20 @@ impl WeightInfo for SubstrateWeight { /// The range of component `n` is `[0, 1024]`. fn seal_hash_blake2_128_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `1643` - // Estimated: `21050` - // Minimum execution time: 405_819 nanoseconds. - Weight::from_ref_time(406_364_000) - .saturating_add(Weight::from_proof_size(21050)) - // Standard Error: 46_248 - .saturating_add(Weight::from_ref_time(103_189_157).saturating_mul(n.into())) + // Measured: `1675` + // Estimated: `21225` + // Minimum execution time: 405_752 nanoseconds. + Weight::from_ref_time(406_417_000) + .saturating_add(Weight::from_proof_size(21225)) + // Standard Error: 47_051 + .saturating_add(Weight::from_ref_time(103_325_027).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads(6_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) } /// 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(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:1 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) /// Storage: Timestamp Now (r:1 w:0) @@ -1555,13 +1557,13 @@ impl WeightInfo for SubstrateWeight { /// The range of component `r` is `[0, 1]`. fn seal_ecdsa_recover(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `885 + r * (6083 ±0)` - // Estimated: `17295 + r * (30415 ±0)` - // Minimum execution time: 374_836 nanoseconds. - Weight::from_ref_time(379_385_500) - .saturating_add(Weight::from_proof_size(17295)) - // Standard Error: 1_694_427 - .saturating_add(Weight::from_ref_time(3_021_801_000).saturating_mul(r.into())) + // Measured: `917 + r * (6083 ±0)` + // Estimated: `17455 + r * (30415 ±0)` + // Minimum execution time: 373_882 nanoseconds. + Weight::from_ref_time(376_553_787) + .saturating_add(Weight::from_proof_size(17455)) + // Standard Error: 912_833 + .saturating_add(Weight::from_ref_time(3_021_100_412).saturating_mul(r.into())) .saturating_add(T::DbWeight::get().reads(6_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) .saturating_add(Weight::from_proof_size(30415).saturating_mul(r.into())) @@ -1569,7 +1571,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(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:1 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) /// Storage: Timestamp Now (r:1 w:0) @@ -1579,13 +1581,13 @@ impl WeightInfo for SubstrateWeight { /// The range of component `r` is `[0, 1]`. fn seal_ecdsa_to_eth_address(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `854 + r * (3362 ±0)` - // Estimated: `17140 + r * (16810 ±0)` - // Minimum execution time: 374_223 nanoseconds. - Weight::from_ref_time(376_120_230) - .saturating_add(Weight::from_proof_size(17140)) - // Standard Error: 619_576 - .saturating_add(Weight::from_ref_time(754_257_969).saturating_mul(r.into())) + // Measured: `886 + r * (3362 ±0)` + // Estimated: `17300 + r * (16810 ±0)` + // Minimum execution time: 373_673 nanoseconds. + Weight::from_ref_time(375_712_961) + .saturating_add(Weight::from_proof_size(17300)) + // Standard Error: 596_297 + .saturating_add(Weight::from_ref_time(738_257_638).saturating_mul(r.into())) .saturating_add(T::DbWeight::get().reads(6_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) .saturating_add(Weight::from_proof_size(16810).saturating_mul(r.into())) @@ -1593,7 +1595,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(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:1536 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) /// Storage: Timestamp Now (r:1 w:0) @@ -1606,12 +1608,12 @@ impl WeightInfo for SubstrateWeight { fn seal_set_code_hash(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0 + r * (79300 ±0)` - // Estimated: `64652 + r * (942952 ±829)` - // Minimum execution time: 374_442 nanoseconds. - Weight::from_ref_time(375_591_000) - .saturating_add(Weight::from_proof_size(64652)) - // Standard Error: 3_764_193 - .saturating_add(Weight::from_ref_time(1_552_885_601).saturating_mul(r.into())) + // Estimated: `64844 + r * (942952 ±833)` + // Minimum execution time: 374_097 nanoseconds. + Weight::from_ref_time(374_985_000) + .saturating_add(Weight::from_proof_size(64844)) + // Standard Error: 3_772_336 + .saturating_add(Weight::from_ref_time(1_546_402_854).saturating_mul(r.into())) .saturating_add(T::DbWeight::get().reads(6_u64)) .saturating_add(T::DbWeight::get().reads((225_u64).saturating_mul(r.into()))) .saturating_add(T::DbWeight::get().writes(3_u64)) @@ -1621,7 +1623,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(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:1 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) /// Storage: Timestamp Now (r:1 w:0) @@ -1631,13 +1633,13 @@ impl WeightInfo for SubstrateWeight { /// The range of component `r` is `[0, 20]`. fn seal_reentrance_count(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `837 + r * (240 ±0)` - // Estimated: `17055 + r * (1200 ±0)` - // Minimum execution time: 374_922 nanoseconds. - Weight::from_ref_time(376_234_094) - .saturating_add(Weight::from_proof_size(17055)) - // Standard Error: 45_995 - .saturating_add(Weight::from_ref_time(11_606_505).saturating_mul(r.into())) + // Measured: `869 + r * (240 ±0)` + // Estimated: `17215 + r * (1200 ±0)` + // Minimum execution time: 374_249 nanoseconds. + Weight::from_ref_time(377_990_998) + .saturating_add(Weight::from_proof_size(17215)) + // Standard Error: 38_133 + .saturating_add(Weight::from_ref_time(11_483_273).saturating_mul(r.into())) .saturating_add(T::DbWeight::get().reads(6_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) .saturating_add(Weight::from_proof_size(1200).saturating_mul(r.into())) @@ -1645,7 +1647,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(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:1 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) /// Storage: Timestamp Now (r:1 w:0) @@ -1655,21 +1657,21 @@ impl WeightInfo for SubstrateWeight { /// The range of component `r` is `[0, 20]`. fn seal_account_reentrance_count(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `2056 + r * (3153 ±0)` - // Estimated: `21730 + r * (15870 ±2)` - // Minimum execution time: 376_762 nanoseconds. - Weight::from_ref_time(396_934_359) - .saturating_add(Weight::from_proof_size(21730)) - // Standard Error: 68_263 - .saturating_add(Weight::from_ref_time(18_367_270).saturating_mul(r.into())) + // Measured: `2102 + r * (3154 ±0)` + // Estimated: `21980 + r * (15875 ±2)` + // Minimum execution time: 375_552 nanoseconds. + Weight::from_ref_time(400_624_032) + .saturating_add(Weight::from_proof_size(21980)) + // Standard Error: 82_523 + .saturating_add(Weight::from_ref_time(18_057_327).saturating_mul(r.into())) .saturating_add(T::DbWeight::get().reads(6_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) - .saturating_add(Weight::from_proof_size(15870).saturating_mul(r.into())) + .saturating_add(Weight::from_proof_size(15875).saturating_mul(r.into())) } /// 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(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:1 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) /// Storage: Timestamp Now (r:1 w:0) @@ -1681,13 +1683,13 @@ impl WeightInfo for SubstrateWeight { /// The range of component `r` is `[0, 20]`. fn seal_instantiation_nonce(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `840 + r * (240 ±0)` - // Estimated: `18405 + r * (1440 ±0)` - // Minimum execution time: 374_257 nanoseconds. - Weight::from_ref_time(380_453_380) - .saturating_add(Weight::from_proof_size(18405)) - // Standard Error: 42_718 - .saturating_add(Weight::from_ref_time(9_355_253).saturating_mul(r.into())) + // Measured: `872 + r * (240 ±0)` + // Estimated: `18598 + r * (1440 ±0)` + // Minimum execution time: 373_899 nanoseconds. + Weight::from_ref_time(379_733_943) + .saturating_add(Weight::from_proof_size(18598)) + // Standard Error: 32_022 + .saturating_add(Weight::from_ref_time(9_381_180).saturating_mul(r.into())) .saturating_add(T::DbWeight::get().reads(7_u64)) .saturating_add(T::DbWeight::get().writes(4_u64)) .saturating_add(Weight::from_proof_size(1440).saturating_mul(r.into())) @@ -1697,572 +1699,572 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 788 nanoseconds. - Weight::from_ref_time(1_209_829) + // Minimum execution time: 834 nanoseconds. + Weight::from_ref_time(1_009_646) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 3_436 - .saturating_add(Weight::from_ref_time(409_858).saturating_mul(r.into())) + // Standard Error: 388 + .saturating_add(Weight::from_ref_time(411_979).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64load(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 955 nanoseconds. - Weight::from_ref_time(1_526_327) + // Minimum execution time: 882 nanoseconds. + Weight::from_ref_time(1_416_377) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 2_399 - .saturating_add(Weight::from_ref_time(1_084_504).saturating_mul(r.into())) + // Standard Error: 1_133 + .saturating_add(Weight::from_ref_time(1_075_838).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64store(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 967 nanoseconds. - Weight::from_ref_time(1_576_183) + // Minimum execution time: 878 nanoseconds. + Weight::from_ref_time(1_343_056) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 5_719 - .saturating_add(Weight::from_ref_time(1_006_742).saturating_mul(r.into())) + // Standard Error: 426 + .saturating_add(Weight::from_ref_time(1_001_214).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_select(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 849 nanoseconds. - Weight::from_ref_time(1_106_539) + // Minimum execution time: 796 nanoseconds. + Weight::from_ref_time(1_079_086) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 445 - .saturating_add(Weight::from_ref_time(1_149_752).saturating_mul(r.into())) + // Standard Error: 409 + .saturating_add(Weight::from_ref_time(1_149_188).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_if(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 829 nanoseconds. - Weight::from_ref_time(1_171_360) + // Minimum execution time: 800 nanoseconds. + Weight::from_ref_time(1_044_184) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 552 - .saturating_add(Weight::from_ref_time(1_309_914).saturating_mul(r.into())) + // Standard Error: 707 + .saturating_add(Weight::from_ref_time(1_315_686).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_br(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 835 nanoseconds. - Weight::from_ref_time(1_125_578) + // Minimum execution time: 807 nanoseconds. + Weight::from_ref_time(1_049_633) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 374 - .saturating_add(Weight::from_ref_time(641_683).saturating_mul(r.into())) + // Standard Error: 361 + .saturating_add(Weight::from_ref_time(640_530).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_br_if(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 816 nanoseconds. - Weight::from_ref_time(1_032_093) + // Minimum execution time: 774 nanoseconds. + Weight::from_ref_time(1_124_053) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 811 - .saturating_add(Weight::from_ref_time(956_228).saturating_mul(r.into())) + // Standard Error: 784 + .saturating_add(Weight::from_ref_time(949_398).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_br_table(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 801 nanoseconds. - Weight::from_ref_time(816_764) + // Minimum execution time: 810 nanoseconds. + Weight::from_ref_time(676_581) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 2_669 - .saturating_add(Weight::from_ref_time(1_166_556).saturating_mul(r.into())) + // Standard Error: 2_356 + .saturating_add(Weight::from_ref_time(1_163_465).saturating_mul(r.into())) } /// The range of component `e` is `[1, 256]`. fn instr_br_table_per_entry(e: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_639 nanoseconds. - Weight::from_ref_time(2_905_554) + // Minimum execution time: 2_580 nanoseconds. + Weight::from_ref_time(2_835_656) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 62 - .saturating_add(Weight::from_ref_time(4_438).saturating_mul(e.into())) + // Standard Error: 71 + .saturating_add(Weight::from_ref_time(4_686).saturating_mul(e.into())) } /// The range of component `r` is `[0, 50]`. fn instr_call(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 831 nanoseconds. - Weight::from_ref_time(1_729_584) + // Minimum execution time: 826 nanoseconds. + Weight::from_ref_time(1_625_698) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 33_753 - .saturating_add(Weight::from_ref_time(2_380_315).saturating_mul(r.into())) + // Standard Error: 1_740 + .saturating_add(Weight::from_ref_time(2_332_187).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_call_indirect(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 964 nanoseconds. - Weight::from_ref_time(2_445_291) + // Minimum execution time: 901 nanoseconds. + Weight::from_ref_time(2_338_620) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 3_285 - .saturating_add(Weight::from_ref_time(2_938_681).saturating_mul(r.into())) + // Standard Error: 1_642 + .saturating_add(Weight::from_ref_time(2_924_090).saturating_mul(r.into())) } /// The range of component `p` is `[0, 128]`. fn instr_call_indirect_per_param(p: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 4_809 nanoseconds. - Weight::from_ref_time(6_763_286) + // Minimum execution time: 4_670 nanoseconds. + Weight::from_ref_time(5_556_246) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 3_994 - .saturating_add(Weight::from_ref_time(217_632).saturating_mul(p.into())) + // Standard Error: 1_491 + .saturating_add(Weight::from_ref_time(228_965).saturating_mul(p.into())) } /// The range of component `l` is `[0, 1024]`. fn instr_call_per_local(l: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 3_138 nanoseconds. - Weight::from_ref_time(3_894_816) + // Minimum execution time: 3_099 nanoseconds. + Weight::from_ref_time(3_896_177) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 131 - .saturating_add(Weight::from_ref_time(91_699).saturating_mul(l.into())) + // Standard Error: 99 + .saturating_add(Weight::from_ref_time(91_304).saturating_mul(l.into())) } /// The range of component `r` is `[0, 50]`. fn instr_local_get(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_959 nanoseconds. - Weight::from_ref_time(3_271_550) + // Minimum execution time: 3_042 nanoseconds. + Weight::from_ref_time(3_334_621) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 223 - .saturating_add(Weight::from_ref_time(460_056).saturating_mul(r.into())) + // Standard Error: 793 + .saturating_add(Weight::from_ref_time(459_346).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_local_set(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_970 nanoseconds. - Weight::from_ref_time(3_216_157) + // Minimum execution time: 2_968 nanoseconds. + Weight::from_ref_time(3_235_286) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 413 - .saturating_add(Weight::from_ref_time(485_842).saturating_mul(r.into())) + // Standard Error: 427 + .saturating_add(Weight::from_ref_time(485_454).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_local_tee(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_980 nanoseconds. - Weight::from_ref_time(3_323_878) + // Minimum execution time: 3_012 nanoseconds. + Weight::from_ref_time(3_303_555) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 2_652 - .saturating_add(Weight::from_ref_time(660_257).saturating_mul(r.into())) + // Standard Error: 371 + .saturating_add(Weight::from_ref_time(657_811).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_global_get(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 917 nanoseconds. - Weight::from_ref_time(1_445_816) + // Minimum execution time: 865 nanoseconds. + Weight::from_ref_time(1_249_987) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 5_642 - .saturating_add(Weight::from_ref_time(894_521).saturating_mul(r.into())) + // Standard Error: 417 + .saturating_add(Weight::from_ref_time(896_704).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_global_set(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 965 nanoseconds. - Weight::from_ref_time(1_373_722) + // Minimum execution time: 866 nanoseconds. + Weight::from_ref_time(1_216_218) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 1_157 - .saturating_add(Weight::from_ref_time(917_643).saturating_mul(r.into())) + // Standard Error: 503 + .saturating_add(Weight::from_ref_time(919_719).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_memory_current(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 982 nanoseconds. - Weight::from_ref_time(1_240_280) + // Minimum execution time: 921 nanoseconds. + Weight::from_ref_time(1_228_408) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 308 - .saturating_add(Weight::from_ref_time(817_972).saturating_mul(r.into())) + // Standard Error: 309 + .saturating_add(Weight::from_ref_time(813_007).saturating_mul(r.into())) } /// The range of component `r` is `[0, 1]`. fn instr_memory_grow(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 858 nanoseconds. - Weight::from_ref_time(962_183) + // Minimum execution time: 820 nanoseconds. + Weight::from_ref_time(914_830) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 6_701 - .saturating_add(Weight::from_ref_time(239_704_216).saturating_mul(r.into())) + // Standard Error: 6_018 + .saturating_add(Weight::from_ref_time(237_062_769).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64clz(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 807 nanoseconds. - Weight::from_ref_time(1_132_872) + // Minimum execution time: 812 nanoseconds. + Weight::from_ref_time(1_554_406) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 303 - .saturating_add(Weight::from_ref_time(633_832).saturating_mul(r.into())) + // Standard Error: 9_979 + .saturating_add(Weight::from_ref_time(625_434).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64ctz(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 823 nanoseconds. - Weight::from_ref_time(1_267_518) + // Minimum execution time: 798 nanoseconds. + Weight::from_ref_time(1_095_113) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 483 - .saturating_add(Weight::from_ref_time(632_620).saturating_mul(r.into())) + // Standard Error: 243 + .saturating_add(Weight::from_ref_time(634_204).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64popcnt(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 857 nanoseconds. - Weight::from_ref_time(1_105_214) + // Minimum execution time: 792 nanoseconds. + Weight::from_ref_time(1_109_845) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 285 - .saturating_add(Weight::from_ref_time(635_039).saturating_mul(r.into())) + // Standard Error: 14_944 + .saturating_add(Weight::from_ref_time(658_834).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64eqz(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 821 nanoseconds. - Weight::from_ref_time(750_223) + // Minimum execution time: 815 nanoseconds. + Weight::from_ref_time(1_068_916) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 15_923 - .saturating_add(Weight::from_ref_time(686_322).saturating_mul(r.into())) + // Standard Error: 327 + .saturating_add(Weight::from_ref_time(652_897).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64extendsi32(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 797 nanoseconds. - Weight::from_ref_time(1_145_072) + // Minimum execution time: 798 nanoseconds. + Weight::from_ref_time(1_069_745) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 311 - .saturating_add(Weight::from_ref_time(618_147).saturating_mul(r.into())) + // Standard Error: 306 + .saturating_add(Weight::from_ref_time(618_481).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64extendui32(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 803 nanoseconds. - Weight::from_ref_time(1_139_498) + // Minimum execution time: 799 nanoseconds. + Weight::from_ref_time(1_398_001) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 284 - .saturating_add(Weight::from_ref_time(617_393).saturating_mul(r.into())) + // Standard Error: 6_234 + .saturating_add(Weight::from_ref_time(611_399).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32wrapi64(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 814 nanoseconds. - Weight::from_ref_time(1_099_405) + // Minimum execution time: 811 nanoseconds. + Weight::from_ref_time(1_098_083) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 663 - .saturating_add(Weight::from_ref_time(618_565).saturating_mul(r.into())) + // Standard Error: 297 + .saturating_add(Weight::from_ref_time(617_692).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64eq(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 819 nanoseconds. - Weight::from_ref_time(1_199_220) + // Minimum execution time: 815 nanoseconds. + Weight::from_ref_time(1_046_922) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 485 - .saturating_add(Weight::from_ref_time(906_878).saturating_mul(r.into())) + // Standard Error: 335 + .saturating_add(Weight::from_ref_time(909_196).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64ne(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 822 nanoseconds. - Weight::from_ref_time(274_212) + // Minimum execution time: 805 nanoseconds. + Weight::from_ref_time(1_093_667) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 29_294 - .saturating_add(Weight::from_ref_time(971_608).saturating_mul(r.into())) + // Standard Error: 233 + .saturating_add(Weight::from_ref_time(907_378).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64lts(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 796 nanoseconds. - Weight::from_ref_time(1_396_586) + // Minimum execution time: 805 nanoseconds. + Weight::from_ref_time(1_290_591) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 7_205 - .saturating_add(Weight::from_ref_time(903_202).saturating_mul(r.into())) + // Standard Error: 3_201 + .saturating_add(Weight::from_ref_time(902_006).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64ltu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 833 nanoseconds. - Weight::from_ref_time(1_115_115) + // Minimum execution time: 783 nanoseconds. + Weight::from_ref_time(1_159_977) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 310 - .saturating_add(Weight::from_ref_time(908_195).saturating_mul(r.into())) + // Standard Error: 2_310 + .saturating_add(Weight::from_ref_time(906_489).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64gts(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 854 nanoseconds. - Weight::from_ref_time(1_170_419) + // Minimum execution time: 790 nanoseconds. + Weight::from_ref_time(1_109_719) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 298 - .saturating_add(Weight::from_ref_time(907_171).saturating_mul(r.into())) + // Standard Error: 261 + .saturating_add(Weight::from_ref_time(906_614).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64gtu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 822 nanoseconds. - Weight::from_ref_time(1_186_349) + // Minimum execution time: 776 nanoseconds. + Weight::from_ref_time(1_076_567) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 302 - .saturating_add(Weight::from_ref_time(917_857).saturating_mul(r.into())) + // Standard Error: 348 + .saturating_add(Weight::from_ref_time(919_374).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64les(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 807 nanoseconds. - Weight::from_ref_time(1_127_093) + // Minimum execution time: 780 nanoseconds. + Weight::from_ref_time(1_069_663) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 1_891 - .saturating_add(Weight::from_ref_time(910_738).saturating_mul(r.into())) + // Standard Error: 265 + .saturating_add(Weight::from_ref_time(908_037).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64leu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 819 nanoseconds. - Weight::from_ref_time(1_143_022) + // Minimum execution time: 832 nanoseconds. + Weight::from_ref_time(930_920) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 309 - .saturating_add(Weight::from_ref_time(919_047).saturating_mul(r.into())) + // Standard Error: 2_170 + .saturating_add(Weight::from_ref_time(929_811).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64ges(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 788 nanoseconds. - Weight::from_ref_time(1_116_914) + // Minimum execution time: 787 nanoseconds. + Weight::from_ref_time(1_087_325) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 643 - .saturating_add(Weight::from_ref_time(911_159).saturating_mul(r.into())) + // Standard Error: 315 + .saturating_add(Weight::from_ref_time(908_321).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64geu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 791 nanoseconds. - Weight::from_ref_time(1_123_747) + // Minimum execution time: 798 nanoseconds. + Weight::from_ref_time(1_029_132) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 583 - .saturating_add(Weight::from_ref_time(910_242).saturating_mul(r.into())) + // Standard Error: 2_095 + .saturating_add(Weight::from_ref_time(913_553).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64add(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 787 nanoseconds. - Weight::from_ref_time(1_109_471) + // Minimum execution time: 791 nanoseconds. + Weight::from_ref_time(1_086_314) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 305 - .saturating_add(Weight::from_ref_time(897_608).saturating_mul(r.into())) + // Standard Error: 197 + .saturating_add(Weight::from_ref_time(896_392).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64sub(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 821 nanoseconds. - Weight::from_ref_time(1_098_631) + // Minimum execution time: 793 nanoseconds. + Weight::from_ref_time(1_078_172) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 523 - .saturating_add(Weight::from_ref_time(887_814).saturating_mul(r.into())) + // Standard Error: 404 + .saturating_add(Weight::from_ref_time(886_329).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64mul(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 794 nanoseconds. - Weight::from_ref_time(1_166_332) + // Minimum execution time: 799 nanoseconds. + Weight::from_ref_time(1_095_010) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 384 - .saturating_add(Weight::from_ref_time(885_584).saturating_mul(r.into())) + // Standard Error: 431 + .saturating_add(Weight::from_ref_time(886_513).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64divs(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 822 nanoseconds. - Weight::from_ref_time(1_155_826) + // Minimum execution time: 810 nanoseconds. + Weight::from_ref_time(1_114_325) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 521 - .saturating_add(Weight::from_ref_time(1_520_958).saturating_mul(r.into())) + // Standard Error: 452 + .saturating_add(Weight::from_ref_time(1_521_849).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64divu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 881 nanoseconds. - Weight::from_ref_time(1_158_125) + // Minimum execution time: 784 nanoseconds. + Weight::from_ref_time(1_123_153) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 624 - .saturating_add(Weight::from_ref_time(1_458_378).saturating_mul(r.into())) + // Standard Error: 475 + .saturating_add(Weight::from_ref_time(1_457_746).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64rems(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 827 nanoseconds. - Weight::from_ref_time(1_209_535) + // Minimum execution time: 809 nanoseconds. + Weight::from_ref_time(1_145_906) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 399 - .saturating_add(Weight::from_ref_time(1_547_640).saturating_mul(r.into())) + // Standard Error: 718 + .saturating_add(Weight::from_ref_time(1_549_964).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64remu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 801 nanoseconds. - Weight::from_ref_time(1_313_872) + // Minimum execution time: 803 nanoseconds. + Weight::from_ref_time(1_110_328) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 2_175 - .saturating_add(Weight::from_ref_time(1_449_416).saturating_mul(r.into())) + // Standard Error: 627 + .saturating_add(Weight::from_ref_time(1_453_013).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64and(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 827 nanoseconds. - Weight::from_ref_time(1_093_874) + // Minimum execution time: 786 nanoseconds. + Weight::from_ref_time(1_108_792) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 708 - .saturating_add(Weight::from_ref_time(901_450).saturating_mul(r.into())) + // Standard Error: 286 + .saturating_add(Weight::from_ref_time(897_035).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64or(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 824 nanoseconds. - Weight::from_ref_time(1_164_076) + // Minimum execution time: 787 nanoseconds. + Weight::from_ref_time(830_000) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 623 - .saturating_add(Weight::from_ref_time(897_579).saturating_mul(r.into())) + // Standard Error: 15_995 + .saturating_add(Weight::from_ref_time(963_344).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64xor(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 789 nanoseconds. - Weight::from_ref_time(1_113_915) + // Minimum execution time: 773 nanoseconds. + Weight::from_ref_time(1_082_459) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 390 - .saturating_add(Weight::from_ref_time(897_354).saturating_mul(r.into())) + // Standard Error: 330 + .saturating_add(Weight::from_ref_time(897_077).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64shl(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 811 nanoseconds. - Weight::from_ref_time(1_117_366) + // Minimum execution time: 810 nanoseconds. + Weight::from_ref_time(1_325_815) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 437 - .saturating_add(Weight::from_ref_time(903_759).saturating_mul(r.into())) + // Standard Error: 3_352 + .saturating_add(Weight::from_ref_time(899_555).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64shrs(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 846 nanoseconds. - Weight::from_ref_time(1_103_954) + // Minimum execution time: 808 nanoseconds. + Weight::from_ref_time(1_085_903) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 414 - .saturating_add(Weight::from_ref_time(903_429).saturating_mul(r.into())) + // Standard Error: 430 + .saturating_add(Weight::from_ref_time(903_249).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64shru(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 803 nanoseconds. - Weight::from_ref_time(1_124_328) + // Minimum execution time: 792 nanoseconds. + Weight::from_ref_time(1_091_261) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 410 - .saturating_add(Weight::from_ref_time(903_216).saturating_mul(r.into())) + // Standard Error: 312 + .saturating_add(Weight::from_ref_time(902_245).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64rotl(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 810 nanoseconds. - Weight::from_ref_time(1_131_433) + // Minimum execution time: 807 nanoseconds. + Weight::from_ref_time(1_121_052) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 402 - .saturating_add(Weight::from_ref_time(903_381).saturating_mul(r.into())) + // Standard Error: 506 + .saturating_add(Weight::from_ref_time(902_772).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64rotr(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 807 nanoseconds. - Weight::from_ref_time(1_144_933) + // Minimum execution time: 823 nanoseconds. + Weight::from_ref_time(1_317_597) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 373 - .saturating_add(Weight::from_ref_time(902_918).saturating_mul(r.into())) + // Standard Error: 6_219 + .saturating_add(Weight::from_ref_time(896_692).saturating_mul(r.into())) } } @@ -2274,8 +2276,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `109` // Estimated: `604` - // Minimum execution time: 2_507 nanoseconds. - Weight::from_ref_time(2_650_000) + // Minimum execution time: 2_591 nanoseconds. + Weight::from_ref_time(2_817_000) .saturating_add(Weight::from_proof_size(604)) .saturating_add(RocksDbWeight::get().reads(1_u64)) } @@ -2286,11 +2288,11 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `481 + k * (69 ±0)` // Estimated: `471 + k * (70 ±0)` - // Minimum execution time: 9_953 nanoseconds. - Weight::from_ref_time(6_467_352) + // Minimum execution time: 10_190 nanoseconds. + Weight::from_ref_time(6_642_117) .saturating_add(Weight::from_proof_size(471)) - // Standard Error: 1_074 - .saturating_add(Weight::from_ref_time(943_946).saturating_mul(k.into())) + // Standard Error: 992 + .saturating_add(Weight::from_ref_time(919_828).saturating_mul(k.into())) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) .saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(k.into()))) @@ -2303,11 +2305,11 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `281 + q * (33 ±0)` // Estimated: `763 + q * (33 ±0)` - // Minimum execution time: 2_545 nanoseconds. - Weight::from_ref_time(10_080_106) + // Minimum execution time: 2_598 nanoseconds. + Weight::from_ref_time(10_288_252) .saturating_add(Weight::from_proof_size(763)) - // Standard Error: 2_929 - .saturating_add(Weight::from_ref_time(1_078_265).saturating_mul(q.into())) + // Standard Error: 2_886 + .saturating_add(Weight::from_ref_time(1_092_420).saturating_mul(q.into())) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) .saturating_add(Weight::from_proof_size(33).saturating_mul(q.into())) @@ -2321,17 +2323,17 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `270 + c * (1 ±0)` // Estimated: `3025 + c * (2 ±0)` - // Minimum execution time: 34_613 nanoseconds. - Weight::from_ref_time(27_355_774) + // Minimum execution time: 34_338 nanoseconds. + Weight::from_ref_time(32_159_677) .saturating_add(Weight::from_proof_size(3025)) - // Standard Error: 81 - .saturating_add(Weight::from_ref_time(51_954).saturating_mul(c.into())) + // Standard Error: 53 + .saturating_add(Weight::from_ref_time(51_034).saturating_mul(c.into())) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) .saturating_add(Weight::from_proof_size(2).saturating_mul(c.into())) } /// Storage: Contracts ContractInfoOf (r:1 w:1) - /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:1 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) /// Storage: Timestamp Now (r:1 w:0) @@ -2343,13 +2345,13 @@ 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: `771` - // Estimated: `16780 + c * (5 ±0)` - // Minimum execution time: 386_104 nanoseconds. - Weight::from_ref_time(396_718_823) - .saturating_add(Weight::from_proof_size(16780)) + // Measured: `803` + // Estimated: `16930 + c * (5 ±0)` + // Minimum execution time: 385_587 nanoseconds. + Weight::from_ref_time(395_545_811) + .saturating_add(Weight::from_proof_size(16930)) // Standard Error: 27 - .saturating_add(Weight::from_ref_time(31_370).saturating_mul(c.into())) + .saturating_add(Weight::from_ref_time(31_342).saturating_mul(c.into())) .saturating_add(RocksDbWeight::get().reads(6_u64)) .saturating_add(RocksDbWeight::get().writes(4_u64)) .saturating_add(Weight::from_proof_size(5).saturating_mul(c.into())) @@ -2359,10 +2361,10 @@ 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(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, 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:1 w:1) + /// Storage: System Account (r:2 w:2) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: System EventTopics (r:3 w:3) /// Proof Skipped: System EventTopics (max_values: None, max_size: None, mode: Measured) @@ -2375,29 +2377,29 @@ 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: `257` - // Estimated: `17752` - // Minimum execution time: 3_786_500 nanoseconds. - Weight::from_ref_time(672_511_565) - .saturating_add(Weight::from_proof_size(17752)) - // Standard Error: 281 - .saturating_add(Weight::from_ref_time(94_538).saturating_mul(c.into())) + // Measured: `270` + // Estimated: `20267` + // Minimum execution time: 3_799_742 nanoseconds. + Weight::from_ref_time(670_115_588) + .saturating_add(Weight::from_proof_size(20267)) + // Standard Error: 287 + .saturating_add(Weight::from_ref_time(93_885).saturating_mul(c.into())) // Standard Error: 16 - .saturating_add(Weight::from_ref_time(1_364).saturating_mul(i.into())) + .saturating_add(Weight::from_ref_time(1_367).saturating_mul(i.into())) // Standard Error: 16 - .saturating_add(Weight::from_ref_time(1_768).saturating_mul(s.into())) - .saturating_add(RocksDbWeight::get().reads(8_u64)) - .saturating_add(RocksDbWeight::get().writes(9_u64)) + .saturating_add(Weight::from_ref_time(1_781).saturating_mul(s.into())) + .saturating_add(RocksDbWeight::get().reads(9_u64)) + .saturating_add(RocksDbWeight::get().writes(10_u64)) } /// Storage: Contracts CodeStorage (r:1 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) /// Storage: Contracts Nonce (r:1 w:1) /// 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(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, 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:1 w:1) + /// Storage: System Account (r:2 w:2) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts OwnerInfoOf (r:1 w:1) /// Proof: Contracts OwnerInfoOf (max_values: None, max_size: Some(88), added: 2563, mode: Measured) @@ -2407,20 +2409,20 @@ impl WeightInfo for () { /// The range of component `s` is `[0, 1048576]`. fn instantiate(i: u32, s: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `533` - // Estimated: `19543` - // Minimum execution time: 1_927_365 nanoseconds. - Weight::from_ref_time(189_843_928) - .saturating_add(Weight::from_proof_size(19543)) + // Measured: `546` + // Estimated: `22039` + // Minimum execution time: 1_949_008 nanoseconds. + Weight::from_ref_time(214_033_418) + .saturating_add(Weight::from_proof_size(22039)) // Standard Error: 8 - .saturating_add(Weight::from_ref_time(1_677).saturating_mul(i.into())) + .saturating_add(Weight::from_ref_time(1_666).saturating_mul(i.into())) // Standard Error: 8 - .saturating_add(Weight::from_ref_time(1_803).saturating_mul(s.into())) - .saturating_add(RocksDbWeight::get().reads(8_u64)) - .saturating_add(RocksDbWeight::get().writes(6_u64)) + .saturating_add(Weight::from_ref_time(1_801).saturating_mul(s.into())) + .saturating_add(RocksDbWeight::get().reads(9_u64)) + .saturating_add(RocksDbWeight::get().writes(7_u64)) } /// Storage: Contracts ContractInfoOf (r:1 w:1) - /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:1 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) /// Storage: Timestamp Now (r:1 w:0) @@ -2431,11 +2433,11 @@ impl WeightInfo for () { /// Proof Skipped: System EventTopics (max_values: None, max_size: None, mode: Measured) fn call() -> Weight { // Proof Size summary in bytes: - // Measured: `823` - // Estimated: `16985` - // Minimum execution time: 146_354 nanoseconds. - Weight::from_ref_time(147_693_000) - .saturating_add(Weight::from_proof_size(16985)) + // Measured: `855` + // Estimated: `17145` + // Minimum execution time: 146_654 nanoseconds. + Weight::from_ref_time(147_528_000) + .saturating_add(Weight::from_proof_size(17145)) .saturating_add(RocksDbWeight::get().reads(6_u64)) .saturating_add(RocksDbWeight::get().writes(4_u64)) } @@ -2452,11 +2454,11 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `109` // Estimated: `5386` - // Minimum execution time: 388_107 nanoseconds. - Weight::from_ref_time(383_172_702) + // Minimum execution time: 387_889 nanoseconds. + Weight::from_ref_time(391_379_335) .saturating_add(Weight::from_proof_size(5386)) - // Standard Error: 73 - .saturating_add(Weight::from_ref_time(95_037).saturating_mul(c.into())) + // Standard Error: 89 + .saturating_add(Weight::from_ref_time(94_810).saturating_mul(c.into())) .saturating_add(RocksDbWeight::get().reads(2_u64)) .saturating_add(RocksDbWeight::get().writes(4_u64)) } @@ -2472,32 +2474,32 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `287` // Estimated: `6098` - // Minimum execution time: 26_278 nanoseconds. - Weight::from_ref_time(26_682_000) + // Minimum execution time: 26_014 nanoseconds. + Weight::from_ref_time(26_510_000) .saturating_add(Weight::from_proof_size(6098)) .saturating_add(RocksDbWeight::get().reads(2_u64)) .saturating_add(RocksDbWeight::get().writes(4_u64)) } /// Storage: Contracts ContractInfoOf (r:1 w:1) - /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts OwnerInfoOf (r:2 w:2) /// Proof: Contracts OwnerInfoOf (max_values: None, max_size: Some(88), added: 2563, mode: Measured) /// Storage: System EventTopics (r:3 w:3) /// Proof Skipped: System EventTopics (max_values: None, max_size: None, mode: Measured) fn set_code() -> Weight { // Proof Size summary in bytes: - // Measured: `634` - // Estimated: `16752` - // Minimum execution time: 30_223 nanoseconds. - Weight::from_ref_time(30_737_000) - .saturating_add(Weight::from_proof_size(16752)) + // Measured: `666` + // Estimated: `16848` + // Minimum execution time: 30_177 nanoseconds. + Weight::from_ref_time(30_639_000) + .saturating_add(Weight::from_proof_size(16848)) .saturating_add(RocksDbWeight::get().reads(6_u64)) .saturating_add(RocksDbWeight::get().writes(6_u64)) } /// 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(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:1 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) /// Storage: Timestamp Now (r:1 w:0) @@ -2507,13 +2509,13 @@ impl WeightInfo for () { /// The range of component `r` is `[0, 20]`. fn seal_caller(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `845 + r * (480 ±0)` - // Estimated: `17120 + r * (2400 ±0)` - // Minimum execution time: 374_780 nanoseconds. - Weight::from_ref_time(379_468_453) - .saturating_add(Weight::from_proof_size(17120)) - // Standard Error: 45_809 - .saturating_add(Weight::from_ref_time(17_553_577).saturating_mul(r.into())) + // Measured: `877 + r * (480 ±0)` + // Estimated: `17295 + r * (2400 ±0)` + // Minimum execution time: 373_786 nanoseconds. + Weight::from_ref_time(377_332_691) + .saturating_add(Weight::from_proof_size(17295)) + // Standard Error: 51_211 + .saturating_add(Weight::from_ref_time(17_715_615).saturating_mul(r.into())) .saturating_add(RocksDbWeight::get().reads(6_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) .saturating_add(Weight::from_proof_size(2400).saturating_mul(r.into())) @@ -2521,7 +2523,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(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:1 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) /// Storage: Timestamp Now (r:1 w:0) @@ -2531,22 +2533,22 @@ impl WeightInfo for () { /// The range of component `r` is `[0, 20]`. fn seal_is_contract(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `882 + r * (19218 ±0)` - // Estimated: `17110 + r * (294100 ±0)` - // Minimum execution time: 374_399 nanoseconds. - Weight::from_ref_time(228_569_211) - .saturating_add(Weight::from_proof_size(17110)) - // Standard Error: 492_562 - .saturating_add(Weight::from_ref_time(251_682_897).saturating_mul(r.into())) + // Measured: `917 + r * (21778 ±0)` + // Estimated: `17295 + r * (306895 ±0)` + // Minimum execution time: 374_009 nanoseconds. + Weight::from_ref_time(238_991_986) + .saturating_add(Weight::from_proof_size(17295)) + // Standard Error: 464_711 + .saturating_add(Weight::from_ref_time(249_099_538).saturating_mul(r.into())) .saturating_add(RocksDbWeight::get().reads(6_u64)) .saturating_add(RocksDbWeight::get().reads((80_u64).saturating_mul(r.into()))) .saturating_add(RocksDbWeight::get().writes(3_u64)) - .saturating_add(Weight::from_proof_size(294100).saturating_mul(r.into())) + .saturating_add(Weight::from_proof_size(306895).saturating_mul(r.into())) } /// 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(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:1 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) /// Storage: Timestamp Now (r:1 w:0) @@ -2556,22 +2558,22 @@ impl WeightInfo for () { /// The range of component `r` is `[0, 20]`. fn seal_code_hash(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `889 + r * (19539 ±0)` - // Estimated: `17170 + r * (295700 ±0)` - // Minimum execution time: 375_980 nanoseconds. - Weight::from_ref_time(232_604_331) - .saturating_add(Weight::from_proof_size(17170)) - // Standard Error: 491_912 - .saturating_add(Weight::from_ref_time(299_479_335).saturating_mul(r.into())) + // Measured: `921 + r * (22099 ±0)` + // Estimated: `17340 + r * (308500 ±0)` + // Minimum execution time: 375_058 nanoseconds. + Weight::from_ref_time(238_765_068) + .saturating_add(Weight::from_proof_size(17340)) + // Standard Error: 662_617 + .saturating_add(Weight::from_ref_time(302_175_089).saturating_mul(r.into())) .saturating_add(RocksDbWeight::get().reads(6_u64)) .saturating_add(RocksDbWeight::get().reads((80_u64).saturating_mul(r.into()))) .saturating_add(RocksDbWeight::get().writes(3_u64)) - .saturating_add(Weight::from_proof_size(295700).saturating_mul(r.into())) + .saturating_add(Weight::from_proof_size(308500).saturating_mul(r.into())) } /// 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(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:1 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) /// Storage: Timestamp Now (r:1 w:0) @@ -2581,13 +2583,13 @@ impl WeightInfo for () { /// The range of component `r` is `[0, 20]`. fn seal_own_code_hash(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `852 + r * (480 ±0)` - // Estimated: `17155 + r * (2400 ±0)` - // Minimum execution time: 375_075 nanoseconds. - Weight::from_ref_time(381_217_372) - .saturating_add(Weight::from_proof_size(17155)) - // Standard Error: 63_950 - .saturating_add(Weight::from_ref_time(21_872_316).saturating_mul(r.into())) + // Measured: `884 + r * (480 ±0)` + // Estimated: `17330 + r * (2400 ±0)` + // Minimum execution time: 374_747 nanoseconds. + Weight::from_ref_time(376_482_380) + .saturating_add(Weight::from_proof_size(17330)) + // Standard Error: 61_919 + .saturating_add(Weight::from_ref_time(22_376_795).saturating_mul(r.into())) .saturating_add(RocksDbWeight::get().reads(6_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) .saturating_add(Weight::from_proof_size(2400).saturating_mul(r.into())) @@ -2595,7 +2597,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(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:1 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) /// Storage: Timestamp Now (r:1 w:0) @@ -2605,13 +2607,13 @@ impl WeightInfo for () { /// The range of component `r` is `[0, 20]`. fn seal_caller_is_origin(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `842 + r * (240 ±0)` - // Estimated: `17080 + r * (1200 ±0)` - // Minimum execution time: 373_260 nanoseconds. - Weight::from_ref_time(377_987_666) - .saturating_add(Weight::from_proof_size(17080)) - // Standard Error: 35_603 - .saturating_add(Weight::from_ref_time(11_274_165).saturating_mul(r.into())) + // Measured: `874 + r * (240 ±0)` + // Estimated: `17265 + r * (1200 ±0)` + // Minimum execution time: 372_287 nanoseconds. + Weight::from_ref_time(376_250_858) + .saturating_add(Weight::from_proof_size(17265)) + // Standard Error: 40_119 + .saturating_add(Weight::from_ref_time(11_359_647).saturating_mul(r.into())) .saturating_add(RocksDbWeight::get().reads(6_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) .saturating_add(Weight::from_proof_size(1200).saturating_mul(r.into())) @@ -2619,7 +2621,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(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:1 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) /// Storage: Timestamp Now (r:1 w:0) @@ -2629,13 +2631,13 @@ impl WeightInfo for () { /// The range of component `r` is `[0, 20]`. fn seal_address(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `846 + r * (480 ±0)` - // Estimated: `17100 + r * (2400 ±0)` - // Minimum execution time: 374_605 nanoseconds. - Weight::from_ref_time(379_395_443) - .saturating_add(Weight::from_proof_size(17100)) - // Standard Error: 49_646 - .saturating_add(Weight::from_ref_time(17_487_585).saturating_mul(r.into())) + // Measured: `878 + r * (480 ±0)` + // Estimated: `17260 + r * (2400 ±0)` + // Minimum execution time: 374_445 nanoseconds. + Weight::from_ref_time(377_243_521) + .saturating_add(Weight::from_proof_size(17260)) + // Standard Error: 53_032 + .saturating_add(Weight::from_ref_time(17_684_246).saturating_mul(r.into())) .saturating_add(RocksDbWeight::get().reads(6_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) .saturating_add(Weight::from_proof_size(2400).saturating_mul(r.into())) @@ -2643,7 +2645,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(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:1 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) /// Storage: Timestamp Now (r:1 w:0) @@ -2653,21 +2655,21 @@ impl WeightInfo for () { /// The range of component `r` is `[0, 20]`. fn seal_gas_left(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `847 + r * (480 ±0)` - // Estimated: `17105 + r * (2400 ±0)` - // Minimum execution time: 374_620 nanoseconds. - Weight::from_ref_time(379_623_792) - .saturating_add(Weight::from_proof_size(17105)) - // Standard Error: 49_990 - .saturating_add(Weight::from_ref_time(17_226_706).saturating_mul(r.into())) + // Measured: `879 + r * (480 ±0)` + // Estimated: `17250 + r * (2405 ±0)` + // Minimum execution time: 374_029 nanoseconds. + Weight::from_ref_time(380_415_186) + .saturating_add(Weight::from_proof_size(17250)) + // Standard Error: 60_562 + .saturating_add(Weight::from_ref_time(17_152_599).saturating_mul(r.into())) .saturating_add(RocksDbWeight::get().reads(6_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) - .saturating_add(Weight::from_proof_size(2400).saturating_mul(r.into())) + .saturating_add(Weight::from_proof_size(2405).saturating_mul(r.into())) } /// 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(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:1 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) /// Storage: Timestamp Now (r:1 w:0) @@ -2677,13 +2679,13 @@ impl WeightInfo for () { /// The range of component `r` is `[0, 20]`. fn seal_balance(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `1017 + r * (480 ±0)` - // Estimated: `19673 + r * (2456 ±4)` - // Minimum execution time: 374_002 nanoseconds. - Weight::from_ref_time(384_615_649) - .saturating_add(Weight::from_proof_size(19673)) - // Standard Error: 85_633 - .saturating_add(Weight::from_ref_time(95_227_118).saturating_mul(r.into())) + // Measured: `1049 + r * (480 ±0)` + // Estimated: `19849 + r * (2456 ±0)` + // Minimum execution time: 373_999 nanoseconds. + Weight::from_ref_time(381_757_033) + .saturating_add(Weight::from_proof_size(19849)) + // Standard Error: 97_983 + .saturating_add(Weight::from_ref_time(98_290_984).saturating_mul(r.into())) .saturating_add(RocksDbWeight::get().reads(7_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) .saturating_add(Weight::from_proof_size(2456).saturating_mul(r.into())) @@ -2691,7 +2693,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(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:1 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) /// Storage: Timestamp Now (r:1 w:0) @@ -2701,13 +2703,13 @@ impl WeightInfo for () { /// The range of component `r` is `[0, 20]`. fn seal_value_transferred(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `856 + r * (480 ±0)` - // Estimated: `17200 + r * (2400 ±0)` - // Minimum execution time: 375_307 nanoseconds. - Weight::from_ref_time(378_389_705) - .saturating_add(Weight::from_proof_size(17200)) - // Standard Error: 42_265 - .saturating_add(Weight::from_ref_time(17_316_680).saturating_mul(r.into())) + // Measured: `888 + r * (480 ±0)` + // Estimated: `17360 + r * (2400 ±0)` + // Minimum execution time: 374_197 nanoseconds. + Weight::from_ref_time(377_755_896) + .saturating_add(Weight::from_proof_size(17360)) + // Standard Error: 60_542 + .saturating_add(Weight::from_ref_time(17_442_065).saturating_mul(r.into())) .saturating_add(RocksDbWeight::get().reads(6_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) .saturating_add(Weight::from_proof_size(2400).saturating_mul(r.into())) @@ -2715,7 +2717,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(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:1 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) /// Storage: Timestamp Now (r:1 w:0) @@ -2725,13 +2727,13 @@ impl WeightInfo for () { /// The range of component `r` is `[0, 20]`. fn seal_minimum_balance(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `854 + r * (480 ±0)` - // Estimated: `17140 + r * (2400 ±0)` - // Minimum execution time: 374_878 nanoseconds. - Weight::from_ref_time(379_364_066) - .saturating_add(Weight::from_proof_size(17140)) - // Standard Error: 49_158 - .saturating_add(Weight::from_ref_time(17_111_145).saturating_mul(r.into())) + // Measured: `886 + r * (480 ±0)` + // Estimated: `17290 + r * (2400 ±0)` + // Minimum execution time: 373_888 nanoseconds. + Weight::from_ref_time(377_825_771) + .saturating_add(Weight::from_proof_size(17290)) + // Standard Error: 38_026 + .saturating_add(Weight::from_ref_time(17_147_903).saturating_mul(r.into())) .saturating_add(RocksDbWeight::get().reads(6_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) .saturating_add(Weight::from_proof_size(2400).saturating_mul(r.into())) @@ -2739,7 +2741,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(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:1 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) /// Storage: Timestamp Now (r:1 w:0) @@ -2749,13 +2751,13 @@ impl WeightInfo for () { /// The range of component `r` is `[0, 20]`. fn seal_block_number(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `851 + r * (480 ±0)` - // Estimated: `17125 + r * (2400 ±0)` - // Minimum execution time: 374_981 nanoseconds. - Weight::from_ref_time(381_539_022) - .saturating_add(Weight::from_proof_size(17125)) - // Standard Error: 61_419 - .saturating_add(Weight::from_ref_time(17_062_381).saturating_mul(r.into())) + // Measured: `883 + r * (480 ±0)` + // Estimated: `17315 + r * (2400 ±0)` + // Minimum execution time: 373_904 nanoseconds. + Weight::from_ref_time(378_652_372) + .saturating_add(Weight::from_proof_size(17315)) + // Standard Error: 43_833 + .saturating_add(Weight::from_ref_time(16_936_781).saturating_mul(r.into())) .saturating_add(RocksDbWeight::get().reads(6_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) .saturating_add(Weight::from_proof_size(2400).saturating_mul(r.into())) @@ -2763,7 +2765,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(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:1 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) /// Storage: Timestamp Now (r:1 w:0) @@ -2773,13 +2775,13 @@ impl WeightInfo for () { /// The range of component `r` is `[0, 20]`. fn seal_now(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `842 + r * (480 ±0)` - // Estimated: `17100 + r * (2400 ±0)` - // Minimum execution time: 374_798 nanoseconds. - Weight::from_ref_time(372_659_915) - .saturating_add(Weight::from_proof_size(17100)) - // Standard Error: 151_499 - .saturating_add(Weight::from_ref_time(18_192_683).saturating_mul(r.into())) + // Measured: `874 + r * (480 ±0)` + // Estimated: `17245 + r * (2400 ±0)` + // Minimum execution time: 373_473 nanoseconds. + Weight::from_ref_time(376_386_312) + .saturating_add(Weight::from_proof_size(17245)) + // Standard Error: 46_945 + .saturating_add(Weight::from_ref_time(17_336_462).saturating_mul(r.into())) .saturating_add(RocksDbWeight::get().reads(6_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) .saturating_add(Weight::from_proof_size(2400).saturating_mul(r.into())) @@ -2787,7 +2789,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(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:1 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) /// Storage: Timestamp Now (r:1 w:0) @@ -2799,13 +2801,13 @@ impl WeightInfo for () { /// The range of component `r` is `[0, 20]`. fn seal_weight_to_fee(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `919 + r * (800 ±0)` - // Estimated: `18835 + r * (4805 ±0)` - // Minimum execution time: 374_841 nanoseconds. - Weight::from_ref_time(385_475_889) - .saturating_add(Weight::from_proof_size(18835)) - // Standard Error: 106_207 - .saturating_add(Weight::from_ref_time(88_099_987).saturating_mul(r.into())) + // Measured: `951 + r * (800 ±0)` + // Estimated: `19046 + r * (4805 ±0)` + // Minimum execution time: 373_661 nanoseconds. + Weight::from_ref_time(385_824_015) + .saturating_add(Weight::from_proof_size(19046)) + // Standard Error: 75_964 + .saturating_add(Weight::from_ref_time(88_530_074).saturating_mul(r.into())) .saturating_add(RocksDbWeight::get().reads(7_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) .saturating_add(Weight::from_proof_size(4805).saturating_mul(r.into())) @@ -2813,7 +2815,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(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:1 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) /// Storage: Timestamp Now (r:1 w:0) @@ -2823,13 +2825,13 @@ impl WeightInfo for () { /// The range of component `r` is `[0, 20]`. fn seal_gas(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `809 + r * (320 ±0)` - // Estimated: `16955 + r * (1600 ±0)` - // Minimum execution time: 134_436 nanoseconds. - Weight::from_ref_time(137_789_498) - .saturating_add(Weight::from_proof_size(16955)) - // Standard Error: 10_622 - .saturating_add(Weight::from_ref_time(8_144_024).saturating_mul(r.into())) + // Measured: `841 + r * (320 ±0)` + // Estimated: `17120 + r * (1600 ±0)` + // Minimum execution time: 133_849 nanoseconds. + Weight::from_ref_time(137_283_391) + .saturating_add(Weight::from_proof_size(17120)) + // Standard Error: 13_312 + .saturating_add(Weight::from_ref_time(8_055_328).saturating_mul(r.into())) .saturating_add(RocksDbWeight::get().reads(6_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) .saturating_add(Weight::from_proof_size(1600).saturating_mul(r.into())) @@ -2837,7 +2839,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(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:1 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) /// Storage: Timestamp Now (r:1 w:0) @@ -2847,13 +2849,13 @@ impl WeightInfo for () { /// The range of component `r` is `[0, 20]`. fn seal_input(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `844 + r * (480 ±0)` - // Estimated: `17085 + r * (2400 ±0)` - // Minimum execution time: 374_480 nanoseconds. - Weight::from_ref_time(379_723_392) - .saturating_add(Weight::from_proof_size(17085)) - // Standard Error: 50_240 - .saturating_add(Weight::from_ref_time(15_358_041).saturating_mul(r.into())) + // Measured: `876 + r * (480 ±0)` + // Estimated: `17245 + r * (2400 ±0)` + // Minimum execution time: 373_468 nanoseconds. + Weight::from_ref_time(376_121_093) + .saturating_add(Weight::from_proof_size(17245)) + // Standard Error: 61_857 + .saturating_add(Weight::from_ref_time(15_868_414).saturating_mul(r.into())) .saturating_add(RocksDbWeight::get().reads(6_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) .saturating_add(Weight::from_proof_size(2400).saturating_mul(r.into())) @@ -2861,7 +2863,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(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:1 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) /// Storage: Timestamp Now (r:1 w:0) @@ -2871,20 +2873,20 @@ impl WeightInfo for () { /// The range of component `n` is `[0, 1024]`. fn seal_input_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `1324` - // Estimated: `19490` - // Minimum execution time: 392_282 nanoseconds. - Weight::from_ref_time(418_943_323) - .saturating_add(Weight::from_proof_size(19490)) - // Standard Error: 4_673 - .saturating_add(Weight::from_ref_time(9_664_301).saturating_mul(n.into())) + // Measured: `1356` + // Estimated: `19650` + // Minimum execution time: 390_668 nanoseconds. + Weight::from_ref_time(419_608_449) + .saturating_add(Weight::from_proof_size(19650)) + // Standard Error: 4_890 + .saturating_add(Weight::from_ref_time(9_672_288).saturating_mul(n.into())) .saturating_add(RocksDbWeight::get().reads(6_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) } /// 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(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:1 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) /// Storage: Timestamp Now (r:1 w:0) @@ -2894,11 +2896,13 @@ impl WeightInfo for () { /// The range of component `r` is `[0, 1]`. fn seal_return(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `832 + r * (45 ±0)` - // Estimated: `17030 + r * (225 ±0)` - // Minimum execution time: 372_207 nanoseconds. - Weight::from_ref_time(376_232_444) - .saturating_add(Weight::from_proof_size(17030)) + // Measured: `864 + r * (45 ±0)` + // Estimated: `17190 + r * (225 ±0)` + // Minimum execution time: 371_309 nanoseconds. + Weight::from_ref_time(373_625_402) + .saturating_add(Weight::from_proof_size(17190)) + // Standard Error: 419_605 + .saturating_add(Weight::from_ref_time(1_737_397).saturating_mul(r.into())) .saturating_add(RocksDbWeight::get().reads(6_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) .saturating_add(Weight::from_proof_size(225).saturating_mul(r.into())) @@ -2906,7 +2910,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(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:1 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) /// Storage: Timestamp Now (r:1 w:0) @@ -2916,20 +2920,20 @@ impl WeightInfo for () { /// The range of component `n` is `[0, 1024]`. fn seal_return_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `842` - // Estimated: `17125` - // Minimum execution time: 374_743 nanoseconds. - Weight::from_ref_time(377_365_053) - .saturating_add(Weight::from_proof_size(17125)) - // Standard Error: 1_073 - .saturating_add(Weight::from_ref_time(231_251).saturating_mul(n.into())) + // Measured: `874` + // Estimated: `17285` + // Minimum execution time: 374_094 nanoseconds. + Weight::from_ref_time(375_965_200) + .saturating_add(Weight::from_proof_size(17285)) + // Standard Error: 1_127 + .saturating_add(Weight::from_ref_time(232_645).saturating_mul(n.into())) .saturating_add(RocksDbWeight::get().reads(6_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) } - /// Storage: System Account (r:3 w:3) + /// Storage: System Account (r:4 w:4) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:1 w:1) - /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:1 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) /// Storage: Timestamp Now (r:1 w:0) @@ -2943,23 +2947,23 @@ impl WeightInfo for () { /// The range of component `r` is `[0, 1]`. fn seal_terminate(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `874 + r * (280 ±0)` - // Estimated: `19880 + r * (11465 ±0)` - // Minimum execution time: 374_873 nanoseconds. - Weight::from_ref_time(378_422_289) - .saturating_add(Weight::from_proof_size(19880)) - // Standard Error: 979_734 - .saturating_add(Weight::from_ref_time(57_035_310).saturating_mul(r.into())) + // Measured: `906 + r * (452 ±0)` + // Estimated: `20242 + r * (15004 ±0)` + // Minimum execution time: 373_123 nanoseconds. + Weight::from_ref_time(374_924_634) + .saturating_add(Weight::from_proof_size(20242)) + // Standard Error: 378_010 + .saturating_add(Weight::from_ref_time(70_441_665).saturating_mul(r.into())) .saturating_add(RocksDbWeight::get().reads(6_u64)) - .saturating_add(RocksDbWeight::get().reads((5_u64).saturating_mul(r.into()))) + .saturating_add(RocksDbWeight::get().reads((6_u64).saturating_mul(r.into()))) .saturating_add(RocksDbWeight::get().writes(3_u64)) - .saturating_add(RocksDbWeight::get().writes((6_u64).saturating_mul(r.into()))) - .saturating_add(Weight::from_proof_size(11465).saturating_mul(r.into())) + .saturating_add(RocksDbWeight::get().writes((7_u64).saturating_mul(r.into()))) + .saturating_add(Weight::from_proof_size(15004).saturating_mul(r.into())) } /// 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(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:1 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) /// Storage: Timestamp Now (r:1 w:0) @@ -2971,13 +2975,13 @@ impl WeightInfo for () { /// The range of component `r` is `[0, 20]`. fn seal_random(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `889 + r * (800 ±0)` - // Estimated: `18643 + r * (4805 ±0)` - // Minimum execution time: 375_001 nanoseconds. - Weight::from_ref_time(382_558_599) - .saturating_add(Weight::from_proof_size(18643)) - // Standard Error: 94_918 - .saturating_add(Weight::from_ref_time(112_973_277).saturating_mul(r.into())) + // Measured: `921 + r * (800 ±0)` + // Estimated: `18835 + r * (4805 ±0)` + // Minimum execution time: 373_291 nanoseconds. + Weight::from_ref_time(385_684_344) + .saturating_add(Weight::from_proof_size(18835)) + // Standard Error: 99_025 + .saturating_add(Weight::from_ref_time(111_308_793).saturating_mul(r.into())) .saturating_add(RocksDbWeight::get().reads(7_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) .saturating_add(Weight::from_proof_size(4805).saturating_mul(r.into())) @@ -2985,7 +2989,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(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:1 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) /// Storage: Timestamp Now (r:1 w:0) @@ -2995,13 +2999,13 @@ impl WeightInfo for () { /// The range of component `r` is `[0, 20]`. fn seal_deposit_event(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `842 + r * (800 ±0)` - // Estimated: `17075 + r * (4000 ±0)` - // Minimum execution time: 372_547 nanoseconds. - Weight::from_ref_time(383_278_916) - .saturating_add(Weight::from_proof_size(17075)) - // Standard Error: 128_339 - .saturating_add(Weight::from_ref_time(229_356_088).saturating_mul(r.into())) + // Measured: `874 + r * (800 ±0)` + // Estimated: `17250 + r * (4000 ±0)` + // Minimum execution time: 371_900 nanoseconds. + Weight::from_ref_time(384_166_626) + .saturating_add(Weight::from_proof_size(17250)) + // Standard Error: 205_255 + .saturating_add(Weight::from_ref_time(229_214_157).saturating_mul(r.into())) .saturating_add(RocksDbWeight::get().reads(6_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) .saturating_add(Weight::from_proof_size(4000).saturating_mul(r.into())) @@ -3009,7 +3013,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(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:1 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) /// Storage: Timestamp Now (r:1 w:0) @@ -3020,15 +3024,15 @@ impl WeightInfo for () { /// The range of component `n` is `[0, 16]`. fn seal_deposit_event_per_topic_and_kb(t: u32, n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `1778 + t * (2608 ±0) + n * (8 ±0)` - // Estimated: `21675 + t * (211030 ±0) + n * (50 ±0)` - // Minimum execution time: 1_290_432 nanoseconds. - Weight::from_ref_time(595_859_216) - .saturating_add(Weight::from_proof_size(21675)) - // Standard Error: 602_943 - .saturating_add(Weight::from_ref_time(178_128_149).saturating_mul(t.into())) - // Standard Error: 165_597 - .saturating_add(Weight::from_ref_time(71_475_468).saturating_mul(n.into())) + // Measured: `1821 + t * (2608 ±0) + n * (7 ±0)` + // Estimated: `21870 + t * (211030 ±0) + n * (50 ±0)` + // Minimum execution time: 1_289_873 nanoseconds. + Weight::from_ref_time(581_702_206) + .saturating_add(Weight::from_proof_size(21870)) + // Standard Error: 665_638 + .saturating_add(Weight::from_ref_time(181_470_553).saturating_mul(t.into())) + // Standard Error: 182_816 + .saturating_add(Weight::from_ref_time(71_635_250).saturating_mul(n.into())) .saturating_add(RocksDbWeight::get().reads(6_u64)) .saturating_add(RocksDbWeight::get().reads((80_u64).saturating_mul(t.into()))) .saturating_add(RocksDbWeight::get().writes(3_u64)) @@ -3039,7 +3043,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(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:1 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) /// Storage: Timestamp Now (r:1 w:0) @@ -3049,13 +3053,13 @@ impl WeightInfo for () { /// The range of component `r` is `[0, 20]`. fn seal_debug_message(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `841 + r * (560 ±0)` - // Estimated: `17065 + r * (2800 ±0)` - // Minimum execution time: 149_020 nanoseconds. - Weight::from_ref_time(152_893_012) - .saturating_add(Weight::from_proof_size(17065)) - // Standard Error: 31_804 - .saturating_add(Weight::from_ref_time(14_497_512).saturating_mul(r.into())) + // Measured: `873 + r * (560 ±0)` + // Estimated: `17240 + r * (2800 ±0)` + // Minimum execution time: 148_635 nanoseconds. + Weight::from_ref_time(154_095_712) + .saturating_add(Weight::from_proof_size(17240)) + // Standard Error: 77_790 + .saturating_add(Weight::from_ref_time(14_837_085).saturating_mul(r.into())) .saturating_add(RocksDbWeight::get().reads(6_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) .saturating_add(Weight::from_proof_size(2800).saturating_mul(r.into())) @@ -3063,7 +3067,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(258), added: 2733, mode: MaxEncodedLen) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: MaxEncodedLen) /// Storage: Contracts CodeStorage (r:1 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: MaxEncodedLen) /// Storage: Timestamp Now (r:1 w:0) @@ -3073,13 +3077,13 @@ impl WeightInfo for () { /// The range of component `i` is `[0, 1024]`. fn seal_debug_message_per_kb(i: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `125792` - // Estimated: `265059` - // Minimum execution time: 502_589 nanoseconds. - Weight::from_ref_time(506_695_307) - .saturating_add(Weight::from_proof_size(265059)) - // Standard Error: 2_148 - .saturating_add(Weight::from_ref_time(814_647).saturating_mul(i.into())) + // Measured: `125824` + // Estimated: `265128` + // Minimum execution time: 501_014 nanoseconds. + Weight::from_ref_time(505_634_218) + .saturating_add(Weight::from_proof_size(265128)) + // Standard Error: 2_441 + .saturating_add(Weight::from_ref_time(819_257).saturating_mul(i.into())) .saturating_add(RocksDbWeight::get().reads(6_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) } @@ -3088,85 +3092,85 @@ impl WeightInfo for () { /// The range of component `r` is `[0, 10]`. fn seal_set_storage(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `883 + r * (23417 ±0)` - // Estimated: `883 + r * (23417 ±0)` - // Minimum execution time: 375_473 nanoseconds. - Weight::from_ref_time(291_125_810) - .saturating_add(Weight::from_proof_size(883)) - // Standard Error: 824_971 - .saturating_add(Weight::from_ref_time(477_999_695).saturating_mul(r.into())) + // Measured: `911 + r * (23420 ±0)` + // Estimated: `911 + r * (23418 ±0)` + // Minimum execution time: 375_301 nanoseconds. + Weight::from_ref_time(291_498_841) + .saturating_add(Weight::from_proof_size(911)) + // Standard Error: 809_989 + .saturating_add(Weight::from_ref_time(464_550_291).saturating_mul(r.into())) .saturating_add(RocksDbWeight::get().reads(6_u64)) .saturating_add(RocksDbWeight::get().reads((80_u64).saturating_mul(r.into()))) .saturating_add(RocksDbWeight::get().writes(3_u64)) .saturating_add(RocksDbWeight::get().writes((80_u64).saturating_mul(r.into()))) - .saturating_add(Weight::from_proof_size(23417).saturating_mul(r.into())) + .saturating_add(Weight::from_proof_size(23418).saturating_mul(r.into())) } /// Storage: Skipped Metadata (r:0 w:0) /// Proof Skipped: Skipped Metadata (max_values: None, max_size: None, mode: Measured) /// The range of component `n` is `[0, 8]`. fn seal_set_storage_per_new_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `12583 + n * (11969 ±0)` - // Estimated: `8500 + n * (12813 ±61)` - // Minimum execution time: 515_962 nanoseconds. - Weight::from_ref_time(697_904_030) - .saturating_add(Weight::from_proof_size(8500)) - // Standard Error: 1_684_000 - .saturating_add(Weight::from_ref_time(98_411_710).saturating_mul(n.into())) + // Measured: `12672 + n * (11945 ±0)` + // Estimated: `8529 + n * (12814 ±61)` + // Minimum execution time: 506_318 nanoseconds. + Weight::from_ref_time(676_935_313) + .saturating_add(Weight::from_proof_size(8529)) + // Standard Error: 1_589_291 + .saturating_add(Weight::from_ref_time(97_839_399).saturating_mul(n.into())) .saturating_add(RocksDbWeight::get().reads(52_u64)) .saturating_add(RocksDbWeight::get().reads((7_u64).saturating_mul(n.into()))) .saturating_add(RocksDbWeight::get().writes(50_u64)) .saturating_add(RocksDbWeight::get().writes((7_u64).saturating_mul(n.into()))) - .saturating_add(Weight::from_proof_size(12813).saturating_mul(n.into())) + .saturating_add(Weight::from_proof_size(12814).saturating_mul(n.into())) } /// Storage: Skipped Metadata (r:0 w:0) /// Proof Skipped: Skipped Metadata (max_values: None, max_size: None, mode: Measured) /// The range of component `n` is `[0, 8]`. fn seal_set_storage_per_old_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `15138 + n * (175775 ±0)` - // Estimated: `9898 + n * (176855 ±74)` - // Minimum execution time: 515_828 nanoseconds. - Weight::from_ref_time(661_240_495) - .saturating_add(Weight::from_proof_size(9898)) - // Standard Error: 1_338_661 - .saturating_add(Weight::from_ref_time(65_767_819).saturating_mul(n.into())) + // Measured: `15170 + n * (175775 ±0)` + // Estimated: `9914 + n * (176858 ±74)` + // Minimum execution time: 506_148 nanoseconds. + Weight::from_ref_time(648_278_778) + .saturating_add(Weight::from_proof_size(9914)) + // Standard Error: 1_343_586 + .saturating_add(Weight::from_ref_time(65_789_595).saturating_mul(n.into())) .saturating_add(RocksDbWeight::get().reads(51_u64)) .saturating_add(RocksDbWeight::get().reads((7_u64).saturating_mul(n.into()))) .saturating_add(RocksDbWeight::get().writes(49_u64)) .saturating_add(RocksDbWeight::get().writes((7_u64).saturating_mul(n.into()))) - .saturating_add(Weight::from_proof_size(176855).saturating_mul(n.into())) + .saturating_add(Weight::from_proof_size(176858).saturating_mul(n.into())) } /// Storage: Skipped Metadata (r:0 w:0) /// Proof Skipped: Skipped Metadata (max_values: None, max_size: None, mode: Measured) /// The range of component `r` is `[0, 10]`. fn seal_clear_storage(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `876 + r * (23098 ±0)` - // Estimated: `881 + r * (23097 ±0)` - // Minimum execution time: 375_528 nanoseconds. - Weight::from_ref_time(296_453_612) - .saturating_add(Weight::from_proof_size(881)) - // Standard Error: 809_232 - .saturating_add(Weight::from_ref_time(465_365_815).saturating_mul(r.into())) + // Measured: `903 + r * (23099 ±0)` + // Estimated: `908 + r * (23099 ±0)` + // Minimum execution time: 374_344 nanoseconds. + Weight::from_ref_time(293_272_061) + .saturating_add(Weight::from_proof_size(908)) + // Standard Error: 810_412 + .saturating_add(Weight::from_ref_time(453_315_956).saturating_mul(r.into())) .saturating_add(RocksDbWeight::get().reads(6_u64)) .saturating_add(RocksDbWeight::get().reads((80_u64).saturating_mul(r.into()))) .saturating_add(RocksDbWeight::get().writes(3_u64)) .saturating_add(RocksDbWeight::get().writes((80_u64).saturating_mul(r.into()))) - .saturating_add(Weight::from_proof_size(23097).saturating_mul(r.into())) + .saturating_add(Weight::from_proof_size(23099).saturating_mul(r.into())) } /// Storage: Skipped Metadata (r:0 w:0) /// Proof Skipped: Skipped Metadata (max_values: None, max_size: None, mode: Measured) /// The range of component `n` is `[0, 8]`. fn seal_clear_storage_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `14863 + n * (175768 ±0)` - // Estimated: `9519 + n * (176867 ±75)` - // Minimum execution time: 480_427 nanoseconds. - Weight::from_ref_time(640_337_570) - .saturating_add(Weight::from_proof_size(9519)) - // Standard Error: 1_497_141 - .saturating_add(Weight::from_ref_time(67_963_696).saturating_mul(n.into())) + // Measured: `14895 + n * (175768 ±0)` + // Estimated: `9551 + n * (176867 ±75)` + // Minimum execution time: 478_564 nanoseconds. + Weight::from_ref_time(630_839_142) + .saturating_add(Weight::from_proof_size(9551)) + // Standard Error: 1_427_520 + .saturating_add(Weight::from_ref_time(66_813_592).saturating_mul(n.into())) .saturating_add(RocksDbWeight::get().reads(51_u64)) .saturating_add(RocksDbWeight::get().reads((7_u64).saturating_mul(n.into()))) .saturating_add(RocksDbWeight::get().writes(48_u64)) @@ -3178,30 +3182,30 @@ impl WeightInfo for () { /// The range of component `r` is `[0, 10]`. fn seal_get_storage(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `878 + r * (23740 ±0)` - // Estimated: `880 + r * (23739 ±0)` - // Minimum execution time: 375_725 nanoseconds. - Weight::from_ref_time(307_839_394) - .saturating_add(Weight::from_proof_size(880)) - // Standard Error: 710_694 - .saturating_add(Weight::from_ref_time(381_738_407).saturating_mul(r.into())) + // Measured: `896 + r * (23744 ±0)` + // Estimated: `909 + r * (23740 ±0)` + // Minimum execution time: 374_479 nanoseconds. + Weight::from_ref_time(311_839_315) + .saturating_add(Weight::from_proof_size(909)) + // Standard Error: 666_553 + .saturating_add(Weight::from_ref_time(371_213_042).saturating_mul(r.into())) .saturating_add(RocksDbWeight::get().reads(6_u64)) .saturating_add(RocksDbWeight::get().reads((80_u64).saturating_mul(r.into()))) .saturating_add(RocksDbWeight::get().writes(3_u64)) - .saturating_add(Weight::from_proof_size(23739).saturating_mul(r.into())) + .saturating_add(Weight::from_proof_size(23740).saturating_mul(r.into())) } /// Storage: Skipped Metadata (r:0 w:0) /// Proof Skipped: Skipped Metadata (max_values: None, max_size: None, mode: Measured) /// The range of component `n` is `[0, 8]`. fn seal_get_storage_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `15469 + n * (175775 ±0)` - // Estimated: `10010 + n * (176900 ±76)` - // Minimum execution time: 461_871 nanoseconds. - Weight::from_ref_time(605_755_493) - .saturating_add(Weight::from_proof_size(10010)) - // Standard Error: 1_375_044 - .saturating_add(Weight::from_ref_time(161_332_330).saturating_mul(n.into())) + // Measured: `15501 + n * (175775 ±0)` + // Estimated: `10042 + n * (176900 ±76)` + // Minimum execution time: 460_639 nanoseconds. + Weight::from_ref_time(591_187_094) + .saturating_add(Weight::from_proof_size(10042)) + // Standard Error: 1_233_792 + .saturating_add(Weight::from_ref_time(160_874_477).saturating_mul(n.into())) .saturating_add(RocksDbWeight::get().reads(51_u64)) .saturating_add(RocksDbWeight::get().reads((7_u64).saturating_mul(n.into()))) .saturating_add(RocksDbWeight::get().writes(3_u64)) @@ -3212,47 +3216,47 @@ impl WeightInfo for () { /// The range of component `r` is `[0, 10]`. fn seal_contains_storage(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `871 + r * (23100 ±0)` - // Estimated: `873 + r * (23099 ±0)` - // Minimum execution time: 375_325 nanoseconds. - Weight::from_ref_time(305_508_307) - .saturating_add(Weight::from_proof_size(873)) - // Standard Error: 715_627 - .saturating_add(Weight::from_ref_time(369_985_438).saturating_mul(r.into())) + // Measured: `914 + r * (23098 ±0)` + // Estimated: `920 + r * (23098 ±0)` + // Minimum execution time: 374_272 nanoseconds. + Weight::from_ref_time(311_446_269) + .saturating_add(Weight::from_proof_size(920)) + // Standard Error: 630_307 + .saturating_add(Weight::from_ref_time(357_134_931).saturating_mul(r.into())) .saturating_add(RocksDbWeight::get().reads(6_u64)) .saturating_add(RocksDbWeight::get().reads((80_u64).saturating_mul(r.into()))) .saturating_add(RocksDbWeight::get().writes(3_u64)) - .saturating_add(Weight::from_proof_size(23099).saturating_mul(r.into())) + .saturating_add(Weight::from_proof_size(23098).saturating_mul(r.into())) } /// Storage: Skipped Metadata (r:0 w:0) /// Proof Skipped: Skipped Metadata (max_values: None, max_size: None, mode: Measured) /// The range of component `n` is `[0, 8]`. fn seal_contains_storage_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `14814 + n * (175782 ±0)` - // Estimated: `9502 + n * (176872 ±75)` - // Minimum execution time: 457_128 nanoseconds. - Weight::from_ref_time(582_799_799) - .saturating_add(Weight::from_proof_size(9502)) - // Standard Error: 1_151_126 - .saturating_add(Weight::from_ref_time(63_425_277).saturating_mul(n.into())) + // Measured: `14839 + n * (175789 ±0)` + // Estimated: `9532 + n * (176874 ±75)` + // Minimum execution time: 456_013 nanoseconds. + Weight::from_ref_time(575_116_352) + .saturating_add(Weight::from_proof_size(9532)) + // Standard Error: 1_122_298 + .saturating_add(Weight::from_ref_time(61_786_107).saturating_mul(n.into())) .saturating_add(RocksDbWeight::get().reads(51_u64)) .saturating_add(RocksDbWeight::get().reads((7_u64).saturating_mul(n.into()))) .saturating_add(RocksDbWeight::get().writes(3_u64)) - .saturating_add(Weight::from_proof_size(176872).saturating_mul(n.into())) + .saturating_add(Weight::from_proof_size(176874).saturating_mul(n.into())) } /// Storage: Skipped Metadata (r:0 w:0) /// Proof Skipped: Skipped Metadata (max_values: None, max_size: None, mode: Measured) /// The range of component `r` is `[0, 10]`. fn seal_take_storage(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `879 + r * (23740 ±0)` - // Estimated: `881 + r * (23739 ±0)` - // Minimum execution time: 375_918 nanoseconds. - Weight::from_ref_time(293_217_646) - .saturating_add(Weight::from_proof_size(881)) - // Standard Error: 840_266 - .saturating_add(Weight::from_ref_time(478_374_701).saturating_mul(r.into())) + // Measured: `911 + r * (23740 ±0)` + // Estimated: `913 + r * (23739 ±0)` + // Minimum execution time: 374_621 nanoseconds. + Weight::from_ref_time(299_689_489) + .saturating_add(Weight::from_proof_size(913)) + // Standard Error: 757_735 + .saturating_add(Weight::from_ref_time(465_213_246).saturating_mul(r.into())) .saturating_add(RocksDbWeight::get().reads(6_u64)) .saturating_add(RocksDbWeight::get().reads((80_u64).saturating_mul(r.into()))) .saturating_add(RocksDbWeight::get().writes(3_u64)) @@ -3264,13 +3268,13 @@ impl WeightInfo for () { /// The range of component `n` is `[0, 8]`. fn seal_take_storage_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `15470 + n * (175775 ±0)` - // Estimated: `10010 + n * (176898 ±76)` - // Minimum execution time: 484_207 nanoseconds. - Weight::from_ref_time(664_065_436) - .saturating_add(Weight::from_proof_size(10010)) - // Standard Error: 1_655_442 - .saturating_add(Weight::from_ref_time(166_258_757).saturating_mul(n.into())) + // Measured: `15502 + n * (175775 ±0)` + // Estimated: `10042 + n * (176898 ±76)` + // Minimum execution time: 481_980 nanoseconds. + Weight::from_ref_time(647_289_053) + .saturating_add(Weight::from_proof_size(10042)) + // Standard Error: 1_556_155 + .saturating_add(Weight::from_ref_time(166_592_657).saturating_mul(n.into())) .saturating_add(RocksDbWeight::get().reads(51_u64)) .saturating_add(RocksDbWeight::get().reads((7_u64).saturating_mul(n.into()))) .saturating_add(RocksDbWeight::get().writes(48_u64)) @@ -3280,7 +3284,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(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:1 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) /// Storage: Timestamp Now (r:1 w:0) @@ -3290,23 +3294,23 @@ impl WeightInfo for () { /// The range of component `r` is `[0, 20]`. fn seal_transfer(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `1393 + r * (3602 ±0)` - // Estimated: `21258 + r * (216091 ±0)` - // Minimum execution time: 377_152 nanoseconds. - Weight::from_ref_time(317_470_910) - .saturating_add(Weight::from_proof_size(21258)) - // Standard Error: 994_076 - .saturating_add(Weight::from_ref_time(1_409_416_087).saturating_mul(r.into())) + // Measured: `1457 + r * (3604 ±0)` + // Estimated: `21583 + r * (216101 ±0)` + // Minimum execution time: 374_962 nanoseconds. + Weight::from_ref_time(313_416_386) + .saturating_add(Weight::from_proof_size(21583)) + // Standard Error: 710_675 + .saturating_add(Weight::from_ref_time(1_396_551_156).saturating_mul(r.into())) .saturating_add(RocksDbWeight::get().reads(7_u64)) .saturating_add(RocksDbWeight::get().reads((80_u64).saturating_mul(r.into()))) .saturating_add(RocksDbWeight::get().writes(4_u64)) .saturating_add(RocksDbWeight::get().writes((80_u64).saturating_mul(r.into()))) - .saturating_add(Weight::from_proof_size(216091).saturating_mul(r.into())) + .saturating_add(Weight::from_proof_size(216101).saturating_mul(r.into())) } /// 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:1601) - /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:2 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) /// Storage: Timestamp Now (r:1 w:0) @@ -3316,23 +3320,23 @@ impl WeightInfo for () { /// The range of component `r` is `[0, 20]`. fn seal_call(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `1551 + r * (20511 ±0)` - // Estimated: `21848 + r * (498651 ±1)` - // Minimum execution time: 376_257 nanoseconds. - Weight::from_ref_time(377_035_000) - .saturating_add(Weight::from_proof_size(21848)) - // Standard Error: 7_966_778 - .saturating_add(Weight::from_ref_time(28_873_495_129).saturating_mul(r.into())) + // Measured: `1609 + r * (23073 ±0)` + // Estimated: `22098 + r * (511456 ±1)` + // Minimum execution time: 375_916 nanoseconds. + Weight::from_ref_time(376_468_000) + .saturating_add(Weight::from_proof_size(22098)) + // Standard Error: 7_246_855 + .saturating_add(Weight::from_ref_time(28_982_425_139).saturating_mul(r.into())) .saturating_add(RocksDbWeight::get().reads(7_u64)) .saturating_add(RocksDbWeight::get().reads((160_u64).saturating_mul(r.into()))) .saturating_add(RocksDbWeight::get().writes(3_u64)) .saturating_add(RocksDbWeight::get().writes((160_u64).saturating_mul(r.into()))) - .saturating_add(Weight::from_proof_size(498651).saturating_mul(r.into())) + .saturating_add(Weight::from_proof_size(511456).saturating_mul(r.into())) } /// 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(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:1536 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) /// Storage: Timestamp Now (r:1 w:0) @@ -3343,22 +3347,22 @@ impl WeightInfo for () { fn seal_delegate_call(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0 + r * (71670 ±0)` - // Estimated: `17125 + r * (659927 ±822)` - // Minimum execution time: 376_544 nanoseconds. - Weight::from_ref_time(377_490_000) - .saturating_add(Weight::from_proof_size(17125)) - // Standard Error: 8_608_050 - .saturating_add(Weight::from_ref_time(28_568_714_410).saturating_mul(r.into())) + // Estimated: `17285 + r * (659930 ±563)` + // Minimum execution time: 375_412 nanoseconds. + Weight::from_ref_time(376_493_000) + .saturating_add(Weight::from_proof_size(17285)) + // Standard Error: 8_239_575 + .saturating_add(Weight::from_ref_time(28_716_347_183).saturating_mul(r.into())) .saturating_add(RocksDbWeight::get().reads(6_u64)) .saturating_add(RocksDbWeight::get().reads((150_u64).saturating_mul(r.into()))) .saturating_add(RocksDbWeight::get().writes(3_u64)) .saturating_add(RocksDbWeight::get().writes((75_u64).saturating_mul(r.into()))) - .saturating_add(Weight::from_proof_size(659927).saturating_mul(r.into())) + .saturating_add(Weight::from_proof_size(659930).saturating_mul(r.into())) } /// Storage: System Account (r:82 w:81) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:81 w:81) - /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:2 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) /// Storage: Timestamp Now (r:1 w:0) @@ -3369,25 +3373,25 @@ impl WeightInfo for () { /// The range of component `c` is `[0, 1024]`. fn seal_call_per_transfer_clone_kb(t: u32, c: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `21611 + t * (15369 ±0)` - // Estimated: `519400 + t * (277320 ±0)` - // Minimum execution time: 10_322_052 nanoseconds. - Weight::from_ref_time(9_248_652_894) - .saturating_add(Weight::from_proof_size(519400)) - // Standard Error: 9_039_638 - .saturating_add(Weight::from_ref_time(1_393_054_441).saturating_mul(t.into())) - // Standard Error: 13_554 - .saturating_add(Weight::from_ref_time(9_819_606).saturating_mul(c.into())) + // Measured: `24269 + t * (16910 ±0)` + // Estimated: `532690 + t * (285025 ±0)` + // Minimum execution time: 10_443_315 nanoseconds. + Weight::from_ref_time(9_342_574_069) + .saturating_add(Weight::from_proof_size(532690)) + // Standard Error: 7_237_279 + .saturating_add(Weight::from_ref_time(1_390_221_936).saturating_mul(t.into())) + // Standard Error: 10_851 + .saturating_add(Weight::from_ref_time(9_842_151).saturating_mul(c.into())) .saturating_add(RocksDbWeight::get().reads(167_u64)) .saturating_add(RocksDbWeight::get().reads((81_u64).saturating_mul(t.into()))) .saturating_add(RocksDbWeight::get().writes(163_u64)) .saturating_add(RocksDbWeight::get().writes((81_u64).saturating_mul(t.into()))) - .saturating_add(Weight::from_proof_size(277320).saturating_mul(t.into())) + .saturating_add(Weight::from_proof_size(285025).saturating_mul(t.into())) } - /// Storage: System Account (r:1602 w:1602) + /// Storage: System Account (r:3202 w:3202) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:1601 w:1601) - /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:1601 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) /// Storage: Timestamp Now (r:1 w:0) @@ -3401,23 +3405,23 @@ impl WeightInfo for () { /// The range of component `r` is `[0, 20]`. fn seal_instantiate(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `1613 + r * (25576 ±0)` - // Estimated: `25698 + r * (1169112 ±1)` - // Minimum execution time: 376_639 nanoseconds. - Weight::from_ref_time(377_892_000) - .saturating_add(Weight::from_proof_size(25698)) - // Standard Error: 21_259_255 - .saturating_add(Weight::from_ref_time(34_131_174_956).saturating_mul(r.into())) + // Measured: `1775 + r * (25568 ±0)` + // Estimated: `26563 + r * (1367114 ±2)` + // Minimum execution time: 376_418 nanoseconds. + Weight::from_ref_time(377_292_000) + .saturating_add(Weight::from_proof_size(26563)) + // Standard Error: 32_312_545 + .saturating_add(Weight::from_ref_time(35_904_826_312).saturating_mul(r.into())) .saturating_add(RocksDbWeight::get().reads(8_u64)) - .saturating_add(RocksDbWeight::get().reads((400_u64).saturating_mul(r.into()))) + .saturating_add(RocksDbWeight::get().reads((480_u64).saturating_mul(r.into()))) .saturating_add(RocksDbWeight::get().writes(5_u64)) - .saturating_add(RocksDbWeight::get().writes((320_u64).saturating_mul(r.into()))) - .saturating_add(Weight::from_proof_size(1169112).saturating_mul(r.into())) + .saturating_add(RocksDbWeight::get().writes((400_u64).saturating_mul(r.into()))) + .saturating_add(Weight::from_proof_size(1367114).saturating_mul(r.into())) } - /// Storage: System Account (r:82 w:82) + /// Storage: System Account (r:162 w:162) /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured) /// Storage: Contracts ContractInfoOf (r:81 w:81) - /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:2 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) /// Storage: Timestamp Now (r:1 w:0) @@ -3433,27 +3437,27 @@ impl WeightInfo for () { /// The range of component `s` is `[0, 960]`. fn seal_instantiate_per_transfer_input_salt_kb(t: u32, i: u32, s: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `5666 + t * (17 ±0)` - // Estimated: `651914 + t * (2762 ±3)` - // Minimum execution time: 130_366_376 nanoseconds. - Weight::from_ref_time(9_844_607_874) - .saturating_add(Weight::from_proof_size(651914)) - // Standard Error: 100_211_149 - .saturating_add(Weight::from_ref_time(390_481_449).saturating_mul(t.into())) - // Standard Error: 163_416 - .saturating_add(Weight::from_ref_time(126_154_200).saturating_mul(i.into())) - // Standard Error: 163_416 - .saturating_add(Weight::from_ref_time(126_430_874).saturating_mul(s.into())) - .saturating_add(RocksDbWeight::get().reads(249_u64)) + // Measured: `5785 + t * (33 ±0)` + // Estimated: `850985 + t * (2671 ±3)` + // Minimum execution time: 132_157_340 nanoseconds. + Weight::from_ref_time(11_329_968_948) + .saturating_add(Weight::from_proof_size(850985)) + // Standard Error: 99_102_968 + .saturating_add(Weight::from_ref_time(84_719_458).saturating_mul(t.into())) + // Standard Error: 161_609 + .saturating_add(Weight::from_ref_time(126_156_627).saturating_mul(i.into())) + // Standard Error: 161_609 + .saturating_add(Weight::from_ref_time(126_628_313).saturating_mul(s.into())) + .saturating_add(RocksDbWeight::get().reads(329_u64)) .saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(t.into()))) - .saturating_add(RocksDbWeight::get().writes(246_u64)) + .saturating_add(RocksDbWeight::get().writes(326_u64)) .saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(t.into()))) - .saturating_add(Weight::from_proof_size(2762).saturating_mul(t.into())) + .saturating_add(Weight::from_proof_size(2671).saturating_mul(t.into())) } /// 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(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:1 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) /// Storage: Timestamp Now (r:1 w:0) @@ -3463,13 +3467,13 @@ impl WeightInfo for () { /// The range of component `r` is `[0, 1]`. fn seal_hash_sha2_256(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `839 + r * (642 ±0)` - // Estimated: `17065 + r * (3210 ±0)` - // Minimum execution time: 373_848 nanoseconds. - Weight::from_ref_time(375_974_597) - .saturating_add(Weight::from_proof_size(17065)) - // Standard Error: 558_923 - .saturating_add(Weight::from_ref_time(42_648_202).saturating_mul(r.into())) + // Measured: `871 + r * (642 ±0)` + // Estimated: `17225 + r * (3210 ±0)` + // Minimum execution time: 373_559 nanoseconds. + Weight::from_ref_time(375_166_904) + .saturating_add(Weight::from_proof_size(17225)) + // Standard Error: 125_024 + .saturating_add(Weight::from_ref_time(42_291_595).saturating_mul(r.into())) .saturating_add(RocksDbWeight::get().reads(6_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) .saturating_add(Weight::from_proof_size(3210).saturating_mul(r.into())) @@ -3477,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(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:1 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) /// Storage: Timestamp Now (r:1 w:0) @@ -3487,20 +3491,20 @@ impl WeightInfo for () { /// The range of component `n` is `[0, 1024]`. fn seal_hash_sha2_256_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `1641` - // Estimated: `21000` - // Minimum execution time: 417_281 nanoseconds. - Weight::from_ref_time(418_086_000) - .saturating_add(Weight::from_proof_size(21000)) - // Standard Error: 43_883 - .saturating_add(Weight::from_ref_time(324_497_460).saturating_mul(n.into())) + // Measured: `1673` + // Estimated: `21160` + // Minimum execution time: 416_233 nanoseconds. + Weight::from_ref_time(416_785_000) + .saturating_add(Weight::from_proof_size(21160)) + // Standard Error: 56_223 + .saturating_add(Weight::from_ref_time(324_513_835).saturating_mul(n.into())) .saturating_add(RocksDbWeight::get().reads(6_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) } /// 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(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:1 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) /// Storage: Timestamp Now (r:1 w:0) @@ -3510,13 +3514,13 @@ impl WeightInfo for () { /// The range of component `r` is `[0, 1]`. fn seal_hash_keccak_256(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `841 + r * (642 ±0)` - // Estimated: `17075 + r * (3210 ±0)` - // Minimum execution time: 372_362 nanoseconds. - Weight::from_ref_time(374_975_677) - .saturating_add(Weight::from_proof_size(17075)) - // Standard Error: 307_932 - .saturating_add(Weight::from_ref_time(57_607_522).saturating_mul(r.into())) + // Measured: `873 + r * (642 ±0)` + // Estimated: `17235 + r * (3210 ±0)` + // Minimum execution time: 371_735 nanoseconds. + Weight::from_ref_time(375_979_430) + .saturating_add(Weight::from_proof_size(17235)) + // Standard Error: 968_037 + .saturating_add(Weight::from_ref_time(57_780_769).saturating_mul(r.into())) .saturating_add(RocksDbWeight::get().reads(6_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) .saturating_add(Weight::from_proof_size(3210).saturating_mul(r.into())) @@ -3524,7 +3528,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(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:1 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) /// Storage: Timestamp Now (r:1 w:0) @@ -3534,20 +3538,20 @@ impl WeightInfo for () { /// The range of component `n` is `[0, 1024]`. fn seal_hash_keccak_256_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `1643` - // Estimated: `21040` - // Minimum execution time: 431_034 nanoseconds. - Weight::from_ref_time(431_571_000) - .saturating_add(Weight::from_proof_size(21040)) - // Standard Error: 80_071 - .saturating_add(Weight::from_ref_time(261_645_325).saturating_mul(n.into())) + // Measured: `1675` + // Estimated: `21205` + // Minimum execution time: 428_196 nanoseconds. + Weight::from_ref_time(429_438_000) + .saturating_add(Weight::from_proof_size(21205)) + // Standard Error: 57_860 + .saturating_add(Weight::from_ref_time(260_917_896).saturating_mul(n.into())) .saturating_add(RocksDbWeight::get().reads(6_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) } /// 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(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:1 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) /// Storage: Timestamp Now (r:1 w:0) @@ -3557,13 +3561,13 @@ impl WeightInfo for () { /// The range of component `r` is `[0, 1]`. fn seal_hash_blake2_256(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `841 + r * (642 ±0)` - // Estimated: `17075 + r * (3210 ±0)` - // Minimum execution time: 372_069 nanoseconds. - Weight::from_ref_time(374_200_608) - .saturating_add(Weight::from_proof_size(17075)) - // Standard Error: 171_799 - .saturating_add(Weight::from_ref_time(32_843_391).saturating_mul(r.into())) + // Measured: `873 + r * (642 ±0)` + // Estimated: `17235 + r * (3210 ±0)` + // Minimum execution time: 371_412 nanoseconds. + Weight::from_ref_time(373_635_818) + .saturating_add(Weight::from_proof_size(17235)) + // Standard Error: 222_973 + .saturating_add(Weight::from_ref_time(33_347_181).saturating_mul(r.into())) .saturating_add(RocksDbWeight::get().reads(6_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) .saturating_add(Weight::from_proof_size(3210).saturating_mul(r.into())) @@ -3571,7 +3575,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(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:1 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) /// Storage: Timestamp Now (r:1 w:0) @@ -3581,20 +3585,20 @@ impl WeightInfo for () { /// The range of component `n` is `[0, 1024]`. fn seal_hash_blake2_256_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `1643` - // Estimated: `21010` - // Minimum execution time: 406_143 nanoseconds. - Weight::from_ref_time(406_744_000) - .saturating_add(Weight::from_proof_size(21010)) - // Standard Error: 48_038 - .saturating_add(Weight::from_ref_time(103_286_295).saturating_mul(n.into())) + // Measured: `1675` + // Estimated: `21180` + // Minimum execution time: 405_858 nanoseconds. + Weight::from_ref_time(406_498_000) + .saturating_add(Weight::from_proof_size(21180)) + // Standard Error: 48_388 + .saturating_add(Weight::from_ref_time(103_283_157).saturating_mul(n.into())) .saturating_add(RocksDbWeight::get().reads(6_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) } /// 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(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:1 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) /// Storage: Timestamp Now (r:1 w:0) @@ -3604,13 +3608,13 @@ impl WeightInfo for () { /// The range of component `r` is `[0, 1]`. fn seal_hash_blake2_128(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `841 + r * (679 ±0)` - // Estimated: `17075 + r * (3395 ±0)` - // Minimum execution time: 372_201 nanoseconds. - Weight::from_ref_time(374_049_708) - .saturating_add(Weight::from_proof_size(17075)) - // Standard Error: 387_179 - .saturating_add(Weight::from_ref_time(38_857_191).saturating_mul(r.into())) + // Measured: `873 + r * (679 ±0)` + // Estimated: `17235 + r * (3395 ±0)` + // Minimum execution time: 371_746 nanoseconds. + Weight::from_ref_time(373_538_171) + .saturating_add(Weight::from_proof_size(17235)) + // Standard Error: 387_332 + .saturating_add(Weight::from_ref_time(35_933_528).saturating_mul(r.into())) .saturating_add(RocksDbWeight::get().reads(6_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) .saturating_add(Weight::from_proof_size(3395).saturating_mul(r.into())) @@ -3618,7 +3622,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(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:1 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) /// Storage: Timestamp Now (r:1 w:0) @@ -3628,20 +3632,20 @@ impl WeightInfo for () { /// The range of component `n` is `[0, 1024]`. fn seal_hash_blake2_128_per_kb(n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `1643` - // Estimated: `21050` - // Minimum execution time: 405_819 nanoseconds. - Weight::from_ref_time(406_364_000) - .saturating_add(Weight::from_proof_size(21050)) - // Standard Error: 46_248 - .saturating_add(Weight::from_ref_time(103_189_157).saturating_mul(n.into())) + // Measured: `1675` + // Estimated: `21225` + // Minimum execution time: 405_752 nanoseconds. + Weight::from_ref_time(406_417_000) + .saturating_add(Weight::from_proof_size(21225)) + // Standard Error: 47_051 + .saturating_add(Weight::from_ref_time(103_325_027).saturating_mul(n.into())) .saturating_add(RocksDbWeight::get().reads(6_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) } /// 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(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:1 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) /// Storage: Timestamp Now (r:1 w:0) @@ -3651,13 +3655,13 @@ impl WeightInfo for () { /// The range of component `r` is `[0, 1]`. fn seal_ecdsa_recover(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `885 + r * (6083 ±0)` - // Estimated: `17295 + r * (30415 ±0)` - // Minimum execution time: 374_836 nanoseconds. - Weight::from_ref_time(379_385_500) - .saturating_add(Weight::from_proof_size(17295)) - // Standard Error: 1_694_427 - .saturating_add(Weight::from_ref_time(3_021_801_000).saturating_mul(r.into())) + // Measured: `917 + r * (6083 ±0)` + // Estimated: `17455 + r * (30415 ±0)` + // Minimum execution time: 373_882 nanoseconds. + Weight::from_ref_time(376_553_787) + .saturating_add(Weight::from_proof_size(17455)) + // Standard Error: 912_833 + .saturating_add(Weight::from_ref_time(3_021_100_412).saturating_mul(r.into())) .saturating_add(RocksDbWeight::get().reads(6_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) .saturating_add(Weight::from_proof_size(30415).saturating_mul(r.into())) @@ -3665,7 +3669,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(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:1 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) /// Storage: Timestamp Now (r:1 w:0) @@ -3675,13 +3679,13 @@ impl WeightInfo for () { /// The range of component `r` is `[0, 1]`. fn seal_ecdsa_to_eth_address(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `854 + r * (3362 ±0)` - // Estimated: `17140 + r * (16810 ±0)` - // Minimum execution time: 374_223 nanoseconds. - Weight::from_ref_time(376_120_230) - .saturating_add(Weight::from_proof_size(17140)) - // Standard Error: 619_576 - .saturating_add(Weight::from_ref_time(754_257_969).saturating_mul(r.into())) + // Measured: `886 + r * (3362 ±0)` + // Estimated: `17300 + r * (16810 ±0)` + // Minimum execution time: 373_673 nanoseconds. + Weight::from_ref_time(375_712_961) + .saturating_add(Weight::from_proof_size(17300)) + // Standard Error: 596_297 + .saturating_add(Weight::from_ref_time(738_257_638).saturating_mul(r.into())) .saturating_add(RocksDbWeight::get().reads(6_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) .saturating_add(Weight::from_proof_size(16810).saturating_mul(r.into())) @@ -3689,7 +3693,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(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:1536 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) /// Storage: Timestamp Now (r:1 w:0) @@ -3702,12 +3706,12 @@ impl WeightInfo for () { fn seal_set_code_hash(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0 + r * (79300 ±0)` - // Estimated: `64652 + r * (942952 ±829)` - // Minimum execution time: 374_442 nanoseconds. - Weight::from_ref_time(375_591_000) - .saturating_add(Weight::from_proof_size(64652)) - // Standard Error: 3_764_193 - .saturating_add(Weight::from_ref_time(1_552_885_601).saturating_mul(r.into())) + // Estimated: `64844 + r * (942952 ±833)` + // Minimum execution time: 374_097 nanoseconds. + Weight::from_ref_time(374_985_000) + .saturating_add(Weight::from_proof_size(64844)) + // Standard Error: 3_772_336 + .saturating_add(Weight::from_ref_time(1_546_402_854).saturating_mul(r.into())) .saturating_add(RocksDbWeight::get().reads(6_u64)) .saturating_add(RocksDbWeight::get().reads((225_u64).saturating_mul(r.into()))) .saturating_add(RocksDbWeight::get().writes(3_u64)) @@ -3717,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(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:1 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) /// Storage: Timestamp Now (r:1 w:0) @@ -3727,13 +3731,13 @@ impl WeightInfo for () { /// The range of component `r` is `[0, 20]`. fn seal_reentrance_count(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `837 + r * (240 ±0)` - // Estimated: `17055 + r * (1200 ±0)` - // Minimum execution time: 374_922 nanoseconds. - Weight::from_ref_time(376_234_094) - .saturating_add(Weight::from_proof_size(17055)) - // Standard Error: 45_995 - .saturating_add(Weight::from_ref_time(11_606_505).saturating_mul(r.into())) + // Measured: `869 + r * (240 ±0)` + // Estimated: `17215 + r * (1200 ±0)` + // Minimum execution time: 374_249 nanoseconds. + Weight::from_ref_time(377_990_998) + .saturating_add(Weight::from_proof_size(17215)) + // Standard Error: 38_133 + .saturating_add(Weight::from_ref_time(11_483_273).saturating_mul(r.into())) .saturating_add(RocksDbWeight::get().reads(6_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) .saturating_add(Weight::from_proof_size(1200).saturating_mul(r.into())) @@ -3741,7 +3745,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(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:1 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) /// Storage: Timestamp Now (r:1 w:0) @@ -3751,21 +3755,21 @@ impl WeightInfo for () { /// The range of component `r` is `[0, 20]`. fn seal_account_reentrance_count(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `2056 + r * (3153 ±0)` - // Estimated: `21730 + r * (15870 ±2)` - // Minimum execution time: 376_762 nanoseconds. - Weight::from_ref_time(396_934_359) - .saturating_add(Weight::from_proof_size(21730)) - // Standard Error: 68_263 - .saturating_add(Weight::from_ref_time(18_367_270).saturating_mul(r.into())) + // Measured: `2102 + r * (3154 ±0)` + // Estimated: `21980 + r * (15875 ±2)` + // Minimum execution time: 375_552 nanoseconds. + Weight::from_ref_time(400_624_032) + .saturating_add(Weight::from_proof_size(21980)) + // Standard Error: 82_523 + .saturating_add(Weight::from_ref_time(18_057_327).saturating_mul(r.into())) .saturating_add(RocksDbWeight::get().reads(6_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) - .saturating_add(Weight::from_proof_size(15870).saturating_mul(r.into())) + .saturating_add(Weight::from_proof_size(15875).saturating_mul(r.into())) } /// 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(258), added: 2733, mode: Measured) + /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured) /// Storage: Contracts CodeStorage (r:1 w:0) /// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured) /// Storage: Timestamp Now (r:1 w:0) @@ -3777,13 +3781,13 @@ impl WeightInfo for () { /// The range of component `r` is `[0, 20]`. fn seal_instantiation_nonce(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `840 + r * (240 ±0)` - // Estimated: `18405 + r * (1440 ±0)` - // Minimum execution time: 374_257 nanoseconds. - Weight::from_ref_time(380_453_380) - .saturating_add(Weight::from_proof_size(18405)) - // Standard Error: 42_718 - .saturating_add(Weight::from_ref_time(9_355_253).saturating_mul(r.into())) + // Measured: `872 + r * (240 ±0)` + // Estimated: `18598 + r * (1440 ±0)` + // Minimum execution time: 373_899 nanoseconds. + Weight::from_ref_time(379_733_943) + .saturating_add(Weight::from_proof_size(18598)) + // Standard Error: 32_022 + .saturating_add(Weight::from_ref_time(9_381_180).saturating_mul(r.into())) .saturating_add(RocksDbWeight::get().reads(7_u64)) .saturating_add(RocksDbWeight::get().writes(4_u64)) .saturating_add(Weight::from_proof_size(1440).saturating_mul(r.into())) @@ -3793,571 +3797,571 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 788 nanoseconds. - Weight::from_ref_time(1_209_829) + // Minimum execution time: 834 nanoseconds. + Weight::from_ref_time(1_009_646) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 3_436 - .saturating_add(Weight::from_ref_time(409_858).saturating_mul(r.into())) + // Standard Error: 388 + .saturating_add(Weight::from_ref_time(411_979).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64load(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 955 nanoseconds. - Weight::from_ref_time(1_526_327) + // Minimum execution time: 882 nanoseconds. + Weight::from_ref_time(1_416_377) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 2_399 - .saturating_add(Weight::from_ref_time(1_084_504).saturating_mul(r.into())) + // Standard Error: 1_133 + .saturating_add(Weight::from_ref_time(1_075_838).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64store(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 967 nanoseconds. - Weight::from_ref_time(1_576_183) + // Minimum execution time: 878 nanoseconds. + Weight::from_ref_time(1_343_056) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 5_719 - .saturating_add(Weight::from_ref_time(1_006_742).saturating_mul(r.into())) + // Standard Error: 426 + .saturating_add(Weight::from_ref_time(1_001_214).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_select(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 849 nanoseconds. - Weight::from_ref_time(1_106_539) + // Minimum execution time: 796 nanoseconds. + Weight::from_ref_time(1_079_086) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 445 - .saturating_add(Weight::from_ref_time(1_149_752).saturating_mul(r.into())) + // Standard Error: 409 + .saturating_add(Weight::from_ref_time(1_149_188).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_if(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 829 nanoseconds. - Weight::from_ref_time(1_171_360) + // Minimum execution time: 800 nanoseconds. + Weight::from_ref_time(1_044_184) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 552 - .saturating_add(Weight::from_ref_time(1_309_914).saturating_mul(r.into())) + // Standard Error: 707 + .saturating_add(Weight::from_ref_time(1_315_686).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_br(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 835 nanoseconds. - Weight::from_ref_time(1_125_578) + // Minimum execution time: 807 nanoseconds. + Weight::from_ref_time(1_049_633) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 374 - .saturating_add(Weight::from_ref_time(641_683).saturating_mul(r.into())) + // Standard Error: 361 + .saturating_add(Weight::from_ref_time(640_530).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_br_if(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 816 nanoseconds. - Weight::from_ref_time(1_032_093) + // Minimum execution time: 774 nanoseconds. + Weight::from_ref_time(1_124_053) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 811 - .saturating_add(Weight::from_ref_time(956_228).saturating_mul(r.into())) + // Standard Error: 784 + .saturating_add(Weight::from_ref_time(949_398).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_br_table(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 801 nanoseconds. - Weight::from_ref_time(816_764) + // Minimum execution time: 810 nanoseconds. + Weight::from_ref_time(676_581) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 2_669 - .saturating_add(Weight::from_ref_time(1_166_556).saturating_mul(r.into())) + // Standard Error: 2_356 + .saturating_add(Weight::from_ref_time(1_163_465).saturating_mul(r.into())) } /// The range of component `e` is `[1, 256]`. fn instr_br_table_per_entry(e: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_639 nanoseconds. - Weight::from_ref_time(2_905_554) + // Minimum execution time: 2_580 nanoseconds. + Weight::from_ref_time(2_835_656) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 62 - .saturating_add(Weight::from_ref_time(4_438).saturating_mul(e.into())) + // Standard Error: 71 + .saturating_add(Weight::from_ref_time(4_686).saturating_mul(e.into())) } /// The range of component `r` is `[0, 50]`. fn instr_call(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 831 nanoseconds. - Weight::from_ref_time(1_729_584) + // Minimum execution time: 826 nanoseconds. + Weight::from_ref_time(1_625_698) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 33_753 - .saturating_add(Weight::from_ref_time(2_380_315).saturating_mul(r.into())) + // Standard Error: 1_740 + .saturating_add(Weight::from_ref_time(2_332_187).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_call_indirect(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 964 nanoseconds. - Weight::from_ref_time(2_445_291) + // Minimum execution time: 901 nanoseconds. + Weight::from_ref_time(2_338_620) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 3_285 - .saturating_add(Weight::from_ref_time(2_938_681).saturating_mul(r.into())) + // Standard Error: 1_642 + .saturating_add(Weight::from_ref_time(2_924_090).saturating_mul(r.into())) } /// The range of component `p` is `[0, 128]`. fn instr_call_indirect_per_param(p: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 4_809 nanoseconds. - Weight::from_ref_time(6_763_286) + // Minimum execution time: 4_670 nanoseconds. + Weight::from_ref_time(5_556_246) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 3_994 - .saturating_add(Weight::from_ref_time(217_632).saturating_mul(p.into())) + // Standard Error: 1_491 + .saturating_add(Weight::from_ref_time(228_965).saturating_mul(p.into())) } /// The range of component `l` is `[0, 1024]`. fn instr_call_per_local(l: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 3_138 nanoseconds. - Weight::from_ref_time(3_894_816) + // Minimum execution time: 3_099 nanoseconds. + Weight::from_ref_time(3_896_177) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 131 - .saturating_add(Weight::from_ref_time(91_699).saturating_mul(l.into())) + // Standard Error: 99 + .saturating_add(Weight::from_ref_time(91_304).saturating_mul(l.into())) } /// The range of component `r` is `[0, 50]`. fn instr_local_get(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_959 nanoseconds. - Weight::from_ref_time(3_271_550) + // Minimum execution time: 3_042 nanoseconds. + Weight::from_ref_time(3_334_621) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 223 - .saturating_add(Weight::from_ref_time(460_056).saturating_mul(r.into())) + // Standard Error: 793 + .saturating_add(Weight::from_ref_time(459_346).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_local_set(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_970 nanoseconds. - Weight::from_ref_time(3_216_157) + // Minimum execution time: 2_968 nanoseconds. + Weight::from_ref_time(3_235_286) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 413 - .saturating_add(Weight::from_ref_time(485_842).saturating_mul(r.into())) + // Standard Error: 427 + .saturating_add(Weight::from_ref_time(485_454).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_local_tee(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_980 nanoseconds. - Weight::from_ref_time(3_323_878) + // Minimum execution time: 3_012 nanoseconds. + Weight::from_ref_time(3_303_555) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 2_652 - .saturating_add(Weight::from_ref_time(660_257).saturating_mul(r.into())) + // Standard Error: 371 + .saturating_add(Weight::from_ref_time(657_811).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_global_get(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 917 nanoseconds. - Weight::from_ref_time(1_445_816) + // Minimum execution time: 865 nanoseconds. + Weight::from_ref_time(1_249_987) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 5_642 - .saturating_add(Weight::from_ref_time(894_521).saturating_mul(r.into())) + // Standard Error: 417 + .saturating_add(Weight::from_ref_time(896_704).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_global_set(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 965 nanoseconds. - Weight::from_ref_time(1_373_722) + // Minimum execution time: 866 nanoseconds. + Weight::from_ref_time(1_216_218) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 1_157 - .saturating_add(Weight::from_ref_time(917_643).saturating_mul(r.into())) + // Standard Error: 503 + .saturating_add(Weight::from_ref_time(919_719).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_memory_current(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 982 nanoseconds. - Weight::from_ref_time(1_240_280) + // Minimum execution time: 921 nanoseconds. + Weight::from_ref_time(1_228_408) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 308 - .saturating_add(Weight::from_ref_time(817_972).saturating_mul(r.into())) + // Standard Error: 309 + .saturating_add(Weight::from_ref_time(813_007).saturating_mul(r.into())) } /// The range of component `r` is `[0, 1]`. fn instr_memory_grow(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 858 nanoseconds. - Weight::from_ref_time(962_183) + // Minimum execution time: 820 nanoseconds. + Weight::from_ref_time(914_830) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 6_701 - .saturating_add(Weight::from_ref_time(239_704_216).saturating_mul(r.into())) + // Standard Error: 6_018 + .saturating_add(Weight::from_ref_time(237_062_769).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64clz(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 807 nanoseconds. - Weight::from_ref_time(1_132_872) + // Minimum execution time: 812 nanoseconds. + Weight::from_ref_time(1_554_406) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 303 - .saturating_add(Weight::from_ref_time(633_832).saturating_mul(r.into())) + // Standard Error: 9_979 + .saturating_add(Weight::from_ref_time(625_434).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64ctz(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 823 nanoseconds. - Weight::from_ref_time(1_267_518) + // Minimum execution time: 798 nanoseconds. + Weight::from_ref_time(1_095_113) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 483 - .saturating_add(Weight::from_ref_time(632_620).saturating_mul(r.into())) + // Standard Error: 243 + .saturating_add(Weight::from_ref_time(634_204).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64popcnt(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 857 nanoseconds. - Weight::from_ref_time(1_105_214) + // Minimum execution time: 792 nanoseconds. + Weight::from_ref_time(1_109_845) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 285 - .saturating_add(Weight::from_ref_time(635_039).saturating_mul(r.into())) + // Standard Error: 14_944 + .saturating_add(Weight::from_ref_time(658_834).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64eqz(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 821 nanoseconds. - Weight::from_ref_time(750_223) + // Minimum execution time: 815 nanoseconds. + Weight::from_ref_time(1_068_916) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 15_923 - .saturating_add(Weight::from_ref_time(686_322).saturating_mul(r.into())) + // Standard Error: 327 + .saturating_add(Weight::from_ref_time(652_897).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64extendsi32(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 797 nanoseconds. - Weight::from_ref_time(1_145_072) + // Minimum execution time: 798 nanoseconds. + Weight::from_ref_time(1_069_745) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 311 - .saturating_add(Weight::from_ref_time(618_147).saturating_mul(r.into())) + // Standard Error: 306 + .saturating_add(Weight::from_ref_time(618_481).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64extendui32(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 803 nanoseconds. - Weight::from_ref_time(1_139_498) + // Minimum execution time: 799 nanoseconds. + Weight::from_ref_time(1_398_001) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 284 - .saturating_add(Weight::from_ref_time(617_393).saturating_mul(r.into())) + // Standard Error: 6_234 + .saturating_add(Weight::from_ref_time(611_399).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i32wrapi64(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 814 nanoseconds. - Weight::from_ref_time(1_099_405) + // Minimum execution time: 811 nanoseconds. + Weight::from_ref_time(1_098_083) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 663 - .saturating_add(Weight::from_ref_time(618_565).saturating_mul(r.into())) + // Standard Error: 297 + .saturating_add(Weight::from_ref_time(617_692).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64eq(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 819 nanoseconds. - Weight::from_ref_time(1_199_220) + // Minimum execution time: 815 nanoseconds. + Weight::from_ref_time(1_046_922) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 485 - .saturating_add(Weight::from_ref_time(906_878).saturating_mul(r.into())) + // Standard Error: 335 + .saturating_add(Weight::from_ref_time(909_196).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64ne(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 822 nanoseconds. - Weight::from_ref_time(274_212) + // Minimum execution time: 805 nanoseconds. + Weight::from_ref_time(1_093_667) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 29_294 - .saturating_add(Weight::from_ref_time(971_608).saturating_mul(r.into())) + // Standard Error: 233 + .saturating_add(Weight::from_ref_time(907_378).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64lts(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 796 nanoseconds. - Weight::from_ref_time(1_396_586) + // Minimum execution time: 805 nanoseconds. + Weight::from_ref_time(1_290_591) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 7_205 - .saturating_add(Weight::from_ref_time(903_202).saturating_mul(r.into())) + // Standard Error: 3_201 + .saturating_add(Weight::from_ref_time(902_006).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64ltu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 833 nanoseconds. - Weight::from_ref_time(1_115_115) + // Minimum execution time: 783 nanoseconds. + Weight::from_ref_time(1_159_977) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 310 - .saturating_add(Weight::from_ref_time(908_195).saturating_mul(r.into())) + // Standard Error: 2_310 + .saturating_add(Weight::from_ref_time(906_489).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64gts(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 854 nanoseconds. - Weight::from_ref_time(1_170_419) + // Minimum execution time: 790 nanoseconds. + Weight::from_ref_time(1_109_719) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 298 - .saturating_add(Weight::from_ref_time(907_171).saturating_mul(r.into())) + // Standard Error: 261 + .saturating_add(Weight::from_ref_time(906_614).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64gtu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 822 nanoseconds. - Weight::from_ref_time(1_186_349) + // Minimum execution time: 776 nanoseconds. + Weight::from_ref_time(1_076_567) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 302 - .saturating_add(Weight::from_ref_time(917_857).saturating_mul(r.into())) + // Standard Error: 348 + .saturating_add(Weight::from_ref_time(919_374).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64les(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 807 nanoseconds. - Weight::from_ref_time(1_127_093) + // Minimum execution time: 780 nanoseconds. + Weight::from_ref_time(1_069_663) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 1_891 - .saturating_add(Weight::from_ref_time(910_738).saturating_mul(r.into())) + // Standard Error: 265 + .saturating_add(Weight::from_ref_time(908_037).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64leu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 819 nanoseconds. - Weight::from_ref_time(1_143_022) + // Minimum execution time: 832 nanoseconds. + Weight::from_ref_time(930_920) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 309 - .saturating_add(Weight::from_ref_time(919_047).saturating_mul(r.into())) + // Standard Error: 2_170 + .saturating_add(Weight::from_ref_time(929_811).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64ges(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 788 nanoseconds. - Weight::from_ref_time(1_116_914) + // Minimum execution time: 787 nanoseconds. + Weight::from_ref_time(1_087_325) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 643 - .saturating_add(Weight::from_ref_time(911_159).saturating_mul(r.into())) + // Standard Error: 315 + .saturating_add(Weight::from_ref_time(908_321).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64geu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 791 nanoseconds. - Weight::from_ref_time(1_123_747) + // Minimum execution time: 798 nanoseconds. + Weight::from_ref_time(1_029_132) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 583 - .saturating_add(Weight::from_ref_time(910_242).saturating_mul(r.into())) + // Standard Error: 2_095 + .saturating_add(Weight::from_ref_time(913_553).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64add(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 787 nanoseconds. - Weight::from_ref_time(1_109_471) + // Minimum execution time: 791 nanoseconds. + Weight::from_ref_time(1_086_314) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 305 - .saturating_add(Weight::from_ref_time(897_608).saturating_mul(r.into())) + // Standard Error: 197 + .saturating_add(Weight::from_ref_time(896_392).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64sub(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 821 nanoseconds. - Weight::from_ref_time(1_098_631) + // Minimum execution time: 793 nanoseconds. + Weight::from_ref_time(1_078_172) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 523 - .saturating_add(Weight::from_ref_time(887_814).saturating_mul(r.into())) + // Standard Error: 404 + .saturating_add(Weight::from_ref_time(886_329).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64mul(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 794 nanoseconds. - Weight::from_ref_time(1_166_332) + // Minimum execution time: 799 nanoseconds. + Weight::from_ref_time(1_095_010) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 384 - .saturating_add(Weight::from_ref_time(885_584).saturating_mul(r.into())) + // Standard Error: 431 + .saturating_add(Weight::from_ref_time(886_513).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64divs(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 822 nanoseconds. - Weight::from_ref_time(1_155_826) + // Minimum execution time: 810 nanoseconds. + Weight::from_ref_time(1_114_325) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 521 - .saturating_add(Weight::from_ref_time(1_520_958).saturating_mul(r.into())) + // Standard Error: 452 + .saturating_add(Weight::from_ref_time(1_521_849).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64divu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 881 nanoseconds. - Weight::from_ref_time(1_158_125) + // Minimum execution time: 784 nanoseconds. + Weight::from_ref_time(1_123_153) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 624 - .saturating_add(Weight::from_ref_time(1_458_378).saturating_mul(r.into())) + // Standard Error: 475 + .saturating_add(Weight::from_ref_time(1_457_746).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64rems(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 827 nanoseconds. - Weight::from_ref_time(1_209_535) + // Minimum execution time: 809 nanoseconds. + Weight::from_ref_time(1_145_906) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 399 - .saturating_add(Weight::from_ref_time(1_547_640).saturating_mul(r.into())) + // Standard Error: 718 + .saturating_add(Weight::from_ref_time(1_549_964).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64remu(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 801 nanoseconds. - Weight::from_ref_time(1_313_872) + // Minimum execution time: 803 nanoseconds. + Weight::from_ref_time(1_110_328) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 2_175 - .saturating_add(Weight::from_ref_time(1_449_416).saturating_mul(r.into())) + // Standard Error: 627 + .saturating_add(Weight::from_ref_time(1_453_013).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64and(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 827 nanoseconds. - Weight::from_ref_time(1_093_874) + // Minimum execution time: 786 nanoseconds. + Weight::from_ref_time(1_108_792) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 708 - .saturating_add(Weight::from_ref_time(901_450).saturating_mul(r.into())) + // Standard Error: 286 + .saturating_add(Weight::from_ref_time(897_035).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64or(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 824 nanoseconds. - Weight::from_ref_time(1_164_076) + // Minimum execution time: 787 nanoseconds. + Weight::from_ref_time(830_000) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 623 - .saturating_add(Weight::from_ref_time(897_579).saturating_mul(r.into())) + // Standard Error: 15_995 + .saturating_add(Weight::from_ref_time(963_344).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64xor(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 789 nanoseconds. - Weight::from_ref_time(1_113_915) + // Minimum execution time: 773 nanoseconds. + Weight::from_ref_time(1_082_459) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 390 - .saturating_add(Weight::from_ref_time(897_354).saturating_mul(r.into())) + // Standard Error: 330 + .saturating_add(Weight::from_ref_time(897_077).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64shl(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 811 nanoseconds. - Weight::from_ref_time(1_117_366) + // Minimum execution time: 810 nanoseconds. + Weight::from_ref_time(1_325_815) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 437 - .saturating_add(Weight::from_ref_time(903_759).saturating_mul(r.into())) + // Standard Error: 3_352 + .saturating_add(Weight::from_ref_time(899_555).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64shrs(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 846 nanoseconds. - Weight::from_ref_time(1_103_954) + // Minimum execution time: 808 nanoseconds. + Weight::from_ref_time(1_085_903) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 414 - .saturating_add(Weight::from_ref_time(903_429).saturating_mul(r.into())) + // Standard Error: 430 + .saturating_add(Weight::from_ref_time(903_249).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64shru(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 803 nanoseconds. - Weight::from_ref_time(1_124_328) + // Minimum execution time: 792 nanoseconds. + Weight::from_ref_time(1_091_261) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 410 - .saturating_add(Weight::from_ref_time(903_216).saturating_mul(r.into())) + // Standard Error: 312 + .saturating_add(Weight::from_ref_time(902_245).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64rotl(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 810 nanoseconds. - Weight::from_ref_time(1_131_433) + // Minimum execution time: 807 nanoseconds. + Weight::from_ref_time(1_121_052) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 402 - .saturating_add(Weight::from_ref_time(903_381).saturating_mul(r.into())) + // Standard Error: 506 + .saturating_add(Weight::from_ref_time(902_772).saturating_mul(r.into())) } /// The range of component `r` is `[0, 50]`. fn instr_i64rotr(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 807 nanoseconds. - Weight::from_ref_time(1_144_933) + // Minimum execution time: 823 nanoseconds. + Weight::from_ref_time(1_317_597) .saturating_add(Weight::from_proof_size(0)) - // Standard Error: 373 - .saturating_add(Weight::from_ref_time(902_918).saturating_mul(r.into())) + // Standard Error: 6_219 + .saturating_add(Weight::from_ref_time(896_692).saturating_mul(r.into())) } }