From 0de97130fb15b4026ae353e434f0960f1325764f Mon Sep 17 00:00:00 2001 From: pgherveou Date: Mon, 22 Apr 2024 10:39:25 +0200 Subject: [PATCH 01/34] wip --- .../frame/contracts/proc-macro/src/lib.rs | 144 +++++++++++++----- .../src/benchmarking/call_builder.rs | 10 ++ .../frame/contracts/src/benchmarking/mod.rs | 21 +++ substrate/frame/contracts/src/wasm/mod.rs | 3 + 4 files changed, 138 insertions(+), 40 deletions(-) diff --git a/substrate/frame/contracts/proc-macro/src/lib.rs b/substrate/frame/contracts/proc-macro/src/lib.rs index 1794d09d5ad2..454d1881b594 100644 --- a/substrate/frame/contracts/proc-macro/src/lib.rs +++ b/substrate/frame/contracts/proc-macro/src/lib.rs @@ -528,8 +528,9 @@ fn expand_env(def: &EnvDef, docs: bool) -> TokenStream2 { /// - real implementation, to register it in the contract execution environment; /// - dummy implementation, to be used as mocks for contract validation step. fn expand_impls(def: &EnvDef) -> TokenStream2 { - let impls = expand_functions(def, true, quote! { crate::wasm::Runtime }); - let dummy_impls = expand_functions(def, false, quote! { () }); + let impls = expand_functions(def, ExpandMode::Impl); + let dummy_impls = expand_functions(def, ExpandMode::MockImpl); + let bench_impls = expand_functions(def, ExpandMode::BenchImpl); quote! { impl<'a, E: Ext> crate::wasm::Environment> for Env @@ -545,6 +546,14 @@ fn expand_impls(def: &EnvDef) -> TokenStream2 { } } + #[cfg(feature = "runtime-benchmarks")] + pub struct BenchEnv(::core::marker::PhantomData); + + #[cfg(feature = "runtime-benchmarks")] + impl BenchEnv { + #bench_impls + } + impl crate::wasm::Environment<()> for Env { fn define( @@ -560,7 +569,29 @@ fn expand_impls(def: &EnvDef) -> TokenStream2 { } } -fn expand_functions(def: &EnvDef, expand_blocks: bool, host_state: TokenStream2) -> TokenStream2 { +enum ExpandMode { + Impl, + BenchImpl, + MockImpl, +} + +impl ExpandMode { + fn expand_blocks(&self) -> bool { + match *self { + ExpandMode::Impl | ExpandMode::BenchImpl => true, + ExpandMode::MockImpl => false, + } + } + + fn host_state(&self) -> TokenStream2 { + match *self { + ExpandMode::Impl | ExpandMode::BenchImpl => quote! { crate::wasm::runtime::Runtime }, + ExpandMode::MockImpl => quote! { () }, + } + } +} + +fn expand_functions(def: &EnvDef, expand_mode: ExpandMode) -> TokenStream2 { let impls = def.host_funcs.iter().map(|f| { // skip the context and memory argument let params = f.item.sig.inputs.iter().skip(2); @@ -608,23 +639,34 @@ fn expand_functions(def: &EnvDef, expand_blocks: bool, host_state: TokenStream2) // - We replace any code by unreachable! // - Allow unused variables as the code that uses is not expanded // - We don't need to map the error as we simply panic if they code would ever be executed - let inner = if expand_blocks { - quote! { || #output { - let (memory, ctx) = __caller__ - .data() - .memory() - .expect("Memory must be set when setting up host data; qed") - .data_and_store_mut(&mut __caller__); - #wrapped_body_with_trace - } } - } else { - quote! { || -> #wasm_output { - // This is part of the implementation for `Environment<()>` which is not - // meant to be actually executed. It is only for validation which will - // never call host functions. - ::core::unreachable!() - } } + let expand_blocks = expand_mode.expand_blocks(); + let inner = match expand_mode { + ExpandMode::Impl => { + quote! { || #output { + let (memory, ctx) = __caller__ + .data() + .memory() + .expect("Memory must be set when setting up host data; qed") + .data_and_store_mut(&mut __caller__); + #wrapped_body_with_trace + } } + }, + ExpandMode::BenchImpl => { + let body = &body.stmts; + quote!{ + #(#body)* + } + }, + ExpandMode::MockImpl => { + quote! { || -> #wasm_output { + // This is part of the implementation for `Environment<()>` which is not + // meant to be actually executed. It is only for validation which will + // never call host functions. + ::core::unreachable!() + } } + }, }; + let into_host = if expand_blocks { quote! { |reason| { @@ -676,29 +718,51 @@ fn expand_functions(def: &EnvDef, expand_blocks: bool, host_state: TokenStream2) quote! { } }; - quote! { - // We need to allow all interfaces when runtime benchmarks are performed because - // we generate the weights even when those interfaces are not enabled. This - // is necessary as the decision whether we allow unstable or deprecated functions - // is a decision made at runtime. Generation of the weights happens statically. - if ::core::cfg!(feature = "runtime-benchmarks") || - ((#is_stable || __allow_unstable__) && (#not_deprecated || __allow_deprecated__)) - { - #allow_unused - linker.define(#module, #name, ::wasmi::Func::wrap(&mut*store, |mut __caller__: ::wasmi::Caller<#host_state>, #( #params, )*| -> #wasm_output { - #sync_gas_before - let mut func = #inner; - let result = func().map_err(#into_host).map(::core::convert::Into::into); - #sync_gas_after - result - }))?; - } + + match expand_mode { + ExpandMode::BenchImpl => { + let name = Ident::new(&format!("{module}_{name}"), Span::call_site()); + quote! { + pub fn #name(ctx: &mut crate::wasm::Runtime, memory: &mut [u8], #(#params),*) #output { + #inner + } + } + }, + _ => { + let host_state = expand_mode.host_state(); + quote! { + // We need to allow all interfaces when runtime benchmarks are performed because + // we generate the weights even when those interfaces are not enabled. This + // is necessary as the decision whether we allow unstable or deprecated functions + // is a decision made at runtime. Generation of the weights happens statically. + if ::core::cfg!(feature = "runtime-benchmarks") || + ((#is_stable || __allow_unstable__) && (#not_deprecated || __allow_deprecated__)) + { + #allow_unused + linker.define(#module, #name, ::wasmi::Func::wrap(&mut*store, |mut __caller__: ::wasmi::Caller<#host_state>, #( #params, )*| -> #wasm_output { + #sync_gas_before + let mut func = #inner; + let result = func().map_err(#into_host).map(::core::convert::Into::into); + #sync_gas_after + result + }))?; + } + } + }, } }); - quote! { - let __allow_unstable__ = matches!(allow_unstable, AllowUnstableInterface::Yes); - let __allow_deprecated__ = matches!(allow_deprecated, AllowDeprecatedInterface::Yes); - #( #impls )* + + match expand_mode { + ExpandMode::BenchImpl => { + quote! { + #( #impls )* + } + }, + _ => quote! { + let __allow_unstable__ = matches!(allow_unstable, AllowUnstableInterface::Yes); + let __allow_deprecated__ = matches!(allow_deprecated, AllowDeprecatedInterface::Yes); + #( #impls )* + }, } } diff --git a/substrate/frame/contracts/src/benchmarking/call_builder.rs b/substrate/frame/contracts/src/benchmarking/call_builder.rs index 285fe0052b4d..ccb849cba1f4 100644 --- a/substrate/frame/contracts/src/benchmarking/call_builder.rs +++ b/substrate/frame/contracts/src/benchmarking/call_builder.rs @@ -57,6 +57,16 @@ pub struct CallSetup { data: Vec, } +impl Default for CallSetup +where + T: Config + pallet_balances::Config, + as HasCompact>::Type: Clone + Eq + PartialEq + Debug + TypeInfo + Encode, +{ + fn default() -> Self { + Self::new(WasmModule::dummy()) + } +} + impl CallSetup where T: Config + pallet_balances::Config, diff --git a/substrate/frame/contracts/src/benchmarking/mod.rs b/substrate/frame/contracts/src/benchmarking/mod.rs index 676fd320a172..5b20713c0cee 100644 --- a/substrate/frame/contracts/src/benchmarking/mod.rs +++ b/substrate/frame/contracts/src/benchmarking/mod.rs @@ -629,6 +629,27 @@ mod benchmarks { } } + #[benchmark(pov_mode = Measured)] + fn seal_caller_2() { + let mut setup = CallSetup::::default(); + let (mut ext, _) = setup.ext(); + let mut runtime = crate::wasm::Runtime::new(&mut ext, vec![]); + let mut memory = [0u8; 36]; + memory[0..4].copy_from_slice(&32u32.to_le_bytes()); + + let result; + #[block] + { + result = crate::wasm::BenchEnv::seal0_caller(&mut runtime, &mut memory, 4, 0); + } + + frame_support::assert_ok!(result); + assert_eq!( + ::decode(&mut &memory[4..]).unwrap(), + ext.caller().account_id().unwrap().clone() + ); + } + #[benchmark(pov_mode = Measured)] fn seal_is_contract(r: Linear<0, API_BENCHMARK_RUNS>) { let accounts = (0..r).map(|n| account::("account", n, 0)).collect::>(); diff --git a/substrate/frame/contracts/src/wasm/mod.rs b/substrate/frame/contracts/src/wasm/mod.rs index 8d7f928dba33..a8ec935b6ecb 100644 --- a/substrate/frame/contracts/src/wasm/mod.rs +++ b/substrate/frame/contracts/src/wasm/mod.rs @@ -31,6 +31,9 @@ pub use { tests::MockExt, }; +#[cfg(feature = "runtime-benchmarks")] +pub use crate::wasm::runtime::BenchEnv; + pub use crate::wasm::{ prepare::{LoadedModule, LoadingMode}, runtime::{ From d4ab2a811f862ea77cd650399af4c93774558e85 Mon Sep 17 00:00:00 2001 From: pgherveou Date: Mon, 22 Apr 2024 20:31:54 +0200 Subject: [PATCH 02/34] wip --- .../frame/contracts/proc-macro/src/lib.rs | 33 +++++++---- .../src/benchmarking/call_builder.rs | 10 ++++ .../frame/contracts/src/benchmarking/code.rs | 30 ++++++++++ .../frame/contracts/src/benchmarking/mod.rs | 58 ++++++------------- substrate/frame/contracts/src/wasm/runtime.rs | 7 +++ 5 files changed, 85 insertions(+), 53 deletions(-) diff --git a/substrate/frame/contracts/proc-macro/src/lib.rs b/substrate/frame/contracts/proc-macro/src/lib.rs index 454d1881b594..2bb1bbcc4caf 100644 --- a/substrate/frame/contracts/proc-macro/src/lib.rs +++ b/substrate/frame/contracts/proc-macro/src/lib.rs @@ -132,6 +132,7 @@ struct HostFn { alias_to: Option, /// Formulating the predicate inverted makes the expression using it simpler. not_deprecated: bool, + cfg: Option, } enum HostFnReturn { @@ -163,13 +164,13 @@ impl ToTokens for HostFn { impl HostFn { pub fn try_from(mut item: syn::ItemFn) -> syn::Result { let err = |span, msg| { - let msg = format!("Invalid host function definition. {}", msg); + let msg = format!("Invalid host function definition.\n{}", msg); syn::Error::new(span, msg) }; // process attributes let msg = - "only #[version()], #[unstable], #[prefixed_alias] and #[deprecated] attributes are allowed."; + "Only #[version()], #[unstable], #[prefixed_alias] and #[deprecated] attributes are allowed."; let span = item.span(); let mut attrs = item.attrs.clone(); attrs.retain(|a| !a.path().is_ident("doc")); @@ -177,6 +178,7 @@ impl HostFn { let mut is_stable = true; let mut alias_to = None; let mut not_deprecated = true; + let mut cfg = None; while let Some(attr) = attrs.pop() { let ident = attr.path().get_ident().ok_or(err(span, msg))?.to_string(); match ident.as_str() { @@ -206,7 +208,13 @@ impl HostFn { } not_deprecated = false; }, - _ => return Err(err(span, msg)), + "cfg" => { + if cfg.is_some() { + return Err(err(span, "#[cfg] can only be specified once")) + } + cfg = Some(attr); + }, + id => return Err(err(span, &format!("Unsupported attribute \"{id}\". {msg}"))), } } let name = item.sig.ident.to_string(); @@ -311,6 +319,7 @@ impl HostFn { is_stable, alias_to, not_deprecated, + cfg, }) }, _ => Err(err(span, &msg)), @@ -532,6 +541,8 @@ fn expand_impls(def: &EnvDef) -> TokenStream2 { let dummy_impls = expand_functions(def, ExpandMode::MockImpl); let bench_impls = expand_functions(def, ExpandMode::BenchImpl); + std::fs::write("/tmp/impls.rs", format!("{}", impls)).unwrap(); + quote! { impl<'a, E: Ext> crate::wasm::Environment> for Env { @@ -595,14 +606,12 @@ fn expand_functions(def: &EnvDef, expand_mode: ExpandMode) -> TokenStream2 { let impls = def.host_funcs.iter().map(|f| { // skip the context and memory argument let params = f.item.sig.inputs.iter().skip(2); - - let (module, name, body, wasm_output, output) = ( - f.module(), - &f.name, - &f.item.block, - f.returns.to_wasm_sig(), - &f.item.sig.output - ); + let module = f.module(); + let cfg = &f.cfg; + let name = &f.name; + let body = &f.item.block; + let wasm_output = f.returns.to_wasm_sig(); + let output = &f.item.sig.output; let is_stable = f.is_stable; let not_deprecated = f.not_deprecated; @@ -718,7 +727,6 @@ fn expand_functions(def: &EnvDef, expand_mode: ExpandMode) -> TokenStream2 { quote! { } }; - match expand_mode { ExpandMode::BenchImpl => { let name = Ident::new(&format!("{module}_{name}"), Span::call_site()); @@ -735,6 +743,7 @@ fn expand_functions(def: &EnvDef, expand_mode: ExpandMode) -> TokenStream2 { // we generate the weights even when those interfaces are not enabled. This // is necessary as the decision whether we allow unstable or deprecated functions // is a decision made at runtime. Generation of the weights happens statically. + #cfg if ::core::cfg!(feature = "runtime-benchmarks") || ((#is_stable || __allow_unstable__) && (#not_deprecated || __allow_deprecated__)) { diff --git a/substrate/frame/contracts/src/benchmarking/call_builder.rs b/substrate/frame/contracts/src/benchmarking/call_builder.rs index ccb849cba1f4..1b1200930430 100644 --- a/substrate/frame/contracts/src/benchmarking/call_builder.rs +++ b/substrate/frame/contracts/src/benchmarking/call_builder.rs @@ -178,3 +178,13 @@ macro_rules! call_builder( let $func = CallSetup::::prepare_call(&mut ext, module, data); }; ); + +#[macro_export] +macro_rules! build_runtime( + ($runtime:ident, $memory:ident: $val:expr) => { + let mut setup = CallSetup::::default(); + let (mut ext, _) = setup.ext(); + let mut $runtime = crate::wasm::Runtime::new(&mut ext, vec![]); + let mut $memory = $val.encode(); + }; +); diff --git a/substrate/frame/contracts/src/benchmarking/code.rs b/substrate/frame/contracts/src/benchmarking/code.rs index b97cf168e26d..a7a350514523 100644 --- a/substrate/frame/contracts/src/benchmarking/code.rs +++ b/substrate/frame/contracts/src/benchmarking/code.rs @@ -322,6 +322,36 @@ impl WasmModule { .into() } + /// TODO doc + pub fn noop(repeat: u32) -> Self { + let pages = max_pages::(); + ModuleDefinition { + memory: Some(ImportedMemory::max::()), + imported_functions: vec![ImportedFunction { + module: "seal0", + name: "noop", + params: vec![], + return_type: None, + }], + // Write the output buffer size. The output size will be overwritten by the + // supervisor with the real size when calling the getter. Since this size does not + // change between calls it suffices to start with an initial value and then just + // leave as whatever value was written there. + data_segments: vec![DataSegment { + offset: 0, + value: (pages * 64 * 1024 - 4).to_le_bytes().to_vec(), + }], + call_body: Some(body::repeated( + repeat, + &[ + Instruction::Call(0), // call the imported function + ], + )), + ..Default::default() + } + .into() + } + /// Creates a wasm module that calls the imported hash function named `name` `repeat` times /// with an input of size `data_size`. Hash functions have the signature /// (input_ptr: u32, input_len: u32, output_ptr: u32) -> () diff --git a/substrate/frame/contracts/src/benchmarking/mod.rs b/substrate/frame/contracts/src/benchmarking/mod.rs index 5b20713c0cee..64cf4c82ea44 100644 --- a/substrate/frame/contracts/src/benchmarking/mod.rs +++ b/substrate/frame/contracts/src/benchmarking/mod.rs @@ -39,7 +39,7 @@ use crate::{ use codec::{Encode, MaxEncodedLen}; use frame_benchmarking::v2::*; use frame_support::{ - self, + self, assert_ok, pallet_prelude::StorageVersion, traits::{fungible::InspectHold, Currency}, weights::{Weight, WeightMeter}, @@ -621,8 +621,8 @@ mod benchmarks { } #[benchmark(pov_mode = Measured)] - fn seal_caller(r: Linear<0, API_BENCHMARK_RUNS>) { - call_builder!(func, WasmModule::getter("seal0", "seal_caller", r)); + fn call_noop_host_fn(r: Linear<0, API_BENCHMARK_RUNS>) { + call_builder!(func, WasmModule::noop(r)); #[block] { func.call(); @@ -630,12 +630,8 @@ mod benchmarks { } #[benchmark(pov_mode = Measured)] - fn seal_caller_2() { - let mut setup = CallSetup::::default(); - let (mut ext, _) = setup.ext(); - let mut runtime = crate::wasm::Runtime::new(&mut ext, vec![]); - let mut memory = [0u8; 36]; - memory[0..4].copy_from_slice(&32u32.to_le_bytes()); + fn seal_caller() { + build_runtime!(runtime, memory: (32u32, [0u8; 32])); let result; #[block] @@ -643,47 +639,27 @@ mod benchmarks { result = crate::wasm::BenchEnv::seal0_caller(&mut runtime, &mut memory, 4, 0); } - frame_support::assert_ok!(result); + assert_ok!(result); assert_eq!( ::decode(&mut &memory[4..]).unwrap(), - ext.caller().account_id().unwrap().clone() + runtime.ext().caller().account_id().unwrap().clone() ); } #[benchmark(pov_mode = Measured)] - fn seal_is_contract(r: Linear<0, API_BENCHMARK_RUNS>) { - let accounts = (0..r).map(|n| account::("account", n, 0)).collect::>(); - let account_len = accounts.get(0).map(|i| i.encode().len()).unwrap_or(0); - let accounts_bytes = accounts.iter().flat_map(|a| a.encode()).collect::>(); - let code = WasmModule::::from(ModuleDefinition { - memory: Some(ImportedMemory::max::()), - imported_functions: vec![ImportedFunction { - module: "seal0", - name: "seal_is_contract", - params: vec![ValueType::I32], - return_type: Some(ValueType::I32), - }], - data_segments: vec![DataSegment { offset: 0, value: accounts_bytes }], - call_body: Some(body::repeated_dyn( - r, - vec![ - Counter(0, account_len as u32), // address_ptr - Regular(Instruction::Call(0)), - Regular(Instruction::Drop), - ], - )), - ..Default::default() - }); - call_builder!(func, instance, code); - let info = instance.info().unwrap(); - // every account would be a contract (worst case) - for acc in accounts.iter() { - >::insert(acc, info.clone()); - } + fn seal_is_contract() { + let Contract { account_id, .. } = + Contract::::with_index(1, WasmModule::dummy(), vec![]).unwrap(); + + build_runtime!(runtime, memory: account_id); + + let result; #[block] { - func.call(); + result = crate::wasm::BenchEnv::seal0_is_contract(&mut runtime, &mut memory, 0); } + + assert_eq!(result.unwrap(), 1); } #[benchmark(pov_mode = Measured)] diff --git a/substrate/frame/contracts/src/wasm/runtime.rs b/substrate/frame/contracts/src/wasm/runtime.rs index 28a08ab0224d..04e087c4107a 100644 --- a/substrate/frame/contracts/src/wasm/runtime.rs +++ b/substrate/frame/contracts/src/wasm/runtime.rs @@ -957,6 +957,13 @@ impl<'a, E: Ext + 'a> Runtime<'a, E> { // for every function. #[define_env(doc)] pub mod env { + + /// Noop function used to benchmark the time it takes to execute an empty function. + #[cfg(feature = "runtime-benchmarks")] + fn noop(ctx: _, memory: _) -> Result<(), TrapReason> { + Ok(()) + } + /// Set the value at the given key in the contract storage. /// See [`pallet_contracts_uapi::HostFn::set_storage`] #[prefixed_alias] From ecedf8c72e6330f023d2499d28b0f7a595815547 Mon Sep 17 00:00:00 2001 From: pgherveou Date: Mon, 22 Apr 2024 21:15:57 +0200 Subject: [PATCH 03/34] wip --- .../src/benchmarking/call_builder.rs | 4 ++ .../frame/contracts/src/benchmarking/mod.rs | 67 +++++++++++++------ 2 files changed, 52 insertions(+), 19 deletions(-) diff --git a/substrate/frame/contracts/src/benchmarking/call_builder.rs b/substrate/frame/contracts/src/benchmarking/call_builder.rs index 1b1200930430..d94a42b8404b 100644 --- a/substrate/frame/contracts/src/benchmarking/call_builder.rs +++ b/substrate/frame/contracts/src/benchmarking/call_builder.rs @@ -182,7 +182,11 @@ macro_rules! call_builder( #[macro_export] macro_rules! build_runtime( ($runtime:ident, $memory:ident: $val:expr) => { + $crate::build_runtime!($runtime, _contract, $memory: $val); + }; + ($runtime:ident, $contract:ident, $memory:ident: $val:expr) => { let mut setup = CallSetup::::default(); + let $contract = setup.contract(); let (mut ext, _) = setup.ext(); let mut $runtime = crate::wasm::Runtime::new(&mut ext, vec![]); let mut $memory = $val.encode(); diff --git a/substrate/frame/contracts/src/benchmarking/mod.rs b/substrate/frame/contracts/src/benchmarking/mod.rs index 64cf4c82ea44..f322ac03adba 100644 --- a/substrate/frame/contracts/src/benchmarking/mod.rs +++ b/substrate/frame/contracts/src/benchmarking/mod.rs @@ -34,6 +34,7 @@ use crate::{ migration::{ codegen::LATEST_MIGRATION_VERSION, v09, v10, v11, v12, v13, v14, v15, v16, MigrationStep, }, + wasm::BenchEnv, Pallet as Contracts, *, }; use codec::{Encode, MaxEncodedLen}; @@ -636,7 +637,7 @@ mod benchmarks { let result; #[block] { - result = crate::wasm::BenchEnv::seal0_caller(&mut runtime, &mut memory, 4, 0); + result = BenchEnv::seal0_caller(&mut runtime, &mut memory, 4, 0); } assert_ok!(result); @@ -656,7 +657,7 @@ mod benchmarks { let result; #[block] { - result = crate::wasm::BenchEnv::seal0_is_contract(&mut runtime, &mut memory, 0); + result = BenchEnv::seal0_is_contract(&mut runtime, &mut memory, 0); } assert_eq!(result.unwrap(), 1); @@ -707,12 +708,19 @@ mod benchmarks { } #[benchmark(pov_mode = Measured)] - fn seal_own_code_hash(r: Linear<0, API_BENCHMARK_RUNS>) { - call_builder!(func, WasmModule::getter("seal0", "seal_own_code_hash", r)); + fn seal_own_code_hash() { + build_runtime!(runtime, contract, memory: (32u32, [0u8; 32])); + let result; #[block] { - func.call(); + result = BenchEnv::seal0_own_code_hash(&mut runtime, &mut memory, 4, 0); } + + assert_ok!(result); + assert_eq!( + as Decode>::decode(&mut &memory[4..]).unwrap(), + contract.info().unwrap().code_hash + ); } #[benchmark(pov_mode = Measured)] @@ -758,48 +766,69 @@ mod benchmarks { } #[benchmark(pov_mode = Measured)] - fn seal_address(r: Linear<0, API_BENCHMARK_RUNS>) { - call_builder!(func, WasmModule::getter("seal0", "seal_address", r)); + fn seal_address() { + build_runtime!(runtime, contract, memory: (32u32, [0u8; 32])); + let result; #[block] { - func.call(); + result = BenchEnv::seal0_address(&mut runtime, &mut memory, 4, 0); } + assert_ok!(result); + assert_eq!( + ::decode(&mut &memory[4..]).unwrap(), + contract.account_id + ); } #[benchmark(pov_mode = Measured)] - fn seal_gas_left(r: Linear<0, API_BENCHMARK_RUNS>) { - call_builder!(func, WasmModule::getter("seal1", "gas_left", r)); + fn seal_gas_left() { + build_runtime!(runtime, memory: (32u32, [0u8; 32])); + let result; #[block] { - func.call(); + result = BenchEnv::seal1_gas_left(&mut runtime, &mut memory, 4, 0); } + assert_ok!(result); + assert_ok!(::decode(&mut &memory[4..])); } #[benchmark(pov_mode = Measured)] - fn seal_balance(r: Linear<0, API_BENCHMARK_RUNS>) { - call_builder!(func, WasmModule::getter("seal0", "seal_balance", r)); + fn seal_balance() { + let out_ptr = ::max_encoded_len() as u32; + build_runtime!(runtime, memory: (out_ptr, T::Balance::default())); + let result; #[block] { - func.call(); + result = BenchEnv::seal0_seal_balance(&mut runtime, &mut memory, 4, 0); } + assert_ok!(result); + assert_ok!(::decode(&mut &memory[4..])); } #[benchmark(pov_mode = Measured)] - fn seal_value_transferred(r: Linear<0, API_BENCHMARK_RUNS>) { - call_builder!(func, WasmModule::getter("seal0", "seal_value_transferred", r)); + fn seal_value_transferred() { + let out_ptr = ::max_encoded_len() as u32; + build_runtime!(runtime, memory: (out_ptr, T::Balance::default())); + let result; #[block] { - func.call(); + result = BenchEnv::seal0_value_transferred(&mut runtime, &mut memory, 4, 0); } + assert_ok!(result); + assert_ok!(::decode(&mut &memory[4..])); } #[benchmark(pov_mode = Measured)] fn seal_minimum_balance(r: Linear<0, API_BENCHMARK_RUNS>) { - call_builder!(func, WasmModule::getter("seal0", "seal_minimum_balance", r)); + let out_ptr = ::max_encoded_len() as u32; + build_runtime!(runtime, memory: (out_ptr, T::Balance::default())); + let result; #[block] { - func.call(); + result = BenchEnv::seal0_minimum_balance(&mut runtime, &mut memory, 4, 0); } + assert_ok!(result); + assert_ok!(::decode(&mut &memory[4..])); } #[benchmark(pov_mode = Measured)] From f2152fe12a442d8eee36001ba7268203a7f089bd Mon Sep 17 00:00:00 2001 From: pgherveou Date: Tue, 23 Apr 2024 22:02:08 +0200 Subject: [PATCH 04/34] wip --- .../src/benchmarking/call_builder.rs | 17 +- .../frame/contracts/src/benchmarking/code.rs | 36 +- .../frame/contracts/src/benchmarking/mod.rs | 845 +++++------------- substrate/frame/contracts/src/exec.rs | 4 +- substrate/frame/contracts/src/wasm/mod.rs | 2 +- 5 files changed, 235 insertions(+), 669 deletions(-) diff --git a/substrate/frame/contracts/src/benchmarking/call_builder.rs b/substrate/frame/contracts/src/benchmarking/call_builder.rs index d94a42b8404b..c69c329ebbf7 100644 --- a/substrate/frame/contracts/src/benchmarking/call_builder.rs +++ b/substrate/frame/contracts/src/benchmarking/call_builder.rs @@ -181,14 +181,23 @@ macro_rules! call_builder( #[macro_export] macro_rules! build_runtime( - ($runtime:ident, $memory:ident: $val:expr) => { - $crate::build_runtime!($runtime, _contract, $memory: $val); + // ($runtime:ident, $memory:ident: $val:expr) => { + // $crate::build_runtime!($runtime, _contract, $memory: $val); + // }; + ($runtime:ident, $memory:ident: [$($segment:expr,)*]) => { + $crate::build_runtime!($runtime, _contract, $memory: [$($segment,)*]); }; - ($runtime:ident, $contract:ident, $memory:ident: $val:expr) => { + ($runtime:ident, $contract:ident, $memory:ident: [$($segment:expr,)*]) => { + $crate::build_runtime!($runtime, $contract); + let mut $memory = vec![] + .into_iter() + $(.chain($segment))* + .collect::>(); + }; + ($runtime:ident, $contract:ident) => { let mut setup = CallSetup::::default(); let $contract = setup.contract(); let (mut ext, _) = setup.ext(); let mut $runtime = crate::wasm::Runtime::new(&mut ext, vec![]); - let mut $memory = $val.encode(); }; ); diff --git a/substrate/frame/contracts/src/benchmarking/code.rs b/substrate/frame/contracts/src/benchmarking/code.rs index a7a350514523..987cc0263275 100644 --- a/substrate/frame/contracts/src/benchmarking/code.rs +++ b/substrate/frame/contracts/src/benchmarking/code.rs @@ -288,41 +288,7 @@ impl WasmModule { module.into() } - /// Creates a wasm module that calls the imported function named `getter_name` `repeat` - /// times. The imported function is expected to have the "getter signature" of - /// (out_ptr: u32, len_ptr: u32) -> (). - pub fn getter(module_name: &'static str, getter_name: &'static str, repeat: u32) -> Self { - let pages = max_pages::(); - ModuleDefinition { - memory: Some(ImportedMemory::max::()), - imported_functions: vec![ImportedFunction { - module: module_name, - name: getter_name, - params: vec![ValueType::I32, ValueType::I32], - return_type: None, - }], - // Write the output buffer size. The output size will be overwritten by the - // supervisor with the real size when calling the getter. Since this size does not - // change between calls it suffices to start with an initial value and then just - // leave as whatever value was written there. - data_segments: vec![DataSegment { - offset: 0, - value: (pages * 64 * 1024 - 4).to_le_bytes().to_vec(), - }], - call_body: Some(body::repeated( - repeat, - &[ - Instruction::I32Const(4), // ptr where to store output - Instruction::I32Const(0), // ptr to length - Instruction::Call(0), // call the imported function - ], - )), - ..Default::default() - } - .into() - } - - /// TODO doc + /// Creates a wasm module that calls the imported function `noop` `repeat` times. pub fn noop(repeat: u32) -> Self { let pages = max_pages::(); ModuleDefinition { diff --git a/substrate/frame/contracts/src/benchmarking/mod.rs b/substrate/frame/contracts/src/benchmarking/mod.rs index 7c8f89650b14..6c1149a6acb0 100644 --- a/substrate/frame/contracts/src/benchmarking/mod.rs +++ b/substrate/frame/contracts/src/benchmarking/mod.rs @@ -30,7 +30,7 @@ use self::{ sandbox::Sandbox, }; use crate::{ - exec::Key, + exec::{Key, SeedOf}, migration::{ codegen::LATEST_MIGRATION_VERSION, v09, v10, v11, v12, v13, v14, v15, v16, MigrationStep, }, @@ -632,7 +632,8 @@ mod benchmarks { #[benchmark(pov_mode = Measured)] fn seal_caller() { - build_runtime!(runtime, memory: (32u32, [0u8; 32])); + let len = ::max_encoded_len() as u32; + build_runtime!(runtime, memory: [len.to_le_bytes(), vec![0u8; len as _], ]); let result; #[block] @@ -642,8 +643,8 @@ mod benchmarks { assert_ok!(result); assert_eq!( - ::decode(&mut &memory[4..]).unwrap(), - runtime.ext().caller().account_id().unwrap().clone() + &::decode(&mut &memory[4..]).unwrap(), + runtime.ext().caller().account_id().unwrap() ); } @@ -652,7 +653,7 @@ mod benchmarks { let Contract { account_id, .. } = Contract::::with_index(1, WasmModule::dummy(), vec![]).unwrap(); - build_runtime!(runtime, memory: account_id); + build_runtime!(runtime, memory: [account_id.encode(), ]); let result; #[block] @@ -664,55 +665,28 @@ mod benchmarks { } #[benchmark(pov_mode = Measured)] - fn seal_code_hash(r: Linear<0, API_BENCHMARK_RUNS>) { - let accounts = (0..r).map(|n| account::("account", n, 0)).collect::>(); - let account_len = accounts.get(0).map(|i| i.encode().len()).unwrap_or(0); - let accounts_bytes = accounts.iter().flat_map(|a| a.encode()).collect::>(); - let code = WasmModule::::from(ModuleDefinition { - memory: Some(ImportedMemory::max::()), - imported_functions: vec![ImportedFunction { - module: "seal0", - name: "seal_code_hash", - params: vec![ValueType::I32, ValueType::I32, ValueType::I32], - return_type: Some(ValueType::I32), - }], - data_segments: vec![ - DataSegment { - offset: 0, - value: 32u32.to_le_bytes().to_vec(), // output length - }, - DataSegment { offset: 36, value: accounts_bytes }, - ], - call_body: Some(body::repeated_dyn( - r, - vec![ - Counter(36, account_len as u32), // address_ptr - Regular(Instruction::I32Const(4)), // ptr to output data - Regular(Instruction::I32Const(0)), // ptr to output length - Regular(Instruction::Call(0)), - Regular(Instruction::Drop), - ], - )), - ..Default::default() - }); - call_builder!(func, instance, code); - let info = instance.info().unwrap(); - // every account would be a contract (worst case) - for acc in accounts.iter() { - >::insert(acc, info.clone()); - } + fn seal_code_hash() { + let contract = Contract::::with_index(1, WasmModule::dummy(), vec![]).unwrap(); + let len = as MaxEncodedLen>::max_encoded_len() as u32; + build_runtime!(runtime, memory: [len.to_le_bytes(), vec![0u8; len as _], contract.account_id.encode(), ]); - let res; + let result; #[block] { - res = func.call(); + result = BenchEnv::seal0_code_hash(&mut runtime, &mut memory, 4 + len, 4, 0); } - assert_eq!(res.did_revert(), false); + + assert_ok!(result); + assert_eq!( + as Decode>::decode(&mut &memory[4..]).unwrap(), + contract.info().unwrap().code_hash + ); } #[benchmark(pov_mode = Measured)] fn seal_own_code_hash() { - build_runtime!(runtime, contract, memory: (32u32, [0u8; 32])); + let len = as MaxEncodedLen>::max_encoded_len() as u32; + build_runtime!(runtime, contract, memory: [len.to_le_bytes(), vec![0u8; len as _], ]); let result; #[block] { @@ -727,56 +701,37 @@ mod benchmarks { } #[benchmark(pov_mode = Measured)] - fn seal_caller_is_origin(r: Linear<0, API_BENCHMARK_RUNS>) { - let code = WasmModule::::from(ModuleDefinition { - memory: Some(ImportedMemory::max::()), - imported_functions: vec![ImportedFunction { - module: "seal0", - name: "seal_caller_is_origin", - params: vec![], - return_type: Some(ValueType::I32), - }], - call_body: Some(body::repeated(r, &[Instruction::Call(0), Instruction::Drop])), - ..Default::default() - }); - call_builder!(func, code); + fn seal_caller_is_origin() { + build_runtime!(runtime, memory: []); - let res; + let result; #[block] { - res = func.call(); + result = BenchEnv::seal0_caller_is_origin(&mut runtime, &mut memory); } - assert_eq!(res.did_revert(), false); + assert_eq!(result.unwrap(), 1u32); } #[benchmark(pov_mode = Measured)] - fn seal_caller_is_root(r: Linear<0, API_BENCHMARK_RUNS>) { - let code = WasmModule::::from(ModuleDefinition { - memory: Some(ImportedMemory::max::()), - imported_functions: vec![ImportedFunction { - module: "seal0", - name: "caller_is_root", - params: vec![], - return_type: Some(ValueType::I32), - }], - call_body: Some(body::repeated(r, &[Instruction::Call(0), Instruction::Drop])), - ..Default::default() - }); - let mut setup = CallSetup::::new(code); + fn seal_caller_is_root() { + let mut setup = CallSetup::::default(); setup.set_origin(Origin::Root); - call_builder!(func, setup: setup); + let (mut ext, _) = setup.ext(); + let mut runtime = crate::wasm::Runtime::new(&mut ext, vec![]); - let res; + let result; #[block] { - res = func.call(); + result = BenchEnv::seal0_caller_is_root(&mut runtime, &mut [0u8; 0]); } - assert_eq!(res.did_revert(), false); + assert_eq!(result.unwrap(), 1u32); } #[benchmark(pov_mode = Measured)] fn seal_address() { - build_runtime!(runtime, contract, memory: (32u32, [0u8; 32])); + let len = as MaxEncodedLen>::max_encoded_len() as u32; + build_runtime!(runtime, memory: [len.to_le_bytes(), vec![0u8; len as _], ]); + let result; #[block] { @@ -784,346 +739,184 @@ mod benchmarks { } assert_ok!(result); assert_eq!( - ::decode(&mut &memory[4..]).unwrap(), - contract.account_id + &::decode(&mut &memory[4..]).unwrap(), + runtime.ext().address() ); } #[benchmark(pov_mode = Measured)] fn seal_gas_left() { - build_runtime!(runtime, memory: (32u32, [0u8; 32])); + // use correct max_encoded_len when new version of parity-scale-codec is released + let len = 18u32; + assert!(::max_encoded_len() as u32 != len); + build_runtime!(runtime, memory: [32u32.to_le_bytes(), vec![0u8; len as _], ]); + let result; #[block] { result = BenchEnv::seal1_gas_left(&mut runtime, &mut memory, 4, 0); } assert_ok!(result); - assert_ok!(::decode(&mut &memory[4..])); + assert_eq!( + ::decode(&mut &memory[4..]).unwrap(), + runtime.ext().gas_meter().gas_left() + ); } #[benchmark(pov_mode = Measured)] fn seal_balance() { - let out_ptr = ::max_encoded_len() as u32; - build_runtime!(runtime, memory: (out_ptr, T::Balance::default())); + let len = ::max_encoded_len() as u32; + build_runtime!(runtime, memory: [len.to_le_bytes(), vec![0u8; len as _], ]); let result; #[block] { result = BenchEnv::seal0_seal_balance(&mut runtime, &mut memory, 4, 0); } assert_ok!(result); - assert_ok!(::decode(&mut &memory[4..])); + assert_eq!( + ::decode(&mut &memory[4..]).unwrap(), + runtime.ext().balance().into() + ); } #[benchmark(pov_mode = Measured)] fn seal_value_transferred() { - let out_ptr = ::max_encoded_len() as u32; - build_runtime!(runtime, memory: (out_ptr, T::Balance::default())); + let len = ::max_encoded_len() as u32; + build_runtime!(runtime, memory: [len.to_le_bytes(), vec![0u8; len as _], ]); let result; #[block] { result = BenchEnv::seal0_value_transferred(&mut runtime, &mut memory, 4, 0); } assert_ok!(result); - assert_ok!(::decode(&mut &memory[4..])); + assert_eq!( + ::decode(&mut &memory[4..]).unwrap(), + runtime.ext().value_transferred().into() + ); } #[benchmark(pov_mode = Measured)] fn seal_minimum_balance(r: Linear<0, API_BENCHMARK_RUNS>) { - let out_ptr = ::max_encoded_len() as u32; - build_runtime!(runtime, memory: (out_ptr, T::Balance::default())); + let len = ::max_encoded_len() as u32; + build_runtime!(runtime, memory: [len.to_le_bytes(), vec![0u8; len as _], ]); let result; #[block] { result = BenchEnv::seal0_minimum_balance(&mut runtime, &mut memory, 4, 0); } assert_ok!(result); - assert_ok!(::decode(&mut &memory[4..])); + assert_eq!( + ::decode(&mut &memory[4..]).unwrap(), + runtime.ext().minimum_balance().into() + ); } #[benchmark(pov_mode = Measured)] - fn seal_block_number(r: Linear<0, API_BENCHMARK_RUNS>) { - call_builder!(func, WasmModule::getter("seal0", "seal_block_number", r)); - - let res; + fn seal_block_number() { + let len = as MaxEncodedLen>::max_encoded_len() as u32; + build_runtime!(runtime, memory: [len.to_le_bytes(), vec![0u8; len as _], ]); + let result; #[block] { - res = func.call(); + result = BenchEnv::seal0_seal_block_number(&mut runtime, &mut memory, 4, 0); } - assert_eq!(res.did_revert(), false); + assert_ok!(result); + assert_eq!( + >::decode(&mut &memory[4..]).unwrap(), + runtime.ext().block_number() + ); } #[benchmark(pov_mode = Measured)] - fn seal_now(r: Linear<0, API_BENCHMARK_RUNS>) { - call_builder!(func, WasmModule::getter("seal0", "seal_now", r)); - - let res; + fn seal_now() { + let len = as MaxEncodedLen>::max_encoded_len() as u32; + build_runtime!(runtime, memory: [len.to_le_bytes(), vec![0u8; len as _], ]); + let result; #[block] { - res = func.call(); + result = BenchEnv::seal0_seal_now(&mut runtime, &mut memory, 4, 0); } - assert_eq!(res.did_revert(), false); + assert_ok!(result); + assert_eq!(>::decode(&mut &memory[4..]).unwrap(), *runtime.ext().now()); } #[benchmark(pov_mode = Measured)] - fn seal_weight_to_fee(r: Linear<0, API_BENCHMARK_RUNS>) { - let pages = code::max_pages::(); - let code = WasmModule::::from(ModuleDefinition { - memory: Some(ImportedMemory::max::()), - imported_functions: vec![ImportedFunction { - module: "seal1", - name: "weight_to_fee", - params: vec![ValueType::I64, ValueType::I64, ValueType::I32, ValueType::I32], - return_type: None, - }], - data_segments: vec![DataSegment { - offset: 0, - value: (pages * 64 * 1024 - 4).to_le_bytes().to_vec(), - }], - call_body: Some(body::repeated( - r, - &[ - Instruction::I64Const(500_000), - Instruction::I64Const(300_000), - Instruction::I32Const(4), - Instruction::I32Const(0), - Instruction::Call(0), - ], - )), - ..Default::default() - }); - call_builder!(func, code); - - let res; + fn seal_weight_to_fee() { + let len = ::max_encoded_len() as u32; + build_runtime!(runtime, memory: [len.to_le_bytes(), vec![0u8; len as _], ]); + let weight = Weight::from_parts(500_000, 300_000); + let result; #[block] { - res = func.call(); + result = BenchEnv::seal1_weight_to_fee( + &mut runtime, + &mut memory, + weight.ref_time(), + weight.proof_size(), + 4, + 0, + ); } - assert_eq!(res.did_revert(), false); + assert_ok!(result); + assert_eq!( + >::decode(&mut &memory[4..]).unwrap(), + runtime.ext().get_weight_price(weight) + ); } #[benchmark(pov_mode = Measured)] - fn seal_input(r: Linear<0, API_BENCHMARK_RUNS>) { - let code = WasmModule::::from(ModuleDefinition { - memory: Some(ImportedMemory::max::()), - imported_functions: vec![ImportedFunction { - module: "seal0", - name: "seal_input", - params: vec![ValueType::I32, ValueType::I32], - return_type: None, - }], - data_segments: vec![DataSegment { offset: 0, value: 0u32.to_le_bytes().to_vec() }], - call_body: Some(body::repeated( - r, - &[ - Instruction::I32Const(4), // ptr where to store output - Instruction::I32Const(0), // ptr to length - Instruction::Call(0), - ], - )), - ..Default::default() - }); - - call_builder!(func, code); + fn seal_input(n: Linear<0, { code::max_pages::() * 64 * 1024 - 4 }>) { + build_runtime!(runtime, memory: [n.to_le_bytes(), vec![42u8; n as usize], ]); - let res; + let result; #[block] { - res = func.call(); + result = BenchEnv::seal0_input(&mut runtime, &mut memory, 4, 0) } - assert_eq!(res.did_revert(), false); - } - - #[benchmark(pov_mode = Measured)] - fn seal_input_per_byte( - n: Linear<0, { code::max_pages::() * 64 * 1024 }>, - ) -> Result<(), BenchmarkError> { - let buffer_size = code::max_pages::() * 64 * 1024 - 4; - let code = WasmModule::::from(ModuleDefinition { - memory: Some(ImportedMemory::max::()), - imported_functions: vec![ImportedFunction { - module: "seal0", - name: "seal_input", - params: vec![ValueType::I32, ValueType::I32], - return_type: None, - }], - data_segments: vec![DataSegment { - offset: 0, - value: buffer_size.to_le_bytes().to_vec(), - }], - call_body: Some(body::plain(vec![ - Instruction::I32Const(4), // ptr where to store output - Instruction::I32Const(0), // ptr to length - Instruction::Call(0), - Instruction::End, - ])), - ..Default::default() - }); - let instance = Contract::::new(code, vec![])?; - let data = vec![42u8; n.min(buffer_size) as usize]; - let origin = RawOrigin::Signed(instance.caller.clone()); - #[extrinsic_call] - call(origin, instance.addr, 0u32.into(), Weight::MAX, None, data); - Ok(()) + assert_ok!(result); } - // We cannot call `seal_return` multiple times. Therefore our weight determination is not - // as precise as with other APIs. Because this function can only be called once per - // contract it cannot be used as an attack vector. #[benchmark(pov_mode = Measured)] - fn seal_return(r: Linear<0, 1>) { - let code = WasmModule::::from(ModuleDefinition { - memory: Some(ImportedMemory::max::()), - imported_functions: vec![ImportedFunction { - module: "seal0", - name: "seal_return", - params: vec![ValueType::I32, ValueType::I32, ValueType::I32], - return_type: None, - }], - call_body: Some(body::repeated( - r, - &[ - Instruction::I32Const(0), // flags - Instruction::I32Const(0), // data_ptr - Instruction::I32Const(0), // data_len - Instruction::Call(0), - ], - )), - ..Default::default() - }); - call_builder!(func, code); + fn seal_return(n: Linear<0, { code::max_pages::() * 64 * 1024 - 4 }>) { + build_runtime!(runtime, memory: [n.to_le_bytes(), vec![42u8; n as usize], ]); - let res; + let result; #[block] { - res = func.call(); + result = BenchEnv::seal0_seal_return(&mut runtime, &mut memory, 0, 0, n) } - assert_eq!(res.did_revert(), false); - } - #[benchmark(pov_mode = Measured)] - fn seal_return_per_byte(n: Linear<0, { code::max_pages::() * 64 * 1024 }>) { - let code = WasmModule::::from(ModuleDefinition { - memory: Some(ImportedMemory::max::()), - imported_functions: vec![ImportedFunction { - module: "seal0", - name: "seal_return", - params: vec![ValueType::I32, ValueType::I32, ValueType::I32], - return_type: None, - }], - call_body: Some(body::plain(vec![ - Instruction::I32Const(0), // flags - Instruction::I32Const(0), // data_ptr - Instruction::I32Const(n as i32), // data_len - Instruction::Call(0), - Instruction::End, - ])), - ..Default::default() - }); - call_builder!(func, code); - - let res; - #[block] - { - res = func.call(); - } - assert_eq!(res.did_revert(), false); + assert!(matches!( + result, + Err(crate::wasm::TrapReason::Return(crate::wasm::ReturnData { .. })) + )); } // The same argument as for `seal_return` is true here. #[benchmark(pov_mode = Measured)] - fn seal_terminate(r: Linear<0, 1>) -> Result<(), BenchmarkError> { + fn seal_terminate() -> Result<(), BenchmarkError> { let beneficiary = account::("beneficiary", 0, 0); - let beneficiary_bytes = beneficiary.encode(); - let beneficiary_len = beneficiary_bytes.len(); let caller = whitelisted_caller(); + build_runtime!(runtime, memory: [beneficiary.encode(),]); + T::Currency::set_balance(&caller, caller_funding::()); // Maximize the delegate_dependencies to account for the worst-case scenario. - let code_hashes = (0..T::MaxDelegateDependencies::get()) - .map(|i| { - let new_code = WasmModule::::dummy_with_bytes(65 + i); - Contracts::::store_code_raw(new_code.code, caller.clone())?; - Ok(new_code.hash) - }) - .collect::, &'static str>>()?; - let code_hash_len = code_hashes.get(0).map(|x| x.encode().len()).unwrap_or(0); - let code_hashes_bytes = code_hashes.iter().flat_map(|x| x.encode()).collect::>(); - - let code = WasmModule::::from(ModuleDefinition { - memory: Some(ImportedMemory::max::()), - imported_functions: vec![ - ImportedFunction { - module: "seal0", - name: "seal_terminate", - params: vec![ValueType::I32, ValueType::I32], - return_type: None, - }, - ImportedFunction { - module: "seal0", - name: "lock_delegate_dependency", - params: vec![ValueType::I32], - return_type: None, - }, - ], - data_segments: vec![ - DataSegment { offset: 0, value: beneficiary_bytes }, - DataSegment { offset: beneficiary_len as u32, value: code_hashes_bytes }, - ], - deploy_body: Some(body::repeated_dyn( - T::MaxDelegateDependencies::get(), - vec![ - Counter(beneficiary_len as u32, code_hash_len as u32), // code_hash_ptr - Regular(Instruction::Call(1)), - ], - )), - call_body: Some(body::repeated( - r, - &[ - Instruction::I32Const(0), // beneficiary_ptr - Instruction::I32Const(beneficiary_len as i32), // beneficiary_len - Instruction::Call(0), - ], - )), - ..Default::default() + (0..T::MaxDelegateDependencies::get()).for_each(|i| { + let new_code = WasmModule::::dummy_with_bytes(65 + i); + Contracts::::store_code_raw(new_code.code, caller.clone()).unwrap(); + runtime.ext().lock_delegate_dependency(new_code.hash).unwrap(); }); - let instance = Contract::::new(code, vec![])?; - let origin = RawOrigin::Signed(instance.caller.clone()); - assert_eq!(T::Currency::total_balance(&beneficiary), 0u32.into()); - assert_eq!( - T::Currency::balance(&instance.account_id), - Pallet::::min_balance() * 2u32.into() - ); - assert_ne!( - T::Currency::balance_on_hold( - &HoldReason::StorageDepositReserve.into(), - &instance.account_id - ), - 0u32.into() - ); - assert_eq!( - ContractInfoOf::::get(&instance.account_id) - .unwrap() - .delegate_dependencies_count() as u32, - T::MaxDelegateDependencies::get() - ); - #[extrinsic_call] - call(origin, instance.addr.clone(), 0u32.into(), Weight::MAX, None, vec![]); - - if r > 0 { - assert_eq!(T::Currency::total_balance(&instance.account_id), 0u32.into()); - assert_eq!( - T::Currency::balance_on_hold( - &HoldReason::StorageDepositReserve.into(), - &instance.account_id - ), - 0u32.into() - ); - assert_eq!( - T::Currency::total_balance(&beneficiary), - Pallet::::min_balance() * 2u32.into() - ); + + let result; + #[block] + { + result = BenchEnv::seal1_terminate(&mut runtime, &mut memory, 0) } + + assert!(matches!(result, Err(crate::wasm::TrapReason::Termination))); + Ok(()) } @@ -1131,161 +924,77 @@ mod benchmarks { // number (< 1 KB). Therefore we are not overcharging too much in case a smaller subject is // used. #[benchmark(pov_mode = Measured)] - fn seal_random(r: Linear<0, API_BENCHMARK_RUNS>) { - let pages = code::max_pages::(); + fn seal_random() { let subject_len = T::Schedule::get().limits.subject_len; assert!(subject_len < 1024); - let code = WasmModule::::from(ModuleDefinition { - memory: Some(ImportedMemory::max::()), - imported_functions: vec![ImportedFunction { - module: "seal0", - name: "seal_random", - params: vec![ValueType::I32, ValueType::I32, ValueType::I32, ValueType::I32], - return_type: None, - }], - data_segments: vec![DataSegment { - offset: 0, - value: (pages * 64 * 1024 - subject_len - 4).to_le_bytes().to_vec(), - }], - call_body: Some(body::repeated( - r, - &[ - Instruction::I32Const(4), // subject_ptr - Instruction::I32Const(subject_len as i32), // subject_len - Instruction::I32Const((subject_len + 4) as i32), // out_ptr - Instruction::I32Const(0), // out_len_ptr - Instruction::Call(0), - ], - )), - ..Default::default() - }); - call_builder!(func, code); - - let res; - #[block] - { - res = func.call(); - } - assert_eq!(res.did_revert(), false); - } - - // Overhead of calling the function without any topic. - // We benchmark for the worst case (largest event). - #[benchmark(pov_mode = Measured)] - fn seal_deposit_event(r: Linear<0, API_BENCHMARK_RUNS>) { - let code = WasmModule::::from(ModuleDefinition { - memory: Some(ImportedMemory::max::()), - imported_functions: vec![ImportedFunction { - module: "seal0", - name: "seal_deposit_event", - params: vec![ValueType::I32, ValueType::I32, ValueType::I32, ValueType::I32], - return_type: None, - }], - call_body: Some(body::repeated( - r, - &[ - Instruction::I32Const(0), // topics_ptr - Instruction::I32Const(0), // topics_len - Instruction::I32Const(0), // data_ptr - Instruction::I32Const(0), // data_len - Instruction::Call(0), - ], - )), - ..Default::default() - }); + let output_len = + <(SeedOf, BlockNumberFor) as MaxEncodedLen>::max_encoded_len() as u32; - call_builder!(func, code); + build_runtime!(runtime, memory: [ + output_len.to_le_bytes(), + vec![42u8; subject_len as _], + vec![0u8; output_len as _], + ]); - let res; + let result; #[block] { - res = func.call(); + result = BenchEnv::seal0_random( + &mut runtime, + &mut memory, + 4, // subject_ptr + subject_len, // subject_len + subject_len + 4, // output_ptr + 0, // output_len_ptr + ) } - assert_eq!(res.did_revert(), false); + + assert_ok!(result); + assert_ok!(<(SeedOf, BlockNumberFor)>::decode(&mut &memory[subject_len as _..])); } // Benchmark the overhead that topics generate. // `t`: Number of topics // `n`: Size of event payload in bytes #[benchmark(pov_mode = Measured)] - fn seal_deposit_event_per_topic_and_byte( + fn seal_deposit_event( t: Linear<0, { T::Schedule::get().limits.event_topics }>, n: Linear<0, { T::Schedule::get().limits.payload_len }>, ) { let topics = (0..t).map(|i| T::Hashing::hash_of(&i)).collect::>().encode(); - let topics_len = topics.len(); - let code = WasmModule::::from(ModuleDefinition { - memory: Some(ImportedMemory::max::()), - imported_functions: vec![ImportedFunction { - module: "seal0", - name: "seal_deposit_event", - params: vec![ValueType::I32, ValueType::I32, ValueType::I32, ValueType::I32], - return_type: None, - }], - data_segments: vec![DataSegment { offset: 0, value: topics }], - call_body: Some(body::plain(vec![ - Instruction::I32Const(0), // topics_ptr - Instruction::I32Const(topics_len as i32), // topics_len - Instruction::I32Const(0), // data_ptr - Instruction::I32Const(n as i32), // data_len - Instruction::Call(0), - Instruction::End, - ])), - ..Default::default() - }); + let topics_len = topics.len() as u32; - call_builder!(func, code); + build_runtime!(runtime, memory: [ + n.to_le_bytes(), + topics, + vec![0u8; n as _], + ]); - let res; + let result; #[block] { - res = func.call(); + result = BenchEnv::seal0_deposit_event( + &mut runtime, + &mut memory, + 4, // topics_ptr + topics_len, // topics_len + 4 + topics_len, // data_ptr + 0, // data_len + ) } - assert_eq!(res.did_revert(), false); + + assert_ok!(result); } - // Benchmark debug_message call with zero input data. + // Benchmark debug_message call // Whereas this function is used in RPC mode only, it still should be secured // against an excessive use. - #[benchmark(pov_mode = Measured)] - fn seal_debug_message(r: Linear<0, API_BENCHMARK_RUNS>) -> Result<(), BenchmarkError> { - let code = WasmModule::::from(ModuleDefinition { - memory: Some(ImportedMemory { min_pages: 1, max_pages: 1 }), - imported_functions: vec![ImportedFunction { - module: "seal0", - name: "seal_debug_message", - params: vec![ValueType::I32, ValueType::I32], - return_type: Some(ValueType::I32), - }], - call_body: Some(body::repeated( - r, - &[ - Instruction::I32Const(0), // value_ptr - Instruction::I32Const(0), // value_len - Instruction::Call(0), - Instruction::Drop, - ], - )), - ..Default::default() - }); - let mut setup = CallSetup::::new(code); - setup.enable_debug_message(); - call_builder!(func, setup: setup); - - let res; - #[block] - { - res = func.call(); - } - assert_eq!(res.did_revert(), false); - Ok(()) - } - - // Vary size of input in bytes up to maximum allowed contract memory - // or maximum allowed debug buffer size, whichever is less. + // + // i: size of input in bytes up to maximum allowed contract memory or maximum allowed debug + // buffer size, whichever is less. #[benchmark] - fn seal_debug_message_per_byte( + fn seal_debug_message( i: Linear< 0, { @@ -1293,113 +1002,21 @@ mod benchmarks { .min(T::MaxDebugBufferLen::get()) }, >, - ) -> Result<(), BenchmarkError> { - // We benchmark versus messages containing printable ASCII codes. - // About 1Kb goes to the contract code instructions, - // whereas all the space left we use for the initialization of the debug messages data. - let message = (0..T::MaxCodeLen::get() - 1024) - .zip((32..127).cycle()) - .map(|i| i.1) - .collect::>(); - let code = WasmModule::::from(ModuleDefinition { - memory: Some(ImportedMemory { - min_pages: T::Schedule::get().limits.memory_pages, - max_pages: T::Schedule::get().limits.memory_pages, - }), - imported_functions: vec![ImportedFunction { - module: "seal0", - name: "seal_debug_message", - params: vec![ValueType::I32, ValueType::I32], - return_type: Some(ValueType::I32), - }], - data_segments: vec![DataSegment { offset: 0, value: message }], - call_body: Some(body::plain(vec![ - Instruction::I32Const(0), // value_ptr - Instruction::I32Const(i as i32), // value_len - Instruction::Call(0), - Instruction::Drop, - Instruction::End, - ])), - ..Default::default() - }); - let mut setup = CallSetup::::new(code); + ) { + let mut setup = CallSetup::::default(); setup.enable_debug_message(); - call_builder!(func, setup: setup); + let (mut ext, _) = setup.ext(); + let mut runtime = crate::wasm::Runtime::new(&mut ext, vec![]); + // Fill memory with printable ASCII bytes. + let mut memory = (0..i).zip((32..127).cycle()).map(|i| i.1).collect::>(); - let res; + let result; #[block] { - res = func.call(); + result = BenchEnv::seal0_debug_message(&mut runtime, &mut memory, 0, i); } - assert_eq!(res.did_revert(), false); + assert_ok!(result); assert_eq!(setup.debug_message().unwrap().len() as u32, i); - Ok(()) - } - - // Only the overhead of calling the function itself with minimal arguments. - // The contract is a bit more complex because it needs to use different keys in order - // to generate unique storage accesses. However, it is still dominated by the storage - // accesses. We store something at all the keys that we are about to write to - // because re-writing at an existing key is always more expensive than writing - // to an key with no data behind it. - // - // # Note - // - // We need to use a smaller `r` because the keys are big and writing them all into the wasm - // might exceed the code size. - #[benchmark(skip_meta, pov_mode = Measured)] - fn seal_set_storage(r: Linear<0, { API_BENCHMARK_RUNS / 2 }>) -> Result<(), BenchmarkError> { - let max_key_len = T::MaxStorageKeyLen::get(); - let keys = (0..r) - .map(|n| { - let mut h = T::Hashing::hash_of(&n).as_ref().to_vec(); - h.resize(max_key_len.try_into().unwrap(), n.to_le_bytes()[0]); - h - }) - .collect::>(); - let keys_bytes = keys.iter().flatten().cloned().collect::>(); - let code = WasmModule::::from(ModuleDefinition { - memory: Some(ImportedMemory::max::()), - imported_functions: vec![ImportedFunction { - module: "seal2", - name: "set_storage", - params: vec![ValueType::I32, ValueType::I32, ValueType::I32, ValueType::I32], - return_type: Some(ValueType::I32), - }], - data_segments: vec![DataSegment { offset: 0, value: keys_bytes }], - call_body: Some(body::repeated_dyn( - r, - vec![ - Counter(0, max_key_len as u32), // key_ptr - Regular(Instruction::I32Const(max_key_len as i32)), // key_len - Regular(Instruction::I32Const(0)), // value_ptr - Regular(Instruction::I32Const(0)), // value_len - Regular(Instruction::Call(0)), - Regular(Instruction::Drop), - ], - )), - ..Default::default() - }); - - call_builder!(func, instance, code); - let info = instance.info()?; - for key in keys { - info.write( - &Key::::try_from_var(key).map_err(|_| "Key has wrong length")?, - Some(vec![]), - None, - false, - ) - .map_err(|_| "Failed to write to storage during setup.")?; - } - - let res; - #[block] - { - res = func.call(); - } - assert_eq!(res.did_revert(), false); - Ok(()) } #[benchmark(skip_meta, pov_mode = Measured)] @@ -1407,43 +1024,30 @@ mod benchmarks { n: Linear<0, { T::Schedule::get().limits.payload_len }>, ) -> Result<(), BenchmarkError> { let max_key_len = T::MaxStorageKeyLen::get(); - let key = vec![0u8; max_key_len as usize]; - let code = WasmModule::::from(ModuleDefinition { - memory: Some(ImportedMemory::max::()), - imported_functions: vec![ImportedFunction { - module: "seal2", - name: "set_storage", - params: vec![ValueType::I32, ValueType::I32, ValueType::I32, ValueType::I32], - return_type: Some(ValueType::I32), - }], - data_segments: vec![DataSegment { offset: 0, value: key.clone() }], - call_body: Some(body::plain(vec![ - Instruction::I32Const(0), // key_ptr - Instruction::I32Const(max_key_len as i32), // key_len - Instruction::I32Const(0), // value_ptr - Instruction::I32Const(n as i32), // value_len - Instruction::Call(0), - Instruction::Drop, - Instruction::End, - ])), - ..Default::default() - }); - call_builder!(func, instance, code); + let key = Key::::try_from_var(vec![0u8; max_key_len as usize]) + .map_err(|_| "Key has wrong length")?; + let value = vec![1u8; n as usize]; + + build_runtime!(runtime, instance, memory: [ key.to_vec(), value.clone(), ]); let info = instance.info()?; - info.write( - &Key::::try_from_var(key).map_err(|_| "Key has wrong length")?, - Some(vec![]), - None, - false, - ) - .map_err(|_| "Failed to write to storage during setup.")?; + info.write(&key, Some(vec![]), None, false) + .map_err(|_| "Failed to write to storage during setup.")?; - let res; + let result; #[block] { - res = func.call(); + result = BenchEnv::seal2_set_storage( + &mut runtime, + &mut memory, + 0, // key_ptr + max_key_len, // key_len + max_key_len, // value_ptr + n, // value_len + ); } - assert_eq!(res.did_revert(), false); + + assert_ok!(result); + assert_eq!(info.read(&key).unwrap(), value); Ok(()) } @@ -1452,44 +1056,31 @@ mod benchmarks { n: Linear<0, { T::Schedule::get().limits.payload_len }>, ) -> Result<(), BenchmarkError> { let max_key_len = T::MaxStorageKeyLen::get(); - let key = vec![0u8; max_key_len as usize]; - let code = WasmModule::::from(ModuleDefinition { - memory: Some(ImportedMemory::max::()), - imported_functions: vec![ImportedFunction { - module: "seal2", - name: "set_storage", - params: vec![ValueType::I32, ValueType::I32, ValueType::I32, ValueType::I32], - return_type: Some(ValueType::I32), - }], - data_segments: vec![DataSegment { offset: 0, value: key.clone() }], - call_body: Some(body::plain(vec![ - Instruction::I32Const(0), // key_ptr - Instruction::I32Const(max_key_len as i32), // key_len - Instruction::I32Const(0), // value_ptr - Instruction::I32Const(0), /* value_len is 0 as testing vs - * pre-existing value len */ - Instruction::Call(0), - Instruction::Drop, - Instruction::End, - ])), - ..Default::default() - }); - call_builder!(func, instance, code); + let key = Key::::try_from_var(vec![0u8; max_key_len as usize]) + .map_err(|_| "Key has wrong length")?; + let value = vec![1u8; n as usize]; + + build_runtime!(runtime, instance, memory: [ key.to_vec(), value.clone(), ]); let info = instance.info()?; - info.write( - &Key::::try_from_var(key).map_err(|_| "Key has wrong length")?, - Some(vec![42u8; n as usize]), - None, - false, - ) - .map_err(|_| "Failed to write to storage during setup.")?; - let res; + info.write(&key, Some(vec![42u8; n as usize]), None, false) + .map_err(|_| "Failed to write to storage during setup.")?; + + let result; #[block] { - res = func.call(); + result = BenchEnv::seal2_set_storage( + &mut runtime, + &mut memory, + 0, // key_ptr + max_key_len, // key_len + max_key_len, // value_ptr + 0, // value_len is 0 as testing vs pre-existing value len + ); } - assert_eq!(res.did_revert(), false); + + assert_ok!(result); + assert!(info.read(&key).unwrap().is_empty()); Ok(()) } diff --git a/substrate/frame/contracts/src/exec.rs b/substrate/frame/contracts/src/exec.rs index 31cdadb4bb43..061d2fc3a1d9 100644 --- a/substrate/frame/contracts/src/exec.rs +++ b/substrate/frame/contracts/src/exec.rs @@ -303,7 +303,7 @@ pub trait Ext: sealing::Sealed { fn ecdsa_to_eth_address(&self, pk: &[u8; 33]) -> Result<[u8; 20], ()>; /// Tests sometimes need to modify and inspect the contract info directly. - #[cfg(test)] + #[cfg(any(test, feature = "runtime-benchmarks"))] fn contract_info(&mut self) -> &mut ContractInfo; /// Sets new code hash for existing contract. @@ -1500,7 +1500,7 @@ where ECDSAPublic::from(*pk).to_eth_address() } - #[cfg(test)] + #[cfg(any(test, feature = "runtime-benchmarks"))] fn contract_info(&mut self) -> &mut ContractInfo { self.top_frame_mut().contract_info() } diff --git a/substrate/frame/contracts/src/wasm/mod.rs b/substrate/frame/contracts/src/wasm/mod.rs index a8ec935b6ecb..380bd366f72a 100644 --- a/substrate/frame/contracts/src/wasm/mod.rs +++ b/substrate/frame/contracts/src/wasm/mod.rs @@ -32,7 +32,7 @@ pub use { }; #[cfg(feature = "runtime-benchmarks")] -pub use crate::wasm::runtime::BenchEnv; +pub use crate::wasm::runtime::{BenchEnv, ReturnData, TrapReason}; pub use crate::wasm::{ prepare::{LoadedModule, LoadingMode}, From 75f1c8c7813483231bf550084b5392af798837c2 Mon Sep 17 00:00:00 2001 From: pgherveou Date: Thu, 25 Apr 2024 17:09:06 +0200 Subject: [PATCH 05/34] wip --- .../src/benchmarking/call_builder.rs | 20 +- .../frame/contracts/src/benchmarking/code.rs | 59 - .../frame/contracts/src/benchmarking/mod.rs | 1510 ++++------------- 3 files changed, 321 insertions(+), 1268 deletions(-) diff --git a/substrate/frame/contracts/src/benchmarking/call_builder.rs b/substrate/frame/contracts/src/benchmarking/call_builder.rs index c69c329ebbf7..9f55e32ec278 100644 --- a/substrate/frame/contracts/src/benchmarking/call_builder.rs +++ b/substrate/frame/contracts/src/benchmarking/call_builder.rs @@ -179,20 +179,24 @@ macro_rules! call_builder( }; ); +#[macro_export] +macro_rules! memory( + ($($bytes:expr,)*) => { + vec![] + .into_iter() + $(.chain($bytes))* + .collect::>() + }; +); + #[macro_export] macro_rules! build_runtime( - // ($runtime:ident, $memory:ident: $val:expr) => { - // $crate::build_runtime!($runtime, _contract, $memory: $val); - // }; ($runtime:ident, $memory:ident: [$($segment:expr,)*]) => { $crate::build_runtime!($runtime, _contract, $memory: [$($segment,)*]); }; - ($runtime:ident, $contract:ident, $memory:ident: [$($segment:expr,)*]) => { + ($runtime:ident, $contract:ident, $memory:ident: [$($bytes:expr,)*]) => { $crate::build_runtime!($runtime, $contract); - let mut $memory = vec![] - .into_iter() - $(.chain($segment))* - .collect::>(); + let mut $memory = $crate::memory!($($bytes,)*); }; ($runtime:ident, $contract:ident) => { let mut setup = CallSetup::::default(); diff --git a/substrate/frame/contracts/src/benchmarking/code.rs b/substrate/frame/contracts/src/benchmarking/code.rs index 987cc0263275..65bcf30683c0 100644 --- a/substrate/frame/contracts/src/benchmarking/code.rs +++ b/substrate/frame/contracts/src/benchmarking/code.rs @@ -317,53 +317,12 @@ impl WasmModule { } .into() } - - /// Creates a wasm module that calls the imported hash function named `name` `repeat` times - /// with an input of size `data_size`. Hash functions have the signature - /// (input_ptr: u32, input_len: u32, output_ptr: u32) -> () - pub fn hasher(name: &'static str, repeat: u32, data_size: u32) -> Self { - ModuleDefinition { - memory: Some(ImportedMemory::max::()), - imported_functions: vec![ImportedFunction { - module: "seal0", - name, - params: vec![ValueType::I32, ValueType::I32, ValueType::I32], - return_type: None, - }], - call_body: Some(body::repeated( - repeat, - &[ - Instruction::I32Const(0), // input_ptr - Instruction::I32Const(data_size as i32), // input_len - Instruction::I32Const(0), // output_ptr - Instruction::Call(0), - ], - )), - ..Default::default() - } - .into() - } } /// Mechanisms to generate a function body that can be used inside a `ModuleDefinition`. pub mod body { use super::*; - /// When generating contract code by repeating a Wasm sequence, it's sometimes necessary - /// to change those instructions on each repetition. The variants of this enum describe - /// various ways in which this can happen. - pub enum DynInstr { - /// Insert the associated instruction. - Regular(Instruction), - /// Insert a I32Const with incrementing value for each insertion. - /// (start_at, increment_by) - Counter(u32, u32), - } - - pub fn plain(instructions: Vec) -> FuncBody { - FuncBody::new(Vec::new(), Instructions::new(instructions)) - } - pub fn repeated(repetitions: u32, instructions: &[Instruction]) -> FuncBody { repeated_with_locals(&[], repetitions, instructions) } @@ -397,24 +356,6 @@ pub mod body { instructions.push(Instruction::End); FuncBody::new(locals.to_vec(), Instructions::new(instructions)) } - - pub fn repeated_dyn(repetitions: u32, mut instructions: Vec) -> FuncBody { - // We need to iterate over indices because we cannot cycle over mutable references - let body = (0..instructions.len()) - .cycle() - .take(instructions.len() * usize::try_from(repetitions).unwrap()) - .flat_map(|idx| match &mut instructions[idx] { - DynInstr::Regular(instruction) => vec![instruction.clone()], - DynInstr::Counter(offset, increment_by) => { - let current = *offset; - *offset += *increment_by; - vec![Instruction::I32Const(current as i32)] - }, - }) - .chain(sp_std::iter::once(Instruction::End)) - .collect(); - FuncBody::new(Vec::new(), Instructions::new(body)) - } } /// The maximum amount of pages any contract is allowed to have according to the current `Schedule`. diff --git a/substrate/frame/contracts/src/benchmarking/mod.rs b/substrate/frame/contracts/src/benchmarking/mod.rs index 6c1149a6acb0..a5e9cacb2a24 100644 --- a/substrate/frame/contracts/src/benchmarking/mod.rs +++ b/substrate/frame/contracts/src/benchmarking/mod.rs @@ -23,10 +23,7 @@ mod code; mod sandbox; use self::{ call_builder::CallSetup, - code::{ - body::{self, DynInstr::*}, - DataSegment, ImportedFunction, ImportedMemory, Location, ModuleDefinition, WasmModule, - }, + code::{body, ImportedFunction, Location, ModuleDefinition, WasmModule}, sandbox::Sandbox, }; use crate::{ @@ -50,7 +47,7 @@ use pallet_balances; use pallet_contracts_uapi::CallFlags; use sp_runtime::traits::{Bounded, Hash}; use sp_std::prelude::*; -use wasm_instrument::parity_wasm::elements::{BlockType, Instruction, Local, ValueType}; +use wasm_instrument::parity_wasm::elements::{Instruction, Local, ValueType}; /// How many runs we do per API benchmark. /// @@ -1084,1419 +1081,530 @@ mod benchmarks { Ok(()) } - // Similar to seal_set_storage. We store all the keys that we are about to - // delete beforehand in order to prevent any optimizations that could occur when - // deleting a non existing key. We generate keys of a maximum length, and have to - // the amount of runs in order to make resulting contract code size less than MaxCodeLen. - #[benchmark(skip_meta, pov_mode = Measured)] - fn seal_clear_storage(r: Linear<0, { API_BENCHMARK_RUNS / 2 }>) -> Result<(), BenchmarkError> { - let max_key_len = T::MaxStorageKeyLen::get(); - let keys = (0..r) - .map(|n| { - let mut h = T::Hashing::hash_of(&n).as_ref().to_vec(); - h.resize(max_key_len.try_into().unwrap(), n.to_le_bytes()[0]); - h - }) - .collect::>(); - let key_bytes = keys.iter().flatten().cloned().collect::>(); - let code = WasmModule::::from(ModuleDefinition { - memory: Some(ImportedMemory::max::()), - imported_functions: vec![ImportedFunction { - module: "seal1", - name: "clear_storage", - params: vec![ValueType::I32, ValueType::I32], - return_type: Some(ValueType::I32), - }], - data_segments: vec![DataSegment { offset: 0, value: key_bytes }], - call_body: Some(body::repeated_dyn( - r, - vec![ - Counter(0, max_key_len as u32), // key_ptr - Regular(Instruction::I32Const(max_key_len as i32)), // key_len - Regular(Instruction::Call(0)), - Regular(Instruction::Drop), - ], - )), - ..Default::default() - }); - call_builder!(func, instance, code); - let info = instance.info()?; - for key in keys { - info.write( - &Key::::try_from_var(key).map_err(|_| "Key has wrong length")?, - Some(vec![]), - None, - false, - ) - .map_err(|_| "Failed to write to storage during setup.")?; - } - >::insert(&instance.account_id, info); - - let res; - #[block] - { - res = func.call(); - } - assert_eq!(res.did_revert(), false); - Ok(()) - } - #[benchmark(skip_meta, pov_mode = Measured)] - fn seal_clear_storage_per_byte( + fn seal_clear_storage( n: Linear<0, { T::Schedule::get().limits.payload_len }>, ) -> Result<(), BenchmarkError> { let max_key_len = T::MaxStorageKeyLen::get(); - let key = vec![0u8; max_key_len as usize]; - let code = WasmModule::::from(ModuleDefinition { - memory: Some(ImportedMemory::max::()), - imported_functions: vec![ImportedFunction { - module: "seal1", - name: "clear_storage", - params: vec![ValueType::I32, ValueType::I32], - return_type: Some(ValueType::I32), - }], - data_segments: vec![DataSegment { offset: 0, value: key.clone() }], - call_body: Some(body::plain(vec![ - Instruction::I32Const(0), // key_ptr - Instruction::I32Const(max_key_len as i32), // key_len - Instruction::Call(0), - Instruction::Drop, - Instruction::End, - ])), - ..Default::default() - }); - call_builder!(func, instance, code); + let key = Key::::try_from_var(vec![0u8; max_key_len as usize]) + .map_err(|_| "Key has wrong length")?; + build_runtime!(runtime, instance, memory: [ key.to_vec(), ]); let info = instance.info()?; - info.write( - &Key::::try_from_var(key).map_err(|_| "Key has wrong length")?, - Some(vec![42u8; n as usize]), - None, - false, - ) - .map_err(|_| "Failed to write to storage during setup.")?; - let res; - #[block] - { - res = func.call(); - } - assert_eq!(res.did_revert(), false); - Ok(()) - } - - // We make sure that all storage accesses are to unique keys. - #[benchmark(skip_meta, pov_mode = Measured)] - fn seal_get_storage(r: Linear<0, { API_BENCHMARK_RUNS / 2 }>) -> Result<(), BenchmarkError> { - let max_key_len = T::MaxStorageKeyLen::get(); - let keys = (0..r) - .map(|n| { - let mut h = T::Hashing::hash_of(&n).as_ref().to_vec(); - h.resize(max_key_len.try_into().unwrap(), n.to_le_bytes()[0]); - h - }) - .collect::>(); - let key_bytes = keys.iter().flatten().cloned().collect::>(); - let key_bytes_len = key_bytes.len(); - let code = WasmModule::::from(ModuleDefinition { - memory: Some(ImportedMemory::max::()), - imported_functions: vec![ImportedFunction { - module: "seal1", - name: "get_storage", - params: vec![ValueType::I32, ValueType::I32, ValueType::I32, ValueType::I32], - return_type: Some(ValueType::I32), - }], - data_segments: vec![ - DataSegment { offset: 0, value: key_bytes }, - DataSegment { - offset: key_bytes_len as u32, - value: T::Schedule::get().limits.payload_len.to_le_bytes().into(), - }, - ], - call_body: Some(body::repeated_dyn( - r, - vec![ - Counter(0, max_key_len), // key_ptr - Regular(Instruction::I32Const(max_key_len as i32)), // key_len - Regular(Instruction::I32Const((key_bytes_len + 4) as i32)), // out_ptr - Regular(Instruction::I32Const(key_bytes_len as i32)), // out_len_ptr - Regular(Instruction::Call(0)), - Regular(Instruction::Drop), - ], - )), - ..Default::default() - }); - call_builder!(func, instance, code); - let info = instance.info()?; - for key in keys { - info.write( - &Key::::try_from_var(key).map_err(|_| "Key has wrong length")?, - Some(vec![]), - None, - false, - ) + info.write(&key, Some(vec![42u8; n as usize]), None, false) .map_err(|_| "Failed to write to storage during setup.")?; - } - >::insert(&instance.account_id, info); - let res; + let result; #[block] { - res = func.call(); + result = BenchEnv::seal1_clear_storage(&mut runtime, &mut memory, 0, max_key_len); } - assert_eq!(res.did_revert(), false); + + assert_ok!(result); + assert!(info.read(&key).is_none()); Ok(()) } #[benchmark(skip_meta, pov_mode = Measured)] - fn seal_get_storage_per_byte( + fn seal_get_storage( n: Linear<0, { T::Schedule::get().limits.payload_len }>, ) -> Result<(), BenchmarkError> { let max_key_len = T::MaxStorageKeyLen::get(); - let key = vec![0u8; max_key_len as usize]; - let code = WasmModule::::from(ModuleDefinition { - memory: Some(ImportedMemory::max::()), - imported_functions: vec![ImportedFunction { - module: "seal1", - name: "get_storage", - params: vec![ValueType::I32, ValueType::I32, ValueType::I32, ValueType::I32], - return_type: Some(ValueType::I32), - }], - data_segments: vec![ - DataSegment { offset: 0, value: key.clone() }, - DataSegment { - offset: max_key_len, - value: T::Schedule::get().limits.payload_len.to_le_bytes().into(), - }, - ], - call_body: Some(body::plain(vec![ - Instruction::I32Const(0), // key_ptr - Instruction::I32Const(max_key_len as i32), // key_len - Instruction::I32Const((max_key_len + 4) as i32), // out_ptr - Instruction::I32Const(max_key_len as i32), // out_len_ptr - Instruction::Call(0), - Instruction::Drop, - Instruction::End, - ])), - ..Default::default() - }); - call_builder!(func, instance, code); + let key = Key::::try_from_var(vec![0u8; max_key_len as usize]) + .map_err(|_| "Key has wrong length")?; + build_runtime!(runtime, instance, memory: [ key.to_vec(), n.to_le_bytes(), vec![0u8; n as _], ]); let info = instance.info()?; - info.write( - &Key::::try_from_var(key).map_err(|_| "Key has wrong length")?, - Some(vec![42u8; n as usize]), - None, - false, - ) - .map_err(|_| "Failed to write to storage during setup.")?; - >::insert(&instance.account_id, info); - let res; + info.write(&key, Some(vec![42u8; n as usize]), None, false) + .map_err(|_| "Failed to write to storage during setup.")?; + + let out_ptr = max_key_len + 4; + let result; #[block] { - res = func.call(); + result = BenchEnv::seal1_get_storage( + &mut runtime, + &mut memory, + 0, // key_ptr + max_key_len, // key_len + out_ptr, // out_ptr + max_key_len, // out_len_ptr + ); } - assert_eq!(res.did_revert(), false); + assert_ok!(result); + assert_eq!(&info.read(&key).unwrap(), &memory[out_ptr as usize..]); Ok(()) } - // We make sure that all storage accesses are to unique keys. #[benchmark(skip_meta, pov_mode = Measured)] fn seal_contains_storage( - r: Linear<0, { API_BENCHMARK_RUNS / 2 }>, + n: Linear<0, { T::Schedule::get().limits.payload_len }>, ) -> Result<(), BenchmarkError> { let max_key_len = T::MaxStorageKeyLen::get(); - let keys = (0..r) - .map(|n| { - let mut h = T::Hashing::hash_of(&n).as_ref().to_vec(); - h.resize(max_key_len.try_into().unwrap(), n.to_le_bytes()[0]); - h - }) - .collect::>(); - let key_bytes = keys.iter().flatten().cloned().collect::>(); - let code = WasmModule::::from(ModuleDefinition { - memory: Some(ImportedMemory::max::()), - imported_functions: vec![ImportedFunction { - module: "seal1", - name: "contains_storage", - params: vec![ValueType::I32, ValueType::I32], - return_type: Some(ValueType::I32), - }], - data_segments: vec![DataSegment { offset: 0, value: key_bytes }], - call_body: Some(body::repeated_dyn( - r, - vec![ - Counter(0, max_key_len as u32), // key_ptr - Regular(Instruction::I32Const(max_key_len as i32)), // key_len - Regular(Instruction::Call(0)), - Regular(Instruction::Drop), - ], - )), - ..Default::default() - }); - call_builder!(func, instance, code); + let key = Key::::try_from_var(vec![0u8; max_key_len as usize]) + .map_err(|_| "Key has wrong length")?; + build_runtime!(runtime, instance, memory: [ key.to_vec(), ]); let info = instance.info()?; - for key in keys { - info.write( - &Key::::try_from_var(key).map_err(|_| "Key has wrong length")?, - Some(vec![]), - None, - false, - ) + + info.write(&key, Some(vec![42u8; n as usize]), None, false) .map_err(|_| "Failed to write to storage during setup.")?; - } - >::insert(&instance.account_id, info); - let res; + let result; #[block] { - res = func.call(); + result = BenchEnv::seal1_contains_storage(&mut runtime, &mut memory, 0, max_key_len); } - assert_eq!(res.did_revert(), false); + + assert_eq!(result.unwrap(), n); Ok(()) } #[benchmark(skip_meta, pov_mode = Measured)] - fn seal_contains_storage_per_byte( + fn seal_take_storage( n: Linear<0, { T::Schedule::get().limits.payload_len }>, ) -> Result<(), BenchmarkError> { let max_key_len = T::MaxStorageKeyLen::get(); - let key = vec![0u8; max_key_len as usize]; - let code = WasmModule::::from(ModuleDefinition { - memory: Some(ImportedMemory::max::()), - imported_functions: vec![ImportedFunction { - module: "seal1", - name: "contains_storage", - params: vec![ValueType::I32, ValueType::I32], - return_type: Some(ValueType::I32), - }], - data_segments: vec![DataSegment { offset: 0, value: key.clone() }], - call_body: Some(body::plain(vec![ - Instruction::I32Const(0), // key_ptr - Instruction::I32Const(max_key_len as i32), // key_len - Instruction::Call(0), - Instruction::Drop, - Instruction::End, - ])), - ..Default::default() - }); - call_builder!(func, instance, code); + let key = Key::::try_from_var(vec![0u8; max_key_len as usize]) + .map_err(|_| "Key has wrong length")?; + build_runtime!(runtime, instance, memory: [ key.to_vec(), n.to_le_bytes(), vec![0u8; n as _], ]); let info = instance.info()?; - info.write( - &Key::::try_from_var(key).map_err(|_| "Key has wrong length")?, - Some(vec![42u8; n as usize]), - None, - false, - ) - .map_err(|_| "Failed to write to storage during setup.")?; - >::insert(&instance.account_id, info); - let res; - #[block] - { - res = func.call(); - } - assert_eq!(res.did_revert(), false); - Ok(()) - } - - #[benchmark(skip_meta, pov_mode = Measured)] - fn seal_take_storage(r: Linear<0, { API_BENCHMARK_RUNS / 2 }>) -> Result<(), BenchmarkError> { - let max_key_len = T::MaxStorageKeyLen::get(); - let keys = (0..r) - .map(|n| { - let mut h = T::Hashing::hash_of(&n).as_ref().to_vec(); - h.resize(max_key_len.try_into().unwrap(), n.to_le_bytes()[0]); - h - }) - .collect::>(); - let key_bytes = keys.iter().flatten().cloned().collect::>(); - let key_bytes_len = key_bytes.len(); - let code = WasmModule::::from(ModuleDefinition { - memory: Some(ImportedMemory::max::()), - imported_functions: vec![ImportedFunction { - module: "seal0", - name: "take_storage", - params: vec![ValueType::I32, ValueType::I32, ValueType::I32, ValueType::I32], - return_type: Some(ValueType::I32), - }], - data_segments: vec![ - DataSegment { offset: 0, value: key_bytes }, - DataSegment { - offset: key_bytes_len as u32, - value: T::Schedule::get().limits.payload_len.to_le_bytes().into(), - }, - ], - call_body: Some(body::repeated_dyn( - r, - vec![ - Counter(0, max_key_len as u32), // key_ptr - Regular(Instruction::I32Const(max_key_len as i32)), // key_len - Regular(Instruction::I32Const((key_bytes_len + 4) as i32)), // out_ptr - Regular(Instruction::I32Const(key_bytes_len as i32)), // out_len_ptr - Regular(Instruction::Call(0)), - Regular(Instruction::Drop), - ], - )), - ..Default::default() - }); - call_builder!(func, instance, code); - let info = instance.info()?; - for key in keys { - info.write( - &Key::::try_from_var(key).map_err(|_| "Key has wrong length")?, - Some(vec![]), - None, - false, - ) + let value = vec![42u8; n as usize]; + info.write(&key, Some(value.clone()), None, false) .map_err(|_| "Failed to write to storage during setup.")?; - } - >::insert(&instance.account_id, info); - let res; + let out_ptr = max_key_len + 4; + let result; #[block] { - res = func.call(); + result = BenchEnv::seal0_take_storage( + &mut runtime, + &mut memory, + 0, // key_ptr + max_key_len, // key_len + out_ptr, // out_ptr + max_key_len, // out_len_ptr + ); } - assert_eq!(res.did_revert(), false); - Ok(()) - } - #[benchmark(skip_meta, pov_mode = Measured)] - fn seal_take_storage_per_byte( - n: Linear<0, { T::Schedule::get().limits.payload_len }>, - ) -> Result<(), BenchmarkError> { - let max_key_len = T::MaxStorageKeyLen::get(); - let key = vec![0u8; max_key_len as usize]; - let code = WasmModule::::from(ModuleDefinition { - memory: Some(ImportedMemory::max::()), - imported_functions: vec![ImportedFunction { - module: "seal0", - name: "take_storage", - params: vec![ValueType::I32, ValueType::I32, ValueType::I32, ValueType::I32], - return_type: Some(ValueType::I32), - }], - data_segments: vec![ - DataSegment { offset: 0, value: key.clone() }, - DataSegment { - offset: max_key_len, - value: T::Schedule::get().limits.payload_len.to_le_bytes().into(), - }, - ], - call_body: Some(body::plain(vec![ - Instruction::I32Const(0), // key_ptr - Instruction::I32Const(max_key_len as i32), // key_len - Instruction::I32Const((max_key_len + 4) as i32), // out_ptr - Instruction::I32Const(max_key_len as i32), // out_len_ptr - Instruction::Call(0), - Instruction::Drop, - Instruction::End, - ])), - ..Default::default() - }); - call_builder!(func, instance, code); - let info = instance.info()?; - info.write( - &Key::::try_from_var(key).map_err(|_| "Key has wrong length")?, - Some(vec![42u8; n as usize]), - None, - false, - ) - .map_err(|_| "Failed to write to storage during setup.")?; - >::insert(&instance.account_id, info); - - let res; - #[block] - { - res = func.call(); - } - assert_eq!(res.did_revert(), false); + assert_ok!(result); + assert!(&info.read(&key).is_none()); + assert_eq!(&value, &memory[out_ptr as usize..]); Ok(()) } // We transfer to unique accounts. #[benchmark(pov_mode = Measured)] - fn seal_transfer(r: Linear<0, API_BENCHMARK_RUNS>) -> Result<(), BenchmarkError> { - let accounts = - (0..r).map(|i| account::("receiver", i, 0)).collect::>(); - let account_len = accounts.get(0).map(|i| i.encode().len()).unwrap_or(0); - let account_bytes = accounts.iter().flat_map(|x| x.encode()).collect(); + fn seal_transfer() { + let account = account::("receiver", 0, 0); let value = Pallet::::min_balance(); assert!(value > 0u32.into()); - let value_bytes = value.encode(); - let value_len = value_bytes.len(); - let code = WasmModule::::from(ModuleDefinition { - memory: Some(ImportedMemory::max::()), - imported_functions: vec![ImportedFunction { - module: "seal0", - name: "seal_transfer", - params: vec![ValueType::I32, ValueType::I32, ValueType::I32, ValueType::I32], - return_type: Some(ValueType::I32), - }], - data_segments: vec![ - DataSegment { offset: 0, value: value_bytes }, - DataSegment { offset: value_len as u32, value: account_bytes }, - ], - call_body: Some(body::repeated_dyn( - r, - vec![ - Counter(value_len as u32, account_len as u32), // account_ptr - Regular(Instruction::I32Const(account_len as i32)), // account_len - Regular(Instruction::I32Const(0)), // value_ptr - Regular(Instruction::I32Const(value_len as i32)), // value_len - Regular(Instruction::Call(0)), - Regular(Instruction::Drop), - ], - )), - ..Default::default() - }); - let mut setup = CallSetup::::new(code); - setup.set_balance(value * (r + 1).into()); - call_builder!(func, setup: setup); - - for account in &accounts { - assert_eq!(T::Currency::total_balance(account), 0u32.into()); - } - let res; - #[block] - { - res = func.call(); - } - assert_eq!(res.did_revert(), false); - - for account in &accounts { - assert_eq!(T::Currency::total_balance(account), value); - } - Ok(()) - } + let mut setup = CallSetup::::default(); + setup.set_balance(value); + let (mut ext, _) = setup.ext(); + let mut runtime = crate::wasm::Runtime::new(&mut ext, vec![]); - // We call unique accounts. - // - // This is a slow call: We reduce the number of runs. - #[benchmark(pov_mode = Measured)] - fn seal_call(r: Linear<0, { API_BENCHMARK_RUNS / 2 }>) -> Result<(), BenchmarkError> { - let dummy_code = WasmModule::::dummy_with_bytes(0); - let callees = (0..r) - .map(|i| Contract::with_index(i + 1, dummy_code.clone(), vec![])) - .collect::, _>>()?; - let callee_len = callees.get(0).map(|i| i.account_id.encode().len()).unwrap_or(0); - let callee_bytes = callees.iter().flat_map(|x| x.account_id.encode()).collect(); - let value: BalanceOf = 0u32.into(); + let account_bytes = account.encode(); + let account_len = account_bytes.len() as u32; let value_bytes = value.encode(); - let value_len = BalanceOf::::max_encoded_len() as u32; - // Set an own limit every 2nd call - let own_limit = (u32::MAX - 100).into(); - let deposits = (0..r) - .map(|i| if i % 2 == 0 { 0u32.into() } else { own_limit }) - .collect::>>(); - let deposits_bytes: Vec = deposits.iter().flat_map(|i| i.encode()).collect(); - let deposits_len = deposits_bytes.len() as u32; - let deposit_len = value_len; - let callee_offset = value_len + deposits_len; - let code = WasmModule::::from(ModuleDefinition { - memory: Some(ImportedMemory::max::()), - imported_functions: vec![ImportedFunction { - module: "seal2", - name: "call", - params: vec![ - ValueType::I32, - ValueType::I32, - ValueType::I64, - ValueType::I64, - ValueType::I32, - ValueType::I32, - ValueType::I32, - ValueType::I32, - ValueType::I32, - ValueType::I32, - ], - return_type: Some(ValueType::I32), - }], - data_segments: vec![ - DataSegment { offset: 0, value: value_bytes }, - DataSegment { offset: value_len, value: deposits_bytes }, - DataSegment { offset: callee_offset, value: callee_bytes }, - ], - call_body: Some(body::repeated_dyn( - r, - vec![ - Regular(Instruction::I32Const(0)), // flags - Counter(callee_offset, callee_len as u32), // callee_ptr - Regular(Instruction::I64Const(0)), // ref_time weight - Regular(Instruction::I64Const(0)), // proof_size weight - Counter(value_len, deposit_len as u32), // deposit_limit_ptr - Regular(Instruction::I32Const(0)), // value_ptr - Regular(Instruction::I32Const(0)), // input_data_ptr - Regular(Instruction::I32Const(0)), // input_data_len - Regular(Instruction::I32Const(SENTINEL as i32)), // output_ptr - Regular(Instruction::I32Const(0)), // output_len_ptr - Regular(Instruction::Call(0)), - Regular(Instruction::Drop), - ], - )), - ..Default::default() - }); - let mut setup = CallSetup::::new(code); - setup.set_storage_deposit_limit(BalanceOf::::from(u32::MAX.into())); - call_builder!(func, setup: setup); + let value_len = value_bytes.len() as u32; + let mut memory = memory!(account_bytes, value_bytes,); - let res; + let result; #[block] { - res = func.call(); + result = BenchEnv::seal0_transfer( + &mut runtime, + &mut memory, + 0, // account_ptr + account_len, + account_len, + value_len, + ); } - assert_eq!(res.did_revert(), false); - Ok(()) - } - // This is a slow call: We reduce the number of runs. - #[benchmark(pov_mode = Measured)] - fn seal_delegate_call(r: Linear<0, { API_BENCHMARK_RUNS / 2 }>) -> Result<(), BenchmarkError> { - let hashes = (0..r) - .map(|i| { - let code = WasmModule::::dummy_with_bytes(i); - let caller = whitelisted_caller(); - T::Currency::set_balance(&caller, caller_funding::()); - Contracts::::store_code_raw(code.code, caller)?; - Ok(code.hash) - }) - .collect::, &'static str>>()?; - let hash_len = hashes.get(0).map(|x| x.encode().len()).unwrap_or(0); - let hashes_bytes = hashes.iter().flat_map(|x| x.encode()).collect::>(); - let hashes_offset = 0; - - let code = WasmModule::::from(ModuleDefinition { - memory: Some(ImportedMemory::max::()), - imported_functions: vec![ImportedFunction { - module: "seal0", - name: "seal_delegate_call", - params: vec![ - ValueType::I32, - ValueType::I32, - ValueType::I32, - ValueType::I32, - ValueType::I32, - ValueType::I32, - ], - return_type: Some(ValueType::I32), - }], - data_segments: vec![DataSegment { offset: hashes_offset as u32, value: hashes_bytes }], - call_body: Some(body::repeated_dyn( - r, - vec![ - Regular(Instruction::I32Const(0)), // flags - Counter(hashes_offset as u32, hash_len as u32), // code_hash_ptr - Regular(Instruction::I32Const(0)), // input_data_ptr - Regular(Instruction::I32Const(0)), // input_data_len - Regular(Instruction::I32Const(u32::max_value() as i32)), // output_ptr - Regular(Instruction::I32Const(0)), // output_len_ptr - Regular(Instruction::Call(0)), - Regular(Instruction::Drop), - ], - )), - ..Default::default() - }); - call_builder!(func, code); - - let res; - #[block] - { - res = func.call(); - } - assert_eq!(res.did_revert(), false); - Ok(()) + assert_ok!(result); } + // d: deposit limit + // t: value to transfer + // c: size of the call data #[benchmark(pov_mode = Measured)] - fn seal_call_per_transfer_clone_byte( + fn seal_call( + d: Linear<0, { 1 }>, t: Linear<0, { 1 }>, c: Linear<0, { code::max_pages::() * 64 * 1024 }>, - ) -> Result<(), BenchmarkError> { - let callee = Contract::with_index(5, >::dummy(), vec![])?; + ) { + let Contract { account_id: callee, .. } = + Contract::::with_index(1, WasmModule::dummy(), vec![]).unwrap(); + let callee_bytes = callee.encode(); + let callee_len = callee_bytes.len() as u32; + let value: BalanceOf = t.into(); let value_bytes = value.encode(); - let value_len = value_bytes.len(); - let code = WasmModule::::from(ModuleDefinition { - memory: Some(ImportedMemory::max::()), - imported_functions: vec![ImportedFunction { - module: "seal1", - name: "seal_call", - params: vec![ - ValueType::I32, - ValueType::I32, - ValueType::I64, - ValueType::I32, - ValueType::I32, - ValueType::I32, - ValueType::I32, - ValueType::I32, - ], - return_type: Some(ValueType::I32), - }], - data_segments: vec![ - DataSegment { offset: 0, value: value_bytes }, - DataSegment { offset: value_len as u32, value: callee.account_id.encode() }, - ], - call_body: Some(body::plain(vec![ - Instruction::I32Const(CallFlags::CLONE_INPUT.bits() as i32), // flags - Instruction::I32Const(value_len as i32), // callee_ptr - Instruction::I64Const(0), // gas - Instruction::I32Const(0), // value_ptr - Instruction::I32Const(0), // input_data_ptr - Instruction::I32Const(0), // input_data_len - Instruction::I32Const(SENTINEL as i32), // output_ptr - Instruction::I32Const(0), // output_len_ptr - Instruction::Call(0), - Instruction::Drop, - Instruction::End, - ])), - ..Default::default() - }); - let mut setup = CallSetup::::new(code); + + let deposit: BalanceOf = (d * (u32::MAX - 100)).into(); + let deposit_bytes = deposit.encode(); + let deposit_len = deposit_bytes.len() as u32; + + let mut setup = CallSetup::::default(); + if d > 0 { + setup.set_storage_deposit_limit(deposit); + } setup.set_data(vec![42; c as usize]); - call_builder!(func, setup: setup); + let (mut ext, _) = setup.ext(); + let mut runtime = crate::wasm::Runtime::new(&mut ext, vec![]); + let mut memory = memory!(callee_bytes, deposit_bytes, value_bytes,); - let res; + let result; #[block] { - res = func.call(); + result = BenchEnv::seal2_call( + &mut runtime, + &mut memory, + CallFlags::CLONE_INPUT.bits(), // flags + 0, // callee_ptr + 0, // ref_time_limit + 0, // proof_size_limit + callee_len, // deposit_ptr + callee_len + deposit_len, // value_ptr + 0, // input_data_ptr + 0, // input_data_len + SENTINEL, // output_ptr + 0, // output_len_ptr + ); } - assert_eq!(res.did_revert(), false); - Ok(()) + + assert_ok!(result); } - // We assume that every instantiate sends at least the minimum balance. - // This is a slow call: we reduce the number of runs. #[benchmark(pov_mode = Measured)] - fn seal_instantiate(r: Linear<1, { API_BENCHMARK_RUNS / 2 }>) -> Result<(), BenchmarkError> { - let hashes = (0..r) - .map(|i| { - let code = WasmModule::::from(ModuleDefinition { - memory: Some(ImportedMemory::max::()), - call_body: Some(body::plain(vec![ - // We need to add this in order to make contracts unique, - // so that they can be deployed from the same sender. - Instruction::I32Const(i as i32), - Instruction::Drop, - Instruction::End, - ])), - ..Default::default() - }); - let caller = whitelisted_caller(); - T::Currency::set_balance(&caller, caller_funding::()); - Contracts::::store_code_raw(code.code, caller)?; - Ok(code.hash) - }) - .collect::, &'static str>>()?; - let hash_len = hashes.get(0).map(|x| x.encode().len()).unwrap_or(0); - let hashes_bytes = hashes.iter().flat_map(|x| x.encode()).collect::>(); - let hashes_len = &hashes_bytes.len(); - let value = Pallet::::min_balance(); - assert!(value > 0u32.into()); - let value_bytes = value.encode(); - let value_len = BalanceOf::::max_encoded_len(); - let addr_len = T::AccountId::max_encoded_len(); - // Offsets where to place static data in contract memory. - let hashes_offset = value_len; - let addr_len_offset = hashes_offset + hashes_len; - let addr_offset = addr_len_offset + addr_len; - let code = WasmModule::::from(ModuleDefinition { - memory: Some(ImportedMemory::max::()), - imported_functions: vec![ImportedFunction { - module: "seal2", - name: "instantiate", - params: vec![ - ValueType::I32, - ValueType::I64, - ValueType::I64, - ValueType::I32, - ValueType::I32, - ValueType::I32, - ValueType::I32, - ValueType::I32, - ValueType::I32, - ValueType::I32, - ValueType::I32, - ValueType::I32, - ValueType::I32, - ], - return_type: Some(ValueType::I32), - }], - data_segments: vec![ - DataSegment { offset: 0, value: value_bytes }, - DataSegment { offset: hashes_offset as u32, value: hashes_bytes }, - DataSegment { - offset: addr_len_offset as u32, - value: addr_len.to_le_bytes().into(), - }, - ], - call_body: Some(body::repeated_dyn( - r, - vec![ - Counter(hashes_offset as u32, hash_len as u32), // code_hash_ptr - Regular(Instruction::I64Const(0)), // ref_time weight - Regular(Instruction::I64Const(0)), // proof_size weight - Regular(Instruction::I32Const(SENTINEL as i32)), /* deposit limit ptr: use - * parent's limit */ - Regular(Instruction::I32Const(0)), // value_ptr - Regular(Instruction::I32Const(0)), // input_data_ptr - Regular(Instruction::I32Const(0)), // input_data_len - Regular(Instruction::I32Const(addr_offset as i32)), // address_ptr - Regular(Instruction::I32Const(addr_len_offset as i32)), // address_len_ptr - Regular(Instruction::I32Const(SENTINEL as i32)), // output_ptr - Regular(Instruction::I32Const(0)), // output_len_ptr - Regular(Instruction::I32Const(0)), // salt_ptr - Regular(Instruction::I32Const(0)), // salt_len_ptr - Regular(Instruction::Call(0)), - Regular(Instruction::Drop), - ], - )), - ..Default::default() - }); - let mut setup = CallSetup::::new(code); - setup.set_balance((value + Pallet::::min_balance()) * (r + 1).into()); - call_builder!(func, instance, setup: setup); - let addresses = hashes - .iter() - .map(|hash| Contracts::::contract_address(&instance.account_id, hash, &[], &[])) - .collect::>(); - - for addr in &addresses { - if ContractInfoOf::::get(&addr).is_some() { - return Err("Expected that contract does not exist at this point.".into()); - } - } + fn seal_delegate_call() -> Result<(), BenchmarkError> { + let hash = Contract::::with_index(1, WasmModule::dummy(), vec![])?.info()?.code_hash; + build_runtime!(runtime, memory: [hash.encode(), ]); - let res; + let result; #[block] { - res = func.call(); - } - assert_eq!(res.did_revert(), false); - for addr in &addresses { - ContractInfoOf::::get(&addr).ok_or("Contract should have been instantiated")?; + result = BenchEnv::seal0_delegate_call( + &mut runtime, + &mut memory, + 0, // flags + 0, // code_hash_ptr + 0, // input_data_ptr + 0, // input_data_len + SENTINEL, // output_ptr + 0, + ); } + + assert_ok!(result); Ok(()) } + // t: value to transfer + // i: size of input in bytes + // s: size of salt in bytes #[benchmark(pov_mode = Measured)] - fn seal_instantiate_per_transfer_input_salt_byte( + fn seal_instantiate( t: Linear<0, 1>, i: Linear<0, { (code::max_pages::() - 1) * 64 * 1024 }>, s: Linear<0, { (code::max_pages::() - 1) * 64 * 1024 }>, ) -> Result<(), BenchmarkError> { - let callee_code = WasmModule::::dummy(); - let hash_bytes = callee_code.hash.encode(); - let hash_len = hash_bytes.len(); - let caller = whitelisted_caller(); - T::Currency::set_balance(&caller, caller_funding::()); - Contracts::::store_code_raw(callee_code.code, caller)?; + let hash = Contract::::with_index(1, WasmModule::dummy(), vec![])?.info()?.code_hash; + let hash_bytes = hash.encode(); + let hash_len = hash_bytes.len() as u32; + let value: BalanceOf = t.into(); let value_bytes = value.encode(); + let value_len = value_bytes.len() as u32; - let code = WasmModule::::from(ModuleDefinition { - memory: Some(ImportedMemory::max::()), - imported_functions: vec![ImportedFunction { - module: "seal1", - name: "seal_instantiate", - params: vec![ - ValueType::I32, - ValueType::I64, - ValueType::I32, - ValueType::I32, - ValueType::I32, - ValueType::I32, - ValueType::I32, - ValueType::I32, - ValueType::I32, - ValueType::I32, - ValueType::I32, - ], - return_type: Some(ValueType::I32), - }], - data_segments: vec![ - DataSegment { offset: 0, value: hash_bytes }, - DataSegment { offset: hash_len as u32, value: value_bytes }, - ], - call_body: Some(body::plain(vec![ - Instruction::I32Const(0 as i32), // code_hash_ptr - Instruction::I64Const(0), // gas - Instruction::I32Const(hash_len as i32), // value_ptr - Instruction::I32Const(0 as i32), // input_data_ptr - Instruction::I32Const(i as i32), // input_data_len - Instruction::I32Const(SENTINEL as i32), // address_ptr - Instruction::I32Const(0), // address_len_ptr - Instruction::I32Const(SENTINEL as i32), // output_ptr - Instruction::I32Const(0), // output_len_ptr - Instruction::I32Const(0 as i32), // salt_ptr - Instruction::I32Const(s as i32), // salt_len - Instruction::Call(0), - Instruction::I32Eqz, - Instruction::If(BlockType::NoResult), - Instruction::Nop, - Instruction::Else, - Instruction::Unreachable, - Instruction::End, - Instruction::End, - ])), - ..Default::default() - }); - let mut setup = CallSetup::::new(code); - setup.set_balance(value + (Pallet::::min_balance() * 2u32.into())); - call_builder!(func, setup: setup); + let deposit: BalanceOf = 0u32.into(); + let deposit_bytes = deposit.encode(); + let deposit_len = deposit_bytes.len() as u32; - let res; - #[block] - { - res = func.call(); - } - assert_eq!(res.did_revert(), false); - Ok(()) - } + let mut setup = CallSetup::::default(); + setup.set_balance(value + (Pallet::::min_balance() * 2u32.into())); + let account_id = &setup.contract().account_id.clone(); + let (mut ext, _) = setup.ext(); + let mut runtime = crate::wasm::Runtime::new(&mut ext, vec![]); - // Only the overhead of calling the function itself with minimal arguments. - #[benchmark(pov_mode = Measured)] - fn seal_hash_sha2_256(r: Linear<0, API_BENCHMARK_RUNS>) { - call_builder!(func, WasmModule::hasher("seal_hash_sha2_256", r, 0)); + let input = vec![42u8; i as _]; + let salt = vec![42u8; s as _]; + let addr = Contracts::::contract_address(&account_id, &hash, &input, &salt); + let mut memory = memory!(hash_bytes, deposit_bytes, value_bytes, input, salt,); - let res; - #[block] - { - res = func.call(); - } - assert_eq!(res.did_revert(), false); - } + let mut offset = { + let mut current = 0u32; + move |after: u32| { + current += after; + current + } + }; - // `n`: Input to hash in bytes - #[benchmark(pov_mode = Measured)] - fn seal_hash_sha2_256_per_byte(n: Linear<0, { code::max_pages::() * 64 * 1024 }>) { - call_builder!(func, WasmModule::hasher("seal_hash_sha2_256", 1, n)); + assert!(ContractInfoOf::::get(&addr).is_none()); - let res; + let result; #[block] { - res = func.call(); + result = BenchEnv::seal2_instantiate( + &mut runtime, + &mut memory, + 0, // code_hash_ptr + 0, // ref_time_limit + 0, // proof_size_limit + offset(hash_len), // deposit_ptr + offset(deposit_len), // value_ptr + offset(value_len), // input_data_ptr + i, // input_data_len + SENTINEL, // address_ptr + 0, // address_len_ptr + SENTINEL, // output_ptr + 0, // output_len_ptr + offset(i), // salt_ptr + s, // salt_len + ); } - assert_eq!(res.did_revert(), false); - } - // Only the overhead of calling the function itself with minimal arguments. - #[benchmark(pov_mode = Measured)] - fn seal_hash_keccak_256(r: Linear<0, API_BENCHMARK_RUNS>) { - call_builder!(func, WasmModule::hasher("seal_hash_keccak_256", r, 0)); - - let res; - #[block] - { - res = func.call(); - } - assert_eq!(res.did_revert(), false); + assert_ok!(result); + assert!(ContractInfoOf::::get(&addr).is_some()); + Ok(()) } // `n`: Input to hash in bytes #[benchmark(pov_mode = Measured)] - fn seal_hash_keccak_256_per_byte(n: Linear<0, { code::max_pages::() * 64 * 1024 }>) { - call_builder!(func, WasmModule::hasher("seal_hash_keccak_256", 1, n)); - - let res; - #[block] - { - res = func.call(); - } - assert_eq!(res.did_revert(), false); - } + fn seal_hash_sha2_256(n: Linear<0, { code::max_pages::() * 64 * 1024 }>) { + build_runtime!(runtime, memory: [[0u8; 32], vec![0u8; n as usize], ]); - // Only the overhead of calling the function itself with minimal arguments. - #[benchmark(pov_mode = Measured)] - fn seal_hash_blake2_256(r: Linear<0, API_BENCHMARK_RUNS>) { - call_builder!(func, WasmModule::hasher("seal_hash_blake2_256", r, 0)); - - let res; + let result; #[block] { - res = func.call(); + result = BenchEnv::seal0_hash_sha2_256(&mut runtime, &mut memory, 32, n, 0); } - assert_eq!(res.did_revert(), false); + assert_eq!(sp_io::hashing::sha2_256(&memory[32..]), &memory[0..32]); + assert_ok!(result); } // `n`: Input to hash in bytes #[benchmark(pov_mode = Measured)] - fn seal_hash_blake2_256_per_byte(n: Linear<0, { code::max_pages::() * 64 * 1024 }>) { - call_builder!(func, WasmModule::hasher("seal_hash_blake2_256", 1, n)); + fn seal_hash_keccak_256(n: Linear<0, { code::max_pages::() * 64 * 1024 }>) { + build_runtime!(runtime, memory: [[0u8; 32], vec![0u8; n as usize], ]); - let res; + let result; #[block] { - res = func.call(); + result = BenchEnv::seal0_hash_keccak_256(&mut runtime, &mut memory, 32, n, 0); } - assert_eq!(res.did_revert(), false); + assert_eq!(sp_io::hashing::keccak_256(&memory[32..]), &memory[0..32]); + assert_ok!(result); } - // Only the overhead of calling the function itself with minimal arguments. + // `n`: Input to hash in bytes #[benchmark(pov_mode = Measured)] - fn seal_hash_blake2_128(r: Linear<0, API_BENCHMARK_RUNS>) { - call_builder!(func, WasmModule::hasher("seal_hash_blake2_128", r, 0)); + fn seal_hash_blake2_256(n: Linear<0, { code::max_pages::() * 64 * 1024 }>) { + build_runtime!(runtime, memory: [[0u8; 32], vec![0u8; n as usize], ]); - let res; + let result; #[block] { - res = func.call(); + result = BenchEnv::seal0_hash_blake2_256(&mut runtime, &mut memory, 32, n, 0); } - assert_eq!(res.did_revert(), false); + assert_eq!(sp_io::hashing::blake2_256(&memory[32..]), &memory[0..32]); + assert_ok!(result); } // `n`: Input to hash in bytes #[benchmark(pov_mode = Measured)] - fn seal_hash_blake2_128_per_byte(n: Linear<0, { code::max_pages::() * 64 * 1024 }>) { - call_builder!(func, WasmModule::hasher("seal_hash_blake2_128", 1, n)); + fn seal_hash_blake2_128(n: Linear<0, { code::max_pages::() * 64 * 1024 }>) { + build_runtime!(runtime, memory: [[0u8; 16], vec![0u8; n as usize], ]); - let res; + let result; #[block] { - res = func.call(); + result = BenchEnv::seal0_hash_blake2_128(&mut runtime, &mut memory, 16, n, 0); } - assert_eq!(res.did_revert(), false); + assert_eq!(sp_io::hashing::blake2_128(&memory[16..]), &memory[0..16]); + assert_ok!(result); } // `n`: Message input length to verify in bytes. // need some buffer so the code size does not exceed the max code size. #[benchmark(pov_mode = Measured)] - fn seal_sr25519_verify_per_byte( - n: Linear<0, { T::MaxCodeLen::get() - 255 }>, - ) -> Result<(), BenchmarkError> { + fn seal_sr25519_verify_per_byte(n: Linear<0, { T::MaxCodeLen::get() - 255 }>) { let message = (0..n).zip((32u8..127u8).cycle()).map(|(_, c)| c).collect::>(); - let message_len = message.len() as i32; + let message_len = message.len() as u32; let key_type = sp_core::crypto::KeyTypeId(*b"code"); let pub_key = sp_io::crypto::sr25519_generate(key_type, None); let sig = sp_io::crypto::sr25519_sign(key_type, &pub_key, &message).expect("Generates signature"); let sig = AsRef::<[u8; 64]>::as_ref(&sig).to_vec(); + let sig_len = sig.len() as u32; - let code = WasmModule::::from(ModuleDefinition { - memory: Some(ImportedMemory::max::()), - imported_functions: vec![ImportedFunction { - module: "seal0", - name: "sr25519_verify", - params: vec![ValueType::I32, ValueType::I32, ValueType::I32, ValueType::I32], - return_type: Some(ValueType::I32), - }], - data_segments: vec![ - DataSegment { offset: 0, value: sig }, - DataSegment { offset: 64, value: pub_key.to_vec() }, - DataSegment { offset: 96, value: message }, - ], - call_body: Some(body::plain(vec![ - Instruction::I32Const(0), // signature_ptr - Instruction::I32Const(64), // pub_key_ptr - Instruction::I32Const(message_len), // message_len - Instruction::I32Const(96), // message_ptr - Instruction::Call(0), - Instruction::Drop, - Instruction::End, - ])), - ..Default::default() - }); - - call_builder!(func, code); + build_runtime!(runtime, memory: [sig, pub_key.to_vec(), message, ]); - let res; + let result; #[block] { - res = func.call(); + result = BenchEnv::seal0_sr25519_verify( + &mut runtime, + &mut memory, + 0, // signature_ptr + sig_len, // pub_key_ptr + message_len, // message_len + sig_len + pub_key.len() as u32, // message_ptr + ); } - assert_eq!(res.did_revert(), false); - Ok(()) - } - // Only calling the function itself with valid arguments. - // It generates different private keys and signatures for the message "Hello world". - // This is a slow call: We reduce the number of runs. - #[benchmark(pov_mode = Measured)] - fn seal_sr25519_verify( - r: Linear<0, { API_BENCHMARK_RUNS / 10 }>, - ) -> Result<(), BenchmarkError> { - let message = b"Hello world".to_vec(); - let message_len = message.len() as i32; - let key_type = sp_core::crypto::KeyTypeId(*b"code"); - let sig_params = (0..r) - .flat_map(|_| { - let pub_key = sp_io::crypto::sr25519_generate(key_type, None); - let sig = sp_io::crypto::sr25519_sign(key_type, &pub_key, &message) - .expect("Generates signature"); - let data: [u8; 96] = [AsRef::<[u8]>::as_ref(&sig), AsRef::<[u8]>::as_ref(&pub_key)] - .concat() - .try_into() - .unwrap(); - data - }) - .collect::>(); - let sig_params_len = sig_params.len() as i32; - - let code = WasmModule::::from(ModuleDefinition { - memory: Some(ImportedMemory::max::()), - imported_functions: vec![ImportedFunction { - module: "seal0", - name: "sr25519_verify", - params: vec![ValueType::I32, ValueType::I32, ValueType::I32, ValueType::I32], - return_type: Some(ValueType::I32), - }], - data_segments: vec![ - DataSegment { offset: 0, value: sig_params }, - DataSegment { offset: sig_params_len as u32, value: message }, - ], - call_body: Some(body::repeated_dyn( - r, - vec![ - Counter(0, 96), // signature_ptr - Counter(64, 96), // pub_key_ptr - Regular(Instruction::I32Const(message_len)), // message_len - Regular(Instruction::I32Const(sig_params_len)), // message_ptr - Regular(Instruction::Call(0)), - Regular(Instruction::Drop), - ], - )), - ..Default::default() - }); - call_builder!(func, code); - - let res; - #[block] - { - res = func.call(); - } - assert_eq!(res.did_revert(), false); - Ok(()) + assert_eq!(result.unwrap(), wasm::ReturnErrorCode::Success); } - // Only calling the function itself with valid arguments. - // It generates different private keys and signatures for the message "Hello world". - // This is a slow call: We reduce the number of runs. #[benchmark(pov_mode = Measured)] - fn seal_ecdsa_recover(r: Linear<0, { API_BENCHMARK_RUNS / 10 }>) -> Result<(), BenchmarkError> { + fn seal_ecdsa_recover() { let message_hash = sp_io::hashing::blake2_256("Hello world".as_bytes()); let key_type = sp_core::crypto::KeyTypeId(*b"code"); - let signatures = (0..r) - .map(|_| { - let pub_key = sp_io::crypto::ecdsa_generate(key_type, None); - let sig = sp_io::crypto::ecdsa_sign_prehashed(key_type, &pub_key, &message_hash) - .expect("Generates signature"); - AsRef::<[u8; 65]>::as_ref(&sig).to_vec() - }) - .collect::>(); - let signatures = signatures.iter().flatten().cloned().collect::>(); - let signatures_bytes_len = signatures.len() as i32; - - let code = WasmModule::::from(ModuleDefinition { - memory: Some(ImportedMemory::max::()), - imported_functions: vec![ImportedFunction { - module: "seal0", - name: "seal_ecdsa_recover", - params: vec![ValueType::I32, ValueType::I32, ValueType::I32], - return_type: Some(ValueType::I32), - }], - data_segments: vec![ - DataSegment { offset: 0, value: message_hash[..].to_vec() }, - DataSegment { offset: 32, value: signatures }, - ], - call_body: Some(body::repeated_dyn( - r, - vec![ - Counter(32, 65), // signature_ptr - Regular(Instruction::I32Const(0)), // message_hash_ptr - Regular(Instruction::I32Const(signatures_bytes_len + 32)), // output_len_ptr - Regular(Instruction::Call(0)), - Regular(Instruction::Drop), - ], - )), - ..Default::default() - }); - call_builder!(func, code); + let signature = { + let pub_key = sp_io::crypto::ecdsa_generate(key_type, None); + let sig = sp_io::crypto::ecdsa_sign_prehashed(key_type, &pub_key, &message_hash) + .expect("Generates signature"); + AsRef::<[u8; 65]>::as_ref(&sig).to_vec() + }; + + build_runtime!(runtime, memory: [signature, message_hash, [0u8; 33], ]); - let res; + let result; #[block] { - res = func.call(); + result = BenchEnv::seal0_ecdsa_recover( + &mut runtime, + &mut memory, + 0, // signature_ptr + 65, // message_hash_ptr + 65 + 32, // output_ptr + ); } - assert_eq!(res.did_revert(), false); - Ok(()) + + assert_eq!(result.unwrap(), wasm::ReturnErrorCode::Success); } // Only calling the function itself for the list of // generated different ECDSA keys. // This is a slow call: We reduce the number of runs. #[benchmark(pov_mode = Measured)] - fn seal_ecdsa_to_eth_address( - r: Linear<0, { API_BENCHMARK_RUNS / 10 }>, - ) -> Result<(), BenchmarkError> { + fn seal_ecdsa_to_eth_address() { let key_type = sp_core::crypto::KeyTypeId(*b"code"); - let pub_keys_bytes = (0..r) - .flat_map(|_| sp_io::crypto::ecdsa_generate(key_type, None).0) - .collect::>(); - let pub_keys_bytes_len = pub_keys_bytes.len() as i32; - let code = WasmModule::::from(ModuleDefinition { - memory: Some(ImportedMemory::max::()), - imported_functions: vec![ImportedFunction { - module: "seal0", - name: "seal_ecdsa_to_eth_address", - params: vec![ValueType::I32, ValueType::I32], - return_type: Some(ValueType::I32), - }], - data_segments: vec![DataSegment { offset: 0, value: pub_keys_bytes }], - call_body: Some(body::repeated_dyn( - r, - vec![ - Counter(0, 33), // pub_key_ptr - Regular(Instruction::I32Const(pub_keys_bytes_len)), // out_ptr - Regular(Instruction::Call(0)), - Regular(Instruction::Drop), - ], - )), - ..Default::default() - }); - call_builder!(func, code); + let pub_key_bytes = sp_io::crypto::ecdsa_generate(key_type, None).0; + build_runtime!(runtime, memory: [[0u8; 20], pub_key_bytes,]); - let res; + let result; #[block] { - res = func.call(); + result = BenchEnv::seal0_ecdsa_to_eth_address( + &mut runtime, + &mut memory, + 20, // key_ptr + 0, // output_ptr + ); } - assert_eq!(res.did_revert(), false); - Ok(()) + + assert_ok!(result); + assert_eq!(&memory[..20], runtime.ext().ecdsa_to_eth_address(&pub_key_bytes).unwrap()); } #[benchmark(pov_mode = Measured)] - fn seal_set_code_hash(r: Linear<0, API_BENCHMARK_RUNS>) -> Result<(), BenchmarkError> { - let code_hashes = (0..r) - .map(|i| { - let new_code = WasmModule::::dummy_with_bytes(i); - let caller = whitelisted_caller(); - T::Currency::set_balance(&caller, caller_funding::()); - Contracts::::store_code_raw(new_code.code, caller)?; - Ok(new_code.hash) - }) - .collect::, &'static str>>()?; - let code_hash_len = code_hashes.get(0).map(|x| x.encode().len()).unwrap_or(0); - let code_hashes_bytes = code_hashes.iter().flat_map(|x| x.encode()).collect::>(); - - let code = WasmModule::::from(ModuleDefinition { - memory: Some(ImportedMemory::max::()), - imported_functions: vec![ImportedFunction { - module: "seal0", - name: "seal_set_code_hash", - params: vec![ValueType::I32], - return_type: Some(ValueType::I32), - }], - data_segments: vec![DataSegment { offset: 0, value: code_hashes_bytes }], - call_body: Some(body::repeated_dyn( - r, - vec![ - Counter(0, code_hash_len as u32), // code_hash_ptr - Regular(Instruction::Call(0)), - Regular(Instruction::Drop), - ], - )), - ..Default::default() - }); - call_builder!(func, code); + fn seal_set_code_hash() -> Result<(), BenchmarkError> { + let code_hash = + Contract::::with_index(1, WasmModule::dummy(), vec![])?.info()?.code_hash; + + build_runtime!(runtime, memory: [ code_hash.encode(),]); - let res; + let result; #[block] { - res = func.call(); + result = BenchEnv::seal0_set_code_hash(&mut runtime, &mut memory, 0); } - assert_eq!(res.did_revert(), false); + + assert_ok!(result); Ok(()) } #[benchmark(pov_mode = Measured)] - fn lock_delegate_dependency( - r: Linear<0, { T::MaxDelegateDependencies::get() }>, - ) -> Result<(), BenchmarkError> { - let code_hashes = (0..r) - .map(|i| { - let new_code = WasmModule::::dummy_with_bytes(65 + i); - let caller = whitelisted_caller(); - T::Currency::set_balance(&caller, caller_funding::()); - Contracts::::store_code_raw(new_code.code, caller)?; - Ok(new_code.hash) - }) - .collect::, &'static str>>()?; - let code_hash_len = code_hashes.get(0).map(|x| x.encode().len()).unwrap_or(0); - let code_hashes_bytes = code_hashes.iter().flat_map(|x| x.encode()).collect::>(); - - let code = WasmModule::::from(ModuleDefinition { - memory: Some(ImportedMemory::max::()), - imported_functions: vec![ImportedFunction { - module: "seal0", - name: "lock_delegate_dependency", - params: vec![ValueType::I32], - return_type: None, - }], - data_segments: vec![DataSegment { offset: 0, value: code_hashes_bytes }], - call_body: Some(body::repeated_dyn( - r, - vec![ - Counter(0, code_hash_len as u32), // code_hash_ptr - Regular(Instruction::Call(0)), - ], - )), - ..Default::default() - }); - call_builder!(func, code); + fn lock_delegate_dependency() -> Result<(), BenchmarkError> { + let code_hash = Contract::::with_index(1, WasmModule::dummy_with_bytes(1), vec![])? + .info()? + .code_hash; - let res; + build_runtime!(runtime, memory: [ code_hash.encode(),]); + + let result; #[block] { - res = func.call(); + result = BenchEnv::seal0_lock_delegate_dependency(&mut runtime, &mut memory, 0); } - assert_eq!(res.did_revert(), false); + + assert_ok!(result); Ok(()) } #[benchmark] - fn unlock_delegate_dependency( - r: Linear<0, { T::MaxDelegateDependencies::get() }>, - ) -> Result<(), BenchmarkError> { - let code_hashes = (0..r) - .map(|i| { - let new_code = WasmModule::::dummy_with_bytes(65 + i); - let caller = whitelisted_caller(); - T::Currency::set_balance(&caller, caller_funding::()); - Contracts::::store_code_raw(new_code.code, caller)?; - Ok(new_code.hash) - }) - .collect::, &'static str>>()?; + fn unlock_delegate_dependency() -> Result<(), BenchmarkError> { + let code_hash = Contract::::with_index(1, WasmModule::dummy_with_bytes(1), vec![])? + .info()? + .code_hash; - let code_hash_len = code_hashes.get(0).map(|x| x.encode().len()).unwrap_or(0); - let code_hashes_bytes = code_hashes.iter().flat_map(|x| x.encode()).collect::>(); - - let code = WasmModule::::from(ModuleDefinition { - memory: Some(ImportedMemory::max::()), - imported_functions: vec![ - ImportedFunction { - module: "seal0", - name: "unlock_delegate_dependency", - params: vec![ValueType::I32], - return_type: None, - }, - ImportedFunction { - module: "seal0", - name: "lock_delegate_dependency", - params: vec![ValueType::I32], - return_type: None, - }, - ], - data_segments: vec![DataSegment { offset: 0, value: code_hashes_bytes }], - deploy_body: Some(body::repeated_dyn( - r, - vec![ - Counter(0, code_hash_len as u32), // code_hash_ptr - Regular(Instruction::Call(1)), - ], - )), - call_body: Some(body::repeated_dyn( - r, - vec![ - Counter(0, code_hash_len as u32), // code_hash_ptr - Regular(Instruction::Call(0)), - ], - )), - ..Default::default() - }); - call_builder!(func, code); + build_runtime!(runtime, memory: [ code_hash.encode(),]); + BenchEnv::seal0_lock_delegate_dependency(&mut runtime, &mut memory, 0).unwrap(); - let res; + let result; #[block] { - res = func.call(); + result = BenchEnv::seal0_unlock_delegate_dependency(&mut runtime, &mut memory, 0); } - assert_eq!(res.did_revert(), false); + + assert_ok!(result); Ok(()) } #[benchmark(pov_mode = Measured)] - fn seal_reentrance_count(r: Linear<0, API_BENCHMARK_RUNS>) -> Result<(), BenchmarkError> { - let code = WasmModule::::from(ModuleDefinition { - memory: Some(ImportedMemory::max::()), - imported_functions: vec![ImportedFunction { - module: "seal0", - name: "reentrance_count", - params: vec![], - return_type: Some(ValueType::I32), - }], - call_body: Some(body::repeated(r, &[Instruction::Call(0), Instruction::Drop])), - ..Default::default() - }); - let instance = Contract::::new(code, vec![])?; - let origin = RawOrigin::Signed(instance.caller.clone()); - #[extrinsic_call] - call(origin, instance.addr, 0u32.into(), Weight::MAX, None, vec![]); - Ok(()) + fn seal_reentrance_count() { + build_runtime!(runtime, memory: []); + let result; + #[block] + { + result = BenchEnv::seal0_reentrance_count(&mut runtime, &mut memory) + } + + assert!(result.unwrap() == 0); } #[benchmark(pov_mode = Measured)] - fn seal_account_reentrance_count( - r: Linear<0, API_BENCHMARK_RUNS>, - ) -> Result<(), BenchmarkError> { - let dummy_code = WasmModule::::dummy_with_bytes(0); - let accounts = (0..r) - .map(|i| Contract::with_index(i + 1, dummy_code.clone(), vec![])) - .collect::, _>>()?; - let account_id_len = accounts.get(0).map(|i| i.account_id.encode().len()).unwrap_or(0); - let account_id_bytes = accounts.iter().flat_map(|x| x.account_id.encode()).collect(); - let code = WasmModule::::from(ModuleDefinition { - memory: Some(ImportedMemory::max::()), - imported_functions: vec![ImportedFunction { - module: "seal0", - name: "account_reentrance_count", - params: vec![ValueType::I32], - return_type: Some(ValueType::I32), - }], - data_segments: vec![DataSegment { offset: 0, value: account_id_bytes }], - call_body: Some(body::repeated_dyn( - r, - vec![ - Counter(0, account_id_len as u32), // account_ptr - Regular(Instruction::Call(0)), - Regular(Instruction::Drop), - ], - )), - ..Default::default() - }); - call_builder!(func, code); + fn seal_account_reentrance_count() { + let Contract { account_id, .. } = + Contract::::with_index(1, WasmModule::dummy(), vec![]).unwrap(); + build_runtime!(runtime, memory: [account_id.encode(),]); - let res; + let result; #[block] { - res = func.call(); + result = BenchEnv::seal0_account_reentrance_count(&mut runtime, &mut memory, 0); } - assert_eq!(res.did_revert(), false); - Ok(()) + + assert!(result.unwrap() == 0); } #[benchmark(pov_mode = Measured)] - fn seal_instantiation_nonce(r: Linear<0, API_BENCHMARK_RUNS>) { - let code = WasmModule::::from(ModuleDefinition { - memory: Some(ImportedMemory::max::()), - imported_functions: vec![ImportedFunction { - module: "seal0", - name: "instantiation_nonce", - params: vec![], - return_type: Some(ValueType::I64), - }], - call_body: Some(body::repeated(r, &[Instruction::Call(0), Instruction::Drop])), - ..Default::default() - }); - call_builder!(func, code); + fn seal_instantiation_nonce() { + build_runtime!(runtime, memory: []); - let res; + let result; #[block] { - res = func.call(); + result = BenchEnv::seal0_instantiation_nonce(&mut runtime, &mut memory); } - assert_eq!(res.did_revert(), false); + + assert_eq!(result.unwrap(), 1); } // We load `i64` values from random linear memory locations and store the loaded From d3921cd60e2b0b44a2225594c460162ab31e790a Mon Sep 17 00:00:00 2001 From: pgherveou Date: Fri, 26 Apr 2024 16:48:35 +0200 Subject: [PATCH 06/34] Fixes --- .../frame/contracts/src/benchmarking/mod.rs | 63 +- substrate/frame/contracts/src/lib.rs | 2 +- substrate/frame/contracts/src/schedule.rs | 319 +-- substrate/frame/contracts/src/wasm/runtime.rs | 142 +- substrate/frame/contracts/src/weights.rs | 2253 ++++++----------- 5 files changed, 861 insertions(+), 1918 deletions(-) diff --git a/substrate/frame/contracts/src/benchmarking/mod.rs b/substrate/frame/contracts/src/benchmarking/mod.rs index a5e9cacb2a24..4317c1e33de7 100644 --- a/substrate/frame/contracts/src/benchmarking/mod.rs +++ b/substrate/frame/contracts/src/benchmarking/mod.rs @@ -23,7 +23,7 @@ mod code; mod sandbox; use self::{ call_builder::CallSetup, - code::{body, ImportedFunction, Location, ModuleDefinition, WasmModule}, + code::{body, ImportedMemory, Location, ModuleDefinition, WasmModule}, sandbox::Sandbox, }; use crate::{ @@ -44,7 +44,7 @@ use frame_support::{ }; use frame_system::RawOrigin; use pallet_balances; -use pallet_contracts_uapi::CallFlags; +use pallet_contracts_uapi::{CallFlags, ReturnErrorCode}; use sp_runtime::traits::{Bounded, Hash}; use sp_std::prelude::*; use wasm_instrument::parity_wasm::elements::{Instruction, Local, ValueType}; @@ -440,13 +440,6 @@ mod benchmarks { Ok(()) } - // This constructs a contract that is maximal expensive to instrument. - // It creates a maximum number of metering blocks per byte. - // The size of the salt influences the runtime because is is hashed in order to - // determine the contract address. All code is generated to the `call` function so that - // we don't benchmark the actual execution of this code but merely what it takes to load - // a code of that size into the sandbox. - // // `c`: Size of the code in bytes. // `i`: Size of the input in bytes. // `s`: Size of the salt in bytes. @@ -480,7 +473,6 @@ mod benchmarks { assert_eq!(T::Currency::balance(&addr), value + Pallet::::min_balance()); } - // Instantiate uses a dummy contract constructor to measure the overhead of the instantiate. // `i`: Size of the input in bytes. // `s`: Size of the salt in bytes. #[benchmark(pov_mode = Measured)] @@ -793,7 +785,7 @@ mod benchmarks { } #[benchmark(pov_mode = Measured)] - fn seal_minimum_balance(r: Linear<0, API_BENCHMARK_RUNS>) { + fn seal_minimum_balance() { let len = ::max_encoded_len() as u32; build_runtime!(runtime, memory: [len.to_le_bytes(), vec![0u8; len as _], ]); let result; @@ -1228,14 +1220,14 @@ mod benchmarks { assert_ok!(result); } - // d: deposit limit - // t: value to transfer - // c: size of the call data + // c: with or without clone flag + // t: with or without some value to transfer + // i: size of the input data #[benchmark(pov_mode = Measured)] fn seal_call( - d: Linear<0, { 1 }>, - t: Linear<0, { 1 }>, - c: Linear<0, { code::max_pages::() * 64 * 1024 }>, + t: Linear<0, 1>, + c: Linear<0, 1>, + i: Linear<0, { code::max_pages::() * 64 * 1024 }>, ) { let Contract { account_id: callee, .. } = Contract::::with_index(1, WasmModule::dummy(), vec![]).unwrap(); @@ -1245,35 +1237,36 @@ mod benchmarks { let value: BalanceOf = t.into(); let value_bytes = value.encode(); - let deposit: BalanceOf = (d * (u32::MAX - 100)).into(); + let deposit: BalanceOf = (u32::MAX - 100).into(); let deposit_bytes = deposit.encode(); let deposit_len = deposit_bytes.len() as u32; let mut setup = CallSetup::::default(); - if d > 0 { - setup.set_storage_deposit_limit(deposit); - } - setup.set_data(vec![42; c as usize]); + setup.set_storage_deposit_limit(deposit); + + setup.set_data(vec![42; i as usize]); let (mut ext, _) = setup.ext(); let mut runtime = crate::wasm::Runtime::new(&mut ext, vec![]); let mut memory = memory!(callee_bytes, deposit_bytes, value_bytes,); + let flags = if c == 1 { CallFlags::CLONE_INPUT } else { CallFlags::empty() }; + let result; #[block] { result = BenchEnv::seal2_call( &mut runtime, &mut memory, - CallFlags::CLONE_INPUT.bits(), // flags - 0, // callee_ptr - 0, // ref_time_limit - 0, // proof_size_limit - callee_len, // deposit_ptr - callee_len + deposit_len, // value_ptr - 0, // input_data_ptr - 0, // input_data_len - SENTINEL, // output_ptr - 0, // output_len_ptr + flags.bits(), // flags + 0, // callee_ptr + 0, // ref_time_limit + 0, // proof_size_limit + callee_len, // deposit_ptr + callee_len + deposit_len, // value_ptr + 0, // input_data_ptr + 0, // input_data_len + SENTINEL, // output_ptr + 0, // output_len_ptr ); } @@ -1432,7 +1425,7 @@ mod benchmarks { // `n`: Message input length to verify in bytes. // need some buffer so the code size does not exceed the max code size. #[benchmark(pov_mode = Measured)] - fn seal_sr25519_verify_per_byte(n: Linear<0, { T::MaxCodeLen::get() - 255 }>) { + fn seal_sr25519_verify(n: Linear<0, { T::MaxCodeLen::get() - 255 }>) { let message = (0..n).zip((32u8..127u8).cycle()).map(|(_, c)| c).collect::>(); let message_len = message.len() as u32; @@ -1458,7 +1451,7 @@ mod benchmarks { ); } - assert_eq!(result.unwrap(), wasm::ReturnErrorCode::Success); + assert_eq!(result.unwrap(), ReturnErrorCode::Success); } #[benchmark(pov_mode = Measured)] @@ -1486,7 +1479,7 @@ mod benchmarks { ); } - assert_eq!(result.unwrap(), wasm::ReturnErrorCode::Success); + assert_eq!(result.unwrap(), ReturnErrorCode::Success); } // Only calling the function itself for the list of diff --git a/substrate/frame/contracts/src/lib.rs b/substrate/frame/contracts/src/lib.rs index b381fd2dc4f0..7c3ee913dbbc 100644 --- a/substrate/frame/contracts/src/lib.rs +++ b/substrate/frame/contracts/src/lib.rs @@ -146,7 +146,7 @@ pub use crate::{ exec::Frame, migration::{MigrateSequence, Migration, NoopMigration}, pallet::*, - schedule::{HostFnWeights, InstructionWeights, Limits, Schedule}, + schedule::{InstructionWeights, Limits, Schedule}, wasm::Determinism, }; pub use weights::WeightInfo; diff --git a/substrate/frame/contracts/src/schedule.rs b/substrate/frame/contracts/src/schedule.rs index 06a7c2005aa5..a1fbdea4228b 100644 --- a/substrate/frame/contracts/src/schedule.rs +++ b/substrate/frame/contracts/src/schedule.rs @@ -22,7 +22,7 @@ use crate::{weights::WeightInfo, Config}; use codec::{Decode, Encode}; use core::marker::PhantomData; -use frame_support::{weights::Weight, DefaultNoBound}; +use frame_support::DefaultNoBound; use scale_info::TypeInfo; #[cfg(feature = "std")] use serde::{Deserialize, Serialize}; @@ -60,9 +60,6 @@ pub struct Schedule { /// The weights for individual wasm instructions. pub instruction_weights: InstructionWeights, - - /// The weights for each imported function a contract is allowed to call. - pub host_fn_weights: HostFnWeights, } /// Describes the upper limits on various metrics. @@ -109,230 +106,6 @@ pub struct InstructionWeights { pub _phantom: PhantomData, } -/// Describes the weight for each imported function that a contract is allowed to call. -#[cfg_attr(feature = "std", derive(Serialize, Deserialize))] -#[cfg_attr(feature = "runtime-benchmarks", derive(pallet_contracts_proc_macro::WeightDebug))] -#[derive(Clone, Encode, Decode, PartialEq, Eq, TypeInfo)] -#[scale_info(skip_type_params(T))] -pub struct HostFnWeights { - /// Weight of calling `seal_caller`. - pub caller: Weight, - - /// Weight of calling `seal_is_contract`. - pub is_contract: Weight, - - /// Weight of calling `seal_code_hash`. - pub code_hash: Weight, - - /// Weight of calling `seal_own_code_hash`. - pub own_code_hash: Weight, - - /// Weight of calling `seal_caller_is_origin`. - pub caller_is_origin: Weight, - - /// Weight of calling `seal_caller_is_root`. - pub caller_is_root: Weight, - - /// Weight of calling `seal_address`. - pub address: Weight, - - /// Weight of calling `seal_gas_left`. - pub gas_left: Weight, - - /// Weight of calling `seal_balance`. - pub balance: Weight, - - /// Weight of calling `seal_value_transferred`. - pub value_transferred: Weight, - - /// Weight of calling `seal_minimum_balance`. - pub minimum_balance: Weight, - - /// Weight of calling `seal_block_number`. - pub block_number: Weight, - - /// Weight of calling `seal_now`. - pub now: Weight, - - /// Weight of calling `seal_weight_to_fee`. - pub weight_to_fee: Weight, - - /// Weight of calling `seal_input`. - pub input: Weight, - - /// Weight per input byte copied to contract memory by `seal_input`. - pub input_per_byte: Weight, - - /// Weight of calling `seal_return`. - pub r#return: Weight, - - /// Weight per byte returned through `seal_return`. - pub return_per_byte: Weight, - - /// Weight of calling `seal_terminate`. - pub terminate: Weight, - - /// Weight of calling `seal_random`. - pub random: Weight, - - /// Weight of calling `seal_reposit_event`. - pub deposit_event: Weight, - - /// Weight per topic supplied to `seal_deposit_event`. - pub deposit_event_per_topic: Weight, - - /// Weight per byte of an event deposited through `seal_deposit_event`. - pub deposit_event_per_byte: Weight, - - /// Weight of calling `seal_debug_message`. - pub debug_message: Weight, - - /// Weight of calling `seal_debug_message` per byte of the message. - pub debug_message_per_byte: Weight, - - /// Weight of calling `seal_set_storage`. - pub set_storage: Weight, - - /// Weight per written byte of an item stored with `seal_set_storage`. - pub set_storage_per_new_byte: Weight, - - /// Weight per overwritten byte of an item stored with `seal_set_storage`. - pub set_storage_per_old_byte: Weight, - - /// Weight of calling `seal_set_code_hash`. - pub set_code_hash: Weight, - - /// Weight of calling `seal_clear_storage`. - pub clear_storage: Weight, - - /// Weight of calling `seal_clear_storage` per byte of the stored item. - pub clear_storage_per_byte: Weight, - - /// Weight of calling `seal_contains_storage`. - pub contains_storage: Weight, - - /// Weight of calling `seal_contains_storage` per byte of the stored item. - pub contains_storage_per_byte: Weight, - - /// Weight of calling `seal_get_storage`. - pub get_storage: Weight, - - /// Weight per byte of an item received via `seal_get_storage`. - pub get_storage_per_byte: Weight, - - /// Weight of calling `seal_take_storage`. - pub take_storage: Weight, - - /// Weight per byte of an item received via `seal_take_storage`. - pub take_storage_per_byte: Weight, - - /// Weight of calling `seal_transfer`. - pub transfer: Weight, - - /// Weight of calling `seal_call`. - pub call: Weight, - - /// Weight of calling `seal_delegate_call`. - pub delegate_call: Weight, - - /// Weight surcharge that is claimed if `seal_call` does a balance transfer. - pub call_transfer_surcharge: Weight, - - /// Weight per byte that is cloned by supplying the `CLONE_INPUT` flag. - pub call_per_cloned_byte: Weight, - - /// Weight of calling `seal_instantiate`. - pub instantiate: Weight, - - /// Weight surcharge that is claimed if `seal_instantiate` does a balance transfer. - pub instantiate_transfer_surcharge: Weight, - - /// Weight per input byte supplied to `seal_instantiate`. - pub instantiate_per_input_byte: Weight, - - /// Weight per salt byte supplied to `seal_instantiate`. - pub instantiate_per_salt_byte: Weight, - - /// Weight of calling `seal_hash_sha_256`. - pub hash_sha2_256: Weight, - - /// Weight per byte hashed by `seal_hash_sha_256`. - pub hash_sha2_256_per_byte: Weight, - - /// Weight of calling `seal_hash_keccak_256`. - pub hash_keccak_256: Weight, - - /// Weight per byte hashed by `seal_hash_keccak_256`. - pub hash_keccak_256_per_byte: Weight, - - /// Weight of calling `seal_hash_blake2_256`. - pub hash_blake2_256: Weight, - - /// Weight per byte hashed by `seal_hash_blake2_256`. - pub hash_blake2_256_per_byte: Weight, - - /// Weight of calling `seal_hash_blake2_128`. - pub hash_blake2_128: Weight, - - /// Weight per byte hashed by `seal_hash_blake2_128`. - pub hash_blake2_128_per_byte: Weight, - - /// Weight of calling `seal_ecdsa_recover`. - pub ecdsa_recover: Weight, - - /// Weight of calling `seal_ecdsa_to_eth_address`. - pub ecdsa_to_eth_address: Weight, - - /// Weight of calling `sr25519_verify`. - pub sr25519_verify: Weight, - - /// Weight per byte of calling `sr25519_verify`. - pub sr25519_verify_per_byte: Weight, - - /// Weight of calling `reentrance_count`. - pub reentrance_count: Weight, - - /// Weight of calling `account_reentrance_count`. - pub account_reentrance_count: Weight, - - /// Weight of calling `instantiation_nonce`. - pub instantiation_nonce: Weight, - - /// Weight of calling `lock_delegate_dependency`. - pub lock_delegate_dependency: Weight, - - /// Weight of calling `unlock_delegate_dependency`. - pub unlock_delegate_dependency: Weight, - - /// The type parameter is used in the default implementation. - #[codec(skip)] - pub _phantom: PhantomData, -} - -macro_rules! replace_token { - ($_in:tt $replacement:tt) => { - $replacement - }; -} - -macro_rules! call_zero { - ($name:ident, $( $arg:expr ),*) => { - T::WeightInfo::$name($( replace_token!($arg 0) ),*) - }; -} - -macro_rules! cost_args { - ($name:ident, $( $arg: expr ),+) => { - (T::WeightInfo::$name($( $arg ),+).saturating_sub(call_zero!($name, $( $arg ),+))) - } -} - -macro_rules! cost { - ($name:ident) => { - cost_args!($name, 1) - }; -} - impl Default for Limits { fn default() -> Self { Self { @@ -350,94 +123,10 @@ impl Default for InstructionWeights { /// computed gas costs by 6 to have a rough estimate as to how expensive each /// single executed instruction is going to be. fn default() -> Self { - let instr_cost = cost!(instr_i64_load_store).ref_time() as u32; + let instr_cost = T::WeightInfo::instr_i64_load_store(1) + .saturating_sub(T::WeightInfo::instr_i64_load_store(0)) + .ref_time() as u32; let base = instr_cost / 6; Self { base, _phantom: PhantomData } } } - -impl Default for HostFnWeights { - fn default() -> Self { - Self { - caller: cost!(seal_caller), - is_contract: cost!(seal_is_contract), - code_hash: cost!(seal_code_hash), - own_code_hash: cost!(seal_own_code_hash), - caller_is_origin: cost!(seal_caller_is_origin), - caller_is_root: cost!(seal_caller_is_root), - address: cost!(seal_address), - gas_left: cost!(seal_gas_left), - balance: cost!(seal_balance), - value_transferred: cost!(seal_value_transferred), - minimum_balance: cost!(seal_minimum_balance), - block_number: cost!(seal_block_number), - now: cost!(seal_now), - weight_to_fee: cost!(seal_weight_to_fee), - input: cost!(seal_input), - input_per_byte: cost!(seal_input_per_byte), - r#return: cost!(seal_return), - return_per_byte: cost!(seal_return_per_byte), - terminate: cost!(seal_terminate), - random: cost!(seal_random), - deposit_event: cost!(seal_deposit_event), - deposit_event_per_topic: cost_args!(seal_deposit_event_per_topic_and_byte, 1, 0), - deposit_event_per_byte: cost_args!(seal_deposit_event_per_topic_and_byte, 0, 1), - debug_message: cost!(seal_debug_message), - debug_message_per_byte: cost!(seal_debug_message_per_byte), - set_storage: cost!(seal_set_storage), - set_code_hash: cost!(seal_set_code_hash), - set_storage_per_new_byte: cost!(seal_set_storage_per_new_byte), - set_storage_per_old_byte: cost!(seal_set_storage_per_old_byte), - clear_storage: cost!(seal_clear_storage), - clear_storage_per_byte: cost!(seal_clear_storage_per_byte), - contains_storage: cost!(seal_contains_storage), - contains_storage_per_byte: cost!(seal_contains_storage_per_byte), - get_storage: cost!(seal_get_storage), - get_storage_per_byte: cost!(seal_get_storage_per_byte), - take_storage: cost!(seal_take_storage), - take_storage_per_byte: cost!(seal_take_storage_per_byte), - transfer: cost!(seal_transfer), - call: cost!(seal_call), - delegate_call: cost!(seal_delegate_call), - call_transfer_surcharge: cost_args!(seal_call_per_transfer_clone_byte, 1, 0), - call_per_cloned_byte: cost_args!(seal_call_per_transfer_clone_byte, 0, 1), - instantiate: cost!(seal_instantiate), - instantiate_transfer_surcharge: cost_args!( - seal_instantiate_per_transfer_input_salt_byte, - 1, - 0, - 0 - ), - instantiate_per_input_byte: cost_args!( - seal_instantiate_per_transfer_input_salt_byte, - 0, - 1, - 0 - ), - instantiate_per_salt_byte: cost_args!( - seal_instantiate_per_transfer_input_salt_byte, - 0, - 0, - 1 - ), - hash_sha2_256: cost!(seal_hash_sha2_256), - hash_sha2_256_per_byte: cost!(seal_hash_sha2_256_per_byte), - hash_keccak_256: cost!(seal_hash_keccak_256), - hash_keccak_256_per_byte: cost!(seal_hash_keccak_256_per_byte), - hash_blake2_256: cost!(seal_hash_blake2_256), - hash_blake2_256_per_byte: cost!(seal_hash_blake2_256_per_byte), - hash_blake2_128: cost!(seal_hash_blake2_128), - hash_blake2_128_per_byte: cost!(seal_hash_blake2_128_per_byte), - ecdsa_recover: cost!(seal_ecdsa_recover), - sr25519_verify: cost!(seal_sr25519_verify), - sr25519_verify_per_byte: cost!(seal_sr25519_verify_per_byte), - ecdsa_to_eth_address: cost!(seal_ecdsa_to_eth_address), - reentrance_count: cost!(seal_reentrance_count), - account_reentrance_count: cost!(seal_account_reentrance_count), - instantiation_nonce: cost!(seal_instantiation_nonce), - lock_delegate_dependency: cost!(lock_delegate_dependency), - unlock_delegate_dependency: cost!(unlock_delegate_dependency), - _phantom: PhantomData, - } - } -} diff --git a/substrate/frame/contracts/src/wasm/runtime.rs b/substrate/frame/contracts/src/wasm/runtime.rs index 04e087c4107a..6781836e5d70 100644 --- a/substrate/frame/contracts/src/wasm/runtime.rs +++ b/substrate/frame/contracts/src/wasm/runtime.rs @@ -21,6 +21,7 @@ use crate::{ exec::{ExecError, ExecResult, Ext, Key, TopicOf}, gas::{ChargedAmount, Token}, primitives::ExecReturnValue, + weights::WeightInfo, BalanceOf, CodeHash, Config, DebugBufferVec, Error, SENTINEL, }; use codec::{Decode, DecodeLimit, Encode, MaxEncodedLen}; @@ -245,6 +246,20 @@ pub enum RuntimeCosts { UnlockDelegateDependency, } +macro_rules! cost_args { + // Replace the token with 0. + (@replace_token $_in:tt) => { 0 }; + + // Transform T:::WeightInfo::name(a, b, c) into T:::WeightInfo::name(0, 0, 0) + (@call_zero $name:ident, $( $arg:expr ),*) => { + T::WeightInfo::$name($( cost_args!(@replace_token $arg) ),*) + }; + + ($name:ident, $( $arg: expr ),+) => { + (T::WeightInfo::$name($( $arg ),+).saturating_sub(cost_args!(@call_zero $name, $( $arg ),+))) + } +} + impl Token for RuntimeCosts { fn influence_lowest_gas_limit(&self) -> bool { match self { @@ -254,85 +269,59 @@ impl Token for RuntimeCosts { } fn weight(&self) -> Weight { - let s = T::Schedule::get().host_fn_weights; use self::RuntimeCosts::*; match *self { - CopyFromContract(len) => s.return_per_byte.saturating_mul(len.into()), - CopyToContract(len) => s.input_per_byte.saturating_mul(len.into()), - Caller => s.caller, - IsContract => s.is_contract, - CodeHash => s.code_hash, - OwnCodeHash => s.own_code_hash, - CallerIsOrigin => s.caller_is_origin, - CallerIsRoot => s.caller_is_root, - Address => s.address, - GasLeft => s.gas_left, - Balance => s.balance, - ValueTransferred => s.value_transferred, - MinimumBalance => s.minimum_balance, - BlockNumber => s.block_number, - Now => s.now, - WeightToFee => s.weight_to_fee, - InputBase => s.input, - Return(len) => s.r#return.saturating_add(s.return_per_byte.saturating_mul(len.into())), - Terminate => s.terminate, - Random => s.random, - DepositEvent { num_topic, len } => s - .deposit_event - .saturating_add(s.deposit_event_per_topic.saturating_mul(num_topic.into())) - .saturating_add(s.deposit_event_per_byte.saturating_mul(len.into())), - DebugMessage(len) => s - .debug_message - .saturating_add(s.deposit_event_per_byte.saturating_mul(len.into())), - SetStorage { new_bytes, old_bytes } => s - .set_storage - .saturating_add(s.set_storage_per_new_byte.saturating_mul(new_bytes.into())) - .saturating_add(s.set_storage_per_old_byte.saturating_mul(old_bytes.into())), - ClearStorage(len) => s - .clear_storage - .saturating_add(s.clear_storage_per_byte.saturating_mul(len.into())), - ContainsStorage(len) => s - .contains_storage - .saturating_add(s.contains_storage_per_byte.saturating_mul(len.into())), - GetStorage(len) => - s.get_storage.saturating_add(s.get_storage_per_byte.saturating_mul(len.into())), - TakeStorage(len) => s - .take_storage - .saturating_add(s.take_storage_per_byte.saturating_mul(len.into())), - Transfer => s.transfer, - CallBase => s.call, - DelegateCallBase => s.delegate_call, - CallSurchargeTransfer => s.call_transfer_surcharge, - CallInputCloned(len) => s.call_per_cloned_byte.saturating_mul(len.into()), - InstantiateBase { input_data_len, salt_len } => s - .instantiate - .saturating_add(s.instantiate_per_input_byte.saturating_mul(input_data_len.into())) - .saturating_add(s.instantiate_per_salt_byte.saturating_mul(salt_len.into())), - InstantiateSurchargeTransfer => s.instantiate_transfer_surcharge, - HashSha256(len) => s - .hash_sha2_256 - .saturating_add(s.hash_sha2_256_per_byte.saturating_mul(len.into())), - HashKeccak256(len) => s - .hash_keccak_256 - .saturating_add(s.hash_keccak_256_per_byte.saturating_mul(len.into())), - HashBlake256(len) => s - .hash_blake2_256 - .saturating_add(s.hash_blake2_256_per_byte.saturating_mul(len.into())), - HashBlake128(len) => s - .hash_blake2_128 - .saturating_add(s.hash_blake2_128_per_byte.saturating_mul(len.into())), - EcdsaRecovery => s.ecdsa_recover, - Sr25519Verify(len) => s - .sr25519_verify - .saturating_add(s.sr25519_verify_per_byte.saturating_mul(len.into())), + CopyFromContract(len) => T::WeightInfo::seal_return(len), + CopyToContract(len) => cost_args!(seal_input, len), + Caller => T::WeightInfo::seal_caller(), + IsContract => T::WeightInfo::seal_is_contract(), + CodeHash => T::WeightInfo::seal_code_hash(), + OwnCodeHash => T::WeightInfo::seal_own_code_hash(), + CallerIsOrigin => T::WeightInfo::seal_caller_is_origin(), + CallerIsRoot => T::WeightInfo::seal_caller_is_root(), + Address => T::WeightInfo::seal_address(), + GasLeft => T::WeightInfo::seal_gas_left(), + Balance => T::WeightInfo::seal_balance(), + ValueTransferred => T::WeightInfo::seal_value_transferred(), + MinimumBalance => T::WeightInfo::seal_minimum_balance(), + BlockNumber => T::WeightInfo::seal_block_number(), + Now => T::WeightInfo::seal_now(), + WeightToFee => T::WeightInfo::seal_weight_to_fee(), + InputBase => T::WeightInfo::seal_input(0), + Return(len) => T::WeightInfo::seal_return(len), + Terminate => T::WeightInfo::seal_terminate(), + Random => T::WeightInfo::seal_random(), + DepositEvent { num_topic, len } => T::WeightInfo::seal_deposit_event(num_topic, len), + DebugMessage(len) => T::WeightInfo::seal_debug_message(len), + SetStorage { new_bytes, old_bytes } => + T::WeightInfo::seal_set_storage_per_new_byte(new_bytes) + .saturating_add(T::WeightInfo::seal_set_storage_per_old_byte(old_bytes)), + ClearStorage(len) => T::WeightInfo::seal_clear_storage(len), + ContainsStorage(len) => T::WeightInfo::seal_contains_storage(len), + GetStorage(len) => T::WeightInfo::seal_get_storage(len), + TakeStorage(len) => T::WeightInfo::seal_take_storage(len), + Transfer => T::WeightInfo::seal_transfer(), + CallBase => T::WeightInfo::seal_call(0, 0, 0), + DelegateCallBase => T::WeightInfo::seal_delegate_call(), + CallSurchargeTransfer => cost_args!(seal_call, 1, 0, 0), + CallInputCloned(len) => cost_args!(seal_call, 0, 1, len), + InstantiateBase { input_data_len, salt_len } => + T::WeightInfo::seal_instantiate(0, input_data_len, salt_len), + InstantiateSurchargeTransfer => cost_args!(seal_instantiate, 1, 0, 0), + HashSha256(len) => T::WeightInfo::seal_hash_sha2_256(len), + HashKeccak256(len) => T::WeightInfo::seal_hash_keccak_256(len), + HashBlake256(len) => T::WeightInfo::seal_hash_blake2_256(len), + HashBlake128(len) => T::WeightInfo::seal_hash_blake2_128(len), + EcdsaRecovery => T::WeightInfo::seal_ecdsa_recover(), + Sr25519Verify(len) => T::WeightInfo::seal_sr25519_verify(len), ChainExtension(weight) | CallRuntime(weight) | CallXcmExecute(weight) => weight, - SetCodeHash => s.set_code_hash, - EcdsaToEthAddress => s.ecdsa_to_eth_address, - ReentrantCount => s.reentrance_count, - AccountEntranceCount => s.account_reentrance_count, - InstantiationNonce => s.instantiation_nonce, - LockDelegateDependency => s.lock_delegate_dependency, - UnlockDelegateDependency => s.unlock_delegate_dependency, + SetCodeHash => T::WeightInfo::seal_set_code_hash(), + EcdsaToEthAddress => T::WeightInfo::seal_ecdsa_to_eth_address(), + ReentrantCount => T::WeightInfo::seal_reentrance_count(), + AccountEntranceCount => T::WeightInfo::seal_account_reentrance_count(), + InstantiationNonce => T::WeightInfo::seal_instantiation_nonce(), + LockDelegateDependency => T::WeightInfo::lock_delegate_dependency(), + UnlockDelegateDependency => T::WeightInfo::unlock_delegate_dependency(), } } } @@ -817,6 +806,7 @@ impl<'a, E: Ext + 'a> Runtime<'a, E> { output_len_ptr: u32, ) -> Result { self.charge_gas(call_type.cost())?; + let input_data = if flags.contains(CallFlags::CLONE_INPUT) { let input = self.input_data.as_ref().ok_or(Error::::InputForwarded)?; charge_gas!(self, RuntimeCosts::CallInputCloned(input.len() as u32))?; diff --git a/substrate/frame/contracts/src/weights.rs b/substrate/frame/contracts/src/weights.rs index b95b1d1a9a2e..f0b5804069ba 100644 --- a/substrate/frame/contracts/src/weights.rs +++ b/substrate/frame/contracts/src/weights.rs @@ -1,42 +1,24 @@ -// This file is part of Substrate. - -// Copyright (C) Parity Technologies (UK) Ltd. -// SPDX-License-Identifier: Apache-2.0 - -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. //! Autogenerated weights for `pallet_contracts` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 32.0.0 -//! DATE: 2024-04-15, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2024-04-26, STEPS: `2`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` -//! HOSTNAME: `runner-anb7yjbi-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz` -//! WASM-EXECUTION: `Compiled`, CHAIN: `Some("dev")`, DB CACHE: `1024` +//! HOSTNAME: `pgs-laptop.lan`, CPU: `` +//! WASM-EXECUTION: `Compiled`, CHAIN: `None`, DB CACHE: `1024` // Executed Command: -// target/production/substrate-node +// target/debug/substrate-node // benchmark // pallet -// --steps=50 -// --repeat=20 -// --extrinsic=* -// --wasm-execution=compiled -// --heap-pages=4096 -// --json-file=/builds/parity/mirrors/polkadot-sdk/.git/.artifacts/bench.json -// --pallet=pallet_contracts -// --chain=dev -// --header=./substrate/HEADER-APACHE2 -// --output=./substrate/frame/contracts/src/weights.rs +// --steps +// 2 +// -p +// pallet_contracts +// -e +// * +// --output +// substrate/frame/contracts/src/weights.rs // --template=./substrate/.maintain/frame-weight-template.hbs #![cfg_attr(rustfmt, rustfmt_skip)] @@ -72,65 +54,50 @@ pub trait WeightInfo { fn upload_code_determinism_relaxed(c: u32, ) -> Weight; fn remove_code() -> Weight; fn set_code() -> Weight; - fn seal_caller(r: u32, ) -> Weight; - fn seal_is_contract(r: u32, ) -> Weight; - fn seal_code_hash(r: u32, ) -> Weight; - fn seal_own_code_hash(r: u32, ) -> Weight; - fn seal_caller_is_origin(r: u32, ) -> Weight; - fn seal_caller_is_root(r: u32, ) -> Weight; - fn seal_address(r: u32, ) -> Weight; - fn seal_gas_left(r: u32, ) -> Weight; - fn seal_balance(r: u32, ) -> Weight; - fn seal_value_transferred(r: u32, ) -> Weight; - fn seal_minimum_balance(r: u32, ) -> Weight; - fn seal_block_number(r: u32, ) -> Weight; - fn seal_now(r: u32, ) -> Weight; - fn seal_weight_to_fee(r: u32, ) -> Weight; - fn seal_input(r: u32, ) -> Weight; - fn seal_input_per_byte(n: u32, ) -> Weight; - fn seal_return(r: u32, ) -> Weight; - fn seal_return_per_byte(n: u32, ) -> Weight; - fn seal_terminate(r: u32, ) -> Weight; - fn seal_random(r: u32, ) -> Weight; - fn seal_deposit_event(r: u32, ) -> Weight; - fn seal_deposit_event_per_topic_and_byte(t: u32, n: u32, ) -> Weight; - fn seal_debug_message(r: u32, ) -> Weight; - fn seal_debug_message_per_byte(i: u32, ) -> Weight; - fn seal_set_storage(r: u32, ) -> Weight; + fn call_noop_host_fn(r: u32, ) -> Weight; + fn seal_caller() -> Weight; + fn seal_is_contract() -> Weight; + fn seal_code_hash() -> Weight; + fn seal_own_code_hash() -> Weight; + fn seal_caller_is_origin() -> Weight; + fn seal_caller_is_root() -> Weight; + fn seal_address() -> Weight; + fn seal_gas_left() -> Weight; + fn seal_balance() -> Weight; + fn seal_value_transferred() -> Weight; + fn seal_minimum_balance() -> Weight; + fn seal_block_number() -> Weight; + fn seal_now() -> Weight; + fn seal_weight_to_fee() -> Weight; + fn seal_input(n: u32, ) -> Weight; + fn seal_return(n: u32, ) -> Weight; + fn seal_terminate() -> Weight; + fn seal_random() -> Weight; + fn seal_deposit_event(t: u32, n: u32, ) -> Weight; + fn seal_debug_message(i: u32, ) -> Weight; fn seal_set_storage_per_new_byte(n: u32, ) -> Weight; fn seal_set_storage_per_old_byte(n: u32, ) -> Weight; - fn seal_clear_storage(r: u32, ) -> Weight; - fn seal_clear_storage_per_byte(n: u32, ) -> Weight; - fn seal_get_storage(r: u32, ) -> Weight; - fn seal_get_storage_per_byte(n: u32, ) -> Weight; - fn seal_contains_storage(r: u32, ) -> Weight; - fn seal_contains_storage_per_byte(n: u32, ) -> Weight; - fn seal_take_storage(r: u32, ) -> Weight; - fn seal_take_storage_per_byte(n: u32, ) -> Weight; - fn seal_transfer(r: u32, ) -> Weight; - fn seal_call(r: u32, ) -> Weight; - fn seal_delegate_call(r: u32, ) -> Weight; - fn seal_call_per_transfer_clone_byte(t: u32, c: u32, ) -> Weight; - fn seal_instantiate(r: u32, ) -> Weight; - fn seal_instantiate_per_transfer_input_salt_byte(t: u32, i: u32, s: u32, ) -> Weight; - fn seal_hash_sha2_256(r: u32, ) -> Weight; - fn seal_hash_sha2_256_per_byte(n: u32, ) -> Weight; - fn seal_hash_keccak_256(r: u32, ) -> Weight; - fn seal_hash_keccak_256_per_byte(n: u32, ) -> Weight; - fn seal_hash_blake2_256(r: u32, ) -> Weight; - fn seal_hash_blake2_256_per_byte(n: u32, ) -> Weight; - fn seal_hash_blake2_128(r: u32, ) -> Weight; - fn seal_hash_blake2_128_per_byte(n: u32, ) -> Weight; - fn seal_sr25519_verify_per_byte(n: u32, ) -> Weight; - fn seal_sr25519_verify(r: u32, ) -> Weight; - fn seal_ecdsa_recover(r: u32, ) -> Weight; - fn seal_ecdsa_to_eth_address(r: u32, ) -> Weight; - fn seal_set_code_hash(r: u32, ) -> Weight; - fn lock_delegate_dependency(r: u32, ) -> Weight; - fn unlock_delegate_dependency(r: u32, ) -> Weight; - fn seal_reentrance_count(r: u32, ) -> Weight; - fn seal_account_reentrance_count(r: u32, ) -> Weight; - fn seal_instantiation_nonce(r: u32, ) -> Weight; + fn seal_clear_storage(n: u32, ) -> Weight; + fn seal_get_storage(n: u32, ) -> Weight; + fn seal_contains_storage(n: u32, ) -> Weight; + fn seal_take_storage(n: u32, ) -> Weight; + fn seal_transfer() -> Weight; + fn seal_call(c: u32, t: u32, i: u32, ) -> Weight; + fn seal_delegate_call() -> Weight; + fn seal_instantiate(t: u32, i: u32, s: u32, ) -> Weight; + fn seal_hash_sha2_256(n: u32, ) -> Weight; + fn seal_hash_keccak_256(n: u32, ) -> Weight; + fn seal_hash_blake2_256(n: u32, ) -> Weight; + fn seal_hash_blake2_128(n: u32, ) -> Weight; + fn seal_sr25519_verify(n: u32, ) -> Weight; + fn seal_ecdsa_recover() -> Weight; + fn seal_ecdsa_to_eth_address() -> Weight; + fn seal_set_code_hash() -> Weight; + fn lock_delegate_dependency() -> Weight; + fn unlock_delegate_dependency() -> Weight; + fn seal_reentrance_count() -> Weight; + fn seal_account_reentrance_count() -> Weight; + fn seal_instantiation_nonce() -> Weight; fn instr_i64_load_store(r: u32, ) -> Weight; } @@ -143,8 +110,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `142` // Estimated: `1627` - // Minimum execution time: 2_149_000 picoseconds. - Weight::from_parts(2_274_000, 1627) + // Minimum execution time: 21_000_000 picoseconds. + Weight::from_parts(22_000_000, 1627) .saturating_add(T::DbWeight::get().reads(1_u64)) } /// Storage: `Skipped::Metadata` (r:0 w:0) @@ -152,12 +119,12 @@ impl WeightInfo for SubstrateWeight { /// The range of component `k` is `[0, 1024]`. fn on_initialize_per_trie_key(k: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `452 + k * (69 ±0)` - // Estimated: `442 + k * (70 ±0)` - // Minimum execution time: 12_863_000 picoseconds. - Weight::from_parts(13_188_000, 442) - // Standard Error: 1_053 - .saturating_add(Weight::from_parts(1_105_325, 0).saturating_mul(k.into())) + // Measured: `318 + k * (69 ±0)` + // Estimated: `318 + k * (70 ±0)` + // Minimum execution time: 106_000_000 picoseconds. + Weight::from_parts(118_200_000, 318) + // Standard Error: 30_650 + .saturating_add(Weight::from_parts(7_881_933, 0).saturating_mul(k.into())) .saturating_add(T::DbWeight::get().reads(2_u64)) .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(k.into()))) .saturating_add(T::DbWeight::get().writes(2_u64)) @@ -169,12 +136,12 @@ impl WeightInfo for SubstrateWeight { /// The range of component `c` is `[0, 125952]`. fn v9_migration_step(c: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `211 + c * (1 ±0)` - // Estimated: `6149 + c * (1 ±0)` - // Minimum execution time: 8_432_000 picoseconds. - Weight::from_parts(9_203_290, 6149) - // Standard Error: 1 - .saturating_add(Weight::from_parts(1_186, 0).saturating_mul(c.into())) + // Measured: `203 + c * (1 ±0)` + // Estimated: `6143 + c * (1 ±0)` + // Minimum execution time: 90_000_000 picoseconds. + Weight::from_parts(92_900_000, 6143) + // Standard Error: 7 + .saturating_add(Weight::from_parts(744, 0).saturating_mul(c.into())) .saturating_add(T::DbWeight::get().reads(2_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(c.into())) @@ -187,8 +154,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `510` // Estimated: `6450` - // Minimum execution time: 17_177_000 picoseconds. - Weight::from_parts(17_663_000, 6450) + // Minimum execution time: 149_000_000 picoseconds. + Weight::from_parts(164_000_000, 6450) .saturating_add(T::DbWeight::get().reads(3_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -199,14 +166,14 @@ impl WeightInfo for SubstrateWeight { /// The range of component `k` is `[0, 1024]`. fn v11_migration_step(k: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `171 + k * (1 ±0)` - // Estimated: `3635 + k * (1 ±0)` - // Minimum execution time: 3_636_000 picoseconds. - Weight::from_parts(3_774_000, 3635) - // Standard Error: 542 - .saturating_add(Weight::from_parts(1_260_058, 0).saturating_mul(k.into())) + // Measured: `166 + k * (1 ±0)` + // Estimated: `3631 + k * (1 ±0)` + // Minimum execution time: 32_000_000 picoseconds. + Weight::from_parts(33_399_999, 3631) + // Standard Error: 56_913 + .saturating_add(Weight::from_parts(15_769_238, 0).saturating_mul(k.into())) .saturating_add(T::DbWeight::get().reads(1_u64)) - .saturating_add(T::DbWeight::get().writes(2_u64)) + .saturating_add(T::DbWeight::get().writes(1_u64)) .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(k.into()))) .saturating_add(Weight::from_parts(0, 1).saturating_mul(k.into())) } @@ -223,12 +190,12 @@ impl WeightInfo for SubstrateWeight { /// The range of component `c` is `[0, 125952]`. fn v12_migration_step(c: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `328 + c * (1 ±0)` - // Estimated: `6266 + c * (1 ±0)` - // Minimum execution time: 21_585_000 picoseconds. - Weight::from_parts(22_069_944, 6266) - // Standard Error: 1 - .saturating_add(Weight::from_parts(404, 0).saturating_mul(c.into())) + // Measured: `320 + c * (1 ±0)` + // Estimated: `6260 + c * (1 ±0)` + // Minimum execution time: 205_000_000 picoseconds. + Weight::from_parts(219_100_000, 6260) + // Standard Error: 31 + .saturating_add(Weight::from_parts(342, 0).saturating_mul(c.into())) .saturating_add(T::DbWeight::get().reads(6_u64)) .saturating_add(T::DbWeight::get().writes(2_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(c.into())) @@ -239,8 +206,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `440` // Estimated: `6380` - // Minimum execution time: 13_283_000 picoseconds. - Weight::from_parts(14_015_000, 6380) + // Minimum execution time: 112_000_000 picoseconds. + Weight::from_parts(117_000_000, 6380) .saturating_add(T::DbWeight::get().reads(2_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -254,8 +221,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `352` // Estimated: `6292` - // Minimum execution time: 48_022_000 picoseconds. - Weight::from_parts(49_627_000, 6292) + // Minimum execution time: 487_000_000 picoseconds. + Weight::from_parts(507_000_000, 6292) .saturating_add(T::DbWeight::get().reads(4_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -267,8 +234,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `594` // Estimated: `6534` - // Minimum execution time: 58_374_000 picoseconds. - Weight::from_parts(59_615_000, 6534) + // Minimum execution time: 430_000_000 picoseconds. + Weight::from_parts(518_000_000, 6534) .saturating_add(T::DbWeight::get().reads(4_u64)) .saturating_add(T::DbWeight::get().writes(2_u64)) } @@ -278,8 +245,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `409` // Estimated: `6349` - // Minimum execution time: 12_559_000 picoseconds. - Weight::from_parts(12_947_000, 6349) + // Minimum execution time: 110_000_000 picoseconds. + Weight::from_parts(122_000_000, 6349) .saturating_add(T::DbWeight::get().reads(2_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -289,8 +256,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `142` // Estimated: `1627` - // Minimum execution time: 2_480_000 picoseconds. - Weight::from_parts(2_680_000, 1627) + // Minimum execution time: 23_000_000 picoseconds. + Weight::from_parts(25_000_000, 1627) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -302,8 +269,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `166` // Estimated: `3631` - // Minimum execution time: 12_625_000 picoseconds. - Weight::from_parts(13_094_000, 3631) + // Minimum execution time: 114_000_000 picoseconds. + Weight::from_parts(118_000_000, 3631) .saturating_add(T::DbWeight::get().reads(2_u64)) .saturating_add(T::DbWeight::get().writes(2_u64)) } @@ -313,8 +280,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `142` // Estimated: `3607` - // Minimum execution time: 4_836_000 picoseconds. - Weight::from_parts(5_182_000, 3607) + // Minimum execution time: 42_000_000 picoseconds. + Weight::from_parts(43_000_000, 3607) .saturating_add(T::DbWeight::get().reads(1_u64)) } /// Storage: UNKNOWN KEY `0x4342193e496fab7ec59d615ed0dc55304e7b9012096b41c4eb3aaf947f6ea429` (r:1 w:0) @@ -325,8 +292,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `167` // Estimated: `3632` - // Minimum execution time: 6_319_000 picoseconds. - Weight::from_parts(6_582_000, 3632) + // Minimum execution time: 56_000_000 picoseconds. + Weight::from_parts(60_000_000, 3632) .saturating_add(T::DbWeight::get().reads(2_u64)) } /// Storage: UNKNOWN KEY `0x4342193e496fab7ec59d615ed0dc55304e7b9012096b41c4eb3aaf947f6ea429` (r:1 w:0) @@ -337,8 +304,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `142` // Estimated: `3607` - // Minimum execution time: 6_532_000 picoseconds. - Weight::from_parts(6_909_000, 3607) + // Minimum execution time: 56_000_000 picoseconds. + Weight::from_parts(58_000_000, 3607) .saturating_add(T::DbWeight::get().reads(2_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -361,12 +328,12 @@ impl WeightInfo for SubstrateWeight { /// The range of component `c` is `[0, 125952]`. fn call_with_code_per_byte(c: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `804 + c * (1 ±0)` - // Estimated: `9217 + c * (1 ±0)` - // Minimum execution time: 305_778_000 picoseconds. - Weight::from_parts(282_321_249, 9217) - // Standard Error: 72 - .saturating_add(Weight::from_parts(33_456, 0).saturating_mul(c.into())) + // Measured: `832` + // Estimated: `9247 + c * (1 ±0)` + // Minimum execution time: 2_201_000_000 picoseconds. + Weight::from_parts(2_297_000_000, 9247) + // Standard Error: 362 + .saturating_add(Weight::from_parts(83_549, 0).saturating_mul(c.into())) .saturating_add(T::DbWeight::get().reads(11_u64)) .saturating_add(T::DbWeight::get().writes(4_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(c.into())) @@ -396,16 +363,16 @@ 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: `326` - // Estimated: `8740` - // Minimum execution time: 3_810_809_000 picoseconds. - Weight::from_parts(739_511_598, 8740) - // Standard Error: 140 - .saturating_add(Weight::from_parts(67_574, 0).saturating_mul(c.into())) - // Standard Error: 16 - .saturating_add(Weight::from_parts(1_488, 0).saturating_mul(i.into())) - // Standard Error: 16 - .saturating_add(Weight::from_parts(1_537, 0).saturating_mul(s.into())) + // Measured: `443` + // Estimated: `8858` + // Minimum execution time: 8_151_000_000 picoseconds. + Weight::from_parts(5_385_233_352, 8858) + // Standard Error: 497 + .saturating_add(Weight::from_parts(161_394, 0).saturating_mul(c.into())) + // Standard Error: 59 + .saturating_add(Weight::from_parts(1_312, 0).saturating_mul(i.into())) + // Standard Error: 59 + .saturating_add(Weight::from_parts(1_839, 0).saturating_mul(s.into())) .saturating_add(T::DbWeight::get().reads(14_u64)) .saturating_add(T::DbWeight::get().writes(10_u64)) } @@ -433,14 +400,14 @@ 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: `563` - // Estimated: `8982` - // Minimum execution time: 1_986_789_000 picoseconds. - Weight::from_parts(2_017_466_000, 8982) - // Standard Error: 26 - .saturating_add(Weight::from_parts(827, 0).saturating_mul(i.into())) - // Standard Error: 26 - .saturating_add(Weight::from_parts(781, 0).saturating_mul(s.into())) + // Measured: `615` + // Estimated: `9030` + // Minimum execution time: 4_448_000_000 picoseconds. + Weight::from_parts(3_037_050_000, 9030) + // Standard Error: 32 + .saturating_add(Weight::from_parts(1_818, 0).saturating_mul(i.into())) + // Standard Error: 32 + .saturating_add(Weight::from_parts(1_611, 0).saturating_mul(s.into())) .saturating_add(T::DbWeight::get().reads(13_u64)) .saturating_add(T::DbWeight::get().writes(7_u64)) } @@ -464,8 +431,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `829` // Estimated: `9244` - // Minimum execution time: 210_724_000 picoseconds. - Weight::from_parts(218_608_000, 9244) + // Minimum execution time: 2_158_000_000 picoseconds. + Weight::from_parts(2_235_000_000, 9244) .saturating_add(T::DbWeight::get().reads(11_u64)) .saturating_add(T::DbWeight::get().writes(4_u64)) } @@ -486,10 +453,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `145` // Estimated: `6085` - // Minimum execution time: 271_259_000 picoseconds. - Weight::from_parts(298_852_854, 6085) - // Standard Error: 65 - .saturating_add(Weight::from_parts(33_547, 0).saturating_mul(c.into())) + // Minimum execution time: 1_951_000_000 picoseconds. + Weight::from_parts(2_063_900_000, 6085) + // Standard Error: 430 + .saturating_add(Weight::from_parts(83_991, 0).saturating_mul(c.into())) .saturating_add(T::DbWeight::get().reads(6_u64)) .saturating_add(T::DbWeight::get().writes(4_u64)) } @@ -510,10 +477,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `145` // Estimated: `6085` - // Minimum execution time: 278_167_000 picoseconds. - Weight::from_parts(311_888_941, 6085) - // Standard Error: 58 - .saturating_add(Weight::from_parts(33_595, 0).saturating_mul(c.into())) + // Minimum execution time: 2_110_000_000 picoseconds. + Weight::from_parts(2_274_000_000, 6085) + // Standard Error: 286 + .saturating_add(Weight::from_parts(84_193, 0).saturating_mul(c.into())) .saturating_add(T::DbWeight::get().reads(6_u64)) .saturating_add(T::DbWeight::get().writes(4_u64)) } @@ -531,8 +498,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `315` // Estimated: `3780` - // Minimum execution time: 47_403_000 picoseconds. - Weight::from_parts(48_707_000, 3780) + // Minimum execution time: 485_000_000 picoseconds. + Weight::from_parts(523_000_000, 3780) .saturating_add(T::DbWeight::get().reads(4_u64)) .saturating_add(T::DbWeight::get().writes(4_u64)) } @@ -548,335 +515,205 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `552` // Estimated: `8967` - // Minimum execution time: 35_361_000 picoseconds. - Weight::from_parts(36_714_000, 8967) + // Minimum execution time: 321_000_000 picoseconds. + Weight::from_parts(364_000_000, 8967) .saturating_add(T::DbWeight::get().reads(7_u64)) .saturating_add(T::DbWeight::get().writes(6_u64)) } /// The range of component `r` is `[0, 1600]`. - fn seal_caller(r: u32, ) -> Weight { + fn call_noop_host_fn(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 9_340_000 picoseconds. - Weight::from_parts(9_360_237, 0) - // Standard Error: 269 - .saturating_add(Weight::from_parts(249_611, 0).saturating_mul(r.into())) + // Minimum execution time: 150_000_000 picoseconds. + Weight::from_parts(159_300_000, 0) + // Standard Error: 1_567 + .saturating_add(Weight::from_parts(74_625, 0).saturating_mul(r.into())) } - /// Storage: `Contracts::ContractInfoOf` (r:1600 w:0) + fn seal_caller() -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 6_000_000 picoseconds. + Weight::from_parts(7_000_000, 0) + } + /// Storage: `Contracts::ContractInfoOf` (r:1 w:0) /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) - /// The range of component `r` is `[0, 1600]`. - fn seal_is_contract(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `509 + r * (77 ±0)` - // Estimated: `1467 + r * (2552 ±0)` - // Minimum execution time: 9_059_000 picoseconds. - Weight::from_parts(9_201_000, 1467) - // Standard Error: 5_643 - .saturating_add(Weight::from_parts(3_343_859, 0).saturating_mul(r.into())) - .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(r.into()))) - .saturating_add(Weight::from_parts(0, 2552).saturating_mul(r.into())) - } - /// Storage: `Contracts::ContractInfoOf` (r:1600 w:0) + fn seal_is_contract() -> Weight { + // Proof Size summary in bytes: + // Measured: `354` + // Estimated: `3819` + // Minimum execution time: 57_000_000 picoseconds. + Weight::from_parts(61_000_000, 3819) + .saturating_add(T::DbWeight::get().reads(1_u64)) + } + /// Storage: `Contracts::ContractInfoOf` (r:1 w:0) /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) - /// The range of component `r` is `[0, 1600]`. - fn seal_code_hash(r: u32, ) -> Weight { + fn seal_code_hash() -> Weight { // Proof Size summary in bytes: - // Measured: `517 + r * (170 ±0)` - // Estimated: `1468 + r * (2645 ±0)` - // Minimum execution time: 9_220_000 picoseconds. - Weight::from_parts(9_399_000, 1468) - // Standard Error: 6_194 - .saturating_add(Weight::from_parts(4_172_011, 0).saturating_mul(r.into())) - .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(r.into()))) - .saturating_add(Weight::from_parts(0, 2645).saturating_mul(r.into())) + // Measured: `447` + // Estimated: `3912` + // Minimum execution time: 68_000_000 picoseconds. + Weight::from_parts(72_000_000, 3912) + .saturating_add(T::DbWeight::get().reads(1_u64)) } - /// The range of component `r` is `[0, 1600]`. - fn seal_own_code_hash(r: u32, ) -> Weight { + fn seal_own_code_hash() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 9_707_000 picoseconds. - Weight::from_parts(10_100_456, 0) - // Standard Error: 234 - .saturating_add(Weight::from_parts(338_464, 0).saturating_mul(r.into())) + // Minimum execution time: 8_000_000 picoseconds. + Weight::from_parts(9_000_000, 0) } - /// The range of component `r` is `[0, 1600]`. - fn seal_caller_is_origin(r: u32, ) -> Weight { + fn seal_caller_is_origin() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 9_524_000 picoseconds. - Weight::from_parts(10_813_389, 0) - // Standard Error: 76 - .saturating_add(Weight::from_parts(102_535, 0).saturating_mul(r.into())) + // Minimum execution time: 2_000_000 picoseconds. + Weight::from_parts(3_000_000, 0) } - /// The range of component `r` is `[0, 1600]`. - fn seal_caller_is_root(r: u32, ) -> Weight { + fn seal_caller_is_root() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 9_799_000 picoseconds. - Weight::from_parts(10_886_744, 0) - // Standard Error: 75 - .saturating_add(Weight::from_parts(80_901, 0).saturating_mul(r.into())) + // Minimum execution time: 2_000_000 picoseconds. + Weight::from_parts(3_000_000, 0) } - /// The range of component `r` is `[0, 1600]`. - fn seal_address(r: u32, ) -> Weight { + fn seal_address() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 9_895_000 picoseconds. - Weight::from_parts(10_658_338, 0) - // Standard Error: 189 - .saturating_add(Weight::from_parts(249_694, 0).saturating_mul(r.into())) + // Minimum execution time: 6_000_000 picoseconds. + Weight::from_parts(6_000_000, 0) } - /// The range of component `r` is `[0, 1600]`. - fn seal_gas_left(r: u32, ) -> Weight { + fn seal_gas_left() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 9_643_000 picoseconds. - Weight::from_parts(10_932_126, 0) - // Standard Error: 153 - .saturating_add(Weight::from_parts(280_924, 0).saturating_mul(r.into())) + // Minimum execution time: 6_000_000 picoseconds. + Weight::from_parts(6_000_000, 0) } /// Storage: `System::Account` (r:1 w:0) /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`) - /// The range of component `r` is `[0, 1600]`. - fn seal_balance(r: u32, ) -> Weight { + fn seal_balance() -> Weight { // Proof Size summary in bytes: // Measured: `140` - // Estimated: `3599` - // Minimum execution time: 9_548_000 picoseconds. - Weight::from_parts(9_737_000, 3599) - // Standard Error: 971 - .saturating_add(Weight::from_parts(1_704_134, 0).saturating_mul(r.into())) + // Estimated: `3605` + // Minimum execution time: 45_000_000 picoseconds. + Weight::from_parts(47_000_000, 3605) .saturating_add(T::DbWeight::get().reads(1_u64)) } - /// The range of component `r` is `[0, 1600]`. - fn seal_value_transferred(r: u32, ) -> Weight { + fn seal_value_transferred() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 9_172_000 picoseconds. - Weight::from_parts(18_255_933, 0) - // Standard Error: 540 - .saturating_add(Weight::from_parts(230_929, 0).saturating_mul(r.into())) + // Minimum execution time: 6_000_000 picoseconds. + Weight::from_parts(7_000_000, 0) } - /// The range of component `r` is `[0, 1600]`. - fn seal_minimum_balance(r: u32, ) -> Weight { + fn seal_minimum_balance() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 9_232_000 picoseconds. - Weight::from_parts(9_796_584, 0) - // Standard Error: 208 - .saturating_add(Weight::from_parts(239_962, 0).saturating_mul(r.into())) + // Minimum execution time: 6_000_000 picoseconds. + Weight::from_parts(6_000_000, 0) } - /// The range of component `r` is `[0, 1600]`. - fn seal_block_number(r: u32, ) -> Weight { + fn seal_block_number() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 9_747_000 picoseconds. - Weight::from_parts(8_733_230, 0) - // Standard Error: 377 - .saturating_add(Weight::from_parts(253_801, 0).saturating_mul(r.into())) + // Minimum execution time: 6_000_000 picoseconds. + Weight::from_parts(6_000_000, 0) } - /// The range of component `r` is `[0, 1600]`. - fn seal_now(r: u32, ) -> Weight { + fn seal_now() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 9_214_000 picoseconds. - Weight::from_parts(10_194_153, 0) - // Standard Error: 516 - .saturating_add(Weight::from_parts(247_621, 0).saturating_mul(r.into())) + // Minimum execution time: 6_000_000 picoseconds. + Weight::from_parts(7_000_000, 0) } /// Storage: `TransactionPayment::NextFeeMultiplier` (r:1 w:0) /// Proof: `TransactionPayment::NextFeeMultiplier` (`max_values`: Some(1), `max_size`: Some(16), added: 511, mode: `Measured`) - /// The range of component `r` is `[0, 1600]`. - fn seal_weight_to_fee(r: u32, ) -> Weight { + fn seal_weight_to_fee() -> Weight { // Proof Size summary in bytes: // Measured: `67` // Estimated: `1552` - // Minimum execution time: 9_022_000 picoseconds. - Weight::from_parts(22_051_160, 1552) - // Standard Error: 697 - .saturating_add(Weight::from_parts(709_612, 0).saturating_mul(r.into())) + // Minimum execution time: 35_000_000 picoseconds. + Weight::from_parts(37_000_000, 1552) .saturating_add(T::DbWeight::get().reads(1_u64)) } - /// The range of component `r` is `[0, 1600]`. - fn seal_input(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 9_135_000 picoseconds. - Weight::from_parts(10_646_215, 0) - // Standard Error: 161 - .saturating_add(Weight::from_parts(170_336, 0).saturating_mul(r.into())) - } - /// Storage: `Contracts::MigrationInProgress` (r:1 w:0) - /// Proof: `Contracts::MigrationInProgress` (`max_values`: Some(1), `max_size`: Some(1026), added: 1521, mode: `Measured`) - /// Storage: `System::Account` (r:1 w:0) - /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`) - /// Storage: `Parameters::Parameters` (r:3 w:0) - /// Proof: `Parameters::Parameters` (`max_values`: None, `max_size`: Some(36), added: 2511, mode: `Measured`) - /// Storage: `Contracts::ContractInfoOf` (r:1 w:1) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) - /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) - /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) - /// Storage: `Contracts::PristineCode` (r:1 w:0) - /// Proof: `Contracts::PristineCode` (`max_values`: None, `max_size`: Some(125988), added: 128463, 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::EventTopics` (r:2 w:2) - /// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`) - /// The range of component `n` is `[0, 1048576]`. - fn seal_input_per_byte(n: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `872` - // Estimated: `9287` - // Minimum execution time: 273_896_000 picoseconds. - Weight::from_parts(148_309_654, 9287) - // Standard Error: 16 - .saturating_add(Weight::from_parts(1_355, 0).saturating_mul(n.into())) - .saturating_add(T::DbWeight::get().reads(11_u64)) - .saturating_add(T::DbWeight::get().writes(3_u64)) - } - /// The range of component `r` is `[0, 1]`. - fn seal_return(r: u32, ) -> Weight { + /// The range of component `n` is `[0, 1048572]`. + fn seal_input(_n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 8_906_000 picoseconds. - Weight::from_parts(9_264_446, 0) - // Standard Error: 19_760 - .saturating_add(Weight::from_parts(1_256_053, 0).saturating_mul(r.into())) + // Minimum execution time: 4_000_000 picoseconds. + Weight::from_parts(4_900_000, 0) } - /// The range of component `n` is `[0, 1048576]`. - fn seal_return_per_byte(n: u32, ) -> Weight { + /// The range of component `n` is `[0, 1048572]`. + fn seal_return(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 10_266_000 picoseconds. - Weight::from_parts(10_602_261, 0) + // Minimum execution time: 2_000_000 picoseconds. + Weight::from_parts(2_400_000, 0) // Standard Error: 0 - .saturating_add(Weight::from_parts(318, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(158, 0).saturating_mul(n.into())) } - /// Storage: `Contracts::MigrationInProgress` (r:1 w:0) - /// Proof: `Contracts::MigrationInProgress` (`max_values`: Some(1), `max_size`: Some(1026), added: 1521, mode: `Measured`) - /// Storage: `System::Account` (r:3 w:3) - /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`) - /// Storage: `Parameters::Parameters` (r:1 w:0) - /// Proof: `Parameters::Parameters` (`max_values`: None, `max_size`: Some(36), added: 2511, mode: `Measured`) - /// Storage: `Contracts::ContractInfoOf` (r:1 w:1) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) - /// Storage: `Contracts::CodeInfoOf` (r:33 w:33) - /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) - /// Storage: `Contracts::PristineCode` (r:1 w:0) - /// Proof: `Contracts::PristineCode` (`max_values`: None, `max_size`: Some(125988), added: 128463, 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: `Contracts::DeletionQueueCounter` (r:1 w:1) /// Proof: `Contracts::DeletionQueueCounter` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`) - /// Storage: `System::EventTopics` (r:4 w:4) + /// Storage: `Contracts::CodeInfoOf` (r:33 w:33) + /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) + /// Storage: `System::EventTopics` (r:2 w:2) /// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`) - /// Storage: `Balances::Holds` (r:1 w:1) - /// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(193), added: 2668, mode: `Measured`) + /// Storage: `Contracts::ContractInfoOf` (r:0 w:1) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::DeletionQueue` (r:0 w:1) /// Proof: `Contracts::DeletionQueue` (`max_values`: None, `max_size`: Some(142), added: 2617, mode: `Measured`) - /// The range of component `r` is `[0, 1]`. - fn seal_terminate(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `4805 + r * (2121 ±0)` - // Estimated: `13220 + r * (81321 ±0)` - // Minimum execution time: 295_922_000 picoseconds. - Weight::from_parts(322_472_877, 13220) - // Standard Error: 993_812 - .saturating_add(Weight::from_parts(259_075_422, 0).saturating_mul(r.into())) - .saturating_add(T::DbWeight::get().reads(11_u64)) - .saturating_add(T::DbWeight::get().reads((36_u64).saturating_mul(r.into()))) - .saturating_add(T::DbWeight::get().writes(3_u64)) - .saturating_add(T::DbWeight::get().writes((41_u64).saturating_mul(r.into()))) - .saturating_add(Weight::from_parts(0, 81321).saturating_mul(r.into())) + fn seal_terminate() -> Weight { + // Proof Size summary in bytes: + // Measured: `2821` + // Estimated: `85486` + // Minimum execution time: 1_390_000_000 picoseconds. + Weight::from_parts(1_470_000_000, 85486) + .saturating_add(T::DbWeight::get().reads(36_u64)) + .saturating_add(T::DbWeight::get().writes(38_u64)) } /// Storage: `RandomnessCollectiveFlip::RandomMaterial` (r:1 w:0) /// Proof: `RandomnessCollectiveFlip::RandomMaterial` (`max_values`: Some(1), `max_size`: Some(2594), added: 3089, mode: `Measured`) - /// The range of component `r` is `[0, 1600]`. - fn seal_random(r: u32, ) -> Weight { + fn seal_random() -> Weight { // Proof Size summary in bytes: // Measured: `76` // Estimated: `1561` - // Minimum execution time: 9_427_000 picoseconds. - Weight::from_parts(12_996_213, 1561) - // Standard Error: 845 - .saturating_add(Weight::from_parts(1_182_642, 0).saturating_mul(r.into())) + // Minimum execution time: 33_000_000 picoseconds. + Weight::from_parts(36_000_000, 1561) .saturating_add(T::DbWeight::get().reads(1_u64)) } - /// The range of component `r` is `[0, 1600]`. - fn seal_deposit_event(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 9_304_000 picoseconds. - Weight::from_parts(25_678_842, 0) - // Standard Error: 1_855 - .saturating_add(Weight::from_parts(1_814_511, 0).saturating_mul(r.into())) - } /// Storage: `System::EventTopics` (r:4 w:4) /// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`) /// The range of component `t` is `[0, 4]`. /// The range of component `n` is `[0, 16384]`. - fn seal_deposit_event_per_topic_and_byte(t: u32, n: u32, ) -> Weight { + fn seal_deposit_event(t: u32, n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` - // Estimated: `990 + t * (2475 ±0)` - // Minimum execution time: 23_425_000 picoseconds. - Weight::from_parts(15_229_010, 990) - // Standard Error: 14_380 - .saturating_add(Weight::from_parts(2_545_653, 0).saturating_mul(t.into())) - // Standard Error: 4 - .saturating_add(Weight::from_parts(594, 0).saturating_mul(n.into())) + // Estimated: `641 + t * (2562 ±0)` + // Minimum execution time: 27_000_000 picoseconds. + Weight::from_parts(28_999_999, 641) + // Standard Error: 651_505 + .saturating_add(Weight::from_parts(31_650_000, 0).saturating_mul(t.into())) + // Standard Error: 159 + .saturating_add(Weight::from_parts(134, 0).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(t.into()))) .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(t.into()))) - .saturating_add(Weight::from_parts(0, 2475).saturating_mul(t.into())) - } - /// The range of component `r` is `[0, 1600]`. - fn seal_debug_message(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 11_117_000 picoseconds. - Weight::from_parts(12_887_533, 0) - // Standard Error: 83 - .saturating_add(Weight::from_parts(99_373, 0).saturating_mul(r.into())) + .saturating_add(Weight::from_parts(0, 2562).saturating_mul(t.into())) } /// The range of component `i` is `[0, 1048576]`. - fn seal_debug_message_per_byte(i: u32, ) -> Weight { + fn seal_debug_message(i: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 10_982_000 picoseconds. - Weight::from_parts(11_176_000, 0) - // Standard Error: 8 - .saturating_add(Weight::from_parts(983, 0).saturating_mul(i.into())) - } - /// Storage: `Skipped::Metadata` (r:0 w:0) - /// Proof: `Skipped::Metadata` (`max_values`: None, `max_size`: None, mode: `Measured`) - /// The range of component `r` is `[0, 800]`. - fn seal_set_storage(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `108 + r * (150 ±0)` - // Estimated: `105 + r * (151 ±0)` - // Minimum execution time: 9_150_000 picoseconds. - Weight::from_parts(9_269_000, 105) - // Standard Error: 8_147 - .saturating_add(Weight::from_parts(5_339_554, 0).saturating_mul(r.into())) - .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(r.into()))) - .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(r.into()))) - .saturating_add(Weight::from_parts(0, 151).saturating_mul(r.into())) + // Minimum execution time: 2_000_000 picoseconds. + Weight::from_parts(3_100_000, 0) + // Standard Error: 1 + .saturating_add(Weight::from_parts(445, 0).saturating_mul(i.into())) } /// Storage: `Skipped::Metadata` (r:0 w:0) /// Proof: `Skipped::Metadata` (`max_values`: None, `max_size`: None, mode: `Measured`) @@ -885,10 +722,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `245` // Estimated: `245` - // Minimum execution time: 19_085_000 picoseconds. - Weight::from_parts(20_007_323, 245) - // Standard Error: 3 - .saturating_add(Weight::from_parts(291, 0).saturating_mul(n.into())) + // Minimum execution time: 55_000_000 picoseconds. + Weight::from_parts(61_800_000, 245) + // Standard Error: 132 + .saturating_add(Weight::from_parts(476, 0).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -897,196 +734,83 @@ impl WeightInfo for SubstrateWeight { /// The range of component `n` is `[0, 16384]`. fn seal_set_storage_per_old_byte(n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `248 + n * (1 ±0)` - // Estimated: `248 + n * (1 ±0)` - // Minimum execution time: 19_127_000 picoseconds. - Weight::from_parts(21_152_987, 248) - // Standard Error: 3 - .saturating_add(Weight::from_parts(42, 0).saturating_mul(n.into())) + // Measured: `245 + n * (1 ±0)` + // Estimated: `245 + n * (1 ±0)` + // Minimum execution time: 56_000_000 picoseconds. + Weight::from_parts(63_900_000, 245) + // Standard Error: 93 + .saturating_add(Weight::from_parts(48, 0).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) } /// Storage: `Skipped::Metadata` (r:0 w:0) /// Proof: `Skipped::Metadata` (`max_values`: None, `max_size`: None, mode: `Measured`) - /// The range of component `r` is `[0, 800]`. - fn seal_clear_storage(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `108 + r * (150 ±0)` - // Estimated: `105 + r * (151 ±0)` - // Minimum execution time: 9_264_000 picoseconds. - Weight::from_parts(9_449_000, 105) - // Standard Error: 8_196 - .saturating_add(Weight::from_parts(5_325_578, 0).saturating_mul(r.into())) - .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(r.into()))) - .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(r.into()))) - .saturating_add(Weight::from_parts(0, 151).saturating_mul(r.into())) - } - /// Storage: `Skipped::Metadata` (r:0 w:0) - /// Proof: `Skipped::Metadata` (`max_values`: None, `max_size`: None, mode: `Measured`) /// The range of component `n` is `[0, 16384]`. - fn seal_clear_storage_per_byte(n: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `248 + n * (1 ±0)` - // Estimated: `248 + n * (1 ±0)` - // Minimum execution time: 18_489_000 picoseconds. - Weight::from_parts(19_916_153, 248) - // Standard Error: 2 - .saturating_add(Weight::from_parts(97, 0).saturating_mul(n.into())) + fn seal_clear_storage(n: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `245 + n * (1 ±0)` + // Estimated: `245 + n * (1 ±0)` + // Minimum execution time: 55_000_000 picoseconds. + Weight::from_parts(61_100_000, 245) + // Standard Error: 113 + .saturating_add(Weight::from_parts(708, 0).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) } /// Storage: `Skipped::Metadata` (r:0 w:0) /// Proof: `Skipped::Metadata` (`max_values`: None, `max_size`: None, mode: `Measured`) - /// The range of component `r` is `[0, 800]`. - fn seal_get_storage(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `108 + r * (150 ±0)` - // Estimated: `105 + r * (151 ±0)` - // Minimum execution time: 9_299_000 picoseconds. - Weight::from_parts(9_464_000, 105) - // Standard Error: 6_827 - .saturating_add(Weight::from_parts(4_720_699, 0).saturating_mul(r.into())) - .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(r.into()))) - .saturating_add(Weight::from_parts(0, 151).saturating_mul(r.into())) - } - /// Storage: `Skipped::Metadata` (r:0 w:0) - /// Proof: `Skipped::Metadata` (`max_values`: None, `max_size`: None, mode: `Measured`) /// The range of component `n` is `[0, 16384]`. - fn seal_get_storage_per_byte(n: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `248 + n * (1 ±0)` - // Estimated: `248 + n * (1 ±0)` - // Minimum execution time: 17_981_000 picoseconds. - Weight::from_parts(19_802_353, 248) - // Standard Error: 3 - .saturating_add(Weight::from_parts(617, 0).saturating_mul(n.into())) + fn seal_get_storage(n: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `245 + n * (1 ±0)` + // Estimated: `245 + n * (1 ±0)` + // Minimum execution time: 53_000_000 picoseconds. + Weight::from_parts(61_800_000, 245) + // Standard Error: 160 + .saturating_add(Weight::from_parts(1_196, 0).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) } /// Storage: `Skipped::Metadata` (r:0 w:0) /// Proof: `Skipped::Metadata` (`max_values`: None, `max_size`: None, mode: `Measured`) - /// The range of component `r` is `[0, 800]`. - fn seal_contains_storage(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `108 + r * (150 ±0)` - // Estimated: `105 + r * (151 ±0)` - // Minimum execution time: 9_891_000 picoseconds. - Weight::from_parts(10_046_000, 105) - // Standard Error: 6_993 - .saturating_add(Weight::from_parts(4_601_167, 0).saturating_mul(r.into())) - .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(r.into()))) - .saturating_add(Weight::from_parts(0, 151).saturating_mul(r.into())) - } - /// Storage: `Skipped::Metadata` (r:0 w:0) - /// Proof: `Skipped::Metadata` (`max_values`: None, `max_size`: None, mode: `Measured`) /// The range of component `n` is `[0, 16384]`. - fn seal_contains_storage_per_byte(n: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `248 + n * (1 ±0)` - // Estimated: `248 + n * (1 ±0)` - // Minimum execution time: 17_229_000 picoseconds. - Weight::from_parts(18_302_733, 248) - // Standard Error: 2 - .saturating_add(Weight::from_parts(112, 0).saturating_mul(n.into())) + fn seal_contains_storage(n: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `245 + n * (1 ±0)` + // Estimated: `245 + n * (1 ±0)` + // Minimum execution time: 51_000_000 picoseconds. + Weight::from_parts(58_500_000, 245) + // Standard Error: 80 + .saturating_add(Weight::from_parts(299, 0).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) } /// Storage: `Skipped::Metadata` (r:0 w:0) /// Proof: `Skipped::Metadata` (`max_values`: None, `max_size`: None, mode: `Measured`) - /// The range of component `r` is `[0, 800]`. - fn seal_take_storage(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `108 + r * (150 ±0)` - // Estimated: `105 + r * (151 ±0)` - // Minimum execution time: 9_323_000 picoseconds. - Weight::from_parts(9_462_000, 105) - // Standard Error: 8_031 - .saturating_add(Weight::from_parts(5_433_981, 0).saturating_mul(r.into())) - .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(r.into()))) - .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(r.into()))) - .saturating_add(Weight::from_parts(0, 151).saturating_mul(r.into())) - } - /// Storage: `Skipped::Metadata` (r:0 w:0) - /// Proof: `Skipped::Metadata` (`max_values`: None, `max_size`: None, mode: `Measured`) /// The range of component `n` is `[0, 16384]`. - fn seal_take_storage_per_byte(n: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `248 + n * (1 ±0)` - // Estimated: `248 + n * (1 ±0)` - // Minimum execution time: 18_711_000 picoseconds. - Weight::from_parts(20_495_670, 248) - // Standard Error: 3 - .saturating_add(Weight::from_parts(640, 0).saturating_mul(n.into())) + fn seal_take_storage(n: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `245 + n * (1 ±0)` + // Estimated: `245 + n * (1 ±0)` + // Minimum execution time: 57_000_000 picoseconds. + Weight::from_parts(66_300_000, 245) + // Standard Error: 188 + .saturating_add(Weight::from_parts(1_110, 0).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) } - /// Storage: `System::Account` (r:1601 w:1601) + /// Storage: `System::Account` (r:1 w:0) /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`) - /// The range of component `r` is `[0, 1600]`. - fn seal_transfer(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `770` - // Estimated: `4221 + r * (2475 ±0)` - // Minimum execution time: 9_226_000 picoseconds. - Weight::from_parts(9_394_000, 4221) - // Standard Error: 14_741 - .saturating_add(Weight::from_parts(34_179_316, 0).saturating_mul(r.into())) + fn seal_transfer() -> Weight { + // Proof Size summary in bytes: + // Measured: `140` + // Estimated: `3605` + // Minimum execution time: 99_000_000 picoseconds. + Weight::from_parts(102_000_000, 3605) .saturating_add(T::DbWeight::get().reads(1_u64)) - .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(r.into()))) - .saturating_add(T::DbWeight::get().writes(1_u64)) - .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(r.into()))) - .saturating_add(Weight::from_parts(0, 2475).saturating_mul(r.into())) - } - /// Storage: `Contracts::ContractInfoOf` (r:800 w:801) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) - /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) - /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) - /// Storage: `Contracts::PristineCode` (r:1 w:0) - /// Proof: `Contracts::PristineCode` (`max_values`: None, `max_size`: Some(125988), added: 128463, mode: `Measured`) - /// Storage: `System::EventTopics` (r:801 w:801) - /// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`) - /// Storage: `Parameters::Parameters` (r:2 w:0) - /// Proof: `Parameters::Parameters` (`max_values`: None, `max_size`: Some(36), added: 2511, mode: `Measured`) - /// The range of component `r` is `[0, 800]`. - fn seal_call(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `520 + r * (170 ±0)` - // Estimated: `6463 + r * (2646 ±0)` - // Minimum execution time: 9_455_000 picoseconds. - Weight::from_parts(9_671_000, 6463) - // Standard Error: 126_080 - .saturating_add(Weight::from_parts(244_204_040, 0).saturating_mul(r.into())) - .saturating_add(T::DbWeight::get().reads(5_u64)) - .saturating_add(T::DbWeight::get().reads((2_u64).saturating_mul(r.into()))) - .saturating_add(T::DbWeight::get().writes(2_u64)) - .saturating_add(T::DbWeight::get().writes((2_u64).saturating_mul(r.into()))) - .saturating_add(Weight::from_parts(0, 2646).saturating_mul(r.into())) - } - /// Storage: `Contracts::CodeInfoOf` (r:735 w:0) - /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) - /// Storage: `Contracts::PristineCode` (r:735 w:0) - /// Proof: `Contracts::PristineCode` (`max_values`: None, `max_size`: Some(125988), added: 128463, mode: `Measured`) - /// Storage: `System::EventTopics` (r:736 w:736) - /// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`) - /// Storage: `Parameters::Parameters` (r:2 w:0) - /// Proof: `Parameters::Parameters` (`max_values`: None, `max_size`: Some(36), added: 2511, mode: `Measured`) - /// Storage: `Contracts::ContractInfoOf` (r:0 w:1) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) - /// The range of component `r` is `[0, 800]`. - fn seal_delegate_call(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0 + r * (527 ±0)` - // Estimated: `6447 + r * (2583 ±10)` - // Minimum execution time: 9_274_000 picoseconds. - Weight::from_parts(9_437_000, 6447) - // Standard Error: 150_832 - .saturating_add(Weight::from_parts(244_196_269, 0).saturating_mul(r.into())) - .saturating_add(T::DbWeight::get().reads((3_u64).saturating_mul(r.into()))) - .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(r.into()))) - .saturating_add(Weight::from_parts(0, 2583).saturating_mul(r.into())) } /// Storage: `Contracts::ContractInfoOf` (r:1 w:2) /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) @@ -1096,56 +820,47 @@ impl WeightInfo for SubstrateWeight { /// Proof: `Contracts::PristineCode` (`max_values`: None, `max_size`: Some(125988), added: 128463, mode: `Measured`) /// 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:2 w:2) - /// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `Parameters::Parameters` (r:2 w:0) /// Proof: `Parameters::Parameters` (`max_values`: None, `max_size`: Some(36), added: 2511, mode: `Measured`) + /// Storage: `System::EventTopics` (r:2 w:2) + /// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// The range of component `c` is `[0, 1]`. /// The range of component `t` is `[0, 1]`. - /// The range of component `c` is `[0, 1048576]`. - fn seal_call_per_transfer_clone_byte(t: u32, c: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `699 + t * (277 ±0)` - // Estimated: `6639 + t * (3458 ±0)` - // Minimum execution time: 214_483_000 picoseconds. - Weight::from_parts(122_634_366, 6639) - // Standard Error: 2_499_235 - .saturating_add(Weight::from_parts(41_326_008, 0).saturating_mul(t.into())) - // Standard Error: 3 - .saturating_add(Weight::from_parts(422, 0).saturating_mul(c.into())) + /// The range of component `i` is `[0, 1048576]`. + fn seal_call(c: u32, t: u32, _i: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `623 + t * (280 ±0)` + // Estimated: `6563 + t * (3421 ±0)` + // Minimum execution time: 1_604_000_000 picoseconds. + Weight::from_parts(1_723_533_333, 6563) + // Standard Error: 18_493_246 + .saturating_add(Weight::from_parts(15_933_333, 0).saturating_mul(c.into())) + // Standard Error: 18_493_246 + .saturating_add(Weight::from_parts(414_233_333, 0).saturating_mul(t.into())) .saturating_add(T::DbWeight::get().reads(7_u64)) .saturating_add(T::DbWeight::get().reads((2_u64).saturating_mul(t.into()))) .saturating_add(T::DbWeight::get().writes(4_u64)) .saturating_add(T::DbWeight::get().writes((2_u64).saturating_mul(t.into()))) - .saturating_add(Weight::from_parts(0, 3458).saturating_mul(t.into())) + .saturating_add(Weight::from_parts(0, 3421).saturating_mul(t.into())) } - /// Storage: `Contracts::CodeInfoOf` (r:800 w:800) + /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) - /// Storage: `Contracts::PristineCode` (r:800 w:0) + /// Storage: `Contracts::PristineCode` (r:1 w:0) /// Proof: `Contracts::PristineCode` (`max_values`: None, `max_size`: Some(125988), added: 128463, mode: `Measured`) - /// Storage: `Contracts::Nonce` (r:1 w:0) - /// Proof: `Contracts::Nonce` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`) - /// Storage: `Contracts::ContractInfoOf` (r:800 w:801) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) - /// Storage: `System::Account` (r:802 w:802) - /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`) + /// Storage: `System::EventTopics` (r:2 w:2) + /// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `Parameters::Parameters` (r:2 w:0) /// Proof: `Parameters::Parameters` (`max_values`: None, `max_size`: Some(36), added: 2511, mode: `Measured`) - /// Storage: `System::EventTopics` (r:801 w:801) - /// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`) - /// The range of component `r` is `[1, 800]`. - fn seal_instantiate(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `1097 + r * (188 ±0)` - // Estimated: `6990 + r * (2664 ±0)` - // Minimum execution time: 341_569_000 picoseconds. - Weight::from_parts(360_574_000, 6990) - // Standard Error: 259_746 - .saturating_add(Weight::from_parts(337_944_674, 0).saturating_mul(r.into())) + /// Storage: `Contracts::ContractInfoOf` (r:0 w:1) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) + fn seal_delegate_call() -> Weight { + // Proof Size summary in bytes: + // Measured: `433` + // Estimated: `6373` + // Minimum execution time: 1_524_000_000 picoseconds. + Weight::from_parts(1_558_000_000, 6373) .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().writes(4_u64)) - .saturating_add(T::DbWeight::get().writes((4_u64).saturating_mul(r.into()))) - .saturating_add(Weight::from_parts(0, 2664).saturating_mul(r.into())) + .saturating_add(T::DbWeight::get().writes(3_u64)) } /// Storage: `Contracts::CodeInfoOf` (r:1 w:1) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) @@ -1164,245 +879,149 @@ impl WeightInfo for SubstrateWeight { /// The range of component `t` is `[0, 1]`. /// The range of component `i` is `[0, 983040]`. /// The range of component `s` is `[0, 983040]`. - fn seal_instantiate_per_transfer_input_salt_byte(t: u32, i: u32, s: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `760 + t * (104 ±0)` - // Estimated: `6719 + t * (2549 ±1)` - // Minimum execution time: 1_863_119_000 picoseconds. - Weight::from_parts(900_189_174, 6719) - // Standard Error: 13_040_979 - .saturating_add(Weight::from_parts(4_056_063, 0).saturating_mul(t.into())) - // Standard Error: 20 - .saturating_add(Weight::from_parts(1_028, 0).saturating_mul(i.into())) - // Standard Error: 20 - .saturating_add(Weight::from_parts(1_173, 0).saturating_mul(s.into())) + fn seal_instantiate(t: u32, i: u32, s: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `627 + t * (102 ±0)` + // Estimated: `6567 + t * (2577 ±0)` + // Minimum execution time: 3_863_000_000 picoseconds. + Weight::from_parts(2_236_566_666, 6567) + // Standard Error: 41_979_515 + .saturating_add(Weight::from_parts(469_166_666, 0).saturating_mul(t.into())) + // Standard Error: 42 + .saturating_add(Weight::from_parts(1_417, 0).saturating_mul(i.into())) + // Standard Error: 42 + .saturating_add(Weight::from_parts(1_492, 0).saturating_mul(s.into())) .saturating_add(T::DbWeight::get().reads(10_u64)) .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(t.into()))) .saturating_add(T::DbWeight::get().writes(7_u64)) .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(t.into()))) - .saturating_add(Weight::from_parts(0, 2549).saturating_mul(t.into())) - } - /// The range of component `r` is `[0, 1600]`. - fn seal_hash_sha2_256(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 9_211_000 picoseconds. - Weight::from_parts(11_696_412, 0) - // Standard Error: 388 - .saturating_add(Weight::from_parts(265_538, 0).saturating_mul(r.into())) + .saturating_add(Weight::from_parts(0, 2577).saturating_mul(t.into())) } /// The range of component `n` is `[0, 1048576]`. - fn seal_hash_sha2_256_per_byte(n: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 10_296_000 picoseconds. - Weight::from_parts(572_494, 0) - // Standard Error: 1 - .saturating_add(Weight::from_parts(1_067, 0).saturating_mul(n.into())) - } - /// The range of component `r` is `[0, 1600]`. - fn seal_hash_keccak_256(r: u32, ) -> Weight { + fn seal_hash_sha2_256(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 9_177_000 picoseconds. - Weight::from_parts(8_620_481, 0) - // Standard Error: 249 - .saturating_add(Weight::from_parts(674_502, 0).saturating_mul(r.into())) + // Minimum execution time: 8_000_000 picoseconds. + Weight::from_parts(13_000_000, 0) + // Standard Error: 13 + .saturating_add(Weight::from_parts(3_238, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 1048576]`. - fn seal_hash_keccak_256_per_byte(n: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 11_240_000 picoseconds. - Weight::from_parts(8_696_186, 0) - // Standard Error: 0 - .saturating_add(Weight::from_parts(3_328, 0).saturating_mul(n.into())) - } - /// The range of component `r` is `[0, 1600]`. - fn seal_hash_blake2_256(r: u32, ) -> Weight { + fn seal_hash_keccak_256(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 9_889_000 picoseconds. - Weight::from_parts(16_103_170, 0) - // Standard Error: 343 - .saturating_add(Weight::from_parts(328_939, 0).saturating_mul(r.into())) + // Minimum execution time: 9_000_000 picoseconds. + Weight::from_parts(12_900_000, 0) + // Standard Error: 16 + .saturating_add(Weight::from_parts(4_844, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 1048576]`. - fn seal_hash_blake2_256_per_byte(n: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 10_405_000 picoseconds. - Weight::from_parts(2_264_024, 0) - // Standard Error: 0 - .saturating_add(Weight::from_parts(1_196, 0).saturating_mul(n.into())) - } - /// The range of component `r` is `[0, 1600]`. - fn seal_hash_blake2_128(r: u32, ) -> Weight { + fn seal_hash_blake2_256(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 9_215_000 picoseconds. - Weight::from_parts(10_505_632, 0) - // Standard Error: 240 - .saturating_add(Weight::from_parts(324_854, 0).saturating_mul(r.into())) + // Minimum execution time: 5_000_000 picoseconds. + Weight::from_parts(6_000_000, 0) + // Standard Error: 5 + .saturating_add(Weight::from_parts(1_190, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 1048576]`. - fn seal_hash_blake2_128_per_byte(n: u32, ) -> Weight { + fn seal_hash_blake2_128(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 10_440_000 picoseconds. - Weight::from_parts(2_575_889, 0) - // Standard Error: 1 - .saturating_add(Weight::from_parts(1_199, 0).saturating_mul(n.into())) + // Minimum execution time: 5_000_000 picoseconds. + Weight::from_parts(5_600_000, 0) + // Standard Error: 4 + .saturating_add(Weight::from_parts(1_165, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 125697]`. - fn seal_sr25519_verify_per_byte(n: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 55_119_000 picoseconds. - Weight::from_parts(56_732_248, 0) - // Standard Error: 8 - .saturating_add(Weight::from_parts(4_639, 0).saturating_mul(n.into())) - } - /// The range of component `r` is `[0, 160]`. - fn seal_sr25519_verify(r: u32, ) -> Weight { + fn seal_sr25519_verify(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 9_176_000 picoseconds. - Weight::from_parts(9_861_102, 0) - // Standard Error: 6_029 - .saturating_add(Weight::from_parts(45_948_571, 0).saturating_mul(r.into())) + // Minimum execution time: 58_000_000 picoseconds. + Weight::from_parts(63_500_000, 0) + // Standard Error: 39 + .saturating_add(Weight::from_parts(7_818, 0).saturating_mul(n.into())) } - /// The range of component `r` is `[0, 160]`. - fn seal_ecdsa_recover(r: u32, ) -> Weight { + fn seal_ecdsa_recover() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 9_293_000 picoseconds. - Weight::from_parts(28_785_765, 0) - // Standard Error: 9_160 - .saturating_add(Weight::from_parts(45_566_150, 0).saturating_mul(r.into())) + // Minimum execution time: 312_000_000 picoseconds. + Weight::from_parts(329_000_000, 0) } - /// The range of component `r` is `[0, 160]`. - fn seal_ecdsa_to_eth_address(r: u32, ) -> Weight { + fn seal_ecdsa_to_eth_address() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 9_206_000 picoseconds. - Weight::from_parts(12_420_664, 0) - // Standard Error: 3_489 - .saturating_add(Weight::from_parts(11_628_989, 0).saturating_mul(r.into())) + // Minimum execution time: 16_000_000 picoseconds. + Weight::from_parts(19_000_000, 0) } - /// Storage: `Contracts::CodeInfoOf` (r:1536 w:1536) + /// Storage: `Contracts::CodeInfoOf` (r:1 w:1) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) - /// Storage: `Contracts::PristineCode` (r:1535 w:0) + /// Storage: `Contracts::PristineCode` (r:1 w:0) /// Proof: `Contracts::PristineCode` (`max_values`: None, `max_size`: Some(125988), added: 128463, mode: `Measured`) /// Storage: `Parameters::Parameters` (r:2 w:0) /// Proof: `Parameters::Parameters` (`max_values`: None, `max_size`: Some(36), added: 2511, mode: `Measured`) - /// Storage: `System::EventTopics` (r:1537 w:1537) + /// Storage: `System::EventTopics` (r:2 w:2) /// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`) - /// The range of component `r` is `[0, 1600]`. - fn seal_set_code_hash(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0 + r * (926 ±0)` - // Estimated: `8969 + r * (3047 ±7)` - // Minimum execution time: 9_219_000 picoseconds. - Weight::from_parts(9_385_000, 8969) - // Standard Error: 45_562 - .saturating_add(Weight::from_parts(26_360_661, 0).saturating_mul(r.into())) - .saturating_add(T::DbWeight::get().reads((3_u64).saturating_mul(r.into()))) - .saturating_add(T::DbWeight::get().writes((2_u64).saturating_mul(r.into()))) - .saturating_add(Weight::from_parts(0, 3047).saturating_mul(r.into())) - } - /// Storage: `Contracts::CodeInfoOf` (r:32 w:32) + fn seal_set_code_hash() -> Weight { + // Proof Size summary in bytes: + // Measured: `433` + // Estimated: `6373` + // Minimum execution time: 309_000_000 picoseconds. + Weight::from_parts(332_000_000, 6373) + .saturating_add(T::DbWeight::get().reads(6_u64)) + .saturating_add(T::DbWeight::get().writes(3_u64)) + } + /// Storage: `Contracts::CodeInfoOf` (r:1 w:1) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) - /// The range of component `r` is `[0, 32]`. - fn lock_delegate_dependency(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `274 + r * (78 ±0)` - // Estimated: `1265 + r * (2553 ±0)` - // Minimum execution time: 9_355_000 picoseconds. - Weight::from_parts(15_071_309, 1265) - // Standard Error: 9_722 - .saturating_add(Weight::from_parts(5_328_717, 0).saturating_mul(r.into())) - .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(r.into()))) - .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(r.into()))) - .saturating_add(Weight::from_parts(0, 2553).saturating_mul(r.into())) - } - /// Storage: `Contracts::CodeInfoOf` (r:32 w:32) + fn lock_delegate_dependency() -> Weight { + // Proof Size summary in bytes: + // Measured: `355` + // Estimated: `3820` + // Minimum execution time: 80_000_000 picoseconds. + Weight::from_parts(86_000_000, 3820) + .saturating_add(T::DbWeight::get().reads(1_u64)) + .saturating_add(T::DbWeight::get().writes(1_u64)) + } + /// Storage: `Contracts::CodeInfoOf` (r:1 w:1) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `MaxEncodedLen`) - /// The range of component `r` is `[0, 32]`. - fn unlock_delegate_dependency(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `275 + r * (78 ±0)` - // Estimated: `990 + r * (2568 ±0)` - // Minimum execution time: 8_979_000 picoseconds. - Weight::from_parts(14_362_224, 990) - // Standard Error: 9_137 - .saturating_add(Weight::from_parts(4_488_748, 0).saturating_mul(r.into())) - .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(r.into()))) - .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(r.into()))) - .saturating_add(Weight::from_parts(0, 2568).saturating_mul(r.into())) + fn unlock_delegate_dependency() -> Weight { + // Proof Size summary in bytes: + // Measured: `355` + // Estimated: `3558` + // Minimum execution time: 66_000_000 picoseconds. + Weight::from_parts(69_000_000, 3558) + .saturating_add(T::DbWeight::get().reads(1_u64)) + .saturating_add(T::DbWeight::get().writes(1_u64)) } - /// Storage: `Contracts::MigrationInProgress` (r:1 w:0) - /// Proof: `Contracts::MigrationInProgress` (`max_values`: Some(1), `max_size`: Some(1026), added: 1521, mode: `Measured`) - /// Storage: `System::Account` (r:1 w:0) - /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`) - /// Storage: `Parameters::Parameters` (r:3 w:0) - /// Proof: `Parameters::Parameters` (`max_values`: None, `max_size`: Some(36), added: 2511, mode: `Measured`) - /// Storage: `Contracts::ContractInfoOf` (r:1 w:1) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) - /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) - /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) - /// Storage: `Contracts::PristineCode` (r:1 w:0) - /// Proof: `Contracts::PristineCode` (`max_values`: None, `max_size`: Some(125988), added: 128463, 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::EventTopics` (r:2 w:2) - /// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`) - /// The range of component `r` is `[0, 1600]`. - fn seal_reentrance_count(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `861 + r * (3 ±0)` - // Estimated: `9282 + r * (3 ±0)` - // Minimum execution time: 269_704_000 picoseconds. - Weight::from_parts(289_916_035, 9282) - // Standard Error: 408 - .saturating_add(Weight::from_parts(166_040, 0).saturating_mul(r.into())) - .saturating_add(T::DbWeight::get().reads(11_u64)) - .saturating_add(T::DbWeight::get().writes(3_u64)) - .saturating_add(Weight::from_parts(0, 3).saturating_mul(r.into())) + fn seal_reentrance_count() -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 2_000_000 picoseconds. + Weight::from_parts(3_000_000, 0) } - /// The range of component `r` is `[0, 1600]`. - fn seal_account_reentrance_count(r: u32, ) -> Weight { + fn seal_account_reentrance_count() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 9_361_000 picoseconds. - Weight::from_parts(11_633_836, 0) - // Standard Error: 86 - .saturating_add(Weight::from_parts(83_083, 0).saturating_mul(r.into())) + // Minimum execution time: 2_000_000 picoseconds. + Weight::from_parts(3_000_000, 0) } /// Storage: `Contracts::Nonce` (r:1 w:0) /// Proof: `Contracts::Nonce` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`) - /// The range of component `r` is `[0, 1600]`. - fn seal_instantiation_nonce(r: u32, ) -> Weight { + fn seal_instantiation_nonce() -> Weight { // Proof Size summary in bytes: // Measured: `219` // Estimated: `1704` - // Minimum execution time: 9_133_000 picoseconds. - Weight::from_parts(13_259_836, 1704) - // Standard Error: 121 - .saturating_add(Weight::from_parts(76_878, 0).saturating_mul(r.into())) + // Minimum execution time: 26_000_000 picoseconds. + Weight::from_parts(28_000_000, 1704) .saturating_add(T::DbWeight::get().reads(1_u64)) } /// The range of component `r` is `[0, 5000]`. @@ -1410,10 +1029,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 851_000 picoseconds. - Weight::from_parts(587_883, 0) - // Standard Error: 16 - .saturating_add(Weight::from_parts(14_912, 0).saturating_mul(r.into())) + // Minimum execution time: 5_000_000 picoseconds. + Weight::from_parts(6_000_000, 0) + // Standard Error: 557 + .saturating_add(Weight::from_parts(75_560, 0).saturating_mul(r.into())) } } @@ -1425,8 +1044,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `142` // Estimated: `1627` - // Minimum execution time: 2_149_000 picoseconds. - Weight::from_parts(2_274_000, 1627) + // Minimum execution time: 21_000_000 picoseconds. + Weight::from_parts(22_000_000, 1627) .saturating_add(RocksDbWeight::get().reads(1_u64)) } /// Storage: `Skipped::Metadata` (r:0 w:0) @@ -1434,12 +1053,12 @@ impl WeightInfo for () { /// The range of component `k` is `[0, 1024]`. fn on_initialize_per_trie_key(k: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `452 + k * (69 ±0)` - // Estimated: `442 + k * (70 ±0)` - // Minimum execution time: 12_863_000 picoseconds. - Weight::from_parts(13_188_000, 442) - // Standard Error: 1_053 - .saturating_add(Weight::from_parts(1_105_325, 0).saturating_mul(k.into())) + // Measured: `318 + k * (69 ±0)` + // Estimated: `318 + k * (70 ±0)` + // Minimum execution time: 106_000_000 picoseconds. + Weight::from_parts(118_200_000, 318) + // Standard Error: 30_650 + .saturating_add(Weight::from_parts(7_881_933, 0).saturating_mul(k.into())) .saturating_add(RocksDbWeight::get().reads(2_u64)) .saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(k.into()))) .saturating_add(RocksDbWeight::get().writes(2_u64)) @@ -1451,12 +1070,12 @@ impl WeightInfo for () { /// The range of component `c` is `[0, 125952]`. fn v9_migration_step(c: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `211 + c * (1 ±0)` - // Estimated: `6149 + c * (1 ±0)` - // Minimum execution time: 8_432_000 picoseconds. - Weight::from_parts(9_203_290, 6149) - // Standard Error: 1 - .saturating_add(Weight::from_parts(1_186, 0).saturating_mul(c.into())) + // Measured: `203 + c * (1 ±0)` + // Estimated: `6143 + c * (1 ±0)` + // Minimum execution time: 90_000_000 picoseconds. + Weight::from_parts(92_900_000, 6143) + // Standard Error: 7 + .saturating_add(Weight::from_parts(744, 0).saturating_mul(c.into())) .saturating_add(RocksDbWeight::get().reads(2_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(c.into())) @@ -1469,8 +1088,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `510` // Estimated: `6450` - // Minimum execution time: 17_177_000 picoseconds. - Weight::from_parts(17_663_000, 6450) + // Minimum execution time: 149_000_000 picoseconds. + Weight::from_parts(164_000_000, 6450) .saturating_add(RocksDbWeight::get().reads(3_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -1481,14 +1100,14 @@ impl WeightInfo for () { /// The range of component `k` is `[0, 1024]`. fn v11_migration_step(k: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `171 + k * (1 ±0)` - // Estimated: `3635 + k * (1 ±0)` - // Minimum execution time: 3_636_000 picoseconds. - Weight::from_parts(3_774_000, 3635) - // Standard Error: 542 - .saturating_add(Weight::from_parts(1_260_058, 0).saturating_mul(k.into())) + // Measured: `166 + k * (1 ±0)` + // Estimated: `3631 + k * (1 ±0)` + // Minimum execution time: 32_000_000 picoseconds. + Weight::from_parts(33_399_999, 3631) + // Standard Error: 56_913 + .saturating_add(Weight::from_parts(15_769_238, 0).saturating_mul(k.into())) .saturating_add(RocksDbWeight::get().reads(1_u64)) - .saturating_add(RocksDbWeight::get().writes(2_u64)) + .saturating_add(RocksDbWeight::get().writes(1_u64)) .saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(k.into()))) .saturating_add(Weight::from_parts(0, 1).saturating_mul(k.into())) } @@ -1505,12 +1124,12 @@ impl WeightInfo for () { /// The range of component `c` is `[0, 125952]`. fn v12_migration_step(c: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `328 + c * (1 ±0)` - // Estimated: `6266 + c * (1 ±0)` - // Minimum execution time: 21_585_000 picoseconds. - Weight::from_parts(22_069_944, 6266) - // Standard Error: 1 - .saturating_add(Weight::from_parts(404, 0).saturating_mul(c.into())) + // Measured: `320 + c * (1 ±0)` + // Estimated: `6260 + c * (1 ±0)` + // Minimum execution time: 205_000_000 picoseconds. + Weight::from_parts(219_100_000, 6260) + // Standard Error: 31 + .saturating_add(Weight::from_parts(342, 0).saturating_mul(c.into())) .saturating_add(RocksDbWeight::get().reads(6_u64)) .saturating_add(RocksDbWeight::get().writes(2_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(c.into())) @@ -1521,8 +1140,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `440` // Estimated: `6380` - // Minimum execution time: 13_283_000 picoseconds. - Weight::from_parts(14_015_000, 6380) + // Minimum execution time: 112_000_000 picoseconds. + Weight::from_parts(117_000_000, 6380) .saturating_add(RocksDbWeight::get().reads(2_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -1536,8 +1155,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `352` // Estimated: `6292` - // Minimum execution time: 48_022_000 picoseconds. - Weight::from_parts(49_627_000, 6292) + // Minimum execution time: 487_000_000 picoseconds. + Weight::from_parts(507_000_000, 6292) .saturating_add(RocksDbWeight::get().reads(4_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -1549,8 +1168,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `594` // Estimated: `6534` - // Minimum execution time: 58_374_000 picoseconds. - Weight::from_parts(59_615_000, 6534) + // Minimum execution time: 430_000_000 picoseconds. + Weight::from_parts(518_000_000, 6534) .saturating_add(RocksDbWeight::get().reads(4_u64)) .saturating_add(RocksDbWeight::get().writes(2_u64)) } @@ -1560,8 +1179,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `409` // Estimated: `6349` - // Minimum execution time: 12_559_000 picoseconds. - Weight::from_parts(12_947_000, 6349) + // Minimum execution time: 110_000_000 picoseconds. + Weight::from_parts(122_000_000, 6349) .saturating_add(RocksDbWeight::get().reads(2_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -1571,8 +1190,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `142` // Estimated: `1627` - // Minimum execution time: 2_480_000 picoseconds. - Weight::from_parts(2_680_000, 1627) + // Minimum execution time: 23_000_000 picoseconds. + Weight::from_parts(25_000_000, 1627) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -1584,8 +1203,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `166` // Estimated: `3631` - // Minimum execution time: 12_625_000 picoseconds. - Weight::from_parts(13_094_000, 3631) + // Minimum execution time: 114_000_000 picoseconds. + Weight::from_parts(118_000_000, 3631) .saturating_add(RocksDbWeight::get().reads(2_u64)) .saturating_add(RocksDbWeight::get().writes(2_u64)) } @@ -1595,8 +1214,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `142` // Estimated: `3607` - // Minimum execution time: 4_836_000 picoseconds. - Weight::from_parts(5_182_000, 3607) + // Minimum execution time: 42_000_000 picoseconds. + Weight::from_parts(43_000_000, 3607) .saturating_add(RocksDbWeight::get().reads(1_u64)) } /// Storage: UNKNOWN KEY `0x4342193e496fab7ec59d615ed0dc55304e7b9012096b41c4eb3aaf947f6ea429` (r:1 w:0) @@ -1607,8 +1226,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `167` // Estimated: `3632` - // Minimum execution time: 6_319_000 picoseconds. - Weight::from_parts(6_582_000, 3632) + // Minimum execution time: 56_000_000 picoseconds. + Weight::from_parts(60_000_000, 3632) .saturating_add(RocksDbWeight::get().reads(2_u64)) } /// Storage: UNKNOWN KEY `0x4342193e496fab7ec59d615ed0dc55304e7b9012096b41c4eb3aaf947f6ea429` (r:1 w:0) @@ -1619,8 +1238,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `142` // Estimated: `3607` - // Minimum execution time: 6_532_000 picoseconds. - Weight::from_parts(6_909_000, 3607) + // Minimum execution time: 56_000_000 picoseconds. + Weight::from_parts(58_000_000, 3607) .saturating_add(RocksDbWeight::get().reads(2_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -1643,12 +1262,12 @@ impl WeightInfo for () { /// The range of component `c` is `[0, 125952]`. fn call_with_code_per_byte(c: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `804 + c * (1 ±0)` - // Estimated: `9217 + c * (1 ±0)` - // Minimum execution time: 305_778_000 picoseconds. - Weight::from_parts(282_321_249, 9217) - // Standard Error: 72 - .saturating_add(Weight::from_parts(33_456, 0).saturating_mul(c.into())) + // Measured: `832` + // Estimated: `9247 + c * (1 ±0)` + // Minimum execution time: 2_201_000_000 picoseconds. + Weight::from_parts(2_297_000_000, 9247) + // Standard Error: 362 + .saturating_add(Weight::from_parts(83_549, 0).saturating_mul(c.into())) .saturating_add(RocksDbWeight::get().reads(11_u64)) .saturating_add(RocksDbWeight::get().writes(4_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(c.into())) @@ -1678,16 +1297,16 @@ 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: `326` - // Estimated: `8740` - // Minimum execution time: 3_810_809_000 picoseconds. - Weight::from_parts(739_511_598, 8740) - // Standard Error: 140 - .saturating_add(Weight::from_parts(67_574, 0).saturating_mul(c.into())) - // Standard Error: 16 - .saturating_add(Weight::from_parts(1_488, 0).saturating_mul(i.into())) - // Standard Error: 16 - .saturating_add(Weight::from_parts(1_537, 0).saturating_mul(s.into())) + // Measured: `443` + // Estimated: `8858` + // Minimum execution time: 8_151_000_000 picoseconds. + Weight::from_parts(5_385_233_352, 8858) + // Standard Error: 497 + .saturating_add(Weight::from_parts(161_394, 0).saturating_mul(c.into())) + // Standard Error: 59 + .saturating_add(Weight::from_parts(1_312, 0).saturating_mul(i.into())) + // Standard Error: 59 + .saturating_add(Weight::from_parts(1_839, 0).saturating_mul(s.into())) .saturating_add(RocksDbWeight::get().reads(14_u64)) .saturating_add(RocksDbWeight::get().writes(10_u64)) } @@ -1715,14 +1334,14 @@ impl WeightInfo for () { /// The range of component `s` is `[0, 1048576]`. fn instantiate(i: u32, s: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `563` - // Estimated: `8982` - // Minimum execution time: 1_986_789_000 picoseconds. - Weight::from_parts(2_017_466_000, 8982) - // Standard Error: 26 - .saturating_add(Weight::from_parts(827, 0).saturating_mul(i.into())) - // Standard Error: 26 - .saturating_add(Weight::from_parts(781, 0).saturating_mul(s.into())) + // Measured: `615` + // Estimated: `9030` + // Minimum execution time: 4_448_000_000 picoseconds. + Weight::from_parts(3_037_050_000, 9030) + // Standard Error: 32 + .saturating_add(Weight::from_parts(1_818, 0).saturating_mul(i.into())) + // Standard Error: 32 + .saturating_add(Weight::from_parts(1_611, 0).saturating_mul(s.into())) .saturating_add(RocksDbWeight::get().reads(13_u64)) .saturating_add(RocksDbWeight::get().writes(7_u64)) } @@ -1746,8 +1365,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `829` // Estimated: `9244` - // Minimum execution time: 210_724_000 picoseconds. - Weight::from_parts(218_608_000, 9244) + // Minimum execution time: 2_158_000_000 picoseconds. + Weight::from_parts(2_235_000_000, 9244) .saturating_add(RocksDbWeight::get().reads(11_u64)) .saturating_add(RocksDbWeight::get().writes(4_u64)) } @@ -1768,10 +1387,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `145` // Estimated: `6085` - // Minimum execution time: 271_259_000 picoseconds. - Weight::from_parts(298_852_854, 6085) - // Standard Error: 65 - .saturating_add(Weight::from_parts(33_547, 0).saturating_mul(c.into())) + // Minimum execution time: 1_951_000_000 picoseconds. + Weight::from_parts(2_063_900_000, 6085) + // Standard Error: 430 + .saturating_add(Weight::from_parts(83_991, 0).saturating_mul(c.into())) .saturating_add(RocksDbWeight::get().reads(6_u64)) .saturating_add(RocksDbWeight::get().writes(4_u64)) } @@ -1792,10 +1411,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `145` // Estimated: `6085` - // Minimum execution time: 278_167_000 picoseconds. - Weight::from_parts(311_888_941, 6085) - // Standard Error: 58 - .saturating_add(Weight::from_parts(33_595, 0).saturating_mul(c.into())) + // Minimum execution time: 2_110_000_000 picoseconds. + Weight::from_parts(2_274_000_000, 6085) + // Standard Error: 286 + .saturating_add(Weight::from_parts(84_193, 0).saturating_mul(c.into())) .saturating_add(RocksDbWeight::get().reads(6_u64)) .saturating_add(RocksDbWeight::get().writes(4_u64)) } @@ -1813,8 +1432,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `315` // Estimated: `3780` - // Minimum execution time: 47_403_000 picoseconds. - Weight::from_parts(48_707_000, 3780) + // Minimum execution time: 485_000_000 picoseconds. + Weight::from_parts(523_000_000, 3780) .saturating_add(RocksDbWeight::get().reads(4_u64)) .saturating_add(RocksDbWeight::get().writes(4_u64)) } @@ -1830,335 +1449,205 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `552` // Estimated: `8967` - // Minimum execution time: 35_361_000 picoseconds. - Weight::from_parts(36_714_000, 8967) + // Minimum execution time: 321_000_000 picoseconds. + Weight::from_parts(364_000_000, 8967) .saturating_add(RocksDbWeight::get().reads(7_u64)) .saturating_add(RocksDbWeight::get().writes(6_u64)) } /// The range of component `r` is `[0, 1600]`. - fn seal_caller(r: u32, ) -> Weight { + fn call_noop_host_fn(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 9_340_000 picoseconds. - Weight::from_parts(9_360_237, 0) - // Standard Error: 269 - .saturating_add(Weight::from_parts(249_611, 0).saturating_mul(r.into())) + // Minimum execution time: 150_000_000 picoseconds. + Weight::from_parts(159_300_000, 0) + // Standard Error: 1_567 + .saturating_add(Weight::from_parts(74_625, 0).saturating_mul(r.into())) } - /// Storage: `Contracts::ContractInfoOf` (r:1600 w:0) + fn seal_caller() -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 6_000_000 picoseconds. + Weight::from_parts(7_000_000, 0) + } + /// Storage: `Contracts::ContractInfoOf` (r:1 w:0) /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) - /// The range of component `r` is `[0, 1600]`. - fn seal_is_contract(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `509 + r * (77 ±0)` - // Estimated: `1467 + r * (2552 ±0)` - // Minimum execution time: 9_059_000 picoseconds. - Weight::from_parts(9_201_000, 1467) - // Standard Error: 5_643 - .saturating_add(Weight::from_parts(3_343_859, 0).saturating_mul(r.into())) - .saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(r.into()))) - .saturating_add(Weight::from_parts(0, 2552).saturating_mul(r.into())) - } - /// Storage: `Contracts::ContractInfoOf` (r:1600 w:0) + fn seal_is_contract() -> Weight { + // Proof Size summary in bytes: + // Measured: `354` + // Estimated: `3819` + // Minimum execution time: 57_000_000 picoseconds. + Weight::from_parts(61_000_000, 3819) + .saturating_add(RocksDbWeight::get().reads(1_u64)) + } + /// Storage: `Contracts::ContractInfoOf` (r:1 w:0) /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) - /// The range of component `r` is `[0, 1600]`. - fn seal_code_hash(r: u32, ) -> Weight { + fn seal_code_hash() -> Weight { // Proof Size summary in bytes: - // Measured: `517 + r * (170 ±0)` - // Estimated: `1468 + r * (2645 ±0)` - // Minimum execution time: 9_220_000 picoseconds. - Weight::from_parts(9_399_000, 1468) - // Standard Error: 6_194 - .saturating_add(Weight::from_parts(4_172_011, 0).saturating_mul(r.into())) - .saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(r.into()))) - .saturating_add(Weight::from_parts(0, 2645).saturating_mul(r.into())) + // Measured: `447` + // Estimated: `3912` + // Minimum execution time: 68_000_000 picoseconds. + Weight::from_parts(72_000_000, 3912) + .saturating_add(RocksDbWeight::get().reads(1_u64)) } - /// The range of component `r` is `[0, 1600]`. - fn seal_own_code_hash(r: u32, ) -> Weight { + fn seal_own_code_hash() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 9_707_000 picoseconds. - Weight::from_parts(10_100_456, 0) - // Standard Error: 234 - .saturating_add(Weight::from_parts(338_464, 0).saturating_mul(r.into())) + // Minimum execution time: 8_000_000 picoseconds. + Weight::from_parts(9_000_000, 0) } - /// The range of component `r` is `[0, 1600]`. - fn seal_caller_is_origin(r: u32, ) -> Weight { + fn seal_caller_is_origin() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 9_524_000 picoseconds. - Weight::from_parts(10_813_389, 0) - // Standard Error: 76 - .saturating_add(Weight::from_parts(102_535, 0).saturating_mul(r.into())) + // Minimum execution time: 2_000_000 picoseconds. + Weight::from_parts(3_000_000, 0) } - /// The range of component `r` is `[0, 1600]`. - fn seal_caller_is_root(r: u32, ) -> Weight { + fn seal_caller_is_root() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 9_799_000 picoseconds. - Weight::from_parts(10_886_744, 0) - // Standard Error: 75 - .saturating_add(Weight::from_parts(80_901, 0).saturating_mul(r.into())) + // Minimum execution time: 2_000_000 picoseconds. + Weight::from_parts(3_000_000, 0) } - /// The range of component `r` is `[0, 1600]`. - fn seal_address(r: u32, ) -> Weight { + fn seal_address() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 9_895_000 picoseconds. - Weight::from_parts(10_658_338, 0) - // Standard Error: 189 - .saturating_add(Weight::from_parts(249_694, 0).saturating_mul(r.into())) + // Minimum execution time: 6_000_000 picoseconds. + Weight::from_parts(6_000_000, 0) } - /// The range of component `r` is `[0, 1600]`. - fn seal_gas_left(r: u32, ) -> Weight { + fn seal_gas_left() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 9_643_000 picoseconds. - Weight::from_parts(10_932_126, 0) - // Standard Error: 153 - .saturating_add(Weight::from_parts(280_924, 0).saturating_mul(r.into())) + // Minimum execution time: 6_000_000 picoseconds. + Weight::from_parts(6_000_000, 0) } /// Storage: `System::Account` (r:1 w:0) /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`) - /// The range of component `r` is `[0, 1600]`. - fn seal_balance(r: u32, ) -> Weight { + fn seal_balance() -> Weight { // Proof Size summary in bytes: // Measured: `140` - // Estimated: `3599` - // Minimum execution time: 9_548_000 picoseconds. - Weight::from_parts(9_737_000, 3599) - // Standard Error: 971 - .saturating_add(Weight::from_parts(1_704_134, 0).saturating_mul(r.into())) + // Estimated: `3605` + // Minimum execution time: 45_000_000 picoseconds. + Weight::from_parts(47_000_000, 3605) .saturating_add(RocksDbWeight::get().reads(1_u64)) } - /// The range of component `r` is `[0, 1600]`. - fn seal_value_transferred(r: u32, ) -> Weight { + fn seal_value_transferred() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 9_172_000 picoseconds. - Weight::from_parts(18_255_933, 0) - // Standard Error: 540 - .saturating_add(Weight::from_parts(230_929, 0).saturating_mul(r.into())) + // Minimum execution time: 6_000_000 picoseconds. + Weight::from_parts(7_000_000, 0) } - /// The range of component `r` is `[0, 1600]`. - fn seal_minimum_balance(r: u32, ) -> Weight { + fn seal_minimum_balance() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 9_232_000 picoseconds. - Weight::from_parts(9_796_584, 0) - // Standard Error: 208 - .saturating_add(Weight::from_parts(239_962, 0).saturating_mul(r.into())) + // Minimum execution time: 6_000_000 picoseconds. + Weight::from_parts(6_000_000, 0) } - /// The range of component `r` is `[0, 1600]`. - fn seal_block_number(r: u32, ) -> Weight { + fn seal_block_number() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 9_747_000 picoseconds. - Weight::from_parts(8_733_230, 0) - // Standard Error: 377 - .saturating_add(Weight::from_parts(253_801, 0).saturating_mul(r.into())) + // Minimum execution time: 6_000_000 picoseconds. + Weight::from_parts(6_000_000, 0) } - /// The range of component `r` is `[0, 1600]`. - fn seal_now(r: u32, ) -> Weight { + fn seal_now() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 9_214_000 picoseconds. - Weight::from_parts(10_194_153, 0) - // Standard Error: 516 - .saturating_add(Weight::from_parts(247_621, 0).saturating_mul(r.into())) + // Minimum execution time: 6_000_000 picoseconds. + Weight::from_parts(7_000_000, 0) } /// Storage: `TransactionPayment::NextFeeMultiplier` (r:1 w:0) /// Proof: `TransactionPayment::NextFeeMultiplier` (`max_values`: Some(1), `max_size`: Some(16), added: 511, mode: `Measured`) - /// The range of component `r` is `[0, 1600]`. - fn seal_weight_to_fee(r: u32, ) -> Weight { + fn seal_weight_to_fee() -> Weight { // Proof Size summary in bytes: // Measured: `67` // Estimated: `1552` - // Minimum execution time: 9_022_000 picoseconds. - Weight::from_parts(22_051_160, 1552) - // Standard Error: 697 - .saturating_add(Weight::from_parts(709_612, 0).saturating_mul(r.into())) + // Minimum execution time: 35_000_000 picoseconds. + Weight::from_parts(37_000_000, 1552) .saturating_add(RocksDbWeight::get().reads(1_u64)) } - /// The range of component `r` is `[0, 1600]`. - fn seal_input(r: u32, ) -> Weight { + /// The range of component `n` is `[0, 1048572]`. + fn seal_input(_n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 9_135_000 picoseconds. - Weight::from_parts(10_646_215, 0) - // Standard Error: 161 - .saturating_add(Weight::from_parts(170_336, 0).saturating_mul(r.into())) + // Minimum execution time: 4_000_000 picoseconds. + Weight::from_parts(4_900_000, 0) } - /// Storage: `Contracts::MigrationInProgress` (r:1 w:0) - /// Proof: `Contracts::MigrationInProgress` (`max_values`: Some(1), `max_size`: Some(1026), added: 1521, mode: `Measured`) - /// Storage: `System::Account` (r:1 w:0) - /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`) - /// Storage: `Parameters::Parameters` (r:3 w:0) - /// Proof: `Parameters::Parameters` (`max_values`: None, `max_size`: Some(36), added: 2511, mode: `Measured`) - /// Storage: `Contracts::ContractInfoOf` (r:1 w:1) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) - /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) - /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) - /// Storage: `Contracts::PristineCode` (r:1 w:0) - /// Proof: `Contracts::PristineCode` (`max_values`: None, `max_size`: Some(125988), added: 128463, 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::EventTopics` (r:2 w:2) - /// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`) - /// The range of component `n` is `[0, 1048576]`. - fn seal_input_per_byte(n: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `872` - // Estimated: `9287` - // Minimum execution time: 273_896_000 picoseconds. - Weight::from_parts(148_309_654, 9287) - // Standard Error: 16 - .saturating_add(Weight::from_parts(1_355, 0).saturating_mul(n.into())) - .saturating_add(RocksDbWeight::get().reads(11_u64)) - .saturating_add(RocksDbWeight::get().writes(3_u64)) - } - /// The range of component `r` is `[0, 1]`. - fn seal_return(r: u32, ) -> Weight { + /// The range of component `n` is `[0, 1048572]`. + fn seal_return(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 8_906_000 picoseconds. - Weight::from_parts(9_264_446, 0) - // Standard Error: 19_760 - .saturating_add(Weight::from_parts(1_256_053, 0).saturating_mul(r.into())) - } - /// The range of component `n` is `[0, 1048576]`. - fn seal_return_per_byte(n: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 10_266_000 picoseconds. - Weight::from_parts(10_602_261, 0) + // Minimum execution time: 2_000_000 picoseconds. + Weight::from_parts(2_400_000, 0) // Standard Error: 0 - .saturating_add(Weight::from_parts(318, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(158, 0).saturating_mul(n.into())) } - /// Storage: `Contracts::MigrationInProgress` (r:1 w:0) - /// Proof: `Contracts::MigrationInProgress` (`max_values`: Some(1), `max_size`: Some(1026), added: 1521, mode: `Measured`) - /// Storage: `System::Account` (r:3 w:3) - /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`) - /// Storage: `Parameters::Parameters` (r:1 w:0) - /// Proof: `Parameters::Parameters` (`max_values`: None, `max_size`: Some(36), added: 2511, mode: `Measured`) - /// Storage: `Contracts::ContractInfoOf` (r:1 w:1) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) - /// Storage: `Contracts::CodeInfoOf` (r:33 w:33) - /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) - /// Storage: `Contracts::PristineCode` (r:1 w:0) - /// Proof: `Contracts::PristineCode` (`max_values`: None, `max_size`: Some(125988), added: 128463, 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: `Contracts::DeletionQueueCounter` (r:1 w:1) /// Proof: `Contracts::DeletionQueueCounter` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`) - /// Storage: `System::EventTopics` (r:4 w:4) + /// Storage: `Contracts::CodeInfoOf` (r:33 w:33) + /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) + /// Storage: `System::EventTopics` (r:2 w:2) /// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`) - /// Storage: `Balances::Holds` (r:1 w:1) - /// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(193), added: 2668, mode: `Measured`) + /// Storage: `Contracts::ContractInfoOf` (r:0 w:1) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::DeletionQueue` (r:0 w:1) /// Proof: `Contracts::DeletionQueue` (`max_values`: None, `max_size`: Some(142), added: 2617, mode: `Measured`) - /// The range of component `r` is `[0, 1]`. - fn seal_terminate(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `4805 + r * (2121 ±0)` - // Estimated: `13220 + r * (81321 ±0)` - // Minimum execution time: 295_922_000 picoseconds. - Weight::from_parts(322_472_877, 13220) - // Standard Error: 993_812 - .saturating_add(Weight::from_parts(259_075_422, 0).saturating_mul(r.into())) - .saturating_add(RocksDbWeight::get().reads(11_u64)) - .saturating_add(RocksDbWeight::get().reads((36_u64).saturating_mul(r.into()))) - .saturating_add(RocksDbWeight::get().writes(3_u64)) - .saturating_add(RocksDbWeight::get().writes((41_u64).saturating_mul(r.into()))) - .saturating_add(Weight::from_parts(0, 81321).saturating_mul(r.into())) + fn seal_terminate() -> Weight { + // Proof Size summary in bytes: + // Measured: `2821` + // Estimated: `85486` + // Minimum execution time: 1_390_000_000 picoseconds. + Weight::from_parts(1_470_000_000, 85486) + .saturating_add(RocksDbWeight::get().reads(36_u64)) + .saturating_add(RocksDbWeight::get().writes(38_u64)) } /// Storage: `RandomnessCollectiveFlip::RandomMaterial` (r:1 w:0) /// Proof: `RandomnessCollectiveFlip::RandomMaterial` (`max_values`: Some(1), `max_size`: Some(2594), added: 3089, mode: `Measured`) - /// The range of component `r` is `[0, 1600]`. - fn seal_random(r: u32, ) -> Weight { + fn seal_random() -> Weight { // Proof Size summary in bytes: // Measured: `76` // Estimated: `1561` - // Minimum execution time: 9_427_000 picoseconds. - Weight::from_parts(12_996_213, 1561) - // Standard Error: 845 - .saturating_add(Weight::from_parts(1_182_642, 0).saturating_mul(r.into())) + // Minimum execution time: 33_000_000 picoseconds. + Weight::from_parts(36_000_000, 1561) .saturating_add(RocksDbWeight::get().reads(1_u64)) } - /// The range of component `r` is `[0, 1600]`. - fn seal_deposit_event(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 9_304_000 picoseconds. - Weight::from_parts(25_678_842, 0) - // Standard Error: 1_855 - .saturating_add(Weight::from_parts(1_814_511, 0).saturating_mul(r.into())) - } /// Storage: `System::EventTopics` (r:4 w:4) /// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`) /// The range of component `t` is `[0, 4]`. /// The range of component `n` is `[0, 16384]`. - fn seal_deposit_event_per_topic_and_byte(t: u32, n: u32, ) -> Weight { + fn seal_deposit_event(t: u32, n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` - // Estimated: `990 + t * (2475 ±0)` - // Minimum execution time: 23_425_000 picoseconds. - Weight::from_parts(15_229_010, 990) - // Standard Error: 14_380 - .saturating_add(Weight::from_parts(2_545_653, 0).saturating_mul(t.into())) - // Standard Error: 4 - .saturating_add(Weight::from_parts(594, 0).saturating_mul(n.into())) + // Estimated: `641 + t * (2562 ±0)` + // Minimum execution time: 27_000_000 picoseconds. + Weight::from_parts(28_999_999, 641) + // Standard Error: 651_505 + .saturating_add(Weight::from_parts(31_650_000, 0).saturating_mul(t.into())) + // Standard Error: 159 + .saturating_add(Weight::from_parts(134, 0).saturating_mul(n.into())) .saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(t.into()))) .saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(t.into()))) - .saturating_add(Weight::from_parts(0, 2475).saturating_mul(t.into())) - } - /// The range of component `r` is `[0, 1600]`. - fn seal_debug_message(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 11_117_000 picoseconds. - Weight::from_parts(12_887_533, 0) - // Standard Error: 83 - .saturating_add(Weight::from_parts(99_373, 0).saturating_mul(r.into())) + .saturating_add(Weight::from_parts(0, 2562).saturating_mul(t.into())) } /// The range of component `i` is `[0, 1048576]`. - fn seal_debug_message_per_byte(i: u32, ) -> Weight { + fn seal_debug_message(i: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 10_982_000 picoseconds. - Weight::from_parts(11_176_000, 0) - // Standard Error: 8 - .saturating_add(Weight::from_parts(983, 0).saturating_mul(i.into())) - } - /// Storage: `Skipped::Metadata` (r:0 w:0) - /// Proof: `Skipped::Metadata` (`max_values`: None, `max_size`: None, mode: `Measured`) - /// The range of component `r` is `[0, 800]`. - fn seal_set_storage(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `108 + r * (150 ±0)` - // Estimated: `105 + r * (151 ±0)` - // Minimum execution time: 9_150_000 picoseconds. - Weight::from_parts(9_269_000, 105) - // Standard Error: 8_147 - .saturating_add(Weight::from_parts(5_339_554, 0).saturating_mul(r.into())) - .saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(r.into()))) - .saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(r.into()))) - .saturating_add(Weight::from_parts(0, 151).saturating_mul(r.into())) + // Minimum execution time: 2_000_000 picoseconds. + Weight::from_parts(3_100_000, 0) + // Standard Error: 1 + .saturating_add(Weight::from_parts(445, 0).saturating_mul(i.into())) } /// Storage: `Skipped::Metadata` (r:0 w:0) /// Proof: `Skipped::Metadata` (`max_values`: None, `max_size`: None, mode: `Measured`) @@ -2167,10 +1656,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `245` // Estimated: `245` - // Minimum execution time: 19_085_000 picoseconds. - Weight::from_parts(20_007_323, 245) - // Standard Error: 3 - .saturating_add(Weight::from_parts(291, 0).saturating_mul(n.into())) + // Minimum execution time: 55_000_000 picoseconds. + Weight::from_parts(61_800_000, 245) + // Standard Error: 132 + .saturating_add(Weight::from_parts(476, 0).saturating_mul(n.into())) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -2179,196 +1668,83 @@ impl WeightInfo for () { /// The range of component `n` is `[0, 16384]`. fn seal_set_storage_per_old_byte(n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `248 + n * (1 ±0)` - // Estimated: `248 + n * (1 ±0)` - // Minimum execution time: 19_127_000 picoseconds. - Weight::from_parts(21_152_987, 248) - // Standard Error: 3 - .saturating_add(Weight::from_parts(42, 0).saturating_mul(n.into())) + // Measured: `245 + n * (1 ±0)` + // Estimated: `245 + n * (1 ±0)` + // Minimum execution time: 56_000_000 picoseconds. + Weight::from_parts(63_900_000, 245) + // Standard Error: 93 + .saturating_add(Weight::from_parts(48, 0).saturating_mul(n.into())) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) } /// Storage: `Skipped::Metadata` (r:0 w:0) /// Proof: `Skipped::Metadata` (`max_values`: None, `max_size`: None, mode: `Measured`) - /// The range of component `r` is `[0, 800]`. - fn seal_clear_storage(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `108 + r * (150 ±0)` - // Estimated: `105 + r * (151 ±0)` - // Minimum execution time: 9_264_000 picoseconds. - Weight::from_parts(9_449_000, 105) - // Standard Error: 8_196 - .saturating_add(Weight::from_parts(5_325_578, 0).saturating_mul(r.into())) - .saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(r.into()))) - .saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(r.into()))) - .saturating_add(Weight::from_parts(0, 151).saturating_mul(r.into())) - } - /// Storage: `Skipped::Metadata` (r:0 w:0) - /// Proof: `Skipped::Metadata` (`max_values`: None, `max_size`: None, mode: `Measured`) /// The range of component `n` is `[0, 16384]`. - fn seal_clear_storage_per_byte(n: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `248 + n * (1 ±0)` - // Estimated: `248 + n * (1 ±0)` - // Minimum execution time: 18_489_000 picoseconds. - Weight::from_parts(19_916_153, 248) - // Standard Error: 2 - .saturating_add(Weight::from_parts(97, 0).saturating_mul(n.into())) + fn seal_clear_storage(n: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `245 + n * (1 ±0)` + // Estimated: `245 + n * (1 ±0)` + // Minimum execution time: 55_000_000 picoseconds. + Weight::from_parts(61_100_000, 245) + // Standard Error: 113 + .saturating_add(Weight::from_parts(708, 0).saturating_mul(n.into())) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) } /// Storage: `Skipped::Metadata` (r:0 w:0) /// Proof: `Skipped::Metadata` (`max_values`: None, `max_size`: None, mode: `Measured`) - /// The range of component `r` is `[0, 800]`. - fn seal_get_storage(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `108 + r * (150 ±0)` - // Estimated: `105 + r * (151 ±0)` - // Minimum execution time: 9_299_000 picoseconds. - Weight::from_parts(9_464_000, 105) - // Standard Error: 6_827 - .saturating_add(Weight::from_parts(4_720_699, 0).saturating_mul(r.into())) - .saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(r.into()))) - .saturating_add(Weight::from_parts(0, 151).saturating_mul(r.into())) - } - /// Storage: `Skipped::Metadata` (r:0 w:0) - /// Proof: `Skipped::Metadata` (`max_values`: None, `max_size`: None, mode: `Measured`) /// The range of component `n` is `[0, 16384]`. - fn seal_get_storage_per_byte(n: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `248 + n * (1 ±0)` - // Estimated: `248 + n * (1 ±0)` - // Minimum execution time: 17_981_000 picoseconds. - Weight::from_parts(19_802_353, 248) - // Standard Error: 3 - .saturating_add(Weight::from_parts(617, 0).saturating_mul(n.into())) + fn seal_get_storage(n: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `245 + n * (1 ±0)` + // Estimated: `245 + n * (1 ±0)` + // Minimum execution time: 53_000_000 picoseconds. + Weight::from_parts(61_800_000, 245) + // Standard Error: 160 + .saturating_add(Weight::from_parts(1_196, 0).saturating_mul(n.into())) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) } /// Storage: `Skipped::Metadata` (r:0 w:0) /// Proof: `Skipped::Metadata` (`max_values`: None, `max_size`: None, mode: `Measured`) - /// The range of component `r` is `[0, 800]`. - fn seal_contains_storage(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `108 + r * (150 ±0)` - // Estimated: `105 + r * (151 ±0)` - // Minimum execution time: 9_891_000 picoseconds. - Weight::from_parts(10_046_000, 105) - // Standard Error: 6_993 - .saturating_add(Weight::from_parts(4_601_167, 0).saturating_mul(r.into())) - .saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(r.into()))) - .saturating_add(Weight::from_parts(0, 151).saturating_mul(r.into())) - } - /// Storage: `Skipped::Metadata` (r:0 w:0) - /// Proof: `Skipped::Metadata` (`max_values`: None, `max_size`: None, mode: `Measured`) /// The range of component `n` is `[0, 16384]`. - fn seal_contains_storage_per_byte(n: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `248 + n * (1 ±0)` - // Estimated: `248 + n * (1 ±0)` - // Minimum execution time: 17_229_000 picoseconds. - Weight::from_parts(18_302_733, 248) - // Standard Error: 2 - .saturating_add(Weight::from_parts(112, 0).saturating_mul(n.into())) + fn seal_contains_storage(n: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `245 + n * (1 ±0)` + // Estimated: `245 + n * (1 ±0)` + // Minimum execution time: 51_000_000 picoseconds. + Weight::from_parts(58_500_000, 245) + // Standard Error: 80 + .saturating_add(Weight::from_parts(299, 0).saturating_mul(n.into())) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) } /// Storage: `Skipped::Metadata` (r:0 w:0) /// Proof: `Skipped::Metadata` (`max_values`: None, `max_size`: None, mode: `Measured`) - /// The range of component `r` is `[0, 800]`. - fn seal_take_storage(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `108 + r * (150 ±0)` - // Estimated: `105 + r * (151 ±0)` - // Minimum execution time: 9_323_000 picoseconds. - Weight::from_parts(9_462_000, 105) - // Standard Error: 8_031 - .saturating_add(Weight::from_parts(5_433_981, 0).saturating_mul(r.into())) - .saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(r.into()))) - .saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(r.into()))) - .saturating_add(Weight::from_parts(0, 151).saturating_mul(r.into())) - } - /// Storage: `Skipped::Metadata` (r:0 w:0) - /// Proof: `Skipped::Metadata` (`max_values`: None, `max_size`: None, mode: `Measured`) /// The range of component `n` is `[0, 16384]`. - fn seal_take_storage_per_byte(n: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `248 + n * (1 ±0)` - // Estimated: `248 + n * (1 ±0)` - // Minimum execution time: 18_711_000 picoseconds. - Weight::from_parts(20_495_670, 248) - // Standard Error: 3 - .saturating_add(Weight::from_parts(640, 0).saturating_mul(n.into())) + fn seal_take_storage(n: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `245 + n * (1 ±0)` + // Estimated: `245 + n * (1 ±0)` + // Minimum execution time: 57_000_000 picoseconds. + Weight::from_parts(66_300_000, 245) + // Standard Error: 188 + .saturating_add(Weight::from_parts(1_110, 0).saturating_mul(n.into())) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) } - /// Storage: `System::Account` (r:1601 w:1601) + /// Storage: `System::Account` (r:1 w:0) /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`) - /// The range of component `r` is `[0, 1600]`. - fn seal_transfer(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `770` - // Estimated: `4221 + r * (2475 ±0)` - // Minimum execution time: 9_226_000 picoseconds. - Weight::from_parts(9_394_000, 4221) - // Standard Error: 14_741 - .saturating_add(Weight::from_parts(34_179_316, 0).saturating_mul(r.into())) + fn seal_transfer() -> Weight { + // Proof Size summary in bytes: + // Measured: `140` + // Estimated: `3605` + // Minimum execution time: 99_000_000 picoseconds. + Weight::from_parts(102_000_000, 3605) .saturating_add(RocksDbWeight::get().reads(1_u64)) - .saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(r.into()))) - .saturating_add(RocksDbWeight::get().writes(1_u64)) - .saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(r.into()))) - .saturating_add(Weight::from_parts(0, 2475).saturating_mul(r.into())) - } - /// Storage: `Contracts::ContractInfoOf` (r:800 w:801) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) - /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) - /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) - /// Storage: `Contracts::PristineCode` (r:1 w:0) - /// Proof: `Contracts::PristineCode` (`max_values`: None, `max_size`: Some(125988), added: 128463, mode: `Measured`) - /// Storage: `System::EventTopics` (r:801 w:801) - /// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`) - /// Storage: `Parameters::Parameters` (r:2 w:0) - /// Proof: `Parameters::Parameters` (`max_values`: None, `max_size`: Some(36), added: 2511, mode: `Measured`) - /// The range of component `r` is `[0, 800]`. - fn seal_call(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `520 + r * (170 ±0)` - // Estimated: `6463 + r * (2646 ±0)` - // Minimum execution time: 9_455_000 picoseconds. - Weight::from_parts(9_671_000, 6463) - // Standard Error: 126_080 - .saturating_add(Weight::from_parts(244_204_040, 0).saturating_mul(r.into())) - .saturating_add(RocksDbWeight::get().reads(5_u64)) - .saturating_add(RocksDbWeight::get().reads((2_u64).saturating_mul(r.into()))) - .saturating_add(RocksDbWeight::get().writes(2_u64)) - .saturating_add(RocksDbWeight::get().writes((2_u64).saturating_mul(r.into()))) - .saturating_add(Weight::from_parts(0, 2646).saturating_mul(r.into())) - } - /// Storage: `Contracts::CodeInfoOf` (r:735 w:0) - /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) - /// Storage: `Contracts::PristineCode` (r:735 w:0) - /// Proof: `Contracts::PristineCode` (`max_values`: None, `max_size`: Some(125988), added: 128463, mode: `Measured`) - /// Storage: `System::EventTopics` (r:736 w:736) - /// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`) - /// Storage: `Parameters::Parameters` (r:2 w:0) - /// Proof: `Parameters::Parameters` (`max_values`: None, `max_size`: Some(36), added: 2511, mode: `Measured`) - /// Storage: `Contracts::ContractInfoOf` (r:0 w:1) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) - /// The range of component `r` is `[0, 800]`. - fn seal_delegate_call(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0 + r * (527 ±0)` - // Estimated: `6447 + r * (2583 ±10)` - // Minimum execution time: 9_274_000 picoseconds. - Weight::from_parts(9_437_000, 6447) - // Standard Error: 150_832 - .saturating_add(Weight::from_parts(244_196_269, 0).saturating_mul(r.into())) - .saturating_add(RocksDbWeight::get().reads((3_u64).saturating_mul(r.into()))) - .saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(r.into()))) - .saturating_add(Weight::from_parts(0, 2583).saturating_mul(r.into())) } /// Storage: `Contracts::ContractInfoOf` (r:1 w:2) /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) @@ -2378,56 +1754,47 @@ impl WeightInfo for () { /// Proof: `Contracts::PristineCode` (`max_values`: None, `max_size`: Some(125988), added: 128463, mode: `Measured`) /// 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:2 w:2) - /// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `Parameters::Parameters` (r:2 w:0) /// Proof: `Parameters::Parameters` (`max_values`: None, `max_size`: Some(36), added: 2511, mode: `Measured`) + /// Storage: `System::EventTopics` (r:2 w:2) + /// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// The range of component `c` is `[0, 1]`. /// The range of component `t` is `[0, 1]`. - /// The range of component `c` is `[0, 1048576]`. - fn seal_call_per_transfer_clone_byte(t: u32, c: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `699 + t * (277 ±0)` - // Estimated: `6639 + t * (3458 ±0)` - // Minimum execution time: 214_483_000 picoseconds. - Weight::from_parts(122_634_366, 6639) - // Standard Error: 2_499_235 - .saturating_add(Weight::from_parts(41_326_008, 0).saturating_mul(t.into())) - // Standard Error: 3 - .saturating_add(Weight::from_parts(422, 0).saturating_mul(c.into())) + /// The range of component `i` is `[0, 1048576]`. + fn seal_call(c: u32, t: u32, _i: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `623 + t * (280 ±0)` + // Estimated: `6563 + t * (3421 ±0)` + // Minimum execution time: 1_604_000_000 picoseconds. + Weight::from_parts(1_723_533_333, 6563) + // Standard Error: 18_493_246 + .saturating_add(Weight::from_parts(15_933_333, 0).saturating_mul(c.into())) + // Standard Error: 18_493_246 + .saturating_add(Weight::from_parts(414_233_333, 0).saturating_mul(t.into())) .saturating_add(RocksDbWeight::get().reads(7_u64)) .saturating_add(RocksDbWeight::get().reads((2_u64).saturating_mul(t.into()))) .saturating_add(RocksDbWeight::get().writes(4_u64)) .saturating_add(RocksDbWeight::get().writes((2_u64).saturating_mul(t.into()))) - .saturating_add(Weight::from_parts(0, 3458).saturating_mul(t.into())) + .saturating_add(Weight::from_parts(0, 3421).saturating_mul(t.into())) } - /// Storage: `Contracts::CodeInfoOf` (r:800 w:800) + /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) - /// Storage: `Contracts::PristineCode` (r:800 w:0) + /// Storage: `Contracts::PristineCode` (r:1 w:0) /// Proof: `Contracts::PristineCode` (`max_values`: None, `max_size`: Some(125988), added: 128463, mode: `Measured`) - /// Storage: `Contracts::Nonce` (r:1 w:0) - /// Proof: `Contracts::Nonce` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`) - /// Storage: `Contracts::ContractInfoOf` (r:800 w:801) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) - /// Storage: `System::Account` (r:802 w:802) - /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`) + /// Storage: `System::EventTopics` (r:2 w:2) + /// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `Parameters::Parameters` (r:2 w:0) /// Proof: `Parameters::Parameters` (`max_values`: None, `max_size`: Some(36), added: 2511, mode: `Measured`) - /// Storage: `System::EventTopics` (r:801 w:801) - /// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`) - /// The range of component `r` is `[1, 800]`. - fn seal_instantiate(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `1097 + r * (188 ±0)` - // Estimated: `6990 + r * (2664 ±0)` - // Minimum execution time: 341_569_000 picoseconds. - Weight::from_parts(360_574_000, 6990) - // Standard Error: 259_746 - .saturating_add(Weight::from_parts(337_944_674, 0).saturating_mul(r.into())) + /// Storage: `Contracts::ContractInfoOf` (r:0 w:1) + /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) + fn seal_delegate_call() -> Weight { + // Proof Size summary in bytes: + // Measured: `433` + // Estimated: `6373` + // Minimum execution time: 1_524_000_000 picoseconds. + Weight::from_parts(1_558_000_000, 6373) .saturating_add(RocksDbWeight::get().reads(6_u64)) - .saturating_add(RocksDbWeight::get().reads((5_u64).saturating_mul(r.into()))) - .saturating_add(RocksDbWeight::get().writes(4_u64)) - .saturating_add(RocksDbWeight::get().writes((4_u64).saturating_mul(r.into()))) - .saturating_add(Weight::from_parts(0, 2664).saturating_mul(r.into())) + .saturating_add(RocksDbWeight::get().writes(3_u64)) } /// Storage: `Contracts::CodeInfoOf` (r:1 w:1) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) @@ -2446,245 +1813,149 @@ impl WeightInfo for () { /// The range of component `t` is `[0, 1]`. /// The range of component `i` is `[0, 983040]`. /// The range of component `s` is `[0, 983040]`. - fn seal_instantiate_per_transfer_input_salt_byte(t: u32, i: u32, s: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `760 + t * (104 ±0)` - // Estimated: `6719 + t * (2549 ±1)` - // Minimum execution time: 1_863_119_000 picoseconds. - Weight::from_parts(900_189_174, 6719) - // Standard Error: 13_040_979 - .saturating_add(Weight::from_parts(4_056_063, 0).saturating_mul(t.into())) - // Standard Error: 20 - .saturating_add(Weight::from_parts(1_028, 0).saturating_mul(i.into())) - // Standard Error: 20 - .saturating_add(Weight::from_parts(1_173, 0).saturating_mul(s.into())) + fn seal_instantiate(t: u32, i: u32, s: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `627 + t * (102 ±0)` + // Estimated: `6567 + t * (2577 ±0)` + // Minimum execution time: 3_863_000_000 picoseconds. + Weight::from_parts(2_236_566_666, 6567) + // Standard Error: 41_979_515 + .saturating_add(Weight::from_parts(469_166_666, 0).saturating_mul(t.into())) + // Standard Error: 42 + .saturating_add(Weight::from_parts(1_417, 0).saturating_mul(i.into())) + // Standard Error: 42 + .saturating_add(Weight::from_parts(1_492, 0).saturating_mul(s.into())) .saturating_add(RocksDbWeight::get().reads(10_u64)) .saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(t.into()))) .saturating_add(RocksDbWeight::get().writes(7_u64)) .saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(t.into()))) - .saturating_add(Weight::from_parts(0, 2549).saturating_mul(t.into())) - } - /// The range of component `r` is `[0, 1600]`. - fn seal_hash_sha2_256(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 9_211_000 picoseconds. - Weight::from_parts(11_696_412, 0) - // Standard Error: 388 - .saturating_add(Weight::from_parts(265_538, 0).saturating_mul(r.into())) + .saturating_add(Weight::from_parts(0, 2577).saturating_mul(t.into())) } /// The range of component `n` is `[0, 1048576]`. - fn seal_hash_sha2_256_per_byte(n: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 10_296_000 picoseconds. - Weight::from_parts(572_494, 0) - // Standard Error: 1 - .saturating_add(Weight::from_parts(1_067, 0).saturating_mul(n.into())) - } - /// The range of component `r` is `[0, 1600]`. - fn seal_hash_keccak_256(r: u32, ) -> Weight { + fn seal_hash_sha2_256(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 9_177_000 picoseconds. - Weight::from_parts(8_620_481, 0) - // Standard Error: 249 - .saturating_add(Weight::from_parts(674_502, 0).saturating_mul(r.into())) + // Minimum execution time: 8_000_000 picoseconds. + Weight::from_parts(13_000_000, 0) + // Standard Error: 13 + .saturating_add(Weight::from_parts(3_238, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 1048576]`. - fn seal_hash_keccak_256_per_byte(n: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 11_240_000 picoseconds. - Weight::from_parts(8_696_186, 0) - // Standard Error: 0 - .saturating_add(Weight::from_parts(3_328, 0).saturating_mul(n.into())) - } - /// The range of component `r` is `[0, 1600]`. - fn seal_hash_blake2_256(r: u32, ) -> Weight { + fn seal_hash_keccak_256(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 9_889_000 picoseconds. - Weight::from_parts(16_103_170, 0) - // Standard Error: 343 - .saturating_add(Weight::from_parts(328_939, 0).saturating_mul(r.into())) + // Minimum execution time: 9_000_000 picoseconds. + Weight::from_parts(12_900_000, 0) + // Standard Error: 16 + .saturating_add(Weight::from_parts(4_844, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 1048576]`. - fn seal_hash_blake2_256_per_byte(n: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 10_405_000 picoseconds. - Weight::from_parts(2_264_024, 0) - // Standard Error: 0 - .saturating_add(Weight::from_parts(1_196, 0).saturating_mul(n.into())) - } - /// The range of component `r` is `[0, 1600]`. - fn seal_hash_blake2_128(r: u32, ) -> Weight { + fn seal_hash_blake2_256(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 9_215_000 picoseconds. - Weight::from_parts(10_505_632, 0) - // Standard Error: 240 - .saturating_add(Weight::from_parts(324_854, 0).saturating_mul(r.into())) + // Minimum execution time: 5_000_000 picoseconds. + Weight::from_parts(6_000_000, 0) + // Standard Error: 5 + .saturating_add(Weight::from_parts(1_190, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 1048576]`. - fn seal_hash_blake2_128_per_byte(n: u32, ) -> Weight { + fn seal_hash_blake2_128(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 10_440_000 picoseconds. - Weight::from_parts(2_575_889, 0) - // Standard Error: 1 - .saturating_add(Weight::from_parts(1_199, 0).saturating_mul(n.into())) + // Minimum execution time: 5_000_000 picoseconds. + Weight::from_parts(5_600_000, 0) + // Standard Error: 4 + .saturating_add(Weight::from_parts(1_165, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 125697]`. - fn seal_sr25519_verify_per_byte(n: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 55_119_000 picoseconds. - Weight::from_parts(56_732_248, 0) - // Standard Error: 8 - .saturating_add(Weight::from_parts(4_639, 0).saturating_mul(n.into())) - } - /// The range of component `r` is `[0, 160]`. - fn seal_sr25519_verify(r: u32, ) -> Weight { + fn seal_sr25519_verify(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 9_176_000 picoseconds. - Weight::from_parts(9_861_102, 0) - // Standard Error: 6_029 - .saturating_add(Weight::from_parts(45_948_571, 0).saturating_mul(r.into())) + // Minimum execution time: 58_000_000 picoseconds. + Weight::from_parts(63_500_000, 0) + // Standard Error: 39 + .saturating_add(Weight::from_parts(7_818, 0).saturating_mul(n.into())) } - /// The range of component `r` is `[0, 160]`. - fn seal_ecdsa_recover(r: u32, ) -> Weight { + fn seal_ecdsa_recover() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 9_293_000 picoseconds. - Weight::from_parts(28_785_765, 0) - // Standard Error: 9_160 - .saturating_add(Weight::from_parts(45_566_150, 0).saturating_mul(r.into())) + // Minimum execution time: 312_000_000 picoseconds. + Weight::from_parts(329_000_000, 0) } - /// The range of component `r` is `[0, 160]`. - fn seal_ecdsa_to_eth_address(r: u32, ) -> Weight { + fn seal_ecdsa_to_eth_address() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 9_206_000 picoseconds. - Weight::from_parts(12_420_664, 0) - // Standard Error: 3_489 - .saturating_add(Weight::from_parts(11_628_989, 0).saturating_mul(r.into())) + // Minimum execution time: 16_000_000 picoseconds. + Weight::from_parts(19_000_000, 0) } - /// Storage: `Contracts::CodeInfoOf` (r:1536 w:1536) + /// Storage: `Contracts::CodeInfoOf` (r:1 w:1) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) - /// Storage: `Contracts::PristineCode` (r:1535 w:0) + /// Storage: `Contracts::PristineCode` (r:1 w:0) /// Proof: `Contracts::PristineCode` (`max_values`: None, `max_size`: Some(125988), added: 128463, mode: `Measured`) /// Storage: `Parameters::Parameters` (r:2 w:0) /// Proof: `Parameters::Parameters` (`max_values`: None, `max_size`: Some(36), added: 2511, mode: `Measured`) - /// Storage: `System::EventTopics` (r:1537 w:1537) + /// Storage: `System::EventTopics` (r:2 w:2) /// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`) - /// The range of component `r` is `[0, 1600]`. - fn seal_set_code_hash(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0 + r * (926 ±0)` - // Estimated: `8969 + r * (3047 ±7)` - // Minimum execution time: 9_219_000 picoseconds. - Weight::from_parts(9_385_000, 8969) - // Standard Error: 45_562 - .saturating_add(Weight::from_parts(26_360_661, 0).saturating_mul(r.into())) - .saturating_add(RocksDbWeight::get().reads((3_u64).saturating_mul(r.into()))) - .saturating_add(RocksDbWeight::get().writes((2_u64).saturating_mul(r.into()))) - .saturating_add(Weight::from_parts(0, 3047).saturating_mul(r.into())) - } - /// Storage: `Contracts::CodeInfoOf` (r:32 w:32) + fn seal_set_code_hash() -> Weight { + // Proof Size summary in bytes: + // Measured: `433` + // Estimated: `6373` + // Minimum execution time: 309_000_000 picoseconds. + Weight::from_parts(332_000_000, 6373) + .saturating_add(RocksDbWeight::get().reads(6_u64)) + .saturating_add(RocksDbWeight::get().writes(3_u64)) + } + /// Storage: `Contracts::CodeInfoOf` (r:1 w:1) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) - /// The range of component `r` is `[0, 32]`. - fn lock_delegate_dependency(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `274 + r * (78 ±0)` - // Estimated: `1265 + r * (2553 ±0)` - // Minimum execution time: 9_355_000 picoseconds. - Weight::from_parts(15_071_309, 1265) - // Standard Error: 9_722 - .saturating_add(Weight::from_parts(5_328_717, 0).saturating_mul(r.into())) - .saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(r.into()))) - .saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(r.into()))) - .saturating_add(Weight::from_parts(0, 2553).saturating_mul(r.into())) - } - /// Storage: `Contracts::CodeInfoOf` (r:32 w:32) + fn lock_delegate_dependency() -> Weight { + // Proof Size summary in bytes: + // Measured: `355` + // Estimated: `3820` + // Minimum execution time: 80_000_000 picoseconds. + Weight::from_parts(86_000_000, 3820) + .saturating_add(RocksDbWeight::get().reads(1_u64)) + .saturating_add(RocksDbWeight::get().writes(1_u64)) + } + /// Storage: `Contracts::CodeInfoOf` (r:1 w:1) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `MaxEncodedLen`) - /// The range of component `r` is `[0, 32]`. - fn unlock_delegate_dependency(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `275 + r * (78 ±0)` - // Estimated: `990 + r * (2568 ±0)` - // Minimum execution time: 8_979_000 picoseconds. - Weight::from_parts(14_362_224, 990) - // Standard Error: 9_137 - .saturating_add(Weight::from_parts(4_488_748, 0).saturating_mul(r.into())) - .saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(r.into()))) - .saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(r.into()))) - .saturating_add(Weight::from_parts(0, 2568).saturating_mul(r.into())) + fn unlock_delegate_dependency() -> Weight { + // Proof Size summary in bytes: + // Measured: `355` + // Estimated: `3558` + // Minimum execution time: 66_000_000 picoseconds. + Weight::from_parts(69_000_000, 3558) + .saturating_add(RocksDbWeight::get().reads(1_u64)) + .saturating_add(RocksDbWeight::get().writes(1_u64)) } - /// Storage: `Contracts::MigrationInProgress` (r:1 w:0) - /// Proof: `Contracts::MigrationInProgress` (`max_values`: Some(1), `max_size`: Some(1026), added: 1521, mode: `Measured`) - /// Storage: `System::Account` (r:1 w:0) - /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`) - /// Storage: `Parameters::Parameters` (r:3 w:0) - /// Proof: `Parameters::Parameters` (`max_values`: None, `max_size`: Some(36), added: 2511, mode: `Measured`) - /// Storage: `Contracts::ContractInfoOf` (r:1 w:1) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) - /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) - /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) - /// Storage: `Contracts::PristineCode` (r:1 w:0) - /// Proof: `Contracts::PristineCode` (`max_values`: None, `max_size`: Some(125988), added: 128463, 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::EventTopics` (r:2 w:2) - /// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`) - /// The range of component `r` is `[0, 1600]`. - fn seal_reentrance_count(r: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `861 + r * (3 ±0)` - // Estimated: `9282 + r * (3 ±0)` - // Minimum execution time: 269_704_000 picoseconds. - Weight::from_parts(289_916_035, 9282) - // Standard Error: 408 - .saturating_add(Weight::from_parts(166_040, 0).saturating_mul(r.into())) - .saturating_add(RocksDbWeight::get().reads(11_u64)) - .saturating_add(RocksDbWeight::get().writes(3_u64)) - .saturating_add(Weight::from_parts(0, 3).saturating_mul(r.into())) + fn seal_reentrance_count() -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 2_000_000 picoseconds. + Weight::from_parts(3_000_000, 0) } - /// The range of component `r` is `[0, 1600]`. - fn seal_account_reentrance_count(r: u32, ) -> Weight { + fn seal_account_reentrance_count() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 9_361_000 picoseconds. - Weight::from_parts(11_633_836, 0) - // Standard Error: 86 - .saturating_add(Weight::from_parts(83_083, 0).saturating_mul(r.into())) + // Minimum execution time: 2_000_000 picoseconds. + Weight::from_parts(3_000_000, 0) } /// Storage: `Contracts::Nonce` (r:1 w:0) /// Proof: `Contracts::Nonce` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`) - /// The range of component `r` is `[0, 1600]`. - fn seal_instantiation_nonce(r: u32, ) -> Weight { + fn seal_instantiation_nonce() -> Weight { // Proof Size summary in bytes: // Measured: `219` // Estimated: `1704` - // Minimum execution time: 9_133_000 picoseconds. - Weight::from_parts(13_259_836, 1704) - // Standard Error: 121 - .saturating_add(Weight::from_parts(76_878, 0).saturating_mul(r.into())) + // Minimum execution time: 26_000_000 picoseconds. + Weight::from_parts(28_000_000, 1704) .saturating_add(RocksDbWeight::get().reads(1_u64)) } /// The range of component `r` is `[0, 5000]`. @@ -2692,9 +1963,9 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 851_000 picoseconds. - Weight::from_parts(587_883, 0) - // Standard Error: 16 - .saturating_add(Weight::from_parts(14_912, 0).saturating_mul(r.into())) + // Minimum execution time: 5_000_000 picoseconds. + Weight::from_parts(6_000_000, 0) + // Standard Error: 557 + .saturating_add(Weight::from_parts(75_560, 0).saturating_mul(r.into())) } } From c727dd2d2c2efebdb5877b585b785151dafef89b Mon Sep 17 00:00:00 2001 From: pgherveou Date: Fri, 26 Apr 2024 17:04:07 +0200 Subject: [PATCH 07/34] Fixes --- .../frame/contracts/proc-macro/src/lib.rs | 2 +- .../src/benchmarking/call_builder.rs | 20 ------------------- .../frame/contracts/src/benchmarking/mod.rs | 5 ++++- substrate/frame/contracts/src/wasm/runtime.rs | 15 +++++++------- 4 files changed, 12 insertions(+), 30 deletions(-) diff --git a/substrate/frame/contracts/proc-macro/src/lib.rs b/substrate/frame/contracts/proc-macro/src/lib.rs index 2bb1bbcc4caf..307170393f8c 100644 --- a/substrate/frame/contracts/proc-macro/src/lib.rs +++ b/substrate/frame/contracts/proc-macro/src/lib.rs @@ -170,7 +170,7 @@ impl HostFn { // process attributes let msg = - "Only #[version()], #[unstable], #[prefixed_alias] and #[deprecated] attributes are allowed."; + "Only #[version()], #[unstable], #[prefixed_alias], #[cfg] and #[deprecated] attributes are allowed."; let span = item.span(); let mut attrs = item.attrs.clone(); attrs.retain(|a| !a.path().is_ident("doc")); diff --git a/substrate/frame/contracts/src/benchmarking/call_builder.rs b/substrate/frame/contracts/src/benchmarking/call_builder.rs index 9f55e32ec278..0297eb91a77c 100644 --- a/substrate/frame/contracts/src/benchmarking/call_builder.rs +++ b/substrate/frame/contracts/src/benchmarking/call_builder.rs @@ -159,26 +159,6 @@ where } } -#[macro_export] -macro_rules! call_builder( - ($func: ident, $module:expr) => { - $crate::call_builder!($func, _contract, $module); - }; - ($func: ident, $contract: ident, $module:expr) => { - let mut setup = CallSetup::::new($module); - $crate::call_builder!($func, $contract, setup: setup); - }; - ($func:ident, setup: $setup: ident) => { - $crate::call_builder!($func, _contract, setup: $setup); - }; - ($func:ident, $contract: ident, setup: $setup: ident) => { - let data = $setup.data(); - let $contract = $setup.contract(); - let (mut ext, module) = $setup.ext(); - let $func = CallSetup::::prepare_call(&mut ext, module, data); - }; -); - #[macro_export] macro_rules! memory( ($($bytes:expr,)*) => { diff --git a/substrate/frame/contracts/src/benchmarking/mod.rs b/substrate/frame/contracts/src/benchmarking/mod.rs index 4317c1e33de7..96ee33639526 100644 --- a/substrate/frame/contracts/src/benchmarking/mod.rs +++ b/substrate/frame/contracts/src/benchmarking/mod.rs @@ -612,7 +612,10 @@ mod benchmarks { #[benchmark(pov_mode = Measured)] fn call_noop_host_fn(r: Linear<0, API_BENCHMARK_RUNS>) { - call_builder!(func, WasmModule::noop(r)); + let mut setup = CallSetup::::new(WasmModule::noop(r)); + let data = setup.data(); + let (mut ext, module) = setup.ext(); + let func = CallSetup::::prepare_call(&mut ext, module, data); #[block] { func.call(); diff --git a/substrate/frame/contracts/src/wasm/runtime.rs b/substrate/frame/contracts/src/wasm/runtime.rs index 6781836e5d70..afbdd6ea802e 100644 --- a/substrate/frame/contracts/src/wasm/runtime.rs +++ b/substrate/frame/contracts/src/wasm/runtime.rs @@ -247,17 +247,16 @@ pub enum RuntimeCosts { } macro_rules! cost_args { - // Replace the token with 0. - (@replace_token $_in:tt) => { 0 }; - - // Transform T:::WeightInfo::name(a, b, c) into T:::WeightInfo::name(0, 0, 0) + // cost_args!(name, a, b, c) -> T::WeightInfo::name(a, b, c).saturating_sub(T::WeightInfo::name(0, 0, 0)) + ($name:ident, $( $arg: expr ),+) => { + (T::WeightInfo::$name($( $arg ),+).saturating_sub(cost_args!(@call_zero $name, $( $arg ),+))) + }; + // Transform T::WeightInfo::name(a, b, c) into T::WeightInfo::name(0, 0, 0) (@call_zero $name:ident, $( $arg:expr ),*) => { T::WeightInfo::$name($( cost_args!(@replace_token $arg) ),*) }; - - ($name:ident, $( $arg: expr ),+) => { - (T::WeightInfo::$name($( $arg ),+).saturating_sub(cost_args!(@call_zero $name, $( $arg ),+))) - } + // Replace the token with 0. + (@replace_token $_in:tt) => { 0 }; } impl Token for RuntimeCosts { From cf3362f00077867aff34058d691012fa76550566 Mon Sep 17 00:00:00 2001 From: pgherveou Date: Fri, 26 Apr 2024 17:26:22 +0200 Subject: [PATCH 08/34] Update --- substrate/frame/contracts/proc-macro/src/lib.rs | 3 +++ substrate/frame/contracts/src/benchmarking/mod.rs | 2 +- substrate/frame/contracts/src/wasm/runtime.rs | 3 +++ substrate/frame/contracts/src/weights.rs | 6 +++--- 4 files changed, 10 insertions(+), 4 deletions(-) diff --git a/substrate/frame/contracts/proc-macro/src/lib.rs b/substrate/frame/contracts/proc-macro/src/lib.rs index 307170393f8c..7a91de6112cb 100644 --- a/substrate/frame/contracts/proc-macro/src/lib.rs +++ b/substrate/frame/contracts/proc-macro/src/lib.rs @@ -706,6 +706,9 @@ fn expand_functions(def: &EnvDef, expand_mode: ExpandMode) -> TokenStream2 { .map_err(TrapReason::from) .map_err(#into_host)? }; + __caller__.data_mut().charge_gas(RuntimeCosts::HostFn) + .map_err(TrapReason::from) + .map_err(#into_host)?; } } else { quote! { } diff --git a/substrate/frame/contracts/src/benchmarking/mod.rs b/substrate/frame/contracts/src/benchmarking/mod.rs index 96ee33639526..6fd9308bfeaf 100644 --- a/substrate/frame/contracts/src/benchmarking/mod.rs +++ b/substrate/frame/contracts/src/benchmarking/mod.rs @@ -611,7 +611,7 @@ mod benchmarks { } #[benchmark(pov_mode = Measured)] - fn call_noop_host_fn(r: Linear<0, API_BENCHMARK_RUNS>) { + fn noop_host_fn(r: Linear<0, API_BENCHMARK_RUNS>) { let mut setup = CallSetup::::new(WasmModule::noop(r)); let data = setup.data(); let (mut ext, module) = setup.ext(); diff --git a/substrate/frame/contracts/src/wasm/runtime.rs b/substrate/frame/contracts/src/wasm/runtime.rs index afbdd6ea802e..1f1f0f4d2be8 100644 --- a/substrate/frame/contracts/src/wasm/runtime.rs +++ b/substrate/frame/contracts/src/wasm/runtime.rs @@ -144,6 +144,8 @@ impl HostError for TrapReason {} #[cfg_attr(test, derive(Debug, PartialEq, Eq))] #[derive(Copy, Clone)] pub enum RuntimeCosts { + /// Base Weight of calling a host function. + HostFn, /// Weight charged for copying data from the sandbox. CopyFromContract(u32), /// Weight charged for copying data to the sandbox. @@ -270,6 +272,7 @@ impl Token for RuntimeCosts { fn weight(&self) -> Weight { use self::RuntimeCosts::*; match *self { + HostFn => cost_args!(noop_host_fn, 1), CopyFromContract(len) => T::WeightInfo::seal_return(len), CopyToContract(len) => cost_args!(seal_input, len), Caller => T::WeightInfo::seal_caller(), diff --git a/substrate/frame/contracts/src/weights.rs b/substrate/frame/contracts/src/weights.rs index f0b5804069ba..cbe92908f5ae 100644 --- a/substrate/frame/contracts/src/weights.rs +++ b/substrate/frame/contracts/src/weights.rs @@ -54,7 +54,7 @@ pub trait WeightInfo { fn upload_code_determinism_relaxed(c: u32, ) -> Weight; fn remove_code() -> Weight; fn set_code() -> Weight; - fn call_noop_host_fn(r: u32, ) -> Weight; + fn noop_host_fn(r: u32, ) -> Weight; fn seal_caller() -> Weight; fn seal_is_contract() -> Weight; fn seal_code_hash() -> Weight; @@ -521,7 +521,7 @@ impl WeightInfo for SubstrateWeight { .saturating_add(T::DbWeight::get().writes(6_u64)) } /// The range of component `r` is `[0, 1600]`. - fn call_noop_host_fn(r: u32, ) -> Weight { + fn noop_host_fn(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` @@ -1455,7 +1455,7 @@ impl WeightInfo for () { .saturating_add(RocksDbWeight::get().writes(6_u64)) } /// The range of component `r` is `[0, 1600]`. - fn call_noop_host_fn(r: u32, ) -> Weight { + fn noop_host_fn(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` From aed88a9851d41f0869531fbecc4d590f6232ef48 Mon Sep 17 00:00:00 2001 From: pgherveou Date: Fri, 26 Apr 2024 17:42:25 +0200 Subject: [PATCH 09/34] fixes --- substrate/frame/contracts/proc-macro/src/lib.rs | 4 +++- substrate/frame/contracts/src/tests.rs | 3 +-- substrate/frame/contracts/src/wasm/runtime.rs | 1 + 3 files changed, 5 insertions(+), 3 deletions(-) diff --git a/substrate/frame/contracts/proc-macro/src/lib.rs b/substrate/frame/contracts/proc-macro/src/lib.rs index 7a91de6112cb..f23827e87a5b 100644 --- a/substrate/frame/contracts/proc-macro/src/lib.rs +++ b/substrate/frame/contracts/proc-macro/src/lib.rs @@ -706,7 +706,9 @@ fn expand_functions(def: &EnvDef, expand_mode: ExpandMode) -> TokenStream2 { .map_err(TrapReason::from) .map_err(#into_host)? }; - __caller__.data_mut().charge_gas(RuntimeCosts::HostFn) + + // Charge gas for host function execution. + __caller__.data_mut().charge_gas(crate::wasm::RuntimeCosts::HostFn) .map_err(TrapReason::from) .map_err(#into_host)?; } diff --git a/substrate/frame/contracts/src/tests.rs b/substrate/frame/contracts/src/tests.rs index 8fe845fcf0f8..b4461c6f8409 100644 --- a/substrate/frame/contracts/src/tests.rs +++ b/substrate/frame/contracts/src/tests.rs @@ -874,8 +874,7 @@ fn gas_syncs_work() { let result = builder::bare_call(addr.clone()).data(1u32.encode()).build(); assert_ok!(result.result); let gas_consumed_once = result.gas_consumed.ref_time(); - let host_consumed_once = - ::Schedule::get().host_fn_weights.caller_is_origin.ref_time(); + let host_consumed_once = ::WeightInfo::seal_caller_is_origin().ref_time(); let engine_consumed_once = gas_consumed_once - host_consumed_once - engine_consumed_noop; let result = builder::bare_call(addr).data(2u32.encode()).build(); diff --git a/substrate/frame/contracts/src/wasm/runtime.rs b/substrate/frame/contracts/src/wasm/runtime.rs index 1f1f0f4d2be8..0c91ed8e63e5 100644 --- a/substrate/frame/contracts/src/wasm/runtime.rs +++ b/substrate/frame/contracts/src/wasm/runtime.rs @@ -952,6 +952,7 @@ pub mod env { /// Noop function used to benchmark the time it takes to execute an empty function. #[cfg(feature = "runtime-benchmarks")] + #[unstable] fn noop(ctx: _, memory: _) -> Result<(), TrapReason> { Ok(()) } From 450ca08a43ba635d88826d345f85df3384ffac05 Mon Sep 17 00:00:00 2001 From: command-bot <> Date: Mon, 29 Apr 2024 05:34:27 +0000 Subject: [PATCH 10/34] ".git/.scripts/commands/bench/bench.sh" --subcommand=pallet --runtime=dev --target_dir=substrate --pallet=pallet_contracts --- substrate/frame/contracts/src/weights.rs | 996 ++++++++++++----------- 1 file changed, 507 insertions(+), 489 deletions(-) diff --git a/substrate/frame/contracts/src/weights.rs b/substrate/frame/contracts/src/weights.rs index cbe92908f5ae..ec9f7e841aae 100644 --- a/substrate/frame/contracts/src/weights.rs +++ b/substrate/frame/contracts/src/weights.rs @@ -1,24 +1,42 @@ +// This file is part of Substrate. + +// Copyright (C) Parity Technologies (UK) Ltd. +// SPDX-License-Identifier: Apache-2.0 + +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. //! Autogenerated weights for `pallet_contracts` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 32.0.0 -//! DATE: 2024-04-26, STEPS: `2`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2024-04-29, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` -//! HOSTNAME: `pgs-laptop.lan`, CPU: `` -//! WASM-EXECUTION: `Compiled`, CHAIN: `None`, DB CACHE: `1024` +//! HOSTNAME: `runner-dcu62vjg-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz` +//! WASM-EXECUTION: `Compiled`, CHAIN: `Some("dev")`, DB CACHE: `1024` // Executed Command: -// target/debug/substrate-node +// target/production/substrate-node // benchmark // pallet -// --steps -// 2 -// -p -// pallet_contracts -// -e -// * -// --output -// substrate/frame/contracts/src/weights.rs +// --steps=50 +// --repeat=20 +// --extrinsic=* +// --wasm-execution=compiled +// --heap-pages=4096 +// --json-file=/builds/parity/mirrors/polkadot-sdk/.git/.artifacts/bench.json +// --pallet=pallet_contracts +// --chain=dev +// --header=./substrate/HEADER-APACHE2 +// --output=./substrate/frame/contracts/src/weights.rs // --template=./substrate/.maintain/frame-weight-template.hbs #![cfg_attr(rustfmt, rustfmt_skip)] @@ -82,7 +100,7 @@ pub trait WeightInfo { fn seal_contains_storage(n: u32, ) -> Weight; fn seal_take_storage(n: u32, ) -> Weight; fn seal_transfer() -> Weight; - fn seal_call(c: u32, t: u32, i: u32, ) -> Weight; + fn seal_call(t: u32, c: u32, i: u32, ) -> Weight; fn seal_delegate_call() -> Weight; fn seal_instantiate(t: u32, i: u32, s: u32, ) -> Weight; fn seal_hash_sha2_256(n: u32, ) -> Weight; @@ -110,8 +128,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `142` // Estimated: `1627` - // Minimum execution time: 21_000_000 picoseconds. - Weight::from_parts(22_000_000, 1627) + // Minimum execution time: 1_998_000 picoseconds. + Weight::from_parts(2_105_000, 1627) .saturating_add(T::DbWeight::get().reads(1_u64)) } /// Storage: `Skipped::Metadata` (r:0 w:0) @@ -119,12 +137,12 @@ impl WeightInfo for SubstrateWeight { /// The range of component `k` is `[0, 1024]`. fn on_initialize_per_trie_key(k: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `318 + k * (69 ±0)` - // Estimated: `318 + k * (70 ±0)` - // Minimum execution time: 106_000_000 picoseconds. - Weight::from_parts(118_200_000, 318) - // Standard Error: 30_650 - .saturating_add(Weight::from_parts(7_881_933, 0).saturating_mul(k.into())) + // Measured: `452 + k * (69 ±0)` + // Estimated: `442 + k * (70 ±0)` + // Minimum execution time: 12_810_000 picoseconds. + Weight::from_parts(13_041_000, 442) + // Standard Error: 1_980 + .saturating_add(Weight::from_parts(1_186_675, 0).saturating_mul(k.into())) .saturating_add(T::DbWeight::get().reads(2_u64)) .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(k.into()))) .saturating_add(T::DbWeight::get().writes(2_u64)) @@ -136,12 +154,12 @@ impl WeightInfo for SubstrateWeight { /// The range of component `c` is `[0, 125952]`. fn v9_migration_step(c: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `203 + c * (1 ±0)` - // Estimated: `6143 + c * (1 ±0)` - // Minimum execution time: 90_000_000 picoseconds. - Weight::from_parts(92_900_000, 6143) - // Standard Error: 7 - .saturating_add(Weight::from_parts(744, 0).saturating_mul(c.into())) + // Measured: `211 + c * (1 ±0)` + // Estimated: `6149 + c * (1 ±0)` + // Minimum execution time: 8_141_000 picoseconds. + Weight::from_parts(8_750_889, 6149) + // Standard Error: 1 + .saturating_add(Weight::from_parts(1_220, 0).saturating_mul(c.into())) .saturating_add(T::DbWeight::get().reads(2_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(c.into())) @@ -154,8 +172,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `510` // Estimated: `6450` - // Minimum execution time: 149_000_000 picoseconds. - Weight::from_parts(164_000_000, 6450) + // Minimum execution time: 16_836_000 picoseconds. + Weight::from_parts(17_922_000, 6450) .saturating_add(T::DbWeight::get().reads(3_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -166,14 +184,14 @@ impl WeightInfo for SubstrateWeight { /// The range of component `k` is `[0, 1024]`. fn v11_migration_step(k: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `166 + k * (1 ±0)` - // Estimated: `3631 + k * (1 ±0)` - // Minimum execution time: 32_000_000 picoseconds. - Weight::from_parts(33_399_999, 3631) - // Standard Error: 56_913 - .saturating_add(Weight::from_parts(15_769_238, 0).saturating_mul(k.into())) + // Measured: `171 + k * (1 ±0)` + // Estimated: `3635 + k * (1 ±0)` + // Minimum execution time: 3_422_000 picoseconds. + Weight::from_parts(3_488_000, 3635) + // Standard Error: 1_035 + .saturating_add(Weight::from_parts(1_215_499, 0).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(2_u64)) .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(k.into()))) .saturating_add(Weight::from_parts(0, 1).saturating_mul(k.into())) } @@ -190,12 +208,12 @@ impl WeightInfo for SubstrateWeight { /// The range of component `c` is `[0, 125952]`. fn v12_migration_step(c: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `320 + c * (1 ±0)` - // Estimated: `6260 + c * (1 ±0)` - // Minimum execution time: 205_000_000 picoseconds. - Weight::from_parts(219_100_000, 6260) - // Standard Error: 31 - .saturating_add(Weight::from_parts(342, 0).saturating_mul(c.into())) + // Measured: `328 + c * (1 ±0)` + // Estimated: `6266 + c * (1 ±0)` + // Minimum execution time: 20_859_000 picoseconds. + Weight::from_parts(21_212_479, 6266) + // Standard Error: 0 + .saturating_add(Weight::from_parts(459, 0).saturating_mul(c.into())) .saturating_add(T::DbWeight::get().reads(6_u64)) .saturating_add(T::DbWeight::get().writes(2_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(c.into())) @@ -206,8 +224,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `440` // Estimated: `6380` - // Minimum execution time: 112_000_000 picoseconds. - Weight::from_parts(117_000_000, 6380) + // Minimum execution time: 12_941_000 picoseconds. + Weight::from_parts(13_701_000, 6380) .saturating_add(T::DbWeight::get().reads(2_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -221,8 +239,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `352` // Estimated: `6292` - // Minimum execution time: 487_000_000 picoseconds. - Weight::from_parts(507_000_000, 6292) + // Minimum execution time: 46_900_000 picoseconds. + Weight::from_parts(48_164_000, 6292) .saturating_add(T::DbWeight::get().reads(4_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -234,8 +252,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `594` // Estimated: `6534` - // Minimum execution time: 430_000_000 picoseconds. - Weight::from_parts(518_000_000, 6534) + // Minimum execution time: 56_096_000 picoseconds. + Weight::from_parts(57_603_000, 6534) .saturating_add(T::DbWeight::get().reads(4_u64)) .saturating_add(T::DbWeight::get().writes(2_u64)) } @@ -245,8 +263,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `409` // Estimated: `6349` - // Minimum execution time: 110_000_000 picoseconds. - Weight::from_parts(122_000_000, 6349) + // Minimum execution time: 12_147_000 picoseconds. + Weight::from_parts(12_960_000, 6349) .saturating_add(T::DbWeight::get().reads(2_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -256,8 +274,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `142` // Estimated: `1627` - // Minimum execution time: 23_000_000 picoseconds. - Weight::from_parts(25_000_000, 1627) + // Minimum execution time: 2_436_000 picoseconds. + Weight::from_parts(2_697_000, 1627) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -269,8 +287,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `166` // Estimated: `3631` - // Minimum execution time: 114_000_000 picoseconds. - Weight::from_parts(118_000_000, 3631) + // Minimum execution time: 11_674_000 picoseconds. + Weight::from_parts(12_277_000, 3631) .saturating_add(T::DbWeight::get().reads(2_u64)) .saturating_add(T::DbWeight::get().writes(2_u64)) } @@ -280,8 +298,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `142` // Estimated: `3607` - // Minimum execution time: 42_000_000 picoseconds. - Weight::from_parts(43_000_000, 3607) + // Minimum execution time: 4_717_000 picoseconds. + Weight::from_parts(5_008_000, 3607) .saturating_add(T::DbWeight::get().reads(1_u64)) } /// Storage: UNKNOWN KEY `0x4342193e496fab7ec59d615ed0dc55304e7b9012096b41c4eb3aaf947f6ea429` (r:1 w:0) @@ -292,8 +310,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `167` // Estimated: `3632` - // Minimum execution time: 56_000_000 picoseconds. - Weight::from_parts(60_000_000, 3632) + // Minimum execution time: 5_954_000 picoseconds. + Weight::from_parts(6_331_000, 3632) .saturating_add(T::DbWeight::get().reads(2_u64)) } /// Storage: UNKNOWN KEY `0x4342193e496fab7ec59d615ed0dc55304e7b9012096b41c4eb3aaf947f6ea429` (r:1 w:0) @@ -304,8 +322,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `142` // Estimated: `3607` - // Minimum execution time: 56_000_000 picoseconds. - Weight::from_parts(58_000_000, 3607) + // Minimum execution time: 6_061_000 picoseconds. + Weight::from_parts(6_600_000, 3607) .saturating_add(T::DbWeight::get().reads(2_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -328,12 +346,12 @@ impl WeightInfo for SubstrateWeight { /// The range of component `c` is `[0, 125952]`. fn call_with_code_per_byte(c: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `832` - // Estimated: `9247 + c * (1 ±0)` - // Minimum execution time: 2_201_000_000 picoseconds. - Weight::from_parts(2_297_000_000, 9247) - // Standard Error: 362 - .saturating_add(Weight::from_parts(83_549, 0).saturating_mul(c.into())) + // Measured: `804 + c * (1 ±0)` + // Estimated: `9217 + c * (1 ±0)` + // Minimum execution time: 370_504_000 picoseconds. + Weight::from_parts(345_076_763, 9217) + // Standard Error: 96 + .saturating_add(Weight::from_parts(34_235, 0).saturating_mul(c.into())) .saturating_add(T::DbWeight::get().reads(11_u64)) .saturating_add(T::DbWeight::get().writes(4_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(c.into())) @@ -363,16 +381,16 @@ 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: `443` - // Estimated: `8858` - // Minimum execution time: 8_151_000_000 picoseconds. - Weight::from_parts(5_385_233_352, 8858) - // Standard Error: 497 - .saturating_add(Weight::from_parts(161_394, 0).saturating_mul(c.into())) - // Standard Error: 59 - .saturating_add(Weight::from_parts(1_312, 0).saturating_mul(i.into())) - // Standard Error: 59 - .saturating_add(Weight::from_parts(1_839, 0).saturating_mul(s.into())) + // Measured: `326` + // Estimated: `8740` + // Minimum execution time: 4_359_896_000 picoseconds. + Weight::from_parts(481_322_438, 8740) + // Standard Error: 225 + .saturating_add(Weight::from_parts(70_837, 0).saturating_mul(c.into())) + // Standard Error: 27 + .saturating_add(Weight::from_parts(1_888, 0).saturating_mul(i.into())) + // Standard Error: 27 + .saturating_add(Weight::from_parts(1_957, 0).saturating_mul(s.into())) .saturating_add(T::DbWeight::get().reads(14_u64)) .saturating_add(T::DbWeight::get().writes(10_u64)) } @@ -400,14 +418,14 @@ 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: `615` - // Estimated: `9030` - // Minimum execution time: 4_448_000_000 picoseconds. - Weight::from_parts(3_037_050_000, 9030) - // Standard Error: 32 - .saturating_add(Weight::from_parts(1_818, 0).saturating_mul(i.into())) - // Standard Error: 32 - .saturating_add(Weight::from_parts(1_611, 0).saturating_mul(s.into())) + // Measured: `563` + // Estimated: `8982` + // Minimum execution time: 2_128_155_000 picoseconds. + Weight::from_parts(2_147_287_000, 8982) + // Standard Error: 27 + .saturating_add(Weight::from_parts(964, 0).saturating_mul(i.into())) + // Standard Error: 27 + .saturating_add(Weight::from_parts(822, 0).saturating_mul(s.into())) .saturating_add(T::DbWeight::get().reads(13_u64)) .saturating_add(T::DbWeight::get().writes(7_u64)) } @@ -431,8 +449,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `829` // Estimated: `9244` - // Minimum execution time: 2_158_000_000 picoseconds. - Weight::from_parts(2_235_000_000, 9244) + // Minimum execution time: 214_463_000 picoseconds. + Weight::from_parts(225_091_000, 9244) .saturating_add(T::DbWeight::get().reads(11_u64)) .saturating_add(T::DbWeight::get().writes(4_u64)) } @@ -453,10 +471,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `145` // Estimated: `6085` - // Minimum execution time: 1_951_000_000 picoseconds. - Weight::from_parts(2_063_900_000, 6085) - // Standard Error: 430 - .saturating_add(Weight::from_parts(83_991, 0).saturating_mul(c.into())) + // Minimum execution time: 339_390_000 picoseconds. + Weight::from_parts(334_232_549, 6085) + // Standard Error: 76 + .saturating_add(Weight::from_parts(33_541, 0).saturating_mul(c.into())) .saturating_add(T::DbWeight::get().reads(6_u64)) .saturating_add(T::DbWeight::get().writes(4_u64)) } @@ -477,10 +495,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `145` // Estimated: `6085` - // Minimum execution time: 2_110_000_000 picoseconds. - Weight::from_parts(2_274_000_000, 6085) - // Standard Error: 286 - .saturating_add(Weight::from_parts(84_193, 0).saturating_mul(c.into())) + // Minimum execution time: 351_953_000 picoseconds. + Weight::from_parts(343_509_628, 6085) + // Standard Error: 88 + .saturating_add(Weight::from_parts(34_147, 0).saturating_mul(c.into())) .saturating_add(T::DbWeight::get().reads(6_u64)) .saturating_add(T::DbWeight::get().writes(4_u64)) } @@ -498,8 +516,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `315` // Estimated: `3780` - // Minimum execution time: 485_000_000 picoseconds. - Weight::from_parts(523_000_000, 3780) + // Minimum execution time: 45_660_000 picoseconds. + Weight::from_parts(46_780_000, 3780) .saturating_add(T::DbWeight::get().reads(4_u64)) .saturating_add(T::DbWeight::get().writes(4_u64)) } @@ -515,8 +533,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `552` // Estimated: `8967` - // Minimum execution time: 321_000_000 picoseconds. - Weight::from_parts(364_000_000, 8967) + // Minimum execution time: 35_016_000 picoseconds. + Weight::from_parts(36_078_000, 8967) .saturating_add(T::DbWeight::get().reads(7_u64)) .saturating_add(T::DbWeight::get().writes(6_u64)) } @@ -525,17 +543,17 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 150_000_000 picoseconds. - Weight::from_parts(159_300_000, 0) - // Standard Error: 1_567 - .saturating_add(Weight::from_parts(74_625, 0).saturating_mul(r.into())) + // Minimum execution time: 9_383_000 picoseconds. + Weight::from_parts(10_413_719, 0) + // Standard Error: 49 + .saturating_add(Weight::from_parts(72_020, 0).saturating_mul(r.into())) } fn seal_caller() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 6_000_000 picoseconds. - Weight::from_parts(7_000_000, 0) + // Minimum execution time: 643_000 picoseconds. + Weight::from_parts(703_000, 0) } /// Storage: `Contracts::ContractInfoOf` (r:1 w:0) /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) @@ -543,8 +561,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `354` // Estimated: `3819` - // Minimum execution time: 57_000_000 picoseconds. - Weight::from_parts(61_000_000, 3819) + // Minimum execution time: 6_757_000 picoseconds. + Weight::from_parts(6_890_000, 3819) .saturating_add(T::DbWeight::get().reads(1_u64)) } /// Storage: `Contracts::ContractInfoOf` (r:1 w:0) @@ -553,44 +571,44 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `447` // Estimated: `3912` - // Minimum execution time: 68_000_000 picoseconds. - Weight::from_parts(72_000_000, 3912) + // Minimum execution time: 7_950_000 picoseconds. + Weight::from_parts(8_424_000, 3912) .saturating_add(T::DbWeight::get().reads(1_u64)) } fn seal_own_code_hash() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 8_000_000 picoseconds. - Weight::from_parts(9_000_000, 0) + // Minimum execution time: 832_000 picoseconds. + Weight::from_parts(889_000, 0) } fn seal_caller_is_origin() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_000_000 picoseconds. - Weight::from_parts(3_000_000, 0) + // Minimum execution time: 386_000 picoseconds. + Weight::from_parts(403_000, 0) } fn seal_caller_is_root() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_000_000 picoseconds. - Weight::from_parts(3_000_000, 0) + // Minimum execution time: 334_000 picoseconds. + Weight::from_parts(372_000, 0) } fn seal_address() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 6_000_000 picoseconds. - Weight::from_parts(6_000_000, 0) + // Minimum execution time: 634_000 picoseconds. + Weight::from_parts(685_000, 0) } fn seal_gas_left() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 6_000_000 picoseconds. - Weight::from_parts(6_000_000, 0) + // Minimum execution time: 740_000 picoseconds. + Weight::from_parts(789_000, 0) } /// Storage: `System::Account` (r:1 w:0) /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`) @@ -598,37 +616,37 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `140` // Estimated: `3605` - // Minimum execution time: 45_000_000 picoseconds. - Weight::from_parts(47_000_000, 3605) + // Minimum execution time: 4_792_000 picoseconds. + Weight::from_parts(5_077_000, 3605) .saturating_add(T::DbWeight::get().reads(1_u64)) } fn seal_value_transferred() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 6_000_000 picoseconds. - Weight::from_parts(7_000_000, 0) + // Minimum execution time: 602_000 picoseconds. + Weight::from_parts(629_000, 0) } fn seal_minimum_balance() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 6_000_000 picoseconds. - Weight::from_parts(6_000_000, 0) + // Minimum execution time: 610_000 picoseconds. + Weight::from_parts(692_000, 0) } fn seal_block_number() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 6_000_000 picoseconds. - Weight::from_parts(6_000_000, 0) + // Minimum execution time: 614_000 picoseconds. + Weight::from_parts(662_000, 0) } fn seal_now() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 6_000_000 picoseconds. - Weight::from_parts(7_000_000, 0) + // Minimum execution time: 628_000 picoseconds. + Weight::from_parts(694_000, 0) } /// Storage: `TransactionPayment::NextFeeMultiplier` (r:1 w:0) /// Proof: `TransactionPayment::NextFeeMultiplier` (`max_values`: Some(1), `max_size`: Some(16), added: 511, mode: `Measured`) @@ -636,8 +654,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `67` // Estimated: `1552` - // Minimum execution time: 35_000_000 picoseconds. - Weight::from_parts(37_000_000, 1552) + // Minimum execution time: 4_360_000 picoseconds. + Weight::from_parts(4_613_000, 1552) .saturating_add(T::DbWeight::get().reads(1_u64)) } /// The range of component `n` is `[0, 1048572]`. @@ -645,18 +663,18 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 4_000_000 picoseconds. - Weight::from_parts(4_900_000, 0) + // Minimum execution time: 475_000 picoseconds. + Weight::from_parts(584_657, 0) } /// The range of component `n` is `[0, 1048572]`. fn seal_return(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_000_000 picoseconds. - Weight::from_parts(2_400_000, 0) - // Standard Error: 0 - .saturating_add(Weight::from_parts(158, 0).saturating_mul(n.into())) + // Minimum execution time: 312_000 picoseconds. + Weight::from_parts(343_000, 0) + // Standard Error: 9 + .saturating_add(Weight::from_parts(479, 0).saturating_mul(n.into())) } /// Storage: `Contracts::DeletionQueueCounter` (r:1 w:1) /// Proof: `Contracts::DeletionQueueCounter` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`) @@ -672,8 +690,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `2821` // Estimated: `85486` - // Minimum execution time: 1_390_000_000 picoseconds. - Weight::from_parts(1_470_000_000, 85486) + // Minimum execution time: 134_617_000 picoseconds. + Weight::from_parts(136_454_000, 85486) .saturating_add(T::DbWeight::get().reads(36_u64)) .saturating_add(T::DbWeight::get().writes(38_u64)) } @@ -683,8 +701,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `76` // Estimated: `1561` - // Minimum execution time: 33_000_000 picoseconds. - Weight::from_parts(36_000_000, 1561) + // Minimum execution time: 3_869_000 picoseconds. + Weight::from_parts(4_139_000, 1561) .saturating_add(T::DbWeight::get().reads(1_u64)) } /// Storage: `System::EventTopics` (r:4 w:4) @@ -694,26 +712,26 @@ impl WeightInfo for SubstrateWeight { fn seal_deposit_event(t: u32, n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` - // Estimated: `641 + t * (2562 ±0)` - // Minimum execution time: 27_000_000 picoseconds. - Weight::from_parts(28_999_999, 641) - // Standard Error: 651_505 - .saturating_add(Weight::from_parts(31_650_000, 0).saturating_mul(t.into())) - // Standard Error: 159 - .saturating_add(Weight::from_parts(134, 0).saturating_mul(n.into())) + // Estimated: `990 + t * (2475 ±0)` + // Minimum execution time: 4_137_000 picoseconds. + Weight::from_parts(4_504_239, 990) + // Standard Error: 6_837 + .saturating_add(Weight::from_parts(2_381_563, 0).saturating_mul(t.into())) + // Standard Error: 1 + .saturating_add(Weight::from_parts(20, 0).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(t.into()))) .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(t.into()))) - .saturating_add(Weight::from_parts(0, 2562).saturating_mul(t.into())) + .saturating_add(Weight::from_parts(0, 2475).saturating_mul(t.into())) } /// The range of component `i` is `[0, 1048576]`. fn seal_debug_message(i: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_000_000 picoseconds. - Weight::from_parts(3_100_000, 0) - // Standard Error: 1 - .saturating_add(Weight::from_parts(445, 0).saturating_mul(i.into())) + // Minimum execution time: 395_000 picoseconds. + Weight::from_parts(448_000, 0) + // Standard Error: 10 + .saturating_add(Weight::from_parts(1_272, 0).saturating_mul(i.into())) } /// Storage: `Skipped::Metadata` (r:0 w:0) /// Proof: `Skipped::Metadata` (`max_values`: None, `max_size`: None, mode: `Measured`) @@ -722,10 +740,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `245` // Estimated: `245` - // Minimum execution time: 55_000_000 picoseconds. - Weight::from_parts(61_800_000, 245) - // Standard Error: 132 - .saturating_add(Weight::from_parts(476, 0).saturating_mul(n.into())) + // Minimum execution time: 7_949_000 picoseconds. + Weight::from_parts(8_879_819, 245) + // Standard Error: 1 + .saturating_add(Weight::from_parts(350, 0).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -734,12 +752,12 @@ impl WeightInfo for SubstrateWeight { /// The range of component `n` is `[0, 16384]`. fn seal_set_storage_per_old_byte(n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `245 + n * (1 ±0)` - // Estimated: `245 + n * (1 ±0)` - // Minimum execution time: 56_000_000 picoseconds. - Weight::from_parts(63_900_000, 245) - // Standard Error: 93 - .saturating_add(Weight::from_parts(48, 0).saturating_mul(n.into())) + // Measured: `248 + n * (1 ±0)` + // Estimated: `248 + n * (1 ±0)` + // Minimum execution time: 7_878_000 picoseconds. + Weight::from_parts(9_291_579, 248) + // Standard Error: 2 + .saturating_add(Weight::from_parts(78, 0).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) @@ -749,12 +767,12 @@ impl WeightInfo for SubstrateWeight { /// The range of component `n` is `[0, 16384]`. fn seal_clear_storage(n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `245 + n * (1 ±0)` - // Estimated: `245 + n * (1 ±0)` - // Minimum execution time: 55_000_000 picoseconds. - Weight::from_parts(61_100_000, 245) - // Standard Error: 113 - .saturating_add(Weight::from_parts(708, 0).saturating_mul(n.into())) + // Measured: `248 + n * (1 ±0)` + // Estimated: `248 + n * (1 ±0)` + // Minimum execution time: 8_068_000 picoseconds. + Weight::from_parts(9_253_255, 248) + // Standard Error: 2 + .saturating_add(Weight::from_parts(80, 0).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) @@ -764,12 +782,12 @@ impl WeightInfo for SubstrateWeight { /// The range of component `n` is `[0, 16384]`. fn seal_get_storage(n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `245 + n * (1 ±0)` - // Estimated: `245 + n * (1 ±0)` - // Minimum execution time: 53_000_000 picoseconds. - Weight::from_parts(61_800_000, 245) - // Standard Error: 160 - .saturating_add(Weight::from_parts(1_196, 0).saturating_mul(n.into())) + // Measured: `248 + n * (1 ±0)` + // Estimated: `248 + n * (1 ±0)` + // Minimum execution time: 7_316_000 picoseconds. + Weight::from_parts(9_096_691, 248) + // Standard Error: 3 + .saturating_add(Weight::from_parts(706, 0).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) } @@ -778,12 +796,12 @@ impl WeightInfo for SubstrateWeight { /// The range of component `n` is `[0, 16384]`. fn seal_contains_storage(n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `245 + n * (1 ±0)` - // Estimated: `245 + n * (1 ±0)` - // Minimum execution time: 51_000_000 picoseconds. - Weight::from_parts(58_500_000, 245) - // Standard Error: 80 - .saturating_add(Weight::from_parts(299, 0).saturating_mul(n.into())) + // Measured: `248 + n * (1 ±0)` + // Estimated: `248 + n * (1 ±0)` + // Minimum execution time: 6_660_000 picoseconds. + Weight::from_parts(8_029_136, 248) + // Standard Error: 2 + .saturating_add(Weight::from_parts(85, 0).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) } @@ -792,12 +810,12 @@ impl WeightInfo for SubstrateWeight { /// The range of component `n` is `[0, 16384]`. fn seal_take_storage(n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `245 + n * (1 ±0)` - // Estimated: `245 + n * (1 ±0)` - // Minimum execution time: 57_000_000 picoseconds. - Weight::from_parts(66_300_000, 245) - // Standard Error: 188 - .saturating_add(Weight::from_parts(1_110, 0).saturating_mul(n.into())) + // Measured: `248 + n * (1 ±0)` + // Estimated: `248 + n * (1 ±0)` + // Minimum execution time: 8_497_000 picoseconds. + Weight::from_parts(10_287_954, 248) + // Standard Error: 3 + .saturating_add(Weight::from_parts(699, 0).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) @@ -808,8 +826,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `140` // Estimated: `3605` - // Minimum execution time: 99_000_000 picoseconds. - Weight::from_parts(102_000_000, 3605) + // Minimum execution time: 9_337_000 picoseconds. + Weight::from_parts(9_882_000, 3605) .saturating_add(T::DbWeight::get().reads(1_u64)) } /// Storage: `Contracts::ContractInfoOf` (r:1 w:2) @@ -824,24 +842,26 @@ impl WeightInfo for SubstrateWeight { /// Proof: `Parameters::Parameters` (`max_values`: None, `max_size`: Some(36), added: 2511, mode: `Measured`) /// Storage: `System::EventTopics` (r:2 w:2) /// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`) - /// The range of component `c` is `[0, 1]`. /// The range of component `t` is `[0, 1]`. + /// The range of component `c` is `[0, 1]`. /// The range of component `i` is `[0, 1048576]`. - fn seal_call(c: u32, t: u32, _i: u32, ) -> Weight { + fn seal_call(t: u32, c: u32, i: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `623 + t * (280 ±0)` - // Estimated: `6563 + t * (3421 ±0)` - // Minimum execution time: 1_604_000_000 picoseconds. - Weight::from_parts(1_723_533_333, 6563) - // Standard Error: 18_493_246 - .saturating_add(Weight::from_parts(15_933_333, 0).saturating_mul(c.into())) - // Standard Error: 18_493_246 - .saturating_add(Weight::from_parts(414_233_333, 0).saturating_mul(t.into())) + // Estimated: `6563 + t * (3422 ±0)` + // Minimum execution time: 172_292_000 picoseconds. + Weight::from_parts(167_185_817, 6563) + // Standard Error: 327_522 + .saturating_add(Weight::from_parts(44_974_443, 0).saturating_mul(t.into())) + // Standard Error: 327_522 + .saturating_add(Weight::from_parts(4_283_151, 0).saturating_mul(c.into())) + // Standard Error: 0 + .saturating_add(Weight::from_parts(11, 0).saturating_mul(i.into())) .saturating_add(T::DbWeight::get().reads(7_u64)) .saturating_add(T::DbWeight::get().reads((2_u64).saturating_mul(t.into()))) .saturating_add(T::DbWeight::get().writes(4_u64)) .saturating_add(T::DbWeight::get().writes((2_u64).saturating_mul(t.into()))) - .saturating_add(Weight::from_parts(0, 3421).saturating_mul(t.into())) + .saturating_add(Weight::from_parts(0, 3422).saturating_mul(t.into())) } /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) @@ -857,8 +877,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `433` // Estimated: `6373` - // Minimum execution time: 1_524_000_000 picoseconds. - Weight::from_parts(1_558_000_000, 6373) + // Minimum execution time: 161_490_000 picoseconds. + Weight::from_parts(170_939_000, 6373) .saturating_add(T::DbWeight::get().reads(6_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) } @@ -881,85 +901,83 @@ impl WeightInfo for SubstrateWeight { /// The range of component `s` is `[0, 983040]`. fn seal_instantiate(t: u32, i: u32, s: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `627 + t * (102 ±0)` - // Estimated: `6567 + t * (2577 ±0)` - // Minimum execution time: 3_863_000_000 picoseconds. - Weight::from_parts(2_236_566_666, 6567) - // Standard Error: 41_979_515 - .saturating_add(Weight::from_parts(469_166_666, 0).saturating_mul(t.into())) - // Standard Error: 42 - .saturating_add(Weight::from_parts(1_417, 0).saturating_mul(i.into())) - // Standard Error: 42 - .saturating_add(Weight::from_parts(1_492, 0).saturating_mul(s.into())) + // Measured: `679 + t * (102 ±0)` + // Estimated: `6616 + t * (2565 ±1)` + // Minimum execution time: 1_819_574_000 picoseconds. + Weight::from_parts(1_829_348_000, 6616) + // Standard Error: 14 + .saturating_add(Weight::from_parts(731, 0).saturating_mul(i.into())) + // Standard Error: 14 + .saturating_add(Weight::from_parts(1_005, 0).saturating_mul(s.into())) .saturating_add(T::DbWeight::get().reads(10_u64)) .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(t.into()))) .saturating_add(T::DbWeight::get().writes(7_u64)) .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(t.into()))) - .saturating_add(Weight::from_parts(0, 2577).saturating_mul(t.into())) + .saturating_add(Weight::from_parts(0, 2565).saturating_mul(t.into())) } /// The range of component `n` is `[0, 1048576]`. fn seal_hash_sha2_256(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 8_000_000 picoseconds. - Weight::from_parts(13_000_000, 0) - // Standard Error: 13 - .saturating_add(Weight::from_parts(3_238, 0).saturating_mul(n.into())) + // Minimum execution time: 894_000 picoseconds. + Weight::from_parts(941_000, 0) + // Standard Error: 0 + .saturating_add(Weight::from_parts(1_151, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 1048576]`. fn seal_hash_keccak_256(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 9_000_000 picoseconds. - Weight::from_parts(12_900_000, 0) - // Standard Error: 16 - .saturating_add(Weight::from_parts(4_844, 0).saturating_mul(n.into())) + // Minimum execution time: 1_359_000 picoseconds. + Weight::from_parts(1_403_000, 0) + // Standard Error: 0 + .saturating_add(Weight::from_parts(3_410, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 1048576]`. fn seal_hash_blake2_256(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 5_000_000 picoseconds. - Weight::from_parts(6_000_000, 0) - // Standard Error: 5 - .saturating_add(Weight::from_parts(1_190, 0).saturating_mul(n.into())) + // Minimum execution time: 727_000 picoseconds. + Weight::from_parts(762_000, 0) + // Standard Error: 0 + .saturating_add(Weight::from_parts(1_280, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 1048576]`. fn seal_hash_blake2_128(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 5_000_000 picoseconds. - Weight::from_parts(5_600_000, 0) - // Standard Error: 4 - .saturating_add(Weight::from_parts(1_165, 0).saturating_mul(n.into())) + // Minimum execution time: 772_000 picoseconds. + Weight::from_parts(799_000, 0) + // Standard Error: 0 + .saturating_add(Weight::from_parts(1_279, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 125697]`. fn seal_sr25519_verify(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 58_000_000 picoseconds. - Weight::from_parts(63_500_000, 0) - // Standard Error: 39 - .saturating_add(Weight::from_parts(7_818, 0).saturating_mul(n.into())) + // Minimum execution time: 43_237_000 picoseconds. + Weight::from_parts(44_351_784, 0) + // Standard Error: 8 + .saturating_add(Weight::from_parts(4_756, 0).saturating_mul(n.into())) } fn seal_ecdsa_recover() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 312_000_000 picoseconds. - Weight::from_parts(329_000_000, 0) + // Minimum execution time: 48_204_000 picoseconds. + Weight::from_parts(49_920_000, 0) } fn seal_ecdsa_to_eth_address() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 16_000_000 picoseconds. - Weight::from_parts(19_000_000, 0) + // Minimum execution time: 12_997_000 picoseconds. + Weight::from_parts(13_237_000, 0) } /// Storage: `Contracts::CodeInfoOf` (r:1 w:1) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) @@ -973,8 +991,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `433` // Estimated: `6373` - // Minimum execution time: 309_000_000 picoseconds. - Weight::from_parts(332_000_000, 6373) + // Minimum execution time: 31_613_000 picoseconds. + Weight::from_parts(32_976_000, 6373) .saturating_add(T::DbWeight::get().reads(6_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) } @@ -984,8 +1002,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `355` // Estimated: `3820` - // Minimum execution time: 80_000_000 picoseconds. - Weight::from_parts(86_000_000, 3820) + // Minimum execution time: 9_330_000 picoseconds. + Weight::from_parts(9_933_000, 3820) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -995,8 +1013,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `355` // Estimated: `3558` - // Minimum execution time: 66_000_000 picoseconds. - Weight::from_parts(69_000_000, 3558) + // Minimum execution time: 8_203_000 picoseconds. + Weight::from_parts(8_645_000, 3558) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -1004,15 +1022,15 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_000_000 picoseconds. - Weight::from_parts(3_000_000, 0) + // Minimum execution time: 283_000 picoseconds. + Weight::from_parts(342_000, 0) } fn seal_account_reentrance_count() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_000_000 picoseconds. - Weight::from_parts(3_000_000, 0) + // Minimum execution time: 312_000 picoseconds. + Weight::from_parts(376_000, 0) } /// Storage: `Contracts::Nonce` (r:1 w:0) /// Proof: `Contracts::Nonce` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`) @@ -1020,8 +1038,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `219` // Estimated: `1704` - // Minimum execution time: 26_000_000 picoseconds. - Weight::from_parts(28_000_000, 1704) + // Minimum execution time: 2_996_000 picoseconds. + Weight::from_parts(3_180_000, 1704) .saturating_add(T::DbWeight::get().reads(1_u64)) } /// The range of component `r` is `[0, 5000]`. @@ -1029,10 +1047,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 5_000_000 picoseconds. - Weight::from_parts(6_000_000, 0) - // Standard Error: 557 - .saturating_add(Weight::from_parts(75_560, 0).saturating_mul(r.into())) + // Minimum execution time: 1_200_000 picoseconds. + Weight::from_parts(1_007_275, 0) + // Standard Error: 18 + .saturating_add(Weight::from_parts(15_124, 0).saturating_mul(r.into())) } } @@ -1044,8 +1062,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `142` // Estimated: `1627` - // Minimum execution time: 21_000_000 picoseconds. - Weight::from_parts(22_000_000, 1627) + // Minimum execution time: 1_998_000 picoseconds. + Weight::from_parts(2_105_000, 1627) .saturating_add(RocksDbWeight::get().reads(1_u64)) } /// Storage: `Skipped::Metadata` (r:0 w:0) @@ -1053,12 +1071,12 @@ impl WeightInfo for () { /// The range of component `k` is `[0, 1024]`. fn on_initialize_per_trie_key(k: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `318 + k * (69 ±0)` - // Estimated: `318 + k * (70 ±0)` - // Minimum execution time: 106_000_000 picoseconds. - Weight::from_parts(118_200_000, 318) - // Standard Error: 30_650 - .saturating_add(Weight::from_parts(7_881_933, 0).saturating_mul(k.into())) + // Measured: `452 + k * (69 ±0)` + // Estimated: `442 + k * (70 ±0)` + // Minimum execution time: 12_810_000 picoseconds. + Weight::from_parts(13_041_000, 442) + // Standard Error: 1_980 + .saturating_add(Weight::from_parts(1_186_675, 0).saturating_mul(k.into())) .saturating_add(RocksDbWeight::get().reads(2_u64)) .saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(k.into()))) .saturating_add(RocksDbWeight::get().writes(2_u64)) @@ -1070,12 +1088,12 @@ impl WeightInfo for () { /// The range of component `c` is `[0, 125952]`. fn v9_migration_step(c: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `203 + c * (1 ±0)` - // Estimated: `6143 + c * (1 ±0)` - // Minimum execution time: 90_000_000 picoseconds. - Weight::from_parts(92_900_000, 6143) - // Standard Error: 7 - .saturating_add(Weight::from_parts(744, 0).saturating_mul(c.into())) + // Measured: `211 + c * (1 ±0)` + // Estimated: `6149 + c * (1 ±0)` + // Minimum execution time: 8_141_000 picoseconds. + Weight::from_parts(8_750_889, 6149) + // Standard Error: 1 + .saturating_add(Weight::from_parts(1_220, 0).saturating_mul(c.into())) .saturating_add(RocksDbWeight::get().reads(2_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(c.into())) @@ -1088,8 +1106,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `510` // Estimated: `6450` - // Minimum execution time: 149_000_000 picoseconds. - Weight::from_parts(164_000_000, 6450) + // Minimum execution time: 16_836_000 picoseconds. + Weight::from_parts(17_922_000, 6450) .saturating_add(RocksDbWeight::get().reads(3_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -1100,14 +1118,14 @@ impl WeightInfo for () { /// The range of component `k` is `[0, 1024]`. fn v11_migration_step(k: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `166 + k * (1 ±0)` - // Estimated: `3631 + k * (1 ±0)` - // Minimum execution time: 32_000_000 picoseconds. - Weight::from_parts(33_399_999, 3631) - // Standard Error: 56_913 - .saturating_add(Weight::from_parts(15_769_238, 0).saturating_mul(k.into())) + // Measured: `171 + k * (1 ±0)` + // Estimated: `3635 + k * (1 ±0)` + // Minimum execution time: 3_422_000 picoseconds. + Weight::from_parts(3_488_000, 3635) + // Standard Error: 1_035 + .saturating_add(Weight::from_parts(1_215_499, 0).saturating_mul(k.into())) .saturating_add(RocksDbWeight::get().reads(1_u64)) - .saturating_add(RocksDbWeight::get().writes(1_u64)) + .saturating_add(RocksDbWeight::get().writes(2_u64)) .saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(k.into()))) .saturating_add(Weight::from_parts(0, 1).saturating_mul(k.into())) } @@ -1124,12 +1142,12 @@ impl WeightInfo for () { /// The range of component `c` is `[0, 125952]`. fn v12_migration_step(c: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `320 + c * (1 ±0)` - // Estimated: `6260 + c * (1 ±0)` - // Minimum execution time: 205_000_000 picoseconds. - Weight::from_parts(219_100_000, 6260) - // Standard Error: 31 - .saturating_add(Weight::from_parts(342, 0).saturating_mul(c.into())) + // Measured: `328 + c * (1 ±0)` + // Estimated: `6266 + c * (1 ±0)` + // Minimum execution time: 20_859_000 picoseconds. + Weight::from_parts(21_212_479, 6266) + // Standard Error: 0 + .saturating_add(Weight::from_parts(459, 0).saturating_mul(c.into())) .saturating_add(RocksDbWeight::get().reads(6_u64)) .saturating_add(RocksDbWeight::get().writes(2_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(c.into())) @@ -1140,8 +1158,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `440` // Estimated: `6380` - // Minimum execution time: 112_000_000 picoseconds. - Weight::from_parts(117_000_000, 6380) + // Minimum execution time: 12_941_000 picoseconds. + Weight::from_parts(13_701_000, 6380) .saturating_add(RocksDbWeight::get().reads(2_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -1155,8 +1173,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `352` // Estimated: `6292` - // Minimum execution time: 487_000_000 picoseconds. - Weight::from_parts(507_000_000, 6292) + // Minimum execution time: 46_900_000 picoseconds. + Weight::from_parts(48_164_000, 6292) .saturating_add(RocksDbWeight::get().reads(4_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -1168,8 +1186,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `594` // Estimated: `6534` - // Minimum execution time: 430_000_000 picoseconds. - Weight::from_parts(518_000_000, 6534) + // Minimum execution time: 56_096_000 picoseconds. + Weight::from_parts(57_603_000, 6534) .saturating_add(RocksDbWeight::get().reads(4_u64)) .saturating_add(RocksDbWeight::get().writes(2_u64)) } @@ -1179,8 +1197,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `409` // Estimated: `6349` - // Minimum execution time: 110_000_000 picoseconds. - Weight::from_parts(122_000_000, 6349) + // Minimum execution time: 12_147_000 picoseconds. + Weight::from_parts(12_960_000, 6349) .saturating_add(RocksDbWeight::get().reads(2_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -1190,8 +1208,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `142` // Estimated: `1627` - // Minimum execution time: 23_000_000 picoseconds. - Weight::from_parts(25_000_000, 1627) + // Minimum execution time: 2_436_000 picoseconds. + Weight::from_parts(2_697_000, 1627) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -1203,8 +1221,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `166` // Estimated: `3631` - // Minimum execution time: 114_000_000 picoseconds. - Weight::from_parts(118_000_000, 3631) + // Minimum execution time: 11_674_000 picoseconds. + Weight::from_parts(12_277_000, 3631) .saturating_add(RocksDbWeight::get().reads(2_u64)) .saturating_add(RocksDbWeight::get().writes(2_u64)) } @@ -1214,8 +1232,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `142` // Estimated: `3607` - // Minimum execution time: 42_000_000 picoseconds. - Weight::from_parts(43_000_000, 3607) + // Minimum execution time: 4_717_000 picoseconds. + Weight::from_parts(5_008_000, 3607) .saturating_add(RocksDbWeight::get().reads(1_u64)) } /// Storage: UNKNOWN KEY `0x4342193e496fab7ec59d615ed0dc55304e7b9012096b41c4eb3aaf947f6ea429` (r:1 w:0) @@ -1226,8 +1244,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `167` // Estimated: `3632` - // Minimum execution time: 56_000_000 picoseconds. - Weight::from_parts(60_000_000, 3632) + // Minimum execution time: 5_954_000 picoseconds. + Weight::from_parts(6_331_000, 3632) .saturating_add(RocksDbWeight::get().reads(2_u64)) } /// Storage: UNKNOWN KEY `0x4342193e496fab7ec59d615ed0dc55304e7b9012096b41c4eb3aaf947f6ea429` (r:1 w:0) @@ -1238,8 +1256,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `142` // Estimated: `3607` - // Minimum execution time: 56_000_000 picoseconds. - Weight::from_parts(58_000_000, 3607) + // Minimum execution time: 6_061_000 picoseconds. + Weight::from_parts(6_600_000, 3607) .saturating_add(RocksDbWeight::get().reads(2_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -1262,12 +1280,12 @@ impl WeightInfo for () { /// The range of component `c` is `[0, 125952]`. fn call_with_code_per_byte(c: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `832` - // Estimated: `9247 + c * (1 ±0)` - // Minimum execution time: 2_201_000_000 picoseconds. - Weight::from_parts(2_297_000_000, 9247) - // Standard Error: 362 - .saturating_add(Weight::from_parts(83_549, 0).saturating_mul(c.into())) + // Measured: `804 + c * (1 ±0)` + // Estimated: `9217 + c * (1 ±0)` + // Minimum execution time: 370_504_000 picoseconds. + Weight::from_parts(345_076_763, 9217) + // Standard Error: 96 + .saturating_add(Weight::from_parts(34_235, 0).saturating_mul(c.into())) .saturating_add(RocksDbWeight::get().reads(11_u64)) .saturating_add(RocksDbWeight::get().writes(4_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(c.into())) @@ -1297,16 +1315,16 @@ 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: `443` - // Estimated: `8858` - // Minimum execution time: 8_151_000_000 picoseconds. - Weight::from_parts(5_385_233_352, 8858) - // Standard Error: 497 - .saturating_add(Weight::from_parts(161_394, 0).saturating_mul(c.into())) - // Standard Error: 59 - .saturating_add(Weight::from_parts(1_312, 0).saturating_mul(i.into())) - // Standard Error: 59 - .saturating_add(Weight::from_parts(1_839, 0).saturating_mul(s.into())) + // Measured: `326` + // Estimated: `8740` + // Minimum execution time: 4_359_896_000 picoseconds. + Weight::from_parts(481_322_438, 8740) + // Standard Error: 225 + .saturating_add(Weight::from_parts(70_837, 0).saturating_mul(c.into())) + // Standard Error: 27 + .saturating_add(Weight::from_parts(1_888, 0).saturating_mul(i.into())) + // Standard Error: 27 + .saturating_add(Weight::from_parts(1_957, 0).saturating_mul(s.into())) .saturating_add(RocksDbWeight::get().reads(14_u64)) .saturating_add(RocksDbWeight::get().writes(10_u64)) } @@ -1334,14 +1352,14 @@ impl WeightInfo for () { /// The range of component `s` is `[0, 1048576]`. fn instantiate(i: u32, s: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `615` - // Estimated: `9030` - // Minimum execution time: 4_448_000_000 picoseconds. - Weight::from_parts(3_037_050_000, 9030) - // Standard Error: 32 - .saturating_add(Weight::from_parts(1_818, 0).saturating_mul(i.into())) - // Standard Error: 32 - .saturating_add(Weight::from_parts(1_611, 0).saturating_mul(s.into())) + // Measured: `563` + // Estimated: `8982` + // Minimum execution time: 2_128_155_000 picoseconds. + Weight::from_parts(2_147_287_000, 8982) + // Standard Error: 27 + .saturating_add(Weight::from_parts(964, 0).saturating_mul(i.into())) + // Standard Error: 27 + .saturating_add(Weight::from_parts(822, 0).saturating_mul(s.into())) .saturating_add(RocksDbWeight::get().reads(13_u64)) .saturating_add(RocksDbWeight::get().writes(7_u64)) } @@ -1365,8 +1383,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `829` // Estimated: `9244` - // Minimum execution time: 2_158_000_000 picoseconds. - Weight::from_parts(2_235_000_000, 9244) + // Minimum execution time: 214_463_000 picoseconds. + Weight::from_parts(225_091_000, 9244) .saturating_add(RocksDbWeight::get().reads(11_u64)) .saturating_add(RocksDbWeight::get().writes(4_u64)) } @@ -1387,10 +1405,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `145` // Estimated: `6085` - // Minimum execution time: 1_951_000_000 picoseconds. - Weight::from_parts(2_063_900_000, 6085) - // Standard Error: 430 - .saturating_add(Weight::from_parts(83_991, 0).saturating_mul(c.into())) + // Minimum execution time: 339_390_000 picoseconds. + Weight::from_parts(334_232_549, 6085) + // Standard Error: 76 + .saturating_add(Weight::from_parts(33_541, 0).saturating_mul(c.into())) .saturating_add(RocksDbWeight::get().reads(6_u64)) .saturating_add(RocksDbWeight::get().writes(4_u64)) } @@ -1411,10 +1429,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `145` // Estimated: `6085` - // Minimum execution time: 2_110_000_000 picoseconds. - Weight::from_parts(2_274_000_000, 6085) - // Standard Error: 286 - .saturating_add(Weight::from_parts(84_193, 0).saturating_mul(c.into())) + // Minimum execution time: 351_953_000 picoseconds. + Weight::from_parts(343_509_628, 6085) + // Standard Error: 88 + .saturating_add(Weight::from_parts(34_147, 0).saturating_mul(c.into())) .saturating_add(RocksDbWeight::get().reads(6_u64)) .saturating_add(RocksDbWeight::get().writes(4_u64)) } @@ -1432,8 +1450,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `315` // Estimated: `3780` - // Minimum execution time: 485_000_000 picoseconds. - Weight::from_parts(523_000_000, 3780) + // Minimum execution time: 45_660_000 picoseconds. + Weight::from_parts(46_780_000, 3780) .saturating_add(RocksDbWeight::get().reads(4_u64)) .saturating_add(RocksDbWeight::get().writes(4_u64)) } @@ -1449,8 +1467,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `552` // Estimated: `8967` - // Minimum execution time: 321_000_000 picoseconds. - Weight::from_parts(364_000_000, 8967) + // Minimum execution time: 35_016_000 picoseconds. + Weight::from_parts(36_078_000, 8967) .saturating_add(RocksDbWeight::get().reads(7_u64)) .saturating_add(RocksDbWeight::get().writes(6_u64)) } @@ -1459,17 +1477,17 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 150_000_000 picoseconds. - Weight::from_parts(159_300_000, 0) - // Standard Error: 1_567 - .saturating_add(Weight::from_parts(74_625, 0).saturating_mul(r.into())) + // Minimum execution time: 9_383_000 picoseconds. + Weight::from_parts(10_413_719, 0) + // Standard Error: 49 + .saturating_add(Weight::from_parts(72_020, 0).saturating_mul(r.into())) } fn seal_caller() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 6_000_000 picoseconds. - Weight::from_parts(7_000_000, 0) + // Minimum execution time: 643_000 picoseconds. + Weight::from_parts(703_000, 0) } /// Storage: `Contracts::ContractInfoOf` (r:1 w:0) /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) @@ -1477,8 +1495,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `354` // Estimated: `3819` - // Minimum execution time: 57_000_000 picoseconds. - Weight::from_parts(61_000_000, 3819) + // Minimum execution time: 6_757_000 picoseconds. + Weight::from_parts(6_890_000, 3819) .saturating_add(RocksDbWeight::get().reads(1_u64)) } /// Storage: `Contracts::ContractInfoOf` (r:1 w:0) @@ -1487,44 +1505,44 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `447` // Estimated: `3912` - // Minimum execution time: 68_000_000 picoseconds. - Weight::from_parts(72_000_000, 3912) + // Minimum execution time: 7_950_000 picoseconds. + Weight::from_parts(8_424_000, 3912) .saturating_add(RocksDbWeight::get().reads(1_u64)) } fn seal_own_code_hash() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 8_000_000 picoseconds. - Weight::from_parts(9_000_000, 0) + // Minimum execution time: 832_000 picoseconds. + Weight::from_parts(889_000, 0) } fn seal_caller_is_origin() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_000_000 picoseconds. - Weight::from_parts(3_000_000, 0) + // Minimum execution time: 386_000 picoseconds. + Weight::from_parts(403_000, 0) } fn seal_caller_is_root() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_000_000 picoseconds. - Weight::from_parts(3_000_000, 0) + // Minimum execution time: 334_000 picoseconds. + Weight::from_parts(372_000, 0) } fn seal_address() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 6_000_000 picoseconds. - Weight::from_parts(6_000_000, 0) + // Minimum execution time: 634_000 picoseconds. + Weight::from_parts(685_000, 0) } fn seal_gas_left() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 6_000_000 picoseconds. - Weight::from_parts(6_000_000, 0) + // Minimum execution time: 740_000 picoseconds. + Weight::from_parts(789_000, 0) } /// Storage: `System::Account` (r:1 w:0) /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`) @@ -1532,37 +1550,37 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `140` // Estimated: `3605` - // Minimum execution time: 45_000_000 picoseconds. - Weight::from_parts(47_000_000, 3605) + // Minimum execution time: 4_792_000 picoseconds. + Weight::from_parts(5_077_000, 3605) .saturating_add(RocksDbWeight::get().reads(1_u64)) } fn seal_value_transferred() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 6_000_000 picoseconds. - Weight::from_parts(7_000_000, 0) + // Minimum execution time: 602_000 picoseconds. + Weight::from_parts(629_000, 0) } fn seal_minimum_balance() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 6_000_000 picoseconds. - Weight::from_parts(6_000_000, 0) + // Minimum execution time: 610_000 picoseconds. + Weight::from_parts(692_000, 0) } fn seal_block_number() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 6_000_000 picoseconds. - Weight::from_parts(6_000_000, 0) + // Minimum execution time: 614_000 picoseconds. + Weight::from_parts(662_000, 0) } fn seal_now() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 6_000_000 picoseconds. - Weight::from_parts(7_000_000, 0) + // Minimum execution time: 628_000 picoseconds. + Weight::from_parts(694_000, 0) } /// Storage: `TransactionPayment::NextFeeMultiplier` (r:1 w:0) /// Proof: `TransactionPayment::NextFeeMultiplier` (`max_values`: Some(1), `max_size`: Some(16), added: 511, mode: `Measured`) @@ -1570,8 +1588,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `67` // Estimated: `1552` - // Minimum execution time: 35_000_000 picoseconds. - Weight::from_parts(37_000_000, 1552) + // Minimum execution time: 4_360_000 picoseconds. + Weight::from_parts(4_613_000, 1552) .saturating_add(RocksDbWeight::get().reads(1_u64)) } /// The range of component `n` is `[0, 1048572]`. @@ -1579,18 +1597,18 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 4_000_000 picoseconds. - Weight::from_parts(4_900_000, 0) + // Minimum execution time: 475_000 picoseconds. + Weight::from_parts(584_657, 0) } /// The range of component `n` is `[0, 1048572]`. fn seal_return(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_000_000 picoseconds. - Weight::from_parts(2_400_000, 0) - // Standard Error: 0 - .saturating_add(Weight::from_parts(158, 0).saturating_mul(n.into())) + // Minimum execution time: 312_000 picoseconds. + Weight::from_parts(343_000, 0) + // Standard Error: 9 + .saturating_add(Weight::from_parts(479, 0).saturating_mul(n.into())) } /// Storage: `Contracts::DeletionQueueCounter` (r:1 w:1) /// Proof: `Contracts::DeletionQueueCounter` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`) @@ -1606,8 +1624,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `2821` // Estimated: `85486` - // Minimum execution time: 1_390_000_000 picoseconds. - Weight::from_parts(1_470_000_000, 85486) + // Minimum execution time: 134_617_000 picoseconds. + Weight::from_parts(136_454_000, 85486) .saturating_add(RocksDbWeight::get().reads(36_u64)) .saturating_add(RocksDbWeight::get().writes(38_u64)) } @@ -1617,8 +1635,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `76` // Estimated: `1561` - // Minimum execution time: 33_000_000 picoseconds. - Weight::from_parts(36_000_000, 1561) + // Minimum execution time: 3_869_000 picoseconds. + Weight::from_parts(4_139_000, 1561) .saturating_add(RocksDbWeight::get().reads(1_u64)) } /// Storage: `System::EventTopics` (r:4 w:4) @@ -1628,26 +1646,26 @@ impl WeightInfo for () { fn seal_deposit_event(t: u32, n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` - // Estimated: `641 + t * (2562 ±0)` - // Minimum execution time: 27_000_000 picoseconds. - Weight::from_parts(28_999_999, 641) - // Standard Error: 651_505 - .saturating_add(Weight::from_parts(31_650_000, 0).saturating_mul(t.into())) - // Standard Error: 159 - .saturating_add(Weight::from_parts(134, 0).saturating_mul(n.into())) + // Estimated: `990 + t * (2475 ±0)` + // Minimum execution time: 4_137_000 picoseconds. + Weight::from_parts(4_504_239, 990) + // Standard Error: 6_837 + .saturating_add(Weight::from_parts(2_381_563, 0).saturating_mul(t.into())) + // Standard Error: 1 + .saturating_add(Weight::from_parts(20, 0).saturating_mul(n.into())) .saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(t.into()))) .saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(t.into()))) - .saturating_add(Weight::from_parts(0, 2562).saturating_mul(t.into())) + .saturating_add(Weight::from_parts(0, 2475).saturating_mul(t.into())) } /// The range of component `i` is `[0, 1048576]`. fn seal_debug_message(i: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_000_000 picoseconds. - Weight::from_parts(3_100_000, 0) - // Standard Error: 1 - .saturating_add(Weight::from_parts(445, 0).saturating_mul(i.into())) + // Minimum execution time: 395_000 picoseconds. + Weight::from_parts(448_000, 0) + // Standard Error: 10 + .saturating_add(Weight::from_parts(1_272, 0).saturating_mul(i.into())) } /// Storage: `Skipped::Metadata` (r:0 w:0) /// Proof: `Skipped::Metadata` (`max_values`: None, `max_size`: None, mode: `Measured`) @@ -1656,10 +1674,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `245` // Estimated: `245` - // Minimum execution time: 55_000_000 picoseconds. - Weight::from_parts(61_800_000, 245) - // Standard Error: 132 - .saturating_add(Weight::from_parts(476, 0).saturating_mul(n.into())) + // Minimum execution time: 7_949_000 picoseconds. + Weight::from_parts(8_879_819, 245) + // Standard Error: 1 + .saturating_add(Weight::from_parts(350, 0).saturating_mul(n.into())) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -1668,12 +1686,12 @@ impl WeightInfo for () { /// The range of component `n` is `[0, 16384]`. fn seal_set_storage_per_old_byte(n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `245 + n * (1 ±0)` - // Estimated: `245 + n * (1 ±0)` - // Minimum execution time: 56_000_000 picoseconds. - Weight::from_parts(63_900_000, 245) - // Standard Error: 93 - .saturating_add(Weight::from_parts(48, 0).saturating_mul(n.into())) + // Measured: `248 + n * (1 ±0)` + // Estimated: `248 + n * (1 ±0)` + // Minimum execution time: 7_878_000 picoseconds. + Weight::from_parts(9_291_579, 248) + // Standard Error: 2 + .saturating_add(Weight::from_parts(78, 0).saturating_mul(n.into())) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) @@ -1683,12 +1701,12 @@ impl WeightInfo for () { /// The range of component `n` is `[0, 16384]`. fn seal_clear_storage(n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `245 + n * (1 ±0)` - // Estimated: `245 + n * (1 ±0)` - // Minimum execution time: 55_000_000 picoseconds. - Weight::from_parts(61_100_000, 245) - // Standard Error: 113 - .saturating_add(Weight::from_parts(708, 0).saturating_mul(n.into())) + // Measured: `248 + n * (1 ±0)` + // Estimated: `248 + n * (1 ±0)` + // Minimum execution time: 8_068_000 picoseconds. + Weight::from_parts(9_253_255, 248) + // Standard Error: 2 + .saturating_add(Weight::from_parts(80, 0).saturating_mul(n.into())) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) @@ -1698,12 +1716,12 @@ impl WeightInfo for () { /// The range of component `n` is `[0, 16384]`. fn seal_get_storage(n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `245 + n * (1 ±0)` - // Estimated: `245 + n * (1 ±0)` - // Minimum execution time: 53_000_000 picoseconds. - Weight::from_parts(61_800_000, 245) - // Standard Error: 160 - .saturating_add(Weight::from_parts(1_196, 0).saturating_mul(n.into())) + // Measured: `248 + n * (1 ±0)` + // Estimated: `248 + n * (1 ±0)` + // Minimum execution time: 7_316_000 picoseconds. + Weight::from_parts(9_096_691, 248) + // Standard Error: 3 + .saturating_add(Weight::from_parts(706, 0).saturating_mul(n.into())) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) } @@ -1712,12 +1730,12 @@ impl WeightInfo for () { /// The range of component `n` is `[0, 16384]`. fn seal_contains_storage(n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `245 + n * (1 ±0)` - // Estimated: `245 + n * (1 ±0)` - // Minimum execution time: 51_000_000 picoseconds. - Weight::from_parts(58_500_000, 245) - // Standard Error: 80 - .saturating_add(Weight::from_parts(299, 0).saturating_mul(n.into())) + // Measured: `248 + n * (1 ±0)` + // Estimated: `248 + n * (1 ±0)` + // Minimum execution time: 6_660_000 picoseconds. + Weight::from_parts(8_029_136, 248) + // Standard Error: 2 + .saturating_add(Weight::from_parts(85, 0).saturating_mul(n.into())) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) } @@ -1726,12 +1744,12 @@ impl WeightInfo for () { /// The range of component `n` is `[0, 16384]`. fn seal_take_storage(n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `245 + n * (1 ±0)` - // Estimated: `245 + n * (1 ±0)` - // Minimum execution time: 57_000_000 picoseconds. - Weight::from_parts(66_300_000, 245) - // Standard Error: 188 - .saturating_add(Weight::from_parts(1_110, 0).saturating_mul(n.into())) + // Measured: `248 + n * (1 ±0)` + // Estimated: `248 + n * (1 ±0)` + // Minimum execution time: 8_497_000 picoseconds. + Weight::from_parts(10_287_954, 248) + // Standard Error: 3 + .saturating_add(Weight::from_parts(699, 0).saturating_mul(n.into())) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) @@ -1742,8 +1760,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `140` // Estimated: `3605` - // Minimum execution time: 99_000_000 picoseconds. - Weight::from_parts(102_000_000, 3605) + // Minimum execution time: 9_337_000 picoseconds. + Weight::from_parts(9_882_000, 3605) .saturating_add(RocksDbWeight::get().reads(1_u64)) } /// Storage: `Contracts::ContractInfoOf` (r:1 w:2) @@ -1758,24 +1776,26 @@ impl WeightInfo for () { /// Proof: `Parameters::Parameters` (`max_values`: None, `max_size`: Some(36), added: 2511, mode: `Measured`) /// Storage: `System::EventTopics` (r:2 w:2) /// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`) - /// The range of component `c` is `[0, 1]`. /// The range of component `t` is `[0, 1]`. + /// The range of component `c` is `[0, 1]`. /// The range of component `i` is `[0, 1048576]`. - fn seal_call(c: u32, t: u32, _i: u32, ) -> Weight { + fn seal_call(t: u32, c: u32, i: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `623 + t * (280 ±0)` - // Estimated: `6563 + t * (3421 ±0)` - // Minimum execution time: 1_604_000_000 picoseconds. - Weight::from_parts(1_723_533_333, 6563) - // Standard Error: 18_493_246 - .saturating_add(Weight::from_parts(15_933_333, 0).saturating_mul(c.into())) - // Standard Error: 18_493_246 - .saturating_add(Weight::from_parts(414_233_333, 0).saturating_mul(t.into())) + // Estimated: `6563 + t * (3422 ±0)` + // Minimum execution time: 172_292_000 picoseconds. + Weight::from_parts(167_185_817, 6563) + // Standard Error: 327_522 + .saturating_add(Weight::from_parts(44_974_443, 0).saturating_mul(t.into())) + // Standard Error: 327_522 + .saturating_add(Weight::from_parts(4_283_151, 0).saturating_mul(c.into())) + // Standard Error: 0 + .saturating_add(Weight::from_parts(11, 0).saturating_mul(i.into())) .saturating_add(RocksDbWeight::get().reads(7_u64)) .saturating_add(RocksDbWeight::get().reads((2_u64).saturating_mul(t.into()))) .saturating_add(RocksDbWeight::get().writes(4_u64)) .saturating_add(RocksDbWeight::get().writes((2_u64).saturating_mul(t.into()))) - .saturating_add(Weight::from_parts(0, 3421).saturating_mul(t.into())) + .saturating_add(Weight::from_parts(0, 3422).saturating_mul(t.into())) } /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) @@ -1791,8 +1811,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `433` // Estimated: `6373` - // Minimum execution time: 1_524_000_000 picoseconds. - Weight::from_parts(1_558_000_000, 6373) + // Minimum execution time: 161_490_000 picoseconds. + Weight::from_parts(170_939_000, 6373) .saturating_add(RocksDbWeight::get().reads(6_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) } @@ -1815,85 +1835,83 @@ impl WeightInfo for () { /// The range of component `s` is `[0, 983040]`. fn seal_instantiate(t: u32, i: u32, s: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `627 + t * (102 ±0)` - // Estimated: `6567 + t * (2577 ±0)` - // Minimum execution time: 3_863_000_000 picoseconds. - Weight::from_parts(2_236_566_666, 6567) - // Standard Error: 41_979_515 - .saturating_add(Weight::from_parts(469_166_666, 0).saturating_mul(t.into())) - // Standard Error: 42 - .saturating_add(Weight::from_parts(1_417, 0).saturating_mul(i.into())) - // Standard Error: 42 - .saturating_add(Weight::from_parts(1_492, 0).saturating_mul(s.into())) + // Measured: `679 + t * (102 ±0)` + // Estimated: `6616 + t * (2565 ±1)` + // Minimum execution time: 1_819_574_000 picoseconds. + Weight::from_parts(1_829_348_000, 6616) + // Standard Error: 14 + .saturating_add(Weight::from_parts(731, 0).saturating_mul(i.into())) + // Standard Error: 14 + .saturating_add(Weight::from_parts(1_005, 0).saturating_mul(s.into())) .saturating_add(RocksDbWeight::get().reads(10_u64)) .saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(t.into()))) .saturating_add(RocksDbWeight::get().writes(7_u64)) .saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(t.into()))) - .saturating_add(Weight::from_parts(0, 2577).saturating_mul(t.into())) + .saturating_add(Weight::from_parts(0, 2565).saturating_mul(t.into())) } /// The range of component `n` is `[0, 1048576]`. fn seal_hash_sha2_256(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 8_000_000 picoseconds. - Weight::from_parts(13_000_000, 0) - // Standard Error: 13 - .saturating_add(Weight::from_parts(3_238, 0).saturating_mul(n.into())) + // Minimum execution time: 894_000 picoseconds. + Weight::from_parts(941_000, 0) + // Standard Error: 0 + .saturating_add(Weight::from_parts(1_151, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 1048576]`. fn seal_hash_keccak_256(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 9_000_000 picoseconds. - Weight::from_parts(12_900_000, 0) - // Standard Error: 16 - .saturating_add(Weight::from_parts(4_844, 0).saturating_mul(n.into())) + // Minimum execution time: 1_359_000 picoseconds. + Weight::from_parts(1_403_000, 0) + // Standard Error: 0 + .saturating_add(Weight::from_parts(3_410, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 1048576]`. fn seal_hash_blake2_256(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 5_000_000 picoseconds. - Weight::from_parts(6_000_000, 0) - // Standard Error: 5 - .saturating_add(Weight::from_parts(1_190, 0).saturating_mul(n.into())) + // Minimum execution time: 727_000 picoseconds. + Weight::from_parts(762_000, 0) + // Standard Error: 0 + .saturating_add(Weight::from_parts(1_280, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 1048576]`. fn seal_hash_blake2_128(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 5_000_000 picoseconds. - Weight::from_parts(5_600_000, 0) - // Standard Error: 4 - .saturating_add(Weight::from_parts(1_165, 0).saturating_mul(n.into())) + // Minimum execution time: 772_000 picoseconds. + Weight::from_parts(799_000, 0) + // Standard Error: 0 + .saturating_add(Weight::from_parts(1_279, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 125697]`. fn seal_sr25519_verify(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 58_000_000 picoseconds. - Weight::from_parts(63_500_000, 0) - // Standard Error: 39 - .saturating_add(Weight::from_parts(7_818, 0).saturating_mul(n.into())) + // Minimum execution time: 43_237_000 picoseconds. + Weight::from_parts(44_351_784, 0) + // Standard Error: 8 + .saturating_add(Weight::from_parts(4_756, 0).saturating_mul(n.into())) } fn seal_ecdsa_recover() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 312_000_000 picoseconds. - Weight::from_parts(329_000_000, 0) + // Minimum execution time: 48_204_000 picoseconds. + Weight::from_parts(49_920_000, 0) } fn seal_ecdsa_to_eth_address() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 16_000_000 picoseconds. - Weight::from_parts(19_000_000, 0) + // Minimum execution time: 12_997_000 picoseconds. + Weight::from_parts(13_237_000, 0) } /// Storage: `Contracts::CodeInfoOf` (r:1 w:1) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) @@ -1907,8 +1925,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `433` // Estimated: `6373` - // Minimum execution time: 309_000_000 picoseconds. - Weight::from_parts(332_000_000, 6373) + // Minimum execution time: 31_613_000 picoseconds. + Weight::from_parts(32_976_000, 6373) .saturating_add(RocksDbWeight::get().reads(6_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) } @@ -1918,8 +1936,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `355` // Estimated: `3820` - // Minimum execution time: 80_000_000 picoseconds. - Weight::from_parts(86_000_000, 3820) + // Minimum execution time: 9_330_000 picoseconds. + Weight::from_parts(9_933_000, 3820) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -1929,8 +1947,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `355` // Estimated: `3558` - // Minimum execution time: 66_000_000 picoseconds. - Weight::from_parts(69_000_000, 3558) + // Minimum execution time: 8_203_000 picoseconds. + Weight::from_parts(8_645_000, 3558) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -1938,15 +1956,15 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_000_000 picoseconds. - Weight::from_parts(3_000_000, 0) + // Minimum execution time: 283_000 picoseconds. + Weight::from_parts(342_000, 0) } fn seal_account_reentrance_count() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_000_000 picoseconds. - Weight::from_parts(3_000_000, 0) + // Minimum execution time: 312_000 picoseconds. + Weight::from_parts(376_000, 0) } /// Storage: `Contracts::Nonce` (r:1 w:0) /// Proof: `Contracts::Nonce` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`) @@ -1954,8 +1972,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `219` // Estimated: `1704` - // Minimum execution time: 26_000_000 picoseconds. - Weight::from_parts(28_000_000, 1704) + // Minimum execution time: 2_996_000 picoseconds. + Weight::from_parts(3_180_000, 1704) .saturating_add(RocksDbWeight::get().reads(1_u64)) } /// The range of component `r` is `[0, 5000]`. @@ -1963,9 +1981,9 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 5_000_000 picoseconds. - Weight::from_parts(6_000_000, 0) - // Standard Error: 557 - .saturating_add(Weight::from_parts(75_560, 0).saturating_mul(r.into())) + // Minimum execution time: 1_200_000 picoseconds. + Weight::from_parts(1_007_275, 0) + // Standard Error: 18 + .saturating_add(Weight::from_parts(15_124, 0).saturating_mul(r.into())) } } From c2cd3657b076da919c22d0abc087411815ed68f2 Mon Sep 17 00:00:00 2001 From: pgherveou Date: Mon, 29 Apr 2024 09:30:11 +0200 Subject: [PATCH 11/34] Fixes --- substrate/frame/contracts/proc-macro/src/lib.rs | 2 -- substrate/frame/contracts/src/benchmarking/call_builder.rs | 3 ++- substrate/frame/contracts/src/benchmarking/mod.rs | 7 +++++-- 3 files changed, 7 insertions(+), 5 deletions(-) diff --git a/substrate/frame/contracts/proc-macro/src/lib.rs b/substrate/frame/contracts/proc-macro/src/lib.rs index f23827e87a5b..356b42268da6 100644 --- a/substrate/frame/contracts/proc-macro/src/lib.rs +++ b/substrate/frame/contracts/proc-macro/src/lib.rs @@ -541,8 +541,6 @@ fn expand_impls(def: &EnvDef) -> TokenStream2 { let dummy_impls = expand_functions(def, ExpandMode::MockImpl); let bench_impls = expand_functions(def, ExpandMode::BenchImpl); - std::fs::write("/tmp/impls.rs", format!("{}", impls)).unwrap(); - quote! { impl<'a, E: Ext> crate::wasm::Environment> for Env { diff --git a/substrate/frame/contracts/src/benchmarking/call_builder.rs b/substrate/frame/contracts/src/benchmarking/call_builder.rs index 0297eb91a77c..5a0a043b2e7a 100644 --- a/substrate/frame/contracts/src/benchmarking/call_builder.rs +++ b/substrate/frame/contracts/src/benchmarking/call_builder.rs @@ -181,7 +181,8 @@ macro_rules! build_runtime( ($runtime:ident, $contract:ident) => { let mut setup = CallSetup::::default(); let $contract = setup.contract(); + let input = setup.data(); let (mut ext, _) = setup.ext(); - let mut $runtime = crate::wasm::Runtime::new(&mut ext, vec![]); + let mut $runtime = crate::wasm::Runtime::new(&mut ext, input); }; ); diff --git a/substrate/frame/contracts/src/benchmarking/mod.rs b/substrate/frame/contracts/src/benchmarking/mod.rs index 6fd9308bfeaf..d3796cacaaed 100644 --- a/substrate/frame/contracts/src/benchmarking/mod.rs +++ b/substrate/frame/contracts/src/benchmarking/mod.rs @@ -858,14 +858,17 @@ mod benchmarks { #[benchmark(pov_mode = Measured)] fn seal_input(n: Linear<0, { code::max_pages::() * 64 * 1024 - 4 }>) { - build_runtime!(runtime, memory: [n.to_le_bytes(), vec![42u8; n as usize], ]); - + let mut setup = CallSetup::::default(); + let (mut ext, _) = setup.ext(); + let mut runtime = crate::wasm::Runtime::new(&mut ext, vec![42u8; n as usize]); + let mut memory = memory!(n.to_le_bytes(), vec![0u8; n as usize],); let result; #[block] { result = BenchEnv::seal0_input(&mut runtime, &mut memory, 4, 0) } assert_ok!(result); + assert_eq!(&memory[4..], &vec![42u8; n as usize]); } #[benchmark(pov_mode = Measured)] From 19fb7bf4aec04cb5901acf7ab761dc02c8ed5980 Mon Sep 17 00:00:00 2001 From: pgherveou Date: Mon, 29 Apr 2024 09:36:15 +0200 Subject: [PATCH 12/34] fix --- substrate/frame/contracts/src/benchmarking/mod.rs | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/substrate/frame/contracts/src/benchmarking/mod.rs b/substrate/frame/contracts/src/benchmarking/mod.rs index d3796cacaaed..95256e78a7f0 100644 --- a/substrate/frame/contracts/src/benchmarking/mod.rs +++ b/substrate/frame/contracts/src/benchmarking/mod.rs @@ -613,9 +613,8 @@ mod benchmarks { #[benchmark(pov_mode = Measured)] fn noop_host_fn(r: Linear<0, API_BENCHMARK_RUNS>) { let mut setup = CallSetup::::new(WasmModule::noop(r)); - let data = setup.data(); let (mut ext, module) = setup.ext(); - let func = CallSetup::::prepare_call(&mut ext, module, data); + let func = CallSetup::::prepare_call(&mut ext, module, vec![]); #[block] { func.call(); From 5edcd1839c5069ff31855221b8422ce8cfebdfd0 Mon Sep 17 00:00:00 2001 From: pgherveou Date: Mon, 29 Apr 2024 11:22:06 +0200 Subject: [PATCH 13/34] Rm unused --- substrate/frame/contracts/src/wasm/runtime.rs | 35 +- substrate/frame/contracts/src/weights.rs | 990 +++++++++--------- 2 files changed, 502 insertions(+), 523 deletions(-) diff --git a/substrate/frame/contracts/src/wasm/runtime.rs b/substrate/frame/contracts/src/wasm/runtime.rs index 19021f7309c7..1d425f0cd331 100644 --- a/substrate/frame/contracts/src/wasm/runtime.rs +++ b/substrate/frame/contracts/src/wasm/runtime.rs @@ -185,10 +185,6 @@ pub enum RuntimeCosts { Now, /// Weight of calling `seal_weight_to_fee`. WeightToFee, - /// Weight of calling `seal_input` without the weight of copying the input. - InputBase, - /// Weight of calling `seal_return` for the given output size. - Return(u32), /// Weight of calling `seal_terminate`. Terminate, /// Weight of calling `seal_random`. It includes the weight for copying the subject. @@ -214,13 +210,13 @@ pub enum RuntimeCosts { /// Weight of calling `seal_delegate_call` for the given input size. DelegateCallBase, /// Weight of the transfer performed during a call. - CallSurchargeTransfer, + CallTransferSurcharge, /// Weight per byte that is cloned by supplying the `CLONE_INPUT` flag. CallInputCloned(u32), /// Weight of calling `seal_instantiate` for the given input length and salt. InstantiateBase { input_data_len: u32, salt_len: u32 }, /// Weight of the transfer performed during an instantiate. - InstantiateSurchargeTransfer, + InstantiateTransferSurcharge, /// Weight of calling `seal_hash_sha_256` for the given input size. HashSha256(u32), /// Weight of calling `seal_hash_keccak_256` for the given input size. @@ -244,9 +240,9 @@ pub enum RuntimeCosts { /// Weight of calling `ecdsa_to_eth_address` EcdsaToEthAddress, /// Weight of calling `reentrance_count` - ReentrantCount, + ReentranceCount, /// Weight of calling `account_reentrance_count` - AccountEntranceCount, + AccountReentranceCount, /// Weight of calling `instantiation_nonce` InstantiationNonce, /// Weight of calling `lock_delegate_dependency` @@ -280,8 +276,8 @@ impl Token for RuntimeCosts { use self::RuntimeCosts::*; match *self { HostFn => cost_args!(noop_host_fn, 1), + CopyToContract(len) => T::WeightInfo::seal_input(len), CopyFromContract(len) => T::WeightInfo::seal_return(len), - CopyToContract(len) => cost_args!(seal_input, len), Caller => T::WeightInfo::seal_caller(), IsContract => T::WeightInfo::seal_is_contract(), CodeHash => T::WeightInfo::seal_code_hash(), @@ -296,8 +292,6 @@ impl Token for RuntimeCosts { BlockNumber => T::WeightInfo::seal_block_number(), Now => T::WeightInfo::seal_now(), WeightToFee => T::WeightInfo::seal_weight_to_fee(), - InputBase => T::WeightInfo::seal_input(0), - Return(len) => T::WeightInfo::seal_return(len), Terminate => T::WeightInfo::seal_terminate(), Random => T::WeightInfo::seal_random(), DepositEvent { num_topic, len } => T::WeightInfo::seal_deposit_event(num_topic, len), @@ -312,11 +306,11 @@ impl Token for RuntimeCosts { Transfer => T::WeightInfo::seal_transfer(), CallBase => T::WeightInfo::seal_call(0, 0, 0), DelegateCallBase => T::WeightInfo::seal_delegate_call(), - CallSurchargeTransfer => cost_args!(seal_call, 1, 0, 0), + CallTransferSurcharge => cost_args!(seal_call, 1, 0, 0), CallInputCloned(len) => cost_args!(seal_call, 0, 1, len), InstantiateBase { input_data_len, salt_len } => T::WeightInfo::seal_instantiate(0, input_data_len, salt_len), - InstantiateSurchargeTransfer => cost_args!(seal_instantiate, 1, 0, 0), + InstantiateTransferSurcharge => cost_args!(seal_instantiate, 1, 0, 0), HashSha256(len) => T::WeightInfo::seal_hash_sha2_256(len), HashKeccak256(len) => T::WeightInfo::seal_hash_keccak_256(len), HashBlake256(len) => T::WeightInfo::seal_hash_blake2_256(len), @@ -326,8 +320,8 @@ impl Token for RuntimeCosts { ChainExtension(weight) | CallRuntime(weight) | CallXcmExecute(weight) => weight, SetCodeHash => T::WeightInfo::seal_set_code_hash(), EcdsaToEthAddress => T::WeightInfo::seal_ecdsa_to_eth_address(), - ReentrantCount => T::WeightInfo::seal_reentrance_count(), - AccountEntranceCount => T::WeightInfo::seal_account_reentrance_count(), + ReentranceCount => T::WeightInfo::seal_reentrance_count(), + AccountReentranceCount => T::WeightInfo::seal_account_reentrance_count(), InstantiationNonce => T::WeightInfo::seal_instantiation_nonce(), LockDelegateDependency => T::WeightInfo::lock_delegate_dependency(), UnlockDelegateDependency => T::WeightInfo::unlock_delegate_dependency(), @@ -862,7 +856,7 @@ impl<'a, E: Ext + 'a> Runtime<'a, E> { let value: BalanceOf<::T> = self.read_sandbox_memory_as(memory, value_ptr)?; if value > 0u32.into() { - self.charge_gas(RuntimeCosts::CallSurchargeTransfer)?; + self.charge_gas(RuntimeCosts::CallTransferSurcharge)?; } self.ext.call( weight, @@ -930,7 +924,7 @@ impl<'a, E: Ext + 'a> Runtime<'a, E> { }; let value: BalanceOf<::T> = self.read_sandbox_memory_as(memory, value_ptr)?; if value > 0u32.into() { - self.charge_gas(RuntimeCosts::InstantiateSurchargeTransfer)?; + self.charge_gas(RuntimeCosts::InstantiateTransferSurcharge)?; } let code_hash: CodeHash<::T> = self.read_sandbox_memory_as(memory, code_hash_ptr)?; @@ -1415,7 +1409,6 @@ pub mod env { /// See [`pallet_contracts_uapi::HostFn::input`]. #[prefixed_alias] fn input(ctx: _, memory: _, out_ptr: u32, out_len_ptr: u32) -> Result<(), TrapReason> { - ctx.charge_gas(RuntimeCosts::InputBase)?; if let Some(input) = ctx.input_data.take() { ctx.write_sandbox_output(memory, out_ptr, out_len_ptr, &input, false, |len| { Some(RuntimeCosts::CopyToContract(len)) @@ -1436,7 +1429,7 @@ pub mod env { data_ptr: u32, data_len: u32, ) -> Result<(), TrapReason> { - ctx.charge_gas(RuntimeCosts::Return(data_len))?; + ctx.charge_gas(RuntimeCosts::CopyFromContract(data_len))?; Err(TrapReason::Return(ReturnData { flags, data: ctx.read_sandbox_memory(memory, data_ptr, data_len)?, @@ -2278,7 +2271,7 @@ pub mod env { /// See [`pallet_contracts_uapi::HostFn::reentrance_count`]. #[unstable] fn reentrance_count(ctx: _, memory: _) -> Result { - ctx.charge_gas(RuntimeCosts::ReentrantCount)?; + ctx.charge_gas(RuntimeCosts::ReentranceCount)?; Ok(ctx.ext.reentrance_count()) } @@ -2287,7 +2280,7 @@ pub mod env { /// See [`pallet_contracts_uapi::HostFn::account_reentrance_count`]. #[unstable] fn account_reentrance_count(ctx: _, memory: _, account_ptr: u32) -> Result { - ctx.charge_gas(RuntimeCosts::AccountEntranceCount)?; + ctx.charge_gas(RuntimeCosts::AccountReentranceCount)?; let account_id: <::T as frame_system::Config>::AccountId = ctx.read_sandbox_memory_as(memory, account_ptr)?; Ok(ctx.ext.account_reentrance_count(&account_id)) diff --git a/substrate/frame/contracts/src/weights.rs b/substrate/frame/contracts/src/weights.rs index ec9f7e841aae..afcb2f29c217 100644 --- a/substrate/frame/contracts/src/weights.rs +++ b/substrate/frame/contracts/src/weights.rs @@ -1,42 +1,24 @@ -// This file is part of Substrate. - -// Copyright (C) Parity Technologies (UK) Ltd. -// SPDX-License-Identifier: Apache-2.0 - -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. //! Autogenerated weights for `pallet_contracts` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 32.0.0 -//! DATE: 2024-04-29, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2024-04-29, STEPS: `2`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` -//! HOSTNAME: `runner-dcu62vjg-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz` -//! WASM-EXECUTION: `Compiled`, CHAIN: `Some("dev")`, DB CACHE: `1024` +//! HOSTNAME: `pgs-laptop.lan`, CPU: `` +//! WASM-EXECUTION: `Compiled`, CHAIN: `None`, DB CACHE: `1024` // Executed Command: -// target/production/substrate-node +// target/debug/substrate-node // benchmark // pallet -// --steps=50 -// --repeat=20 -// --extrinsic=* -// --wasm-execution=compiled -// --heap-pages=4096 -// --json-file=/builds/parity/mirrors/polkadot-sdk/.git/.artifacts/bench.json -// --pallet=pallet_contracts -// --chain=dev -// --header=./substrate/HEADER-APACHE2 -// --output=./substrate/frame/contracts/src/weights.rs +// --steps +// 2 +// -p +// pallet_contracts +// -e +// * +// --output +// substrate/frame/contracts/src/weights.rs // --template=./substrate/.maintain/frame-weight-template.hbs #![cfg_attr(rustfmt, rustfmt_skip)] @@ -128,8 +110,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `142` // Estimated: `1627` - // Minimum execution time: 1_998_000 picoseconds. - Weight::from_parts(2_105_000, 1627) + // Minimum execution time: 20_000_000 picoseconds. + Weight::from_parts(21_000_000, 1627) .saturating_add(T::DbWeight::get().reads(1_u64)) } /// Storage: `Skipped::Metadata` (r:0 w:0) @@ -137,12 +119,12 @@ impl WeightInfo for SubstrateWeight { /// The range of component `k` is `[0, 1024]`. fn on_initialize_per_trie_key(k: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `452 + k * (69 ±0)` - // Estimated: `442 + k * (70 ±0)` - // Minimum execution time: 12_810_000 picoseconds. - Weight::from_parts(13_041_000, 442) - // Standard Error: 1_980 - .saturating_add(Weight::from_parts(1_186_675, 0).saturating_mul(k.into())) + // Measured: `318 + k * (69 ±0)` + // Estimated: `318 + k * (70 ±0)` + // Minimum execution time: 104_000_000 picoseconds. + Weight::from_parts(104_700_000, 318) + // Standard Error: 34_890 + .saturating_add(Weight::from_parts(7_380_175, 0).saturating_mul(k.into())) .saturating_add(T::DbWeight::get().reads(2_u64)) .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(k.into()))) .saturating_add(T::DbWeight::get().writes(2_u64)) @@ -154,12 +136,12 @@ impl WeightInfo for SubstrateWeight { /// The range of component `c` is `[0, 125952]`. fn v9_migration_step(c: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `211 + c * (1 ±0)` - // Estimated: `6149 + c * (1 ±0)` - // Minimum execution time: 8_141_000 picoseconds. - Weight::from_parts(8_750_889, 6149) - // Standard Error: 1 - .saturating_add(Weight::from_parts(1_220, 0).saturating_mul(c.into())) + // Measured: `203 + c * (1 ±0)` + // Estimated: `6143 + c * (1 ±0)` + // Minimum execution time: 90_000_000 picoseconds. + Weight::from_parts(91_600_000, 6143) + // Standard Error: 7 + .saturating_add(Weight::from_parts(656, 0).saturating_mul(c.into())) .saturating_add(T::DbWeight::get().reads(2_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(c.into())) @@ -172,8 +154,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `510` // Estimated: `6450` - // Minimum execution time: 16_836_000 picoseconds. - Weight::from_parts(17_922_000, 6450) + // Minimum execution time: 149_000_000 picoseconds. + Weight::from_parts(161_000_000, 6450) .saturating_add(T::DbWeight::get().reads(3_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -184,14 +166,14 @@ impl WeightInfo for SubstrateWeight { /// The range of component `k` is `[0, 1024]`. fn v11_migration_step(k: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `171 + k * (1 ±0)` - // Estimated: `3635 + k * (1 ±0)` - // Minimum execution time: 3_422_000 picoseconds. - Weight::from_parts(3_488_000, 3635) - // Standard Error: 1_035 - .saturating_add(Weight::from_parts(1_215_499, 0).saturating_mul(k.into())) + // Measured: `166 + k * (1 ±0)` + // Estimated: `3631 + k * (1 ±0)` + // Minimum execution time: 32_000_000 picoseconds. + Weight::from_parts(33_299_999, 3631) + // Standard Error: 40_858 + .saturating_add(Weight::from_parts(15_348_925, 0).saturating_mul(k.into())) .saturating_add(T::DbWeight::get().reads(1_u64)) - .saturating_add(T::DbWeight::get().writes(2_u64)) + .saturating_add(T::DbWeight::get().writes(1_u64)) .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(k.into()))) .saturating_add(Weight::from_parts(0, 1).saturating_mul(k.into())) } @@ -208,12 +190,12 @@ impl WeightInfo for SubstrateWeight { /// The range of component `c` is `[0, 125952]`. fn v12_migration_step(c: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `328 + c * (1 ±0)` - // Estimated: `6266 + c * (1 ±0)` - // Minimum execution time: 20_859_000 picoseconds. - Weight::from_parts(21_212_479, 6266) - // Standard Error: 0 - .saturating_add(Weight::from_parts(459, 0).saturating_mul(c.into())) + // Measured: `320 + c * (1 ±0)` + // Estimated: `6260 + c * (1 ±0)` + // Minimum execution time: 205_000_000 picoseconds. + Weight::from_parts(206_400_000, 6260) + // Standard Error: 6 + .saturating_add(Weight::from_parts(304, 0).saturating_mul(c.into())) .saturating_add(T::DbWeight::get().reads(6_u64)) .saturating_add(T::DbWeight::get().writes(2_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(c.into())) @@ -224,8 +206,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `440` // Estimated: `6380` - // Minimum execution time: 12_941_000 picoseconds. - Weight::from_parts(13_701_000, 6380) + // Minimum execution time: 109_000_000 picoseconds. + Weight::from_parts(111_000_000, 6380) .saturating_add(T::DbWeight::get().reads(2_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -239,8 +221,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `352` // Estimated: `6292` - // Minimum execution time: 46_900_000 picoseconds. - Weight::from_parts(48_164_000, 6292) + // Minimum execution time: 492_000_000 picoseconds. + Weight::from_parts(513_000_000, 6292) .saturating_add(T::DbWeight::get().reads(4_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -252,8 +234,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `594` // Estimated: `6534` - // Minimum execution time: 56_096_000 picoseconds. - Weight::from_parts(57_603_000, 6534) + // Minimum execution time: 433_000_000 picoseconds. + Weight::from_parts(471_000_000, 6534) .saturating_add(T::DbWeight::get().reads(4_u64)) .saturating_add(T::DbWeight::get().writes(2_u64)) } @@ -263,8 +245,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `409` // Estimated: `6349` - // Minimum execution time: 12_147_000 picoseconds. - Weight::from_parts(12_960_000, 6349) + // Minimum execution time: 108_000_000 picoseconds. + Weight::from_parts(110_000_000, 6349) .saturating_add(T::DbWeight::get().reads(2_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -274,8 +256,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `142` // Estimated: `1627` - // Minimum execution time: 2_436_000 picoseconds. - Weight::from_parts(2_697_000, 1627) + // Minimum execution time: 23_000_000 picoseconds. + Weight::from_parts(24_000_000, 1627) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -287,8 +269,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `166` // Estimated: `3631` - // Minimum execution time: 11_674_000 picoseconds. - Weight::from_parts(12_277_000, 3631) + // Minimum execution time: 119_000_000 picoseconds. + Weight::from_parts(147_000_000, 3631) .saturating_add(T::DbWeight::get().reads(2_u64)) .saturating_add(T::DbWeight::get().writes(2_u64)) } @@ -298,8 +280,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `142` // Estimated: `3607` - // Minimum execution time: 4_717_000 picoseconds. - Weight::from_parts(5_008_000, 3607) + // Minimum execution time: 42_000_000 picoseconds. + Weight::from_parts(43_000_000, 3607) .saturating_add(T::DbWeight::get().reads(1_u64)) } /// Storage: UNKNOWN KEY `0x4342193e496fab7ec59d615ed0dc55304e7b9012096b41c4eb3aaf947f6ea429` (r:1 w:0) @@ -310,8 +292,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `167` // Estimated: `3632` - // Minimum execution time: 5_954_000 picoseconds. - Weight::from_parts(6_331_000, 3632) + // Minimum execution time: 56_000_000 picoseconds. + Weight::from_parts(58_000_000, 3632) .saturating_add(T::DbWeight::get().reads(2_u64)) } /// Storage: UNKNOWN KEY `0x4342193e496fab7ec59d615ed0dc55304e7b9012096b41c4eb3aaf947f6ea429` (r:1 w:0) @@ -322,8 +304,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `142` // Estimated: `3607` - // Minimum execution time: 6_061_000 picoseconds. - Weight::from_parts(6_600_000, 3607) + // Minimum execution time: 56_000_000 picoseconds. + Weight::from_parts(57_000_000, 3607) .saturating_add(T::DbWeight::get().reads(2_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -346,12 +328,12 @@ impl WeightInfo for SubstrateWeight { /// The range of component `c` is `[0, 125952]`. fn call_with_code_per_byte(c: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `804 + c * (1 ±0)` - // Estimated: `9217 + c * (1 ±0)` - // Minimum execution time: 370_504_000 picoseconds. - Weight::from_parts(345_076_763, 9217) - // Standard Error: 96 - .saturating_add(Weight::from_parts(34_235, 0).saturating_mul(c.into())) + // Measured: `832` + // Estimated: `9247 + c * (1 ±0)` + // Minimum execution time: 2_222_000_000 picoseconds. + Weight::from_parts(2_246_800_000, 9247) + // Standard Error: 194 + .saturating_add(Weight::from_parts(78_581, 0).saturating_mul(c.into())) .saturating_add(T::DbWeight::get().reads(11_u64)) .saturating_add(T::DbWeight::get().writes(4_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(c.into())) @@ -381,16 +363,16 @@ 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: `326` - // Estimated: `8740` - // Minimum execution time: 4_359_896_000 picoseconds. - Weight::from_parts(481_322_438, 8740) - // Standard Error: 225 - .saturating_add(Weight::from_parts(70_837, 0).saturating_mul(c.into())) - // Standard Error: 27 - .saturating_add(Weight::from_parts(1_888, 0).saturating_mul(i.into())) - // Standard Error: 27 - .saturating_add(Weight::from_parts(1_957, 0).saturating_mul(s.into())) + // Measured: `443` + // Estimated: `8858` + // Minimum execution time: 8_001_000_000 picoseconds. + Weight::from_parts(4_996_600_018, 8858) + // Standard Error: 606 + .saturating_add(Weight::from_parts(158_819, 0).saturating_mul(c.into())) + // Standard Error: 72 + .saturating_add(Weight::from_parts(1_394, 0).saturating_mul(i.into())) + // Standard Error: 72 + .saturating_add(Weight::from_parts(1_681, 0).saturating_mul(s.into())) .saturating_add(T::DbWeight::get().reads(14_u64)) .saturating_add(T::DbWeight::get().writes(10_u64)) } @@ -418,14 +400,14 @@ 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: `563` - // Estimated: `8982` - // Minimum execution time: 2_128_155_000 picoseconds. - Weight::from_parts(2_147_287_000, 8982) - // Standard Error: 27 - .saturating_add(Weight::from_parts(964, 0).saturating_mul(i.into())) - // Standard Error: 27 - .saturating_add(Weight::from_parts(822, 0).saturating_mul(s.into())) + // Measured: `615` + // Estimated: `9030` + // Minimum execution time: 4_452_000_000 picoseconds. + Weight::from_parts(3_312_250_000, 9030) + // Standard Error: 24 + .saturating_add(Weight::from_parts(1_571, 0).saturating_mul(i.into())) + // Standard Error: 24 + .saturating_add(Weight::from_parts(1_133, 0).saturating_mul(s.into())) .saturating_add(T::DbWeight::get().reads(13_u64)) .saturating_add(T::DbWeight::get().writes(7_u64)) } @@ -449,8 +431,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `829` // Estimated: `9244` - // Minimum execution time: 214_463_000 picoseconds. - Weight::from_parts(225_091_000, 9244) + // Minimum execution time: 2_150_000_000 picoseconds. + Weight::from_parts(2_237_000_000, 9244) .saturating_add(T::DbWeight::get().reads(11_u64)) .saturating_add(T::DbWeight::get().writes(4_u64)) } @@ -471,10 +453,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `145` // Estimated: `6085` - // Minimum execution time: 339_390_000 picoseconds. - Weight::from_parts(334_232_549, 6085) - // Standard Error: 76 - .saturating_add(Weight::from_parts(33_541, 0).saturating_mul(c.into())) + // Minimum execution time: 1_943_000_000 picoseconds. + Weight::from_parts(2_061_000_000, 6085) + // Standard Error: 425 + .saturating_add(Weight::from_parts(80_155, 0).saturating_mul(c.into())) .saturating_add(T::DbWeight::get().reads(6_u64)) .saturating_add(T::DbWeight::get().writes(4_u64)) } @@ -495,10 +477,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `145` // Estimated: `6085` - // Minimum execution time: 351_953_000 picoseconds. - Weight::from_parts(343_509_628, 6085) - // Standard Error: 88 - .saturating_add(Weight::from_parts(34_147, 0).saturating_mul(c.into())) + // Minimum execution time: 2_143_000_000 picoseconds. + Weight::from_parts(2_231_100_000, 6085) + // Standard Error: 246 + .saturating_add(Weight::from_parts(79_070, 0).saturating_mul(c.into())) .saturating_add(T::DbWeight::get().reads(6_u64)) .saturating_add(T::DbWeight::get().writes(4_u64)) } @@ -516,8 +498,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `315` // Estimated: `3780` - // Minimum execution time: 45_660_000 picoseconds. - Weight::from_parts(46_780_000, 3780) + // Minimum execution time: 483_000_000 picoseconds. + Weight::from_parts(512_000_000, 3780) .saturating_add(T::DbWeight::get().reads(4_u64)) .saturating_add(T::DbWeight::get().writes(4_u64)) } @@ -533,8 +515,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `552` // Estimated: `8967` - // Minimum execution time: 35_016_000 picoseconds. - Weight::from_parts(36_078_000, 8967) + // Minimum execution time: 321_000_000 picoseconds. + Weight::from_parts(334_000_000, 8967) .saturating_add(T::DbWeight::get().reads(7_u64)) .saturating_add(T::DbWeight::get().writes(6_u64)) } @@ -543,17 +525,17 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 9_383_000 picoseconds. - Weight::from_parts(10_413_719, 0) - // Standard Error: 49 - .saturating_add(Weight::from_parts(72_020, 0).saturating_mul(r.into())) + // Minimum execution time: 149_000_000 picoseconds. + Weight::from_parts(150_400_000, 0) + // Standard Error: 190 + .saturating_add(Weight::from_parts(92_875, 0).saturating_mul(r.into())) } fn seal_caller() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 643_000 picoseconds. - Weight::from_parts(703_000, 0) + // Minimum execution time: 6_000_000 picoseconds. + Weight::from_parts(6_000_000, 0) } /// Storage: `Contracts::ContractInfoOf` (r:1 w:0) /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) @@ -561,8 +543,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `354` // Estimated: `3819` - // Minimum execution time: 6_757_000 picoseconds. - Weight::from_parts(6_890_000, 3819) + // Minimum execution time: 56_000_000 picoseconds. + Weight::from_parts(57_000_000, 3819) .saturating_add(T::DbWeight::get().reads(1_u64)) } /// Storage: `Contracts::ContractInfoOf` (r:1 w:0) @@ -571,44 +553,44 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `447` // Estimated: `3912` - // Minimum execution time: 7_950_000 picoseconds. - Weight::from_parts(8_424_000, 3912) + // Minimum execution time: 67_000_000 picoseconds. + Weight::from_parts(69_000_000, 3912) .saturating_add(T::DbWeight::get().reads(1_u64)) } fn seal_own_code_hash() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 832_000 picoseconds. - Weight::from_parts(889_000, 0) + // Minimum execution time: 8_000_000 picoseconds. + Weight::from_parts(8_000_000, 0) } fn seal_caller_is_origin() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 386_000 picoseconds. - Weight::from_parts(403_000, 0) + // Minimum execution time: 2_000_000 picoseconds. + Weight::from_parts(3_000_000, 0) } fn seal_caller_is_root() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 334_000 picoseconds. - Weight::from_parts(372_000, 0) + // Minimum execution time: 2_000_000 picoseconds. + Weight::from_parts(2_000_000, 0) } fn seal_address() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 634_000 picoseconds. - Weight::from_parts(685_000, 0) + // Minimum execution time: 5_000_000 picoseconds. + Weight::from_parts(6_000_000, 0) } fn seal_gas_left() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 740_000 picoseconds. - Weight::from_parts(789_000, 0) + // Minimum execution time: 6_000_000 picoseconds. + Weight::from_parts(6_000_000, 0) } /// Storage: `System::Account` (r:1 w:0) /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`) @@ -616,37 +598,37 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `140` // Estimated: `3605` - // Minimum execution time: 4_792_000 picoseconds. - Weight::from_parts(5_077_000, 3605) + // Minimum execution time: 46_000_000 picoseconds. + Weight::from_parts(46_000_000, 3605) .saturating_add(T::DbWeight::get().reads(1_u64)) } fn seal_value_transferred() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 602_000 picoseconds. - Weight::from_parts(629_000, 0) + // Minimum execution time: 6_000_000 picoseconds. + Weight::from_parts(6_000_000, 0) } fn seal_minimum_balance() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 610_000 picoseconds. - Weight::from_parts(692_000, 0) + // Minimum execution time: 6_000_000 picoseconds. + Weight::from_parts(6_000_000, 0) } fn seal_block_number() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 614_000 picoseconds. - Weight::from_parts(662_000, 0) + // Minimum execution time: 6_000_000 picoseconds. + Weight::from_parts(6_000_000, 0) } fn seal_now() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 628_000 picoseconds. - Weight::from_parts(694_000, 0) + // Minimum execution time: 6_000_000 picoseconds. + Weight::from_parts(6_000_000, 0) } /// Storage: `TransactionPayment::NextFeeMultiplier` (r:1 w:0) /// Proof: `TransactionPayment::NextFeeMultiplier` (`max_values`: Some(1), `max_size`: Some(16), added: 511, mode: `Measured`) @@ -654,27 +636,29 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `67` // Estimated: `1552` - // Minimum execution time: 4_360_000 picoseconds. - Weight::from_parts(4_613_000, 1552) + // Minimum execution time: 34_000_000 picoseconds. + Weight::from_parts(35_000_000, 1552) .saturating_add(T::DbWeight::get().reads(1_u64)) } /// The range of component `n` is `[0, 1048572]`. - fn seal_input(_n: u32, ) -> Weight { + fn seal_input(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 475_000 picoseconds. - Weight::from_parts(584_657, 0) + // Minimum execution time: 4_000_000 picoseconds. + Weight::from_parts(4_800_000, 0) + // Standard Error: 0 + .saturating_add(Weight::from_parts(77, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 1048572]`. fn seal_return(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 312_000 picoseconds. - Weight::from_parts(343_000, 0) - // Standard Error: 9 - .saturating_add(Weight::from_parts(479, 0).saturating_mul(n.into())) + // Minimum execution time: 2_000_000 picoseconds. + Weight::from_parts(2_000_000, 0) + // Standard Error: 0 + .saturating_add(Weight::from_parts(156, 0).saturating_mul(n.into())) } /// Storage: `Contracts::DeletionQueueCounter` (r:1 w:1) /// Proof: `Contracts::DeletionQueueCounter` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`) @@ -690,8 +674,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `2821` // Estimated: `85486` - // Minimum execution time: 134_617_000 picoseconds. - Weight::from_parts(136_454_000, 85486) + // Minimum execution time: 1_399_000_000 picoseconds. + Weight::from_parts(1_407_000_000, 85486) .saturating_add(T::DbWeight::get().reads(36_u64)) .saturating_add(T::DbWeight::get().writes(38_u64)) } @@ -701,37 +685,35 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `76` // Estimated: `1561` - // Minimum execution time: 3_869_000 picoseconds. - Weight::from_parts(4_139_000, 1561) + // Minimum execution time: 33_000_000 picoseconds. + Weight::from_parts(34_000_000, 1561) .saturating_add(T::DbWeight::get().reads(1_u64)) } /// Storage: `System::EventTopics` (r:4 w:4) /// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`) /// The range of component `t` is `[0, 4]`. /// The range of component `n` is `[0, 16384]`. - fn seal_deposit_event(t: u32, n: u32, ) -> Weight { + fn seal_deposit_event(t: u32, _n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` - // Estimated: `990 + t * (2475 ±0)` - // Minimum execution time: 4_137_000 picoseconds. - Weight::from_parts(4_504_239, 990) - // Standard Error: 6_837 - .saturating_add(Weight::from_parts(2_381_563, 0).saturating_mul(t.into())) - // Standard Error: 1 - .saturating_add(Weight::from_parts(20, 0).saturating_mul(n.into())) + // Estimated: `641 + t * (2562 ±0)` + // Minimum execution time: 27_000_000 picoseconds. + Weight::from_parts(33_099_999, 641) + // Standard Error: 132_510 + .saturating_add(Weight::from_parts(28_975_000, 0).saturating_mul(t.into())) .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(t.into()))) .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(t.into()))) - .saturating_add(Weight::from_parts(0, 2475).saturating_mul(t.into())) + .saturating_add(Weight::from_parts(0, 2562).saturating_mul(t.into())) } /// The range of component `i` is `[0, 1048576]`. fn seal_debug_message(i: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 395_000 picoseconds. - Weight::from_parts(448_000, 0) - // Standard Error: 10 - .saturating_add(Weight::from_parts(1_272, 0).saturating_mul(i.into())) + // Minimum execution time: 2_000_000 picoseconds. + Weight::from_parts(2_000_000, 0) + // Standard Error: 0 + .saturating_add(Weight::from_parts(425, 0).saturating_mul(i.into())) } /// Storage: `Skipped::Metadata` (r:0 w:0) /// Proof: `Skipped::Metadata` (`max_values`: None, `max_size`: None, mode: `Measured`) @@ -740,10 +722,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `245` // Estimated: `245` - // Minimum execution time: 7_949_000 picoseconds. - Weight::from_parts(8_879_819, 245) - // Standard Error: 1 - .saturating_add(Weight::from_parts(350, 0).saturating_mul(n.into())) + // Minimum execution time: 55_000_000 picoseconds. + Weight::from_parts(56_300_000, 245) + // Standard Error: 13 + .saturating_add(Weight::from_parts(286, 0).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -752,12 +734,12 @@ impl WeightInfo for SubstrateWeight { /// The range of component `n` is `[0, 16384]`. fn seal_set_storage_per_old_byte(n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `248 + n * (1 ±0)` - // Estimated: `248 + n * (1 ±0)` - // Minimum execution time: 7_878_000 picoseconds. - Weight::from_parts(9_291_579, 248) - // Standard Error: 2 - .saturating_add(Weight::from_parts(78, 0).saturating_mul(n.into())) + // Measured: `245 + n * (1 ±0)` + // Estimated: `245 + n * (1 ±0)` + // Minimum execution time: 55_000_000 picoseconds. + Weight::from_parts(55_300_000, 245) + // Standard Error: 17 + .saturating_add(Weight::from_parts(415, 0).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) @@ -767,12 +749,12 @@ impl WeightInfo for SubstrateWeight { /// The range of component `n` is `[0, 16384]`. fn seal_clear_storage(n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `248 + n * (1 ±0)` - // Estimated: `248 + n * (1 ±0)` - // Minimum execution time: 8_068_000 picoseconds. - Weight::from_parts(9_253_255, 248) - // Standard Error: 2 - .saturating_add(Weight::from_parts(80, 0).saturating_mul(n.into())) + // Measured: `245 + n * (1 ±0)` + // Estimated: `245 + n * (1 ±0)` + // Minimum execution time: 56_000_000 picoseconds. + Weight::from_parts(61_200_000, 245) + // Standard Error: 46 + .saturating_add(Weight::from_parts(73, 0).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) @@ -782,12 +764,12 @@ impl WeightInfo for SubstrateWeight { /// The range of component `n` is `[0, 16384]`. fn seal_get_storage(n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `248 + n * (1 ±0)` - // Estimated: `248 + n * (1 ±0)` - // Minimum execution time: 7_316_000 picoseconds. - Weight::from_parts(9_096_691, 248) - // Standard Error: 3 - .saturating_add(Weight::from_parts(706, 0).saturating_mul(n.into())) + // Measured: `245 + n * (1 ±0)` + // Estimated: `245 + n * (1 ±0)` + // Minimum execution time: 51_000_000 picoseconds. + Weight::from_parts(53_100_000, 245) + // Standard Error: 41 + .saturating_add(Weight::from_parts(891, 0).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) } @@ -796,12 +778,12 @@ impl WeightInfo for SubstrateWeight { /// The range of component `n` is `[0, 16384]`. fn seal_contains_storage(n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `248 + n * (1 ±0)` - // Estimated: `248 + n * (1 ±0)` - // Minimum execution time: 6_660_000 picoseconds. - Weight::from_parts(8_029_136, 248) - // Standard Error: 2 - .saturating_add(Weight::from_parts(85, 0).saturating_mul(n.into())) + // Measured: `245 + n * (1 ±0)` + // Estimated: `245 + n * (1 ±0)` + // Minimum execution time: 50_000_000 picoseconds. + Weight::from_parts(50_700_000, 245) + // Standard Error: 50 + .saturating_add(Weight::from_parts(769, 0).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) } @@ -810,12 +792,12 @@ impl WeightInfo for SubstrateWeight { /// The range of component `n` is `[0, 16384]`. fn seal_take_storage(n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `248 + n * (1 ±0)` - // Estimated: `248 + n * (1 ±0)` - // Minimum execution time: 8_497_000 picoseconds. - Weight::from_parts(10_287_954, 248) - // Standard Error: 3 - .saturating_add(Weight::from_parts(699, 0).saturating_mul(n.into())) + // Measured: `245 + n * (1 ±0)` + // Estimated: `245 + n * (1 ±0)` + // Minimum execution time: 57_000_000 picoseconds. + Weight::from_parts(58_400_000, 245) + // Standard Error: 32 + .saturating_add(Weight::from_parts(854, 0).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) @@ -826,8 +808,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `140` // Estimated: `3605` - // Minimum execution time: 9_337_000 picoseconds. - Weight::from_parts(9_882_000, 3605) + // Minimum execution time: 99_000_000 picoseconds. + Weight::from_parts(103_000_000, 3605) .saturating_add(T::DbWeight::get().reads(1_u64)) } /// Storage: `Contracts::ContractInfoOf` (r:1 w:2) @@ -849,14 +831,14 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `623 + t * (280 ±0)` // Estimated: `6563 + t * (3422 ±0)` - // Minimum execution time: 172_292_000 picoseconds. - Weight::from_parts(167_185_817, 6563) - // Standard Error: 327_522 - .saturating_add(Weight::from_parts(44_974_443, 0).saturating_mul(t.into())) - // Standard Error: 327_522 - .saturating_add(Weight::from_parts(4_283_151, 0).saturating_mul(c.into())) - // Standard Error: 0 - .saturating_add(Weight::from_parts(11, 0).saturating_mul(i.into())) + // Minimum execution time: 1_601_000_000 picoseconds. + Weight::from_parts(1_531_399_999, 6563) + // Standard Error: 15_255_326 + .saturating_add(Weight::from_parts(460_199_999, 0).saturating_mul(t.into())) + // Standard Error: 15_255_326 + .saturating_add(Weight::from_parts(86_499_999, 0).saturating_mul(c.into())) + // Standard Error: 14 + .saturating_add(Weight::from_parts(84, 0).saturating_mul(i.into())) .saturating_add(T::DbWeight::get().reads(7_u64)) .saturating_add(T::DbWeight::get().reads((2_u64).saturating_mul(t.into()))) .saturating_add(T::DbWeight::get().writes(4_u64)) @@ -877,8 +859,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `433` // Estimated: `6373` - // Minimum execution time: 161_490_000 picoseconds. - Weight::from_parts(170_939_000, 6373) + // Minimum execution time: 1_526_000_000 picoseconds. + Weight::from_parts(1_547_000_000, 6373) .saturating_add(T::DbWeight::get().reads(6_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) } @@ -901,83 +883,85 @@ impl WeightInfo for SubstrateWeight { /// The range of component `s` is `[0, 983040]`. fn seal_instantiate(t: u32, i: u32, s: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `679 + t * (102 ±0)` - // Estimated: `6616 + t * (2565 ±1)` - // Minimum execution time: 1_819_574_000 picoseconds. - Weight::from_parts(1_829_348_000, 6616) - // Standard Error: 14 - .saturating_add(Weight::from_parts(731, 0).saturating_mul(i.into())) - // Standard Error: 14 - .saturating_add(Weight::from_parts(1_005, 0).saturating_mul(s.into())) + // Measured: `627 + t * (102 ±0)` + // Estimated: `6567 + t * (2577 ±0)` + // Minimum execution time: 3_818_000_000 picoseconds. + Weight::from_parts(2_080_099_999, 6567) + // Standard Error: 27_716_696 + .saturating_add(Weight::from_parts(389_800_000, 0).saturating_mul(t.into())) + // Standard Error: 28 + .saturating_add(Weight::from_parts(1_471, 0).saturating_mul(i.into())) + // Standard Error: 28 + .saturating_add(Weight::from_parts(1_568, 0).saturating_mul(s.into())) .saturating_add(T::DbWeight::get().reads(10_u64)) .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(t.into()))) .saturating_add(T::DbWeight::get().writes(7_u64)) .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(t.into()))) - .saturating_add(Weight::from_parts(0, 2565).saturating_mul(t.into())) + .saturating_add(Weight::from_parts(0, 2577).saturating_mul(t.into())) } /// The range of component `n` is `[0, 1048576]`. fn seal_hash_sha2_256(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 894_000 picoseconds. - Weight::from_parts(941_000, 0) - // Standard Error: 0 - .saturating_add(Weight::from_parts(1_151, 0).saturating_mul(n.into())) + // Minimum execution time: 7_000_000 picoseconds. + Weight::from_parts(8_000_000, 0) + // Standard Error: 1 + .saturating_add(Weight::from_parts(3_113, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 1048576]`. fn seal_hash_keccak_256(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_359_000 picoseconds. - Weight::from_parts(1_403_000, 0) - // Standard Error: 0 - .saturating_add(Weight::from_parts(3_410, 0).saturating_mul(n.into())) + // Minimum execution time: 8_000_000 picoseconds. + Weight::from_parts(8_600_000, 0) + // Standard Error: 3 + .saturating_add(Weight::from_parts(4_545, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 1048576]`. fn seal_hash_blake2_256(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 727_000 picoseconds. - Weight::from_parts(762_000, 0) - // Standard Error: 0 - .saturating_add(Weight::from_parts(1_280, 0).saturating_mul(n.into())) + // Minimum execution time: 4_000_000 picoseconds. + Weight::from_parts(5_000_000, 0) + // Standard Error: 5 + .saturating_add(Weight::from_parts(1_134, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 1048576]`. fn seal_hash_blake2_128(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 772_000 picoseconds. - Weight::from_parts(799_000, 0) - // Standard Error: 0 - .saturating_add(Weight::from_parts(1_279, 0).saturating_mul(n.into())) + // Minimum execution time: 5_000_000 picoseconds. + Weight::from_parts(5_000_000, 0) + // Standard Error: 3 + .saturating_add(Weight::from_parts(1_122, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 125697]`. fn seal_sr25519_verify(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 43_237_000 picoseconds. - Weight::from_parts(44_351_784, 0) - // Standard Error: 8 - .saturating_add(Weight::from_parts(4_756, 0).saturating_mul(n.into())) + // Minimum execution time: 58_000_000 picoseconds. + Weight::from_parts(58_600_000, 0) + // Standard Error: 4 + .saturating_add(Weight::from_parts(7_695, 0).saturating_mul(n.into())) } fn seal_ecdsa_recover() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 48_204_000 picoseconds. - Weight::from_parts(49_920_000, 0) + // Minimum execution time: 300_000_000 picoseconds. + Weight::from_parts(316_000_000, 0) } fn seal_ecdsa_to_eth_address() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 12_997_000 picoseconds. - Weight::from_parts(13_237_000, 0) + // Minimum execution time: 16_000_000 picoseconds. + Weight::from_parts(16_000_000, 0) } /// Storage: `Contracts::CodeInfoOf` (r:1 w:1) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) @@ -991,8 +975,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `433` // Estimated: `6373` - // Minimum execution time: 31_613_000 picoseconds. - Weight::from_parts(32_976_000, 6373) + // Minimum execution time: 304_000_000 picoseconds. + Weight::from_parts(306_000_000, 6373) .saturating_add(T::DbWeight::get().reads(6_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) } @@ -1002,8 +986,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `355` // Estimated: `3820` - // Minimum execution time: 9_330_000 picoseconds. - Weight::from_parts(9_933_000, 3820) + // Minimum execution time: 79_000_000 picoseconds. + Weight::from_parts(80_000_000, 3820) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -1013,8 +997,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `355` // Estimated: `3558` - // Minimum execution time: 8_203_000 picoseconds. - Weight::from_parts(8_645_000, 3558) + // Minimum execution time: 64_000_000 picoseconds. + Weight::from_parts(66_000_000, 3558) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -1022,15 +1006,15 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 283_000 picoseconds. - Weight::from_parts(342_000, 0) + // Minimum execution time: 2_000_000 picoseconds. + Weight::from_parts(2_000_000, 0) } fn seal_account_reentrance_count() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 312_000 picoseconds. - Weight::from_parts(376_000, 0) + // Minimum execution time: 2_000_000 picoseconds. + Weight::from_parts(2_000_000, 0) } /// Storage: `Contracts::Nonce` (r:1 w:0) /// Proof: `Contracts::Nonce` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`) @@ -1038,8 +1022,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `219` // Estimated: `1704` - // Minimum execution time: 2_996_000 picoseconds. - Weight::from_parts(3_180_000, 1704) + // Minimum execution time: 26_000_000 picoseconds. + Weight::from_parts(26_000_000, 1704) .saturating_add(T::DbWeight::get().reads(1_u64)) } /// The range of component `r` is `[0, 5000]`. @@ -1047,10 +1031,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_200_000 picoseconds. - Weight::from_parts(1_007_275, 0) - // Standard Error: 18 - .saturating_add(Weight::from_parts(15_124, 0).saturating_mul(r.into())) + // Minimum execution time: 5_000_000 picoseconds. + Weight::from_parts(5_900_000, 0) + // Standard Error: 124 + .saturating_add(Weight::from_parts(71_560, 0).saturating_mul(r.into())) } } @@ -1062,8 +1046,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `142` // Estimated: `1627` - // Minimum execution time: 1_998_000 picoseconds. - Weight::from_parts(2_105_000, 1627) + // Minimum execution time: 20_000_000 picoseconds. + Weight::from_parts(21_000_000, 1627) .saturating_add(RocksDbWeight::get().reads(1_u64)) } /// Storage: `Skipped::Metadata` (r:0 w:0) @@ -1071,12 +1055,12 @@ impl WeightInfo for () { /// The range of component `k` is `[0, 1024]`. fn on_initialize_per_trie_key(k: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `452 + k * (69 ±0)` - // Estimated: `442 + k * (70 ±0)` - // Minimum execution time: 12_810_000 picoseconds. - Weight::from_parts(13_041_000, 442) - // Standard Error: 1_980 - .saturating_add(Weight::from_parts(1_186_675, 0).saturating_mul(k.into())) + // Measured: `318 + k * (69 ±0)` + // Estimated: `318 + k * (70 ±0)` + // Minimum execution time: 104_000_000 picoseconds. + Weight::from_parts(104_700_000, 318) + // Standard Error: 34_890 + .saturating_add(Weight::from_parts(7_380_175, 0).saturating_mul(k.into())) .saturating_add(RocksDbWeight::get().reads(2_u64)) .saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(k.into()))) .saturating_add(RocksDbWeight::get().writes(2_u64)) @@ -1088,12 +1072,12 @@ impl WeightInfo for () { /// The range of component `c` is `[0, 125952]`. fn v9_migration_step(c: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `211 + c * (1 ±0)` - // Estimated: `6149 + c * (1 ±0)` - // Minimum execution time: 8_141_000 picoseconds. - Weight::from_parts(8_750_889, 6149) - // Standard Error: 1 - .saturating_add(Weight::from_parts(1_220, 0).saturating_mul(c.into())) + // Measured: `203 + c * (1 ±0)` + // Estimated: `6143 + c * (1 ±0)` + // Minimum execution time: 90_000_000 picoseconds. + Weight::from_parts(91_600_000, 6143) + // Standard Error: 7 + .saturating_add(Weight::from_parts(656, 0).saturating_mul(c.into())) .saturating_add(RocksDbWeight::get().reads(2_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(c.into())) @@ -1106,8 +1090,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `510` // Estimated: `6450` - // Minimum execution time: 16_836_000 picoseconds. - Weight::from_parts(17_922_000, 6450) + // Minimum execution time: 149_000_000 picoseconds. + Weight::from_parts(161_000_000, 6450) .saturating_add(RocksDbWeight::get().reads(3_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -1118,14 +1102,14 @@ impl WeightInfo for () { /// The range of component `k` is `[0, 1024]`. fn v11_migration_step(k: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `171 + k * (1 ±0)` - // Estimated: `3635 + k * (1 ±0)` - // Minimum execution time: 3_422_000 picoseconds. - Weight::from_parts(3_488_000, 3635) - // Standard Error: 1_035 - .saturating_add(Weight::from_parts(1_215_499, 0).saturating_mul(k.into())) + // Measured: `166 + k * (1 ±0)` + // Estimated: `3631 + k * (1 ±0)` + // Minimum execution time: 32_000_000 picoseconds. + Weight::from_parts(33_299_999, 3631) + // Standard Error: 40_858 + .saturating_add(Weight::from_parts(15_348_925, 0).saturating_mul(k.into())) .saturating_add(RocksDbWeight::get().reads(1_u64)) - .saturating_add(RocksDbWeight::get().writes(2_u64)) + .saturating_add(RocksDbWeight::get().writes(1_u64)) .saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(k.into()))) .saturating_add(Weight::from_parts(0, 1).saturating_mul(k.into())) } @@ -1142,12 +1126,12 @@ impl WeightInfo for () { /// The range of component `c` is `[0, 125952]`. fn v12_migration_step(c: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `328 + c * (1 ±0)` - // Estimated: `6266 + c * (1 ±0)` - // Minimum execution time: 20_859_000 picoseconds. - Weight::from_parts(21_212_479, 6266) - // Standard Error: 0 - .saturating_add(Weight::from_parts(459, 0).saturating_mul(c.into())) + // Measured: `320 + c * (1 ±0)` + // Estimated: `6260 + c * (1 ±0)` + // Minimum execution time: 205_000_000 picoseconds. + Weight::from_parts(206_400_000, 6260) + // Standard Error: 6 + .saturating_add(Weight::from_parts(304, 0).saturating_mul(c.into())) .saturating_add(RocksDbWeight::get().reads(6_u64)) .saturating_add(RocksDbWeight::get().writes(2_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(c.into())) @@ -1158,8 +1142,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `440` // Estimated: `6380` - // Minimum execution time: 12_941_000 picoseconds. - Weight::from_parts(13_701_000, 6380) + // Minimum execution time: 109_000_000 picoseconds. + Weight::from_parts(111_000_000, 6380) .saturating_add(RocksDbWeight::get().reads(2_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -1173,8 +1157,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `352` // Estimated: `6292` - // Minimum execution time: 46_900_000 picoseconds. - Weight::from_parts(48_164_000, 6292) + // Minimum execution time: 492_000_000 picoseconds. + Weight::from_parts(513_000_000, 6292) .saturating_add(RocksDbWeight::get().reads(4_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -1186,8 +1170,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `594` // Estimated: `6534` - // Minimum execution time: 56_096_000 picoseconds. - Weight::from_parts(57_603_000, 6534) + // Minimum execution time: 433_000_000 picoseconds. + Weight::from_parts(471_000_000, 6534) .saturating_add(RocksDbWeight::get().reads(4_u64)) .saturating_add(RocksDbWeight::get().writes(2_u64)) } @@ -1197,8 +1181,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `409` // Estimated: `6349` - // Minimum execution time: 12_147_000 picoseconds. - Weight::from_parts(12_960_000, 6349) + // Minimum execution time: 108_000_000 picoseconds. + Weight::from_parts(110_000_000, 6349) .saturating_add(RocksDbWeight::get().reads(2_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -1208,8 +1192,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `142` // Estimated: `1627` - // Minimum execution time: 2_436_000 picoseconds. - Weight::from_parts(2_697_000, 1627) + // Minimum execution time: 23_000_000 picoseconds. + Weight::from_parts(24_000_000, 1627) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -1221,8 +1205,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `166` // Estimated: `3631` - // Minimum execution time: 11_674_000 picoseconds. - Weight::from_parts(12_277_000, 3631) + // Minimum execution time: 119_000_000 picoseconds. + Weight::from_parts(147_000_000, 3631) .saturating_add(RocksDbWeight::get().reads(2_u64)) .saturating_add(RocksDbWeight::get().writes(2_u64)) } @@ -1232,8 +1216,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `142` // Estimated: `3607` - // Minimum execution time: 4_717_000 picoseconds. - Weight::from_parts(5_008_000, 3607) + // Minimum execution time: 42_000_000 picoseconds. + Weight::from_parts(43_000_000, 3607) .saturating_add(RocksDbWeight::get().reads(1_u64)) } /// Storage: UNKNOWN KEY `0x4342193e496fab7ec59d615ed0dc55304e7b9012096b41c4eb3aaf947f6ea429` (r:1 w:0) @@ -1244,8 +1228,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `167` // Estimated: `3632` - // Minimum execution time: 5_954_000 picoseconds. - Weight::from_parts(6_331_000, 3632) + // Minimum execution time: 56_000_000 picoseconds. + Weight::from_parts(58_000_000, 3632) .saturating_add(RocksDbWeight::get().reads(2_u64)) } /// Storage: UNKNOWN KEY `0x4342193e496fab7ec59d615ed0dc55304e7b9012096b41c4eb3aaf947f6ea429` (r:1 w:0) @@ -1256,8 +1240,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `142` // Estimated: `3607` - // Minimum execution time: 6_061_000 picoseconds. - Weight::from_parts(6_600_000, 3607) + // Minimum execution time: 56_000_000 picoseconds. + Weight::from_parts(57_000_000, 3607) .saturating_add(RocksDbWeight::get().reads(2_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -1280,12 +1264,12 @@ impl WeightInfo for () { /// The range of component `c` is `[0, 125952]`. fn call_with_code_per_byte(c: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `804 + c * (1 ±0)` - // Estimated: `9217 + c * (1 ±0)` - // Minimum execution time: 370_504_000 picoseconds. - Weight::from_parts(345_076_763, 9217) - // Standard Error: 96 - .saturating_add(Weight::from_parts(34_235, 0).saturating_mul(c.into())) + // Measured: `832` + // Estimated: `9247 + c * (1 ±0)` + // Minimum execution time: 2_222_000_000 picoseconds. + Weight::from_parts(2_246_800_000, 9247) + // Standard Error: 194 + .saturating_add(Weight::from_parts(78_581, 0).saturating_mul(c.into())) .saturating_add(RocksDbWeight::get().reads(11_u64)) .saturating_add(RocksDbWeight::get().writes(4_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(c.into())) @@ -1315,16 +1299,16 @@ 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: `326` - // Estimated: `8740` - // Minimum execution time: 4_359_896_000 picoseconds. - Weight::from_parts(481_322_438, 8740) - // Standard Error: 225 - .saturating_add(Weight::from_parts(70_837, 0).saturating_mul(c.into())) - // Standard Error: 27 - .saturating_add(Weight::from_parts(1_888, 0).saturating_mul(i.into())) - // Standard Error: 27 - .saturating_add(Weight::from_parts(1_957, 0).saturating_mul(s.into())) + // Measured: `443` + // Estimated: `8858` + // Minimum execution time: 8_001_000_000 picoseconds. + Weight::from_parts(4_996_600_018, 8858) + // Standard Error: 606 + .saturating_add(Weight::from_parts(158_819, 0).saturating_mul(c.into())) + // Standard Error: 72 + .saturating_add(Weight::from_parts(1_394, 0).saturating_mul(i.into())) + // Standard Error: 72 + .saturating_add(Weight::from_parts(1_681, 0).saturating_mul(s.into())) .saturating_add(RocksDbWeight::get().reads(14_u64)) .saturating_add(RocksDbWeight::get().writes(10_u64)) } @@ -1352,14 +1336,14 @@ impl WeightInfo for () { /// The range of component `s` is `[0, 1048576]`. fn instantiate(i: u32, s: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `563` - // Estimated: `8982` - // Minimum execution time: 2_128_155_000 picoseconds. - Weight::from_parts(2_147_287_000, 8982) - // Standard Error: 27 - .saturating_add(Weight::from_parts(964, 0).saturating_mul(i.into())) - // Standard Error: 27 - .saturating_add(Weight::from_parts(822, 0).saturating_mul(s.into())) + // Measured: `615` + // Estimated: `9030` + // Minimum execution time: 4_452_000_000 picoseconds. + Weight::from_parts(3_312_250_000, 9030) + // Standard Error: 24 + .saturating_add(Weight::from_parts(1_571, 0).saturating_mul(i.into())) + // Standard Error: 24 + .saturating_add(Weight::from_parts(1_133, 0).saturating_mul(s.into())) .saturating_add(RocksDbWeight::get().reads(13_u64)) .saturating_add(RocksDbWeight::get().writes(7_u64)) } @@ -1383,8 +1367,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `829` // Estimated: `9244` - // Minimum execution time: 214_463_000 picoseconds. - Weight::from_parts(225_091_000, 9244) + // Minimum execution time: 2_150_000_000 picoseconds. + Weight::from_parts(2_237_000_000, 9244) .saturating_add(RocksDbWeight::get().reads(11_u64)) .saturating_add(RocksDbWeight::get().writes(4_u64)) } @@ -1405,10 +1389,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `145` // Estimated: `6085` - // Minimum execution time: 339_390_000 picoseconds. - Weight::from_parts(334_232_549, 6085) - // Standard Error: 76 - .saturating_add(Weight::from_parts(33_541, 0).saturating_mul(c.into())) + // Minimum execution time: 1_943_000_000 picoseconds. + Weight::from_parts(2_061_000_000, 6085) + // Standard Error: 425 + .saturating_add(Weight::from_parts(80_155, 0).saturating_mul(c.into())) .saturating_add(RocksDbWeight::get().reads(6_u64)) .saturating_add(RocksDbWeight::get().writes(4_u64)) } @@ -1429,10 +1413,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `145` // Estimated: `6085` - // Minimum execution time: 351_953_000 picoseconds. - Weight::from_parts(343_509_628, 6085) - // Standard Error: 88 - .saturating_add(Weight::from_parts(34_147, 0).saturating_mul(c.into())) + // Minimum execution time: 2_143_000_000 picoseconds. + Weight::from_parts(2_231_100_000, 6085) + // Standard Error: 246 + .saturating_add(Weight::from_parts(79_070, 0).saturating_mul(c.into())) .saturating_add(RocksDbWeight::get().reads(6_u64)) .saturating_add(RocksDbWeight::get().writes(4_u64)) } @@ -1450,8 +1434,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `315` // Estimated: `3780` - // Minimum execution time: 45_660_000 picoseconds. - Weight::from_parts(46_780_000, 3780) + // Minimum execution time: 483_000_000 picoseconds. + Weight::from_parts(512_000_000, 3780) .saturating_add(RocksDbWeight::get().reads(4_u64)) .saturating_add(RocksDbWeight::get().writes(4_u64)) } @@ -1467,8 +1451,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `552` // Estimated: `8967` - // Minimum execution time: 35_016_000 picoseconds. - Weight::from_parts(36_078_000, 8967) + // Minimum execution time: 321_000_000 picoseconds. + Weight::from_parts(334_000_000, 8967) .saturating_add(RocksDbWeight::get().reads(7_u64)) .saturating_add(RocksDbWeight::get().writes(6_u64)) } @@ -1477,17 +1461,17 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 9_383_000 picoseconds. - Weight::from_parts(10_413_719, 0) - // Standard Error: 49 - .saturating_add(Weight::from_parts(72_020, 0).saturating_mul(r.into())) + // Minimum execution time: 149_000_000 picoseconds. + Weight::from_parts(150_400_000, 0) + // Standard Error: 190 + .saturating_add(Weight::from_parts(92_875, 0).saturating_mul(r.into())) } fn seal_caller() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 643_000 picoseconds. - Weight::from_parts(703_000, 0) + // Minimum execution time: 6_000_000 picoseconds. + Weight::from_parts(6_000_000, 0) } /// Storage: `Contracts::ContractInfoOf` (r:1 w:0) /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) @@ -1495,8 +1479,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `354` // Estimated: `3819` - // Minimum execution time: 6_757_000 picoseconds. - Weight::from_parts(6_890_000, 3819) + // Minimum execution time: 56_000_000 picoseconds. + Weight::from_parts(57_000_000, 3819) .saturating_add(RocksDbWeight::get().reads(1_u64)) } /// Storage: `Contracts::ContractInfoOf` (r:1 w:0) @@ -1505,44 +1489,44 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `447` // Estimated: `3912` - // Minimum execution time: 7_950_000 picoseconds. - Weight::from_parts(8_424_000, 3912) + // Minimum execution time: 67_000_000 picoseconds. + Weight::from_parts(69_000_000, 3912) .saturating_add(RocksDbWeight::get().reads(1_u64)) } fn seal_own_code_hash() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 832_000 picoseconds. - Weight::from_parts(889_000, 0) + // Minimum execution time: 8_000_000 picoseconds. + Weight::from_parts(8_000_000, 0) } fn seal_caller_is_origin() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 386_000 picoseconds. - Weight::from_parts(403_000, 0) + // Minimum execution time: 2_000_000 picoseconds. + Weight::from_parts(3_000_000, 0) } fn seal_caller_is_root() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 334_000 picoseconds. - Weight::from_parts(372_000, 0) + // Minimum execution time: 2_000_000 picoseconds. + Weight::from_parts(2_000_000, 0) } fn seal_address() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 634_000 picoseconds. - Weight::from_parts(685_000, 0) + // Minimum execution time: 5_000_000 picoseconds. + Weight::from_parts(6_000_000, 0) } fn seal_gas_left() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 740_000 picoseconds. - Weight::from_parts(789_000, 0) + // Minimum execution time: 6_000_000 picoseconds. + Weight::from_parts(6_000_000, 0) } /// Storage: `System::Account` (r:1 w:0) /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`) @@ -1550,37 +1534,37 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `140` // Estimated: `3605` - // Minimum execution time: 4_792_000 picoseconds. - Weight::from_parts(5_077_000, 3605) + // Minimum execution time: 46_000_000 picoseconds. + Weight::from_parts(46_000_000, 3605) .saturating_add(RocksDbWeight::get().reads(1_u64)) } fn seal_value_transferred() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 602_000 picoseconds. - Weight::from_parts(629_000, 0) + // Minimum execution time: 6_000_000 picoseconds. + Weight::from_parts(6_000_000, 0) } fn seal_minimum_balance() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 610_000 picoseconds. - Weight::from_parts(692_000, 0) + // Minimum execution time: 6_000_000 picoseconds. + Weight::from_parts(6_000_000, 0) } fn seal_block_number() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 614_000 picoseconds. - Weight::from_parts(662_000, 0) + // Minimum execution time: 6_000_000 picoseconds. + Weight::from_parts(6_000_000, 0) } fn seal_now() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 628_000 picoseconds. - Weight::from_parts(694_000, 0) + // Minimum execution time: 6_000_000 picoseconds. + Weight::from_parts(6_000_000, 0) } /// Storage: `TransactionPayment::NextFeeMultiplier` (r:1 w:0) /// Proof: `TransactionPayment::NextFeeMultiplier` (`max_values`: Some(1), `max_size`: Some(16), added: 511, mode: `Measured`) @@ -1588,27 +1572,29 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `67` // Estimated: `1552` - // Minimum execution time: 4_360_000 picoseconds. - Weight::from_parts(4_613_000, 1552) + // Minimum execution time: 34_000_000 picoseconds. + Weight::from_parts(35_000_000, 1552) .saturating_add(RocksDbWeight::get().reads(1_u64)) } /// The range of component `n` is `[0, 1048572]`. - fn seal_input(_n: u32, ) -> Weight { + fn seal_input(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 475_000 picoseconds. - Weight::from_parts(584_657, 0) + // Minimum execution time: 4_000_000 picoseconds. + Weight::from_parts(4_800_000, 0) + // Standard Error: 0 + .saturating_add(Weight::from_parts(77, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 1048572]`. fn seal_return(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 312_000 picoseconds. - Weight::from_parts(343_000, 0) - // Standard Error: 9 - .saturating_add(Weight::from_parts(479, 0).saturating_mul(n.into())) + // Minimum execution time: 2_000_000 picoseconds. + Weight::from_parts(2_000_000, 0) + // Standard Error: 0 + .saturating_add(Weight::from_parts(156, 0).saturating_mul(n.into())) } /// Storage: `Contracts::DeletionQueueCounter` (r:1 w:1) /// Proof: `Contracts::DeletionQueueCounter` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`) @@ -1624,8 +1610,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `2821` // Estimated: `85486` - // Minimum execution time: 134_617_000 picoseconds. - Weight::from_parts(136_454_000, 85486) + // Minimum execution time: 1_399_000_000 picoseconds. + Weight::from_parts(1_407_000_000, 85486) .saturating_add(RocksDbWeight::get().reads(36_u64)) .saturating_add(RocksDbWeight::get().writes(38_u64)) } @@ -1635,37 +1621,35 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `76` // Estimated: `1561` - // Minimum execution time: 3_869_000 picoseconds. - Weight::from_parts(4_139_000, 1561) + // Minimum execution time: 33_000_000 picoseconds. + Weight::from_parts(34_000_000, 1561) .saturating_add(RocksDbWeight::get().reads(1_u64)) } /// Storage: `System::EventTopics` (r:4 w:4) /// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`) /// The range of component `t` is `[0, 4]`. /// The range of component `n` is `[0, 16384]`. - fn seal_deposit_event(t: u32, n: u32, ) -> Weight { + fn seal_deposit_event(t: u32, _n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` - // Estimated: `990 + t * (2475 ±0)` - // Minimum execution time: 4_137_000 picoseconds. - Weight::from_parts(4_504_239, 990) - // Standard Error: 6_837 - .saturating_add(Weight::from_parts(2_381_563, 0).saturating_mul(t.into())) - // Standard Error: 1 - .saturating_add(Weight::from_parts(20, 0).saturating_mul(n.into())) + // Estimated: `641 + t * (2562 ±0)` + // Minimum execution time: 27_000_000 picoseconds. + Weight::from_parts(33_099_999, 641) + // Standard Error: 132_510 + .saturating_add(Weight::from_parts(28_975_000, 0).saturating_mul(t.into())) .saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(t.into()))) .saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(t.into()))) - .saturating_add(Weight::from_parts(0, 2475).saturating_mul(t.into())) + .saturating_add(Weight::from_parts(0, 2562).saturating_mul(t.into())) } /// The range of component `i` is `[0, 1048576]`. fn seal_debug_message(i: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 395_000 picoseconds. - Weight::from_parts(448_000, 0) - // Standard Error: 10 - .saturating_add(Weight::from_parts(1_272, 0).saturating_mul(i.into())) + // Minimum execution time: 2_000_000 picoseconds. + Weight::from_parts(2_000_000, 0) + // Standard Error: 0 + .saturating_add(Weight::from_parts(425, 0).saturating_mul(i.into())) } /// Storage: `Skipped::Metadata` (r:0 w:0) /// Proof: `Skipped::Metadata` (`max_values`: None, `max_size`: None, mode: `Measured`) @@ -1674,10 +1658,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `245` // Estimated: `245` - // Minimum execution time: 7_949_000 picoseconds. - Weight::from_parts(8_879_819, 245) - // Standard Error: 1 - .saturating_add(Weight::from_parts(350, 0).saturating_mul(n.into())) + // Minimum execution time: 55_000_000 picoseconds. + Weight::from_parts(56_300_000, 245) + // Standard Error: 13 + .saturating_add(Weight::from_parts(286, 0).saturating_mul(n.into())) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -1686,12 +1670,12 @@ impl WeightInfo for () { /// The range of component `n` is `[0, 16384]`. fn seal_set_storage_per_old_byte(n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `248 + n * (1 ±0)` - // Estimated: `248 + n * (1 ±0)` - // Minimum execution time: 7_878_000 picoseconds. - Weight::from_parts(9_291_579, 248) - // Standard Error: 2 - .saturating_add(Weight::from_parts(78, 0).saturating_mul(n.into())) + // Measured: `245 + n * (1 ±0)` + // Estimated: `245 + n * (1 ±0)` + // Minimum execution time: 55_000_000 picoseconds. + Weight::from_parts(55_300_000, 245) + // Standard Error: 17 + .saturating_add(Weight::from_parts(415, 0).saturating_mul(n.into())) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) @@ -1701,12 +1685,12 @@ impl WeightInfo for () { /// The range of component `n` is `[0, 16384]`. fn seal_clear_storage(n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `248 + n * (1 ±0)` - // Estimated: `248 + n * (1 ±0)` - // Minimum execution time: 8_068_000 picoseconds. - Weight::from_parts(9_253_255, 248) - // Standard Error: 2 - .saturating_add(Weight::from_parts(80, 0).saturating_mul(n.into())) + // Measured: `245 + n * (1 ±0)` + // Estimated: `245 + n * (1 ±0)` + // Minimum execution time: 56_000_000 picoseconds. + Weight::from_parts(61_200_000, 245) + // Standard Error: 46 + .saturating_add(Weight::from_parts(73, 0).saturating_mul(n.into())) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) @@ -1716,12 +1700,12 @@ impl WeightInfo for () { /// The range of component `n` is `[0, 16384]`. fn seal_get_storage(n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `248 + n * (1 ±0)` - // Estimated: `248 + n * (1 ±0)` - // Minimum execution time: 7_316_000 picoseconds. - Weight::from_parts(9_096_691, 248) - // Standard Error: 3 - .saturating_add(Weight::from_parts(706, 0).saturating_mul(n.into())) + // Measured: `245 + n * (1 ±0)` + // Estimated: `245 + n * (1 ±0)` + // Minimum execution time: 51_000_000 picoseconds. + Weight::from_parts(53_100_000, 245) + // Standard Error: 41 + .saturating_add(Weight::from_parts(891, 0).saturating_mul(n.into())) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) } @@ -1730,12 +1714,12 @@ impl WeightInfo for () { /// The range of component `n` is `[0, 16384]`. fn seal_contains_storage(n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `248 + n * (1 ±0)` - // Estimated: `248 + n * (1 ±0)` - // Minimum execution time: 6_660_000 picoseconds. - Weight::from_parts(8_029_136, 248) - // Standard Error: 2 - .saturating_add(Weight::from_parts(85, 0).saturating_mul(n.into())) + // Measured: `245 + n * (1 ±0)` + // Estimated: `245 + n * (1 ±0)` + // Minimum execution time: 50_000_000 picoseconds. + Weight::from_parts(50_700_000, 245) + // Standard Error: 50 + .saturating_add(Weight::from_parts(769, 0).saturating_mul(n.into())) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) } @@ -1744,12 +1728,12 @@ impl WeightInfo for () { /// The range of component `n` is `[0, 16384]`. fn seal_take_storage(n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `248 + n * (1 ±0)` - // Estimated: `248 + n * (1 ±0)` - // Minimum execution time: 8_497_000 picoseconds. - Weight::from_parts(10_287_954, 248) - // Standard Error: 3 - .saturating_add(Weight::from_parts(699, 0).saturating_mul(n.into())) + // Measured: `245 + n * (1 ±0)` + // Estimated: `245 + n * (1 ±0)` + // Minimum execution time: 57_000_000 picoseconds. + Weight::from_parts(58_400_000, 245) + // Standard Error: 32 + .saturating_add(Weight::from_parts(854, 0).saturating_mul(n.into())) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) @@ -1760,8 +1744,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `140` // Estimated: `3605` - // Minimum execution time: 9_337_000 picoseconds. - Weight::from_parts(9_882_000, 3605) + // Minimum execution time: 99_000_000 picoseconds. + Weight::from_parts(103_000_000, 3605) .saturating_add(RocksDbWeight::get().reads(1_u64)) } /// Storage: `Contracts::ContractInfoOf` (r:1 w:2) @@ -1783,14 +1767,14 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `623 + t * (280 ±0)` // Estimated: `6563 + t * (3422 ±0)` - // Minimum execution time: 172_292_000 picoseconds. - Weight::from_parts(167_185_817, 6563) - // Standard Error: 327_522 - .saturating_add(Weight::from_parts(44_974_443, 0).saturating_mul(t.into())) - // Standard Error: 327_522 - .saturating_add(Weight::from_parts(4_283_151, 0).saturating_mul(c.into())) - // Standard Error: 0 - .saturating_add(Weight::from_parts(11, 0).saturating_mul(i.into())) + // Minimum execution time: 1_601_000_000 picoseconds. + Weight::from_parts(1_531_399_999, 6563) + // Standard Error: 15_255_326 + .saturating_add(Weight::from_parts(460_199_999, 0).saturating_mul(t.into())) + // Standard Error: 15_255_326 + .saturating_add(Weight::from_parts(86_499_999, 0).saturating_mul(c.into())) + // Standard Error: 14 + .saturating_add(Weight::from_parts(84, 0).saturating_mul(i.into())) .saturating_add(RocksDbWeight::get().reads(7_u64)) .saturating_add(RocksDbWeight::get().reads((2_u64).saturating_mul(t.into()))) .saturating_add(RocksDbWeight::get().writes(4_u64)) @@ -1811,8 +1795,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `433` // Estimated: `6373` - // Minimum execution time: 161_490_000 picoseconds. - Weight::from_parts(170_939_000, 6373) + // Minimum execution time: 1_526_000_000 picoseconds. + Weight::from_parts(1_547_000_000, 6373) .saturating_add(RocksDbWeight::get().reads(6_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) } @@ -1835,83 +1819,85 @@ impl WeightInfo for () { /// The range of component `s` is `[0, 983040]`. fn seal_instantiate(t: u32, i: u32, s: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `679 + t * (102 ±0)` - // Estimated: `6616 + t * (2565 ±1)` - // Minimum execution time: 1_819_574_000 picoseconds. - Weight::from_parts(1_829_348_000, 6616) - // Standard Error: 14 - .saturating_add(Weight::from_parts(731, 0).saturating_mul(i.into())) - // Standard Error: 14 - .saturating_add(Weight::from_parts(1_005, 0).saturating_mul(s.into())) + // Measured: `627 + t * (102 ±0)` + // Estimated: `6567 + t * (2577 ±0)` + // Minimum execution time: 3_818_000_000 picoseconds. + Weight::from_parts(2_080_099_999, 6567) + // Standard Error: 27_716_696 + .saturating_add(Weight::from_parts(389_800_000, 0).saturating_mul(t.into())) + // Standard Error: 28 + .saturating_add(Weight::from_parts(1_471, 0).saturating_mul(i.into())) + // Standard Error: 28 + .saturating_add(Weight::from_parts(1_568, 0).saturating_mul(s.into())) .saturating_add(RocksDbWeight::get().reads(10_u64)) .saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(t.into()))) .saturating_add(RocksDbWeight::get().writes(7_u64)) .saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(t.into()))) - .saturating_add(Weight::from_parts(0, 2565).saturating_mul(t.into())) + .saturating_add(Weight::from_parts(0, 2577).saturating_mul(t.into())) } /// The range of component `n` is `[0, 1048576]`. fn seal_hash_sha2_256(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 894_000 picoseconds. - Weight::from_parts(941_000, 0) - // Standard Error: 0 - .saturating_add(Weight::from_parts(1_151, 0).saturating_mul(n.into())) + // Minimum execution time: 7_000_000 picoseconds. + Weight::from_parts(8_000_000, 0) + // Standard Error: 1 + .saturating_add(Weight::from_parts(3_113, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 1048576]`. fn seal_hash_keccak_256(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_359_000 picoseconds. - Weight::from_parts(1_403_000, 0) - // Standard Error: 0 - .saturating_add(Weight::from_parts(3_410, 0).saturating_mul(n.into())) + // Minimum execution time: 8_000_000 picoseconds. + Weight::from_parts(8_600_000, 0) + // Standard Error: 3 + .saturating_add(Weight::from_parts(4_545, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 1048576]`. fn seal_hash_blake2_256(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 727_000 picoseconds. - Weight::from_parts(762_000, 0) - // Standard Error: 0 - .saturating_add(Weight::from_parts(1_280, 0).saturating_mul(n.into())) + // Minimum execution time: 4_000_000 picoseconds. + Weight::from_parts(5_000_000, 0) + // Standard Error: 5 + .saturating_add(Weight::from_parts(1_134, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 1048576]`. fn seal_hash_blake2_128(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 772_000 picoseconds. - Weight::from_parts(799_000, 0) - // Standard Error: 0 - .saturating_add(Weight::from_parts(1_279, 0).saturating_mul(n.into())) + // Minimum execution time: 5_000_000 picoseconds. + Weight::from_parts(5_000_000, 0) + // Standard Error: 3 + .saturating_add(Weight::from_parts(1_122, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 125697]`. fn seal_sr25519_verify(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 43_237_000 picoseconds. - Weight::from_parts(44_351_784, 0) - // Standard Error: 8 - .saturating_add(Weight::from_parts(4_756, 0).saturating_mul(n.into())) + // Minimum execution time: 58_000_000 picoseconds. + Weight::from_parts(58_600_000, 0) + // Standard Error: 4 + .saturating_add(Weight::from_parts(7_695, 0).saturating_mul(n.into())) } fn seal_ecdsa_recover() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 48_204_000 picoseconds. - Weight::from_parts(49_920_000, 0) + // Minimum execution time: 300_000_000 picoseconds. + Weight::from_parts(316_000_000, 0) } fn seal_ecdsa_to_eth_address() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 12_997_000 picoseconds. - Weight::from_parts(13_237_000, 0) + // Minimum execution time: 16_000_000 picoseconds. + Weight::from_parts(16_000_000, 0) } /// Storage: `Contracts::CodeInfoOf` (r:1 w:1) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) @@ -1925,8 +1911,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `433` // Estimated: `6373` - // Minimum execution time: 31_613_000 picoseconds. - Weight::from_parts(32_976_000, 6373) + // Minimum execution time: 304_000_000 picoseconds. + Weight::from_parts(306_000_000, 6373) .saturating_add(RocksDbWeight::get().reads(6_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) } @@ -1936,8 +1922,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `355` // Estimated: `3820` - // Minimum execution time: 9_330_000 picoseconds. - Weight::from_parts(9_933_000, 3820) + // Minimum execution time: 79_000_000 picoseconds. + Weight::from_parts(80_000_000, 3820) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -1947,8 +1933,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `355` // Estimated: `3558` - // Minimum execution time: 8_203_000 picoseconds. - Weight::from_parts(8_645_000, 3558) + // Minimum execution time: 64_000_000 picoseconds. + Weight::from_parts(66_000_000, 3558) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -1956,15 +1942,15 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 283_000 picoseconds. - Weight::from_parts(342_000, 0) + // Minimum execution time: 2_000_000 picoseconds. + Weight::from_parts(2_000_000, 0) } fn seal_account_reentrance_count() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 312_000 picoseconds. - Weight::from_parts(376_000, 0) + // Minimum execution time: 2_000_000 picoseconds. + Weight::from_parts(2_000_000, 0) } /// Storage: `Contracts::Nonce` (r:1 w:0) /// Proof: `Contracts::Nonce` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`) @@ -1972,8 +1958,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `219` // Estimated: `1704` - // Minimum execution time: 2_996_000 picoseconds. - Weight::from_parts(3_180_000, 1704) + // Minimum execution time: 26_000_000 picoseconds. + Weight::from_parts(26_000_000, 1704) .saturating_add(RocksDbWeight::get().reads(1_u64)) } /// The range of component `r` is `[0, 5000]`. @@ -1981,9 +1967,9 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_200_000 picoseconds. - Weight::from_parts(1_007_275, 0) - // Standard Error: 18 - .saturating_add(Weight::from_parts(15_124, 0).saturating_mul(r.into())) + // Minimum execution time: 5_000_000 picoseconds. + Weight::from_parts(5_900_000, 0) + // Standard Error: 124 + .saturating_add(Weight::from_parts(71_560, 0).saturating_mul(r.into())) } } From b2eb3145abf3ec04cee7940810b9ffb530b9ef06 Mon Sep 17 00:00:00 2001 From: command-bot <> Date: Mon, 29 Apr 2024 10:05:45 +0000 Subject: [PATCH 14/34] ".git/.scripts/commands/bench/bench.sh" --subcommand=pallet --runtime=dev --target_dir=substrate --pallet=pallet_contracts --- substrate/frame/contracts/src/weights.rs | 994 ++++++++++++----------- 1 file changed, 508 insertions(+), 486 deletions(-) diff --git a/substrate/frame/contracts/src/weights.rs b/substrate/frame/contracts/src/weights.rs index afcb2f29c217..169f2f34e410 100644 --- a/substrate/frame/contracts/src/weights.rs +++ b/substrate/frame/contracts/src/weights.rs @@ -1,24 +1,42 @@ +// This file is part of Substrate. + +// Copyright (C) Parity Technologies (UK) Ltd. +// SPDX-License-Identifier: Apache-2.0 + +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. //! Autogenerated weights for `pallet_contracts` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 32.0.0 -//! DATE: 2024-04-29, STEPS: `2`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2024-04-29, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` -//! HOSTNAME: `pgs-laptop.lan`, CPU: `` -//! WASM-EXECUTION: `Compiled`, CHAIN: `None`, DB CACHE: `1024` +//! HOSTNAME: `runner-unxyhko3-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz` +//! WASM-EXECUTION: `Compiled`, CHAIN: `Some("dev")`, DB CACHE: `1024` // Executed Command: -// target/debug/substrate-node +// target/production/substrate-node // benchmark // pallet -// --steps -// 2 -// -p -// pallet_contracts -// -e -// * -// --output -// substrate/frame/contracts/src/weights.rs +// --steps=50 +// --repeat=20 +// --extrinsic=* +// --wasm-execution=compiled +// --heap-pages=4096 +// --json-file=/builds/parity/mirrors/polkadot-sdk/.git/.artifacts/bench.json +// --pallet=pallet_contracts +// --chain=dev +// --header=./substrate/HEADER-APACHE2 +// --output=./substrate/frame/contracts/src/weights.rs // --template=./substrate/.maintain/frame-weight-template.hbs #![cfg_attr(rustfmt, rustfmt_skip)] @@ -110,8 +128,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `142` // Estimated: `1627` - // Minimum execution time: 20_000_000 picoseconds. - Weight::from_parts(21_000_000, 1627) + // Minimum execution time: 2_026_000 picoseconds. + Weight::from_parts(2_157_000, 1627) .saturating_add(T::DbWeight::get().reads(1_u64)) } /// Storage: `Skipped::Metadata` (r:0 w:0) @@ -119,12 +137,12 @@ impl WeightInfo for SubstrateWeight { /// The range of component `k` is `[0, 1024]`. fn on_initialize_per_trie_key(k: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `318 + k * (69 ±0)` - // Estimated: `318 + k * (70 ±0)` - // Minimum execution time: 104_000_000 picoseconds. - Weight::from_parts(104_700_000, 318) - // Standard Error: 34_890 - .saturating_add(Weight::from_parts(7_380_175, 0).saturating_mul(k.into())) + // Measured: `452 + k * (69 ±0)` + // Estimated: `442 + k * (70 ±0)` + // Minimum execution time: 12_505_000 picoseconds. + Weight::from_parts(12_905_000, 442) + // Standard Error: 1_429 + .saturating_add(Weight::from_parts(1_167_002, 0).saturating_mul(k.into())) .saturating_add(T::DbWeight::get().reads(2_u64)) .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(k.into()))) .saturating_add(T::DbWeight::get().writes(2_u64)) @@ -136,12 +154,12 @@ impl WeightInfo for SubstrateWeight { /// The range of component `c` is `[0, 125952]`. fn v9_migration_step(c: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `203 + c * (1 ±0)` - // Estimated: `6143 + c * (1 ±0)` - // Minimum execution time: 90_000_000 picoseconds. - Weight::from_parts(91_600_000, 6143) - // Standard Error: 7 - .saturating_add(Weight::from_parts(656, 0).saturating_mul(c.into())) + // Measured: `211 + c * (1 ±0)` + // Estimated: `6149 + c * (1 ±0)` + // Minimum execution time: 8_257_000 picoseconds. + Weight::from_parts(8_677_638, 6149) + // Standard Error: 1 + .saturating_add(Weight::from_parts(1_160, 0).saturating_mul(c.into())) .saturating_add(T::DbWeight::get().reads(2_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(c.into())) @@ -154,8 +172,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `510` // Estimated: `6450` - // Minimum execution time: 149_000_000 picoseconds. - Weight::from_parts(161_000_000, 6450) + // Minimum execution time: 17_053_000 picoseconds. + Weight::from_parts(17_518_000, 6450) .saturating_add(T::DbWeight::get().reads(3_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -166,14 +184,14 @@ impl WeightInfo for SubstrateWeight { /// The range of component `k` is `[0, 1024]`. fn v11_migration_step(k: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `166 + k * (1 ±0)` - // Estimated: `3631 + k * (1 ±0)` - // Minimum execution time: 32_000_000 picoseconds. - Weight::from_parts(33_299_999, 3631) - // Standard Error: 40_858 - .saturating_add(Weight::from_parts(15_348_925, 0).saturating_mul(k.into())) + // Measured: `171 + k * (1 ±0)` + // Estimated: `3635 + k * (1 ±0)` + // Minimum execution time: 3_507_000 picoseconds. + Weight::from_parts(2_116_985, 3635) + // Standard Error: 835 + .saturating_add(Weight::from_parts(1_222_371, 0).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(2_u64)) .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(k.into()))) .saturating_add(Weight::from_parts(0, 1).saturating_mul(k.into())) } @@ -190,12 +208,12 @@ impl WeightInfo for SubstrateWeight { /// The range of component `c` is `[0, 125952]`. fn v12_migration_step(c: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `320 + c * (1 ±0)` - // Estimated: `6260 + c * (1 ±0)` - // Minimum execution time: 205_000_000 picoseconds. - Weight::from_parts(206_400_000, 6260) - // Standard Error: 6 - .saturating_add(Weight::from_parts(304, 0).saturating_mul(c.into())) + // Measured: `328 + c * (1 ±0)` + // Estimated: `6266 + c * (1 ±0)` + // Minimum execution time: 20_657_000 picoseconds. + Weight::from_parts(20_858_035, 6266) + // Standard Error: 1 + .saturating_add(Weight::from_parts(383, 0).saturating_mul(c.into())) .saturating_add(T::DbWeight::get().reads(6_u64)) .saturating_add(T::DbWeight::get().writes(2_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(c.into())) @@ -206,8 +224,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `440` // Estimated: `6380` - // Minimum execution time: 109_000_000 picoseconds. - Weight::from_parts(111_000_000, 6380) + // Minimum execution time: 12_848_000 picoseconds. + Weight::from_parts(13_570_000, 6380) .saturating_add(T::DbWeight::get().reads(2_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -221,8 +239,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `352` // Estimated: `6292` - // Minimum execution time: 492_000_000 picoseconds. - Weight::from_parts(513_000_000, 6292) + // Minimum execution time: 46_737_000 picoseconds. + Weight::from_parts(48_131_000, 6292) .saturating_add(T::DbWeight::get().reads(4_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -234,8 +252,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `594` // Estimated: `6534` - // Minimum execution time: 433_000_000 picoseconds. - Weight::from_parts(471_000_000, 6534) + // Minimum execution time: 56_586_000 picoseconds. + Weight::from_parts(59_047_000, 6534) .saturating_add(T::DbWeight::get().reads(4_u64)) .saturating_add(T::DbWeight::get().writes(2_u64)) } @@ -245,8 +263,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `409` // Estimated: `6349` - // Minimum execution time: 108_000_000 picoseconds. - Weight::from_parts(110_000_000, 6349) + // Minimum execution time: 12_355_000 picoseconds. + Weight::from_parts(13_530_000, 6349) .saturating_add(T::DbWeight::get().reads(2_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -256,8 +274,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `142` // Estimated: `1627` - // Minimum execution time: 23_000_000 picoseconds. - Weight::from_parts(24_000_000, 1627) + // Minimum execution time: 2_441_000 picoseconds. + Weight::from_parts(2_656_000, 1627) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -269,8 +287,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `166` // Estimated: `3631` - // Minimum execution time: 119_000_000 picoseconds. - Weight::from_parts(147_000_000, 3631) + // Minimum execution time: 12_083_000 picoseconds. + Weight::from_parts(12_404_000, 3631) .saturating_add(T::DbWeight::get().reads(2_u64)) .saturating_add(T::DbWeight::get().writes(2_u64)) } @@ -280,8 +298,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `142` // Estimated: `3607` - // Minimum execution time: 42_000_000 picoseconds. - Weight::from_parts(43_000_000, 3607) + // Minimum execution time: 4_785_000 picoseconds. + Weight::from_parts(5_105_000, 3607) .saturating_add(T::DbWeight::get().reads(1_u64)) } /// Storage: UNKNOWN KEY `0x4342193e496fab7ec59d615ed0dc55304e7b9012096b41c4eb3aaf947f6ea429` (r:1 w:0) @@ -292,8 +310,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `167` // Estimated: `3632` - // Minimum execution time: 56_000_000 picoseconds. - Weight::from_parts(58_000_000, 3632) + // Minimum execution time: 6_098_000 picoseconds. + Weight::from_parts(6_424_000, 3632) .saturating_add(T::DbWeight::get().reads(2_u64)) } /// Storage: UNKNOWN KEY `0x4342193e496fab7ec59d615ed0dc55304e7b9012096b41c4eb3aaf947f6ea429` (r:1 w:0) @@ -304,8 +322,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `142` // Estimated: `3607` - // Minimum execution time: 56_000_000 picoseconds. - Weight::from_parts(57_000_000, 3607) + // Minimum execution time: 6_168_000 picoseconds. + Weight::from_parts(6_391_000, 3607) .saturating_add(T::DbWeight::get().reads(2_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -328,12 +346,12 @@ impl WeightInfo for SubstrateWeight { /// The range of component `c` is `[0, 125952]`. fn call_with_code_per_byte(c: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `832` - // Estimated: `9247 + c * (1 ±0)` - // Minimum execution time: 2_222_000_000 picoseconds. - Weight::from_parts(2_246_800_000, 9247) - // Standard Error: 194 - .saturating_add(Weight::from_parts(78_581, 0).saturating_mul(c.into())) + // Measured: `804 + c * (1 ±0)` + // Estimated: `9217 + c * (1 ±0)` + // Minimum execution time: 304_486_000 picoseconds. + Weight::from_parts(281_210_403, 9217) + // Standard Error: 71 + .saturating_add(Weight::from_parts(33_632, 0).saturating_mul(c.into())) .saturating_add(T::DbWeight::get().reads(11_u64)) .saturating_add(T::DbWeight::get().writes(4_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(c.into())) @@ -363,16 +381,16 @@ 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: `443` - // Estimated: `8858` - // Minimum execution time: 8_001_000_000 picoseconds. - Weight::from_parts(4_996_600_018, 8858) - // Standard Error: 606 - .saturating_add(Weight::from_parts(158_819, 0).saturating_mul(c.into())) - // Standard Error: 72 - .saturating_add(Weight::from_parts(1_394, 0).saturating_mul(i.into())) - // Standard Error: 72 - .saturating_add(Weight::from_parts(1_681, 0).saturating_mul(s.into())) + // Measured: `326` + // Estimated: `8740` + // Minimum execution time: 4_111_986_000 picoseconds. + Weight::from_parts(381_653_579, 8740) + // Standard Error: 198 + .saturating_add(Weight::from_parts(70_030, 0).saturating_mul(c.into())) + // Standard Error: 23 + .saturating_add(Weight::from_parts(1_669, 0).saturating_mul(i.into())) + // Standard Error: 23 + .saturating_add(Weight::from_parts(1_842, 0).saturating_mul(s.into())) .saturating_add(T::DbWeight::get().reads(14_u64)) .saturating_add(T::DbWeight::get().writes(10_u64)) } @@ -400,14 +418,14 @@ 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: `615` - // Estimated: `9030` - // Minimum execution time: 4_452_000_000 picoseconds. - Weight::from_parts(3_312_250_000, 9030) - // Standard Error: 24 - .saturating_add(Weight::from_parts(1_571, 0).saturating_mul(i.into())) - // Standard Error: 24 - .saturating_add(Weight::from_parts(1_133, 0).saturating_mul(s.into())) + // Measured: `563` + // Estimated: `8982` + // Minimum execution time: 1_996_742_000 picoseconds. + Weight::from_parts(2_026_648_000, 8982) + // Standard Error: 25 + .saturating_add(Weight::from_parts(849, 0).saturating_mul(i.into())) + // Standard Error: 25 + .saturating_add(Weight::from_parts(852, 0).saturating_mul(s.into())) .saturating_add(T::DbWeight::get().reads(13_u64)) .saturating_add(T::DbWeight::get().writes(7_u64)) } @@ -431,8 +449,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `829` // Estimated: `9244` - // Minimum execution time: 2_150_000_000 picoseconds. - Weight::from_parts(2_237_000_000, 9244) + // Minimum execution time: 206_272_000 picoseconds. + Weight::from_parts(217_655_000, 9244) .saturating_add(T::DbWeight::get().reads(11_u64)) .saturating_add(T::DbWeight::get().writes(4_u64)) } @@ -453,10 +471,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `145` // Estimated: `6085` - // Minimum execution time: 1_943_000_000 picoseconds. - Weight::from_parts(2_061_000_000, 6085) - // Standard Error: 425 - .saturating_add(Weight::from_parts(80_155, 0).saturating_mul(c.into())) + // Minimum execution time: 277_885_000 picoseconds. + Weight::from_parts(264_589_547, 6085) + // Standard Error: 73 + .saturating_add(Weight::from_parts(33_704, 0).saturating_mul(c.into())) .saturating_add(T::DbWeight::get().reads(6_u64)) .saturating_add(T::DbWeight::get().writes(4_u64)) } @@ -477,10 +495,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `145` // Estimated: `6085` - // Minimum execution time: 2_143_000_000 picoseconds. - Weight::from_parts(2_231_100_000, 6085) - // Standard Error: 246 - .saturating_add(Weight::from_parts(79_070, 0).saturating_mul(c.into())) + // Minimum execution time: 298_636_000 picoseconds. + Weight::from_parts(271_144_699, 6085) + // Standard Error: 100 + .saturating_add(Weight::from_parts(34_478, 0).saturating_mul(c.into())) .saturating_add(T::DbWeight::get().reads(6_u64)) .saturating_add(T::DbWeight::get().writes(4_u64)) } @@ -498,8 +516,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `315` // Estimated: `3780` - // Minimum execution time: 483_000_000 picoseconds. - Weight::from_parts(512_000_000, 3780) + // Minimum execution time: 46_040_000 picoseconds. + Weight::from_parts(48_079_000, 3780) .saturating_add(T::DbWeight::get().reads(4_u64)) .saturating_add(T::DbWeight::get().writes(4_u64)) } @@ -515,8 +533,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `552` // Estimated: `8967` - // Minimum execution time: 321_000_000 picoseconds. - Weight::from_parts(334_000_000, 8967) + // Minimum execution time: 34_375_000 picoseconds. + Weight::from_parts(36_222_000, 8967) .saturating_add(T::DbWeight::get().reads(7_u64)) .saturating_add(T::DbWeight::get().writes(6_u64)) } @@ -525,17 +543,17 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 149_000_000 picoseconds. - Weight::from_parts(150_400_000, 0) - // Standard Error: 190 - .saturating_add(Weight::from_parts(92_875, 0).saturating_mul(r.into())) + // Minimum execution time: 10_802_000 picoseconds. + Weight::from_parts(11_876_953, 0) + // Standard Error: 85 + .saturating_add(Weight::from_parts(70_319, 0).saturating_mul(r.into())) } fn seal_caller() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 6_000_000 picoseconds. - Weight::from_parts(6_000_000, 0) + // Minimum execution time: 560_000 picoseconds. + Weight::from_parts(627_000, 0) } /// Storage: `Contracts::ContractInfoOf` (r:1 w:0) /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) @@ -543,8 +561,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `354` // Estimated: `3819` - // Minimum execution time: 56_000_000 picoseconds. - Weight::from_parts(57_000_000, 3819) + // Minimum execution time: 6_604_000 picoseconds. + Weight::from_parts(6_824_000, 3819) .saturating_add(T::DbWeight::get().reads(1_u64)) } /// Storage: `Contracts::ContractInfoOf` (r:1 w:0) @@ -553,44 +571,44 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `447` // Estimated: `3912` - // Minimum execution time: 67_000_000 picoseconds. - Weight::from_parts(69_000_000, 3912) + // Minimum execution time: 7_697_000 picoseconds. + Weight::from_parts(8_009_000, 3912) .saturating_add(T::DbWeight::get().reads(1_u64)) } fn seal_own_code_hash() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 8_000_000 picoseconds. - Weight::from_parts(8_000_000, 0) + // Minimum execution time: 783_000 picoseconds. + Weight::from_parts(825_000, 0) } fn seal_caller_is_origin() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_000_000 picoseconds. - Weight::from_parts(3_000_000, 0) + // Minimum execution time: 329_000 picoseconds. + Weight::from_parts(383_000, 0) } fn seal_caller_is_root() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_000_000 picoseconds. - Weight::from_parts(2_000_000, 0) + // Minimum execution time: 309_000 picoseconds. + Weight::from_parts(357_000, 0) } fn seal_address() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 5_000_000 picoseconds. - Weight::from_parts(6_000_000, 0) + // Minimum execution time: 554_000 picoseconds. + Weight::from_parts(601_000, 0) } fn seal_gas_left() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 6_000_000 picoseconds. - Weight::from_parts(6_000_000, 0) + // Minimum execution time: 639_000 picoseconds. + Weight::from_parts(693_000, 0) } /// Storage: `System::Account` (r:1 w:0) /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`) @@ -598,37 +616,37 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `140` // Estimated: `3605` - // Minimum execution time: 46_000_000 picoseconds. - Weight::from_parts(46_000_000, 3605) + // Minimum execution time: 4_720_000 picoseconds. + Weight::from_parts(4_902_000, 3605) .saturating_add(T::DbWeight::get().reads(1_u64)) } fn seal_value_transferred() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 6_000_000 picoseconds. - Weight::from_parts(6_000_000, 0) + // Minimum execution time: 538_000 picoseconds. + Weight::from_parts(586_000, 0) } fn seal_minimum_balance() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 6_000_000 picoseconds. - Weight::from_parts(6_000_000, 0) + // Minimum execution time: 509_000 picoseconds. + Weight::from_parts(571_000, 0) } fn seal_block_number() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 6_000_000 picoseconds. - Weight::from_parts(6_000_000, 0) + // Minimum execution time: 535_000 picoseconds. + Weight::from_parts(586_000, 0) } fn seal_now() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 6_000_000 picoseconds. - Weight::from_parts(6_000_000, 0) + // Minimum execution time: 578_000 picoseconds. + Weight::from_parts(637_000, 0) } /// Storage: `TransactionPayment::NextFeeMultiplier` (r:1 w:0) /// Proof: `TransactionPayment::NextFeeMultiplier` (`max_values`: Some(1), `max_size`: Some(16), added: 511, mode: `Measured`) @@ -636,8 +654,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `67` // Estimated: `1552` - // Minimum execution time: 34_000_000 picoseconds. - Weight::from_parts(35_000_000, 1552) + // Minimum execution time: 4_416_000 picoseconds. + Weight::from_parts(4_611_000, 1552) .saturating_add(T::DbWeight::get().reads(1_u64)) } /// The range of component `n` is `[0, 1048572]`. @@ -645,20 +663,20 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 4_000_000 picoseconds. - Weight::from_parts(4_800_000, 0) - // Standard Error: 0 - .saturating_add(Weight::from_parts(77, 0).saturating_mul(n.into())) + // Minimum execution time: 469_000 picoseconds. + Weight::from_parts(513_000, 0) + // Standard Error: 3 + .saturating_add(Weight::from_parts(294, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 1048572]`. fn seal_return(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_000_000 picoseconds. - Weight::from_parts(2_000_000, 0) - // Standard Error: 0 - .saturating_add(Weight::from_parts(156, 0).saturating_mul(n.into())) + // Minimum execution time: 328_000 picoseconds. + Weight::from_parts(345_000, 0) + // Standard Error: 9 + .saturating_add(Weight::from_parts(400, 0).saturating_mul(n.into())) } /// Storage: `Contracts::DeletionQueueCounter` (r:1 w:1) /// Proof: `Contracts::DeletionQueueCounter` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`) @@ -674,8 +692,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `2821` // Estimated: `85486` - // Minimum execution time: 1_399_000_000 picoseconds. - Weight::from_parts(1_407_000_000, 85486) + // Minimum execution time: 134_982_000 picoseconds. + Weight::from_parts(137_218_000, 85486) .saturating_add(T::DbWeight::get().reads(36_u64)) .saturating_add(T::DbWeight::get().writes(38_u64)) } @@ -685,35 +703,37 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `76` // Estimated: `1561` - // Minimum execution time: 33_000_000 picoseconds. - Weight::from_parts(34_000_000, 1561) + // Minimum execution time: 3_641_000 picoseconds. + Weight::from_parts(3_851_000, 1561) .saturating_add(T::DbWeight::get().reads(1_u64)) } /// Storage: `System::EventTopics` (r:4 w:4) /// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`) /// The range of component `t` is `[0, 4]`. /// The range of component `n` is `[0, 16384]`. - fn seal_deposit_event(t: u32, _n: u32, ) -> Weight { + fn seal_deposit_event(t: u32, n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` - // Estimated: `641 + t * (2562 ±0)` - // Minimum execution time: 27_000_000 picoseconds. - Weight::from_parts(33_099_999, 641) - // Standard Error: 132_510 - .saturating_add(Weight::from_parts(28_975_000, 0).saturating_mul(t.into())) + // Estimated: `990 + t * (2475 ±0)` + // Minimum execution time: 4_143_000 picoseconds. + Weight::from_parts(4_355_459, 990) + // Standard Error: 7_907 + .saturating_add(Weight::from_parts(2_334_740, 0).saturating_mul(t.into())) + // Standard Error: 2 + .saturating_add(Weight::from_parts(28, 0).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(t.into()))) .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(t.into()))) - .saturating_add(Weight::from_parts(0, 2562).saturating_mul(t.into())) + .saturating_add(Weight::from_parts(0, 2475).saturating_mul(t.into())) } /// The range of component `i` is `[0, 1048576]`. fn seal_debug_message(i: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_000_000 picoseconds. - Weight::from_parts(2_000_000, 0) - // Standard Error: 0 - .saturating_add(Weight::from_parts(425, 0).saturating_mul(i.into())) + // Minimum execution time: 436_000 picoseconds. + Weight::from_parts(464_000, 0) + // Standard Error: 10 + .saturating_add(Weight::from_parts(1_204, 0).saturating_mul(i.into())) } /// Storage: `Skipped::Metadata` (r:0 w:0) /// Proof: `Skipped::Metadata` (`max_values`: None, `max_size`: None, mode: `Measured`) @@ -722,10 +742,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `245` // Estimated: `245` - // Minimum execution time: 55_000_000 picoseconds. - Weight::from_parts(56_300_000, 245) - // Standard Error: 13 - .saturating_add(Weight::from_parts(286, 0).saturating_mul(n.into())) + // Minimum execution time: 7_574_000 picoseconds. + Weight::from_parts(8_651_771, 245) + // Standard Error: 1 + .saturating_add(Weight::from_parts(255, 0).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -734,12 +754,12 @@ impl WeightInfo for SubstrateWeight { /// The range of component `n` is `[0, 16384]`. fn seal_set_storage_per_old_byte(n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `245 + n * (1 ±0)` - // Estimated: `245 + n * (1 ±0)` - // Minimum execution time: 55_000_000 picoseconds. - Weight::from_parts(55_300_000, 245) - // Standard Error: 17 - .saturating_add(Weight::from_parts(415, 0).saturating_mul(n.into())) + // Measured: `248 + n * (1 ±0)` + // Estimated: `248 + n * (1 ±0)` + // Minimum execution time: 7_553_000 picoseconds. + Weight::from_parts(9_223_601, 248) + // Standard Error: 2 + .saturating_add(Weight::from_parts(86, 0).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) @@ -749,12 +769,12 @@ impl WeightInfo for SubstrateWeight { /// The range of component `n` is `[0, 16384]`. fn seal_clear_storage(n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `245 + n * (1 ±0)` - // Estimated: `245 + n * (1 ±0)` - // Minimum execution time: 56_000_000 picoseconds. - Weight::from_parts(61_200_000, 245) - // Standard Error: 46 - .saturating_add(Weight::from_parts(73, 0).saturating_mul(n.into())) + // Measured: `248 + n * (1 ±0)` + // Estimated: `248 + n * (1 ±0)` + // Minimum execution time: 7_856_000 picoseconds. + Weight::from_parts(9_180_008, 248) + // Standard Error: 2 + .saturating_add(Weight::from_parts(89, 0).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) @@ -764,12 +784,12 @@ impl WeightInfo for SubstrateWeight { /// The range of component `n` is `[0, 16384]`. fn seal_get_storage(n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `245 + n * (1 ±0)` - // Estimated: `245 + n * (1 ±0)` - // Minimum execution time: 51_000_000 picoseconds. - Weight::from_parts(53_100_000, 245) - // Standard Error: 41 - .saturating_add(Weight::from_parts(891, 0).saturating_mul(n.into())) + // Measured: `248 + n * (1 ±0)` + // Estimated: `248 + n * (1 ±0)` + // Minimum execution time: 7_126_000 picoseconds. + Weight::from_parts(8_921_997, 248) + // Standard Error: 3 + .saturating_add(Weight::from_parts(614, 0).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) } @@ -778,12 +798,12 @@ impl WeightInfo for SubstrateWeight { /// The range of component `n` is `[0, 16384]`. fn seal_contains_storage(n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `245 + n * (1 ±0)` - // Estimated: `245 + n * (1 ±0)` - // Minimum execution time: 50_000_000 picoseconds. - Weight::from_parts(50_700_000, 245) - // Standard Error: 50 - .saturating_add(Weight::from_parts(769, 0).saturating_mul(n.into())) + // Measured: `248 + n * (1 ±0)` + // Estimated: `248 + n * (1 ±0)` + // Minimum execution time: 6_715_000 picoseconds. + Weight::from_parts(7_848_323, 248) + // Standard Error: 2 + .saturating_add(Weight::from_parts(88, 0).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) } @@ -792,12 +812,12 @@ impl WeightInfo for SubstrateWeight { /// The range of component `n` is `[0, 16384]`. fn seal_take_storage(n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `245 + n * (1 ±0)` - // Estimated: `245 + n * (1 ±0)` - // Minimum execution time: 57_000_000 picoseconds. - Weight::from_parts(58_400_000, 245) - // Standard Error: 32 - .saturating_add(Weight::from_parts(854, 0).saturating_mul(n.into())) + // Measured: `248 + n * (1 ±0)` + // Estimated: `248 + n * (1 ±0)` + // Minimum execution time: 8_318_000 picoseconds. + Weight::from_parts(9_990_344, 248) + // Standard Error: 5 + .saturating_add(Weight::from_parts(634, 0).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) @@ -808,8 +828,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `140` // Estimated: `3605` - // Minimum execution time: 99_000_000 picoseconds. - Weight::from_parts(103_000_000, 3605) + // Minimum execution time: 8_900_000 picoseconds. + Weight::from_parts(9_215_000, 3605) .saturating_add(T::DbWeight::get().reads(1_u64)) } /// Storage: `Contracts::ContractInfoOf` (r:1 w:2) @@ -831,14 +851,14 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `623 + t * (280 ±0)` // Estimated: `6563 + t * (3422 ±0)` - // Minimum execution time: 1_601_000_000 picoseconds. - Weight::from_parts(1_531_399_999, 6563) - // Standard Error: 15_255_326 - .saturating_add(Weight::from_parts(460_199_999, 0).saturating_mul(t.into())) - // Standard Error: 15_255_326 - .saturating_add(Weight::from_parts(86_499_999, 0).saturating_mul(c.into())) - // Standard Error: 14 - .saturating_add(Weight::from_parts(84, 0).saturating_mul(i.into())) + // Minimum execution time: 164_943_000 picoseconds. + Weight::from_parts(164_713_349, 6563) + // Standard Error: 323_916 + .saturating_add(Weight::from_parts(43_689_556, 0).saturating_mul(t.into())) + // Standard Error: 323_916 + .saturating_add(Weight::from_parts(2_727_352, 0).saturating_mul(c.into())) + // Standard Error: 0 + .saturating_add(Weight::from_parts(7, 0).saturating_mul(i.into())) .saturating_add(T::DbWeight::get().reads(7_u64)) .saturating_add(T::DbWeight::get().reads((2_u64).saturating_mul(t.into()))) .saturating_add(T::DbWeight::get().writes(4_u64)) @@ -859,8 +879,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `433` // Estimated: `6373` - // Minimum execution time: 1_526_000_000 picoseconds. - Weight::from_parts(1_547_000_000, 6373) + // Minimum execution time: 152_390_000 picoseconds. + Weight::from_parts(165_217_000, 6373) .saturating_add(T::DbWeight::get().reads(6_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) } @@ -883,85 +903,85 @@ impl WeightInfo for SubstrateWeight { /// The range of component `s` is `[0, 983040]`. fn seal_instantiate(t: u32, i: u32, s: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `627 + t * (102 ±0)` - // Estimated: `6567 + t * (2577 ±0)` - // Minimum execution time: 3_818_000_000 picoseconds. - Weight::from_parts(2_080_099_999, 6567) - // Standard Error: 27_716_696 - .saturating_add(Weight::from_parts(389_800_000, 0).saturating_mul(t.into())) - // Standard Error: 28 - .saturating_add(Weight::from_parts(1_471, 0).saturating_mul(i.into())) - // Standard Error: 28 - .saturating_add(Weight::from_parts(1_568, 0).saturating_mul(s.into())) + // Measured: `679 + t * (102 ±0)` + // Estimated: `6616 + t * (2565 ±1)` + // Minimum execution time: 1_709_241_000 picoseconds. + Weight::from_parts(162_472_084, 6616) + // Standard Error: 9_135_790 + .saturating_add(Weight::from_parts(119_325_657, 0).saturating_mul(t.into())) + // Standard Error: 14 + .saturating_add(Weight::from_parts(1_389, 0).saturating_mul(i.into())) + // Standard Error: 14 + .saturating_add(Weight::from_parts(1_787, 0).saturating_mul(s.into())) .saturating_add(T::DbWeight::get().reads(10_u64)) .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(t.into()))) .saturating_add(T::DbWeight::get().writes(7_u64)) .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(t.into()))) - .saturating_add(Weight::from_parts(0, 2577).saturating_mul(t.into())) + .saturating_add(Weight::from_parts(0, 2565).saturating_mul(t.into())) } /// The range of component `n` is `[0, 1048576]`. fn seal_hash_sha2_256(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 7_000_000 picoseconds. - Weight::from_parts(8_000_000, 0) - // Standard Error: 1 - .saturating_add(Weight::from_parts(3_113, 0).saturating_mul(n.into())) + // Minimum execution time: 864_000 picoseconds. + Weight::from_parts(914_000, 0) + // Standard Error: 0 + .saturating_add(Weight::from_parts(1_060, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 1048576]`. fn seal_hash_keccak_256(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 8_000_000 picoseconds. - Weight::from_parts(8_600_000, 0) - // Standard Error: 3 - .saturating_add(Weight::from_parts(4_545, 0).saturating_mul(n.into())) + // Minimum execution time: 1_305_000 picoseconds. + Weight::from_parts(1_342_000, 0) + // Standard Error: 0 + .saturating_add(Weight::from_parts(3_322, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 1048576]`. fn seal_hash_blake2_256(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 4_000_000 picoseconds. - Weight::from_parts(5_000_000, 0) - // Standard Error: 5 - .saturating_add(Weight::from_parts(1_134, 0).saturating_mul(n.into())) + // Minimum execution time: 741_000 picoseconds. + Weight::from_parts(772_000, 0) + // Standard Error: 0 + .saturating_add(Weight::from_parts(1_188, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 1048576]`. fn seal_hash_blake2_128(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 5_000_000 picoseconds. - Weight::from_parts(5_000_000, 0) - // Standard Error: 3 - .saturating_add(Weight::from_parts(1_122, 0).saturating_mul(n.into())) + // Minimum execution time: 735_000 picoseconds. + Weight::from_parts(759_000, 0) + // Standard Error: 0 + .saturating_add(Weight::from_parts(1_188, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 125697]`. fn seal_sr25519_verify(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 58_000_000 picoseconds. - Weight::from_parts(58_600_000, 0) - // Standard Error: 4 - .saturating_add(Weight::from_parts(7_695, 0).saturating_mul(n.into())) + // Minimum execution time: 44_096_000 picoseconds. + Weight::from_parts(45_203_791, 0) + // Standard Error: 7 + .saturating_add(Weight::from_parts(4_670, 0).saturating_mul(n.into())) } fn seal_ecdsa_recover() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 300_000_000 picoseconds. - Weight::from_parts(316_000_000, 0) + // Minimum execution time: 47_195_000 picoseconds. + Weight::from_parts(49_118_000, 0) } fn seal_ecdsa_to_eth_address() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 16_000_000 picoseconds. - Weight::from_parts(16_000_000, 0) + // Minimum execution time: 13_001_000 picoseconds. + Weight::from_parts(13_115_000, 0) } /// Storage: `Contracts::CodeInfoOf` (r:1 w:1) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) @@ -975,8 +995,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `433` // Estimated: `6373` - // Minimum execution time: 304_000_000 picoseconds. - Weight::from_parts(306_000_000, 6373) + // Minimum execution time: 31_502_000 picoseconds. + Weight::from_parts(32_325_000, 6373) .saturating_add(T::DbWeight::get().reads(6_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) } @@ -986,8 +1006,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `355` // Estimated: `3820` - // Minimum execution time: 79_000_000 picoseconds. - Weight::from_parts(80_000_000, 3820) + // Minimum execution time: 9_266_000 picoseconds. + Weight::from_parts(9_628_000, 3820) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -997,8 +1017,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `355` // Estimated: `3558` - // Minimum execution time: 64_000_000 picoseconds. - Weight::from_parts(66_000_000, 3558) + // Minimum execution time: 8_125_000 picoseconds. + Weight::from_parts(8_525_000, 3558) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -1006,15 +1026,15 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_000_000 picoseconds. - Weight::from_parts(2_000_000, 0) + // Minimum execution time: 307_000 picoseconds. + Weight::from_parts(344_000, 0) } fn seal_account_reentrance_count() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_000_000 picoseconds. - Weight::from_parts(2_000_000, 0) + // Minimum execution time: 338_000 picoseconds. + Weight::from_parts(370_000, 0) } /// Storage: `Contracts::Nonce` (r:1 w:0) /// Proof: `Contracts::Nonce` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`) @@ -1022,8 +1042,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `219` // Estimated: `1704` - // Minimum execution time: 26_000_000 picoseconds. - Weight::from_parts(26_000_000, 1704) + // Minimum execution time: 2_892_000 picoseconds. + Weight::from_parts(3_126_000, 1704) .saturating_add(T::DbWeight::get().reads(1_u64)) } /// The range of component `r` is `[0, 5000]`. @@ -1031,10 +1051,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 5_000_000 picoseconds. - Weight::from_parts(5_900_000, 0) - // Standard Error: 124 - .saturating_add(Weight::from_parts(71_560, 0).saturating_mul(r.into())) + // Minimum execution time: 919_000 picoseconds. + Weight::from_parts(514_641, 0) + // Standard Error: 18 + .saturating_add(Weight::from_parts(15_217, 0).saturating_mul(r.into())) } } @@ -1046,8 +1066,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `142` // Estimated: `1627` - // Minimum execution time: 20_000_000 picoseconds. - Weight::from_parts(21_000_000, 1627) + // Minimum execution time: 2_026_000 picoseconds. + Weight::from_parts(2_157_000, 1627) .saturating_add(RocksDbWeight::get().reads(1_u64)) } /// Storage: `Skipped::Metadata` (r:0 w:0) @@ -1055,12 +1075,12 @@ impl WeightInfo for () { /// The range of component `k` is `[0, 1024]`. fn on_initialize_per_trie_key(k: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `318 + k * (69 ±0)` - // Estimated: `318 + k * (70 ±0)` - // Minimum execution time: 104_000_000 picoseconds. - Weight::from_parts(104_700_000, 318) - // Standard Error: 34_890 - .saturating_add(Weight::from_parts(7_380_175, 0).saturating_mul(k.into())) + // Measured: `452 + k * (69 ±0)` + // Estimated: `442 + k * (70 ±0)` + // Minimum execution time: 12_505_000 picoseconds. + Weight::from_parts(12_905_000, 442) + // Standard Error: 1_429 + .saturating_add(Weight::from_parts(1_167_002, 0).saturating_mul(k.into())) .saturating_add(RocksDbWeight::get().reads(2_u64)) .saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(k.into()))) .saturating_add(RocksDbWeight::get().writes(2_u64)) @@ -1072,12 +1092,12 @@ impl WeightInfo for () { /// The range of component `c` is `[0, 125952]`. fn v9_migration_step(c: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `203 + c * (1 ±0)` - // Estimated: `6143 + c * (1 ±0)` - // Minimum execution time: 90_000_000 picoseconds. - Weight::from_parts(91_600_000, 6143) - // Standard Error: 7 - .saturating_add(Weight::from_parts(656, 0).saturating_mul(c.into())) + // Measured: `211 + c * (1 ±0)` + // Estimated: `6149 + c * (1 ±0)` + // Minimum execution time: 8_257_000 picoseconds. + Weight::from_parts(8_677_638, 6149) + // Standard Error: 1 + .saturating_add(Weight::from_parts(1_160, 0).saturating_mul(c.into())) .saturating_add(RocksDbWeight::get().reads(2_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(c.into())) @@ -1090,8 +1110,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `510` // Estimated: `6450` - // Minimum execution time: 149_000_000 picoseconds. - Weight::from_parts(161_000_000, 6450) + // Minimum execution time: 17_053_000 picoseconds. + Weight::from_parts(17_518_000, 6450) .saturating_add(RocksDbWeight::get().reads(3_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -1102,14 +1122,14 @@ impl WeightInfo for () { /// The range of component `k` is `[0, 1024]`. fn v11_migration_step(k: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `166 + k * (1 ±0)` - // Estimated: `3631 + k * (1 ±0)` - // Minimum execution time: 32_000_000 picoseconds. - Weight::from_parts(33_299_999, 3631) - // Standard Error: 40_858 - .saturating_add(Weight::from_parts(15_348_925, 0).saturating_mul(k.into())) + // Measured: `171 + k * (1 ±0)` + // Estimated: `3635 + k * (1 ±0)` + // Minimum execution time: 3_507_000 picoseconds. + Weight::from_parts(2_116_985, 3635) + // Standard Error: 835 + .saturating_add(Weight::from_parts(1_222_371, 0).saturating_mul(k.into())) .saturating_add(RocksDbWeight::get().reads(1_u64)) - .saturating_add(RocksDbWeight::get().writes(1_u64)) + .saturating_add(RocksDbWeight::get().writes(2_u64)) .saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(k.into()))) .saturating_add(Weight::from_parts(0, 1).saturating_mul(k.into())) } @@ -1126,12 +1146,12 @@ impl WeightInfo for () { /// The range of component `c` is `[0, 125952]`. fn v12_migration_step(c: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `320 + c * (1 ±0)` - // Estimated: `6260 + c * (1 ±0)` - // Minimum execution time: 205_000_000 picoseconds. - Weight::from_parts(206_400_000, 6260) - // Standard Error: 6 - .saturating_add(Weight::from_parts(304, 0).saturating_mul(c.into())) + // Measured: `328 + c * (1 ±0)` + // Estimated: `6266 + c * (1 ±0)` + // Minimum execution time: 20_657_000 picoseconds. + Weight::from_parts(20_858_035, 6266) + // Standard Error: 1 + .saturating_add(Weight::from_parts(383, 0).saturating_mul(c.into())) .saturating_add(RocksDbWeight::get().reads(6_u64)) .saturating_add(RocksDbWeight::get().writes(2_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(c.into())) @@ -1142,8 +1162,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `440` // Estimated: `6380` - // Minimum execution time: 109_000_000 picoseconds. - Weight::from_parts(111_000_000, 6380) + // Minimum execution time: 12_848_000 picoseconds. + Weight::from_parts(13_570_000, 6380) .saturating_add(RocksDbWeight::get().reads(2_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -1157,8 +1177,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `352` // Estimated: `6292` - // Minimum execution time: 492_000_000 picoseconds. - Weight::from_parts(513_000_000, 6292) + // Minimum execution time: 46_737_000 picoseconds. + Weight::from_parts(48_131_000, 6292) .saturating_add(RocksDbWeight::get().reads(4_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -1170,8 +1190,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `594` // Estimated: `6534` - // Minimum execution time: 433_000_000 picoseconds. - Weight::from_parts(471_000_000, 6534) + // Minimum execution time: 56_586_000 picoseconds. + Weight::from_parts(59_047_000, 6534) .saturating_add(RocksDbWeight::get().reads(4_u64)) .saturating_add(RocksDbWeight::get().writes(2_u64)) } @@ -1181,8 +1201,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `409` // Estimated: `6349` - // Minimum execution time: 108_000_000 picoseconds. - Weight::from_parts(110_000_000, 6349) + // Minimum execution time: 12_355_000 picoseconds. + Weight::from_parts(13_530_000, 6349) .saturating_add(RocksDbWeight::get().reads(2_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -1192,8 +1212,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `142` // Estimated: `1627` - // Minimum execution time: 23_000_000 picoseconds. - Weight::from_parts(24_000_000, 1627) + // Minimum execution time: 2_441_000 picoseconds. + Weight::from_parts(2_656_000, 1627) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -1205,8 +1225,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `166` // Estimated: `3631` - // Minimum execution time: 119_000_000 picoseconds. - Weight::from_parts(147_000_000, 3631) + // Minimum execution time: 12_083_000 picoseconds. + Weight::from_parts(12_404_000, 3631) .saturating_add(RocksDbWeight::get().reads(2_u64)) .saturating_add(RocksDbWeight::get().writes(2_u64)) } @@ -1216,8 +1236,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `142` // Estimated: `3607` - // Minimum execution time: 42_000_000 picoseconds. - Weight::from_parts(43_000_000, 3607) + // Minimum execution time: 4_785_000 picoseconds. + Weight::from_parts(5_105_000, 3607) .saturating_add(RocksDbWeight::get().reads(1_u64)) } /// Storage: UNKNOWN KEY `0x4342193e496fab7ec59d615ed0dc55304e7b9012096b41c4eb3aaf947f6ea429` (r:1 w:0) @@ -1228,8 +1248,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `167` // Estimated: `3632` - // Minimum execution time: 56_000_000 picoseconds. - Weight::from_parts(58_000_000, 3632) + // Minimum execution time: 6_098_000 picoseconds. + Weight::from_parts(6_424_000, 3632) .saturating_add(RocksDbWeight::get().reads(2_u64)) } /// Storage: UNKNOWN KEY `0x4342193e496fab7ec59d615ed0dc55304e7b9012096b41c4eb3aaf947f6ea429` (r:1 w:0) @@ -1240,8 +1260,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `142` // Estimated: `3607` - // Minimum execution time: 56_000_000 picoseconds. - Weight::from_parts(57_000_000, 3607) + // Minimum execution time: 6_168_000 picoseconds. + Weight::from_parts(6_391_000, 3607) .saturating_add(RocksDbWeight::get().reads(2_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -1264,12 +1284,12 @@ impl WeightInfo for () { /// The range of component `c` is `[0, 125952]`. fn call_with_code_per_byte(c: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `832` - // Estimated: `9247 + c * (1 ±0)` - // Minimum execution time: 2_222_000_000 picoseconds. - Weight::from_parts(2_246_800_000, 9247) - // Standard Error: 194 - .saturating_add(Weight::from_parts(78_581, 0).saturating_mul(c.into())) + // Measured: `804 + c * (1 ±0)` + // Estimated: `9217 + c * (1 ±0)` + // Minimum execution time: 304_486_000 picoseconds. + Weight::from_parts(281_210_403, 9217) + // Standard Error: 71 + .saturating_add(Weight::from_parts(33_632, 0).saturating_mul(c.into())) .saturating_add(RocksDbWeight::get().reads(11_u64)) .saturating_add(RocksDbWeight::get().writes(4_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(c.into())) @@ -1299,16 +1319,16 @@ 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: `443` - // Estimated: `8858` - // Minimum execution time: 8_001_000_000 picoseconds. - Weight::from_parts(4_996_600_018, 8858) - // Standard Error: 606 - .saturating_add(Weight::from_parts(158_819, 0).saturating_mul(c.into())) - // Standard Error: 72 - .saturating_add(Weight::from_parts(1_394, 0).saturating_mul(i.into())) - // Standard Error: 72 - .saturating_add(Weight::from_parts(1_681, 0).saturating_mul(s.into())) + // Measured: `326` + // Estimated: `8740` + // Minimum execution time: 4_111_986_000 picoseconds. + Weight::from_parts(381_653_579, 8740) + // Standard Error: 198 + .saturating_add(Weight::from_parts(70_030, 0).saturating_mul(c.into())) + // Standard Error: 23 + .saturating_add(Weight::from_parts(1_669, 0).saturating_mul(i.into())) + // Standard Error: 23 + .saturating_add(Weight::from_parts(1_842, 0).saturating_mul(s.into())) .saturating_add(RocksDbWeight::get().reads(14_u64)) .saturating_add(RocksDbWeight::get().writes(10_u64)) } @@ -1336,14 +1356,14 @@ impl WeightInfo for () { /// The range of component `s` is `[0, 1048576]`. fn instantiate(i: u32, s: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `615` - // Estimated: `9030` - // Minimum execution time: 4_452_000_000 picoseconds. - Weight::from_parts(3_312_250_000, 9030) - // Standard Error: 24 - .saturating_add(Weight::from_parts(1_571, 0).saturating_mul(i.into())) - // Standard Error: 24 - .saturating_add(Weight::from_parts(1_133, 0).saturating_mul(s.into())) + // Measured: `563` + // Estimated: `8982` + // Minimum execution time: 1_996_742_000 picoseconds. + Weight::from_parts(2_026_648_000, 8982) + // Standard Error: 25 + .saturating_add(Weight::from_parts(849, 0).saturating_mul(i.into())) + // Standard Error: 25 + .saturating_add(Weight::from_parts(852, 0).saturating_mul(s.into())) .saturating_add(RocksDbWeight::get().reads(13_u64)) .saturating_add(RocksDbWeight::get().writes(7_u64)) } @@ -1367,8 +1387,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `829` // Estimated: `9244` - // Minimum execution time: 2_150_000_000 picoseconds. - Weight::from_parts(2_237_000_000, 9244) + // Minimum execution time: 206_272_000 picoseconds. + Weight::from_parts(217_655_000, 9244) .saturating_add(RocksDbWeight::get().reads(11_u64)) .saturating_add(RocksDbWeight::get().writes(4_u64)) } @@ -1389,10 +1409,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `145` // Estimated: `6085` - // Minimum execution time: 1_943_000_000 picoseconds. - Weight::from_parts(2_061_000_000, 6085) - // Standard Error: 425 - .saturating_add(Weight::from_parts(80_155, 0).saturating_mul(c.into())) + // Minimum execution time: 277_885_000 picoseconds. + Weight::from_parts(264_589_547, 6085) + // Standard Error: 73 + .saturating_add(Weight::from_parts(33_704, 0).saturating_mul(c.into())) .saturating_add(RocksDbWeight::get().reads(6_u64)) .saturating_add(RocksDbWeight::get().writes(4_u64)) } @@ -1413,10 +1433,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `145` // Estimated: `6085` - // Minimum execution time: 2_143_000_000 picoseconds. - Weight::from_parts(2_231_100_000, 6085) - // Standard Error: 246 - .saturating_add(Weight::from_parts(79_070, 0).saturating_mul(c.into())) + // Minimum execution time: 298_636_000 picoseconds. + Weight::from_parts(271_144_699, 6085) + // Standard Error: 100 + .saturating_add(Weight::from_parts(34_478, 0).saturating_mul(c.into())) .saturating_add(RocksDbWeight::get().reads(6_u64)) .saturating_add(RocksDbWeight::get().writes(4_u64)) } @@ -1434,8 +1454,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `315` // Estimated: `3780` - // Minimum execution time: 483_000_000 picoseconds. - Weight::from_parts(512_000_000, 3780) + // Minimum execution time: 46_040_000 picoseconds. + Weight::from_parts(48_079_000, 3780) .saturating_add(RocksDbWeight::get().reads(4_u64)) .saturating_add(RocksDbWeight::get().writes(4_u64)) } @@ -1451,8 +1471,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `552` // Estimated: `8967` - // Minimum execution time: 321_000_000 picoseconds. - Weight::from_parts(334_000_000, 8967) + // Minimum execution time: 34_375_000 picoseconds. + Weight::from_parts(36_222_000, 8967) .saturating_add(RocksDbWeight::get().reads(7_u64)) .saturating_add(RocksDbWeight::get().writes(6_u64)) } @@ -1461,17 +1481,17 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 149_000_000 picoseconds. - Weight::from_parts(150_400_000, 0) - // Standard Error: 190 - .saturating_add(Weight::from_parts(92_875, 0).saturating_mul(r.into())) + // Minimum execution time: 10_802_000 picoseconds. + Weight::from_parts(11_876_953, 0) + // Standard Error: 85 + .saturating_add(Weight::from_parts(70_319, 0).saturating_mul(r.into())) } fn seal_caller() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 6_000_000 picoseconds. - Weight::from_parts(6_000_000, 0) + // Minimum execution time: 560_000 picoseconds. + Weight::from_parts(627_000, 0) } /// Storage: `Contracts::ContractInfoOf` (r:1 w:0) /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) @@ -1479,8 +1499,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `354` // Estimated: `3819` - // Minimum execution time: 56_000_000 picoseconds. - Weight::from_parts(57_000_000, 3819) + // Minimum execution time: 6_604_000 picoseconds. + Weight::from_parts(6_824_000, 3819) .saturating_add(RocksDbWeight::get().reads(1_u64)) } /// Storage: `Contracts::ContractInfoOf` (r:1 w:0) @@ -1489,44 +1509,44 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `447` // Estimated: `3912` - // Minimum execution time: 67_000_000 picoseconds. - Weight::from_parts(69_000_000, 3912) + // Minimum execution time: 7_697_000 picoseconds. + Weight::from_parts(8_009_000, 3912) .saturating_add(RocksDbWeight::get().reads(1_u64)) } fn seal_own_code_hash() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 8_000_000 picoseconds. - Weight::from_parts(8_000_000, 0) + // Minimum execution time: 783_000 picoseconds. + Weight::from_parts(825_000, 0) } fn seal_caller_is_origin() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_000_000 picoseconds. - Weight::from_parts(3_000_000, 0) + // Minimum execution time: 329_000 picoseconds. + Weight::from_parts(383_000, 0) } fn seal_caller_is_root() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_000_000 picoseconds. - Weight::from_parts(2_000_000, 0) + // Minimum execution time: 309_000 picoseconds. + Weight::from_parts(357_000, 0) } fn seal_address() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 5_000_000 picoseconds. - Weight::from_parts(6_000_000, 0) + // Minimum execution time: 554_000 picoseconds. + Weight::from_parts(601_000, 0) } fn seal_gas_left() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 6_000_000 picoseconds. - Weight::from_parts(6_000_000, 0) + // Minimum execution time: 639_000 picoseconds. + Weight::from_parts(693_000, 0) } /// Storage: `System::Account` (r:1 w:0) /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`) @@ -1534,37 +1554,37 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `140` // Estimated: `3605` - // Minimum execution time: 46_000_000 picoseconds. - Weight::from_parts(46_000_000, 3605) + // Minimum execution time: 4_720_000 picoseconds. + Weight::from_parts(4_902_000, 3605) .saturating_add(RocksDbWeight::get().reads(1_u64)) } fn seal_value_transferred() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 6_000_000 picoseconds. - Weight::from_parts(6_000_000, 0) + // Minimum execution time: 538_000 picoseconds. + Weight::from_parts(586_000, 0) } fn seal_minimum_balance() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 6_000_000 picoseconds. - Weight::from_parts(6_000_000, 0) + // Minimum execution time: 509_000 picoseconds. + Weight::from_parts(571_000, 0) } fn seal_block_number() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 6_000_000 picoseconds. - Weight::from_parts(6_000_000, 0) + // Minimum execution time: 535_000 picoseconds. + Weight::from_parts(586_000, 0) } fn seal_now() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 6_000_000 picoseconds. - Weight::from_parts(6_000_000, 0) + // Minimum execution time: 578_000 picoseconds. + Weight::from_parts(637_000, 0) } /// Storage: `TransactionPayment::NextFeeMultiplier` (r:1 w:0) /// Proof: `TransactionPayment::NextFeeMultiplier` (`max_values`: Some(1), `max_size`: Some(16), added: 511, mode: `Measured`) @@ -1572,8 +1592,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `67` // Estimated: `1552` - // Minimum execution time: 34_000_000 picoseconds. - Weight::from_parts(35_000_000, 1552) + // Minimum execution time: 4_416_000 picoseconds. + Weight::from_parts(4_611_000, 1552) .saturating_add(RocksDbWeight::get().reads(1_u64)) } /// The range of component `n` is `[0, 1048572]`. @@ -1581,20 +1601,20 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 4_000_000 picoseconds. - Weight::from_parts(4_800_000, 0) - // Standard Error: 0 - .saturating_add(Weight::from_parts(77, 0).saturating_mul(n.into())) + // Minimum execution time: 469_000 picoseconds. + Weight::from_parts(513_000, 0) + // Standard Error: 3 + .saturating_add(Weight::from_parts(294, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 1048572]`. fn seal_return(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_000_000 picoseconds. - Weight::from_parts(2_000_000, 0) - // Standard Error: 0 - .saturating_add(Weight::from_parts(156, 0).saturating_mul(n.into())) + // Minimum execution time: 328_000 picoseconds. + Weight::from_parts(345_000, 0) + // Standard Error: 9 + .saturating_add(Weight::from_parts(400, 0).saturating_mul(n.into())) } /// Storage: `Contracts::DeletionQueueCounter` (r:1 w:1) /// Proof: `Contracts::DeletionQueueCounter` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`) @@ -1610,8 +1630,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `2821` // Estimated: `85486` - // Minimum execution time: 1_399_000_000 picoseconds. - Weight::from_parts(1_407_000_000, 85486) + // Minimum execution time: 134_982_000 picoseconds. + Weight::from_parts(137_218_000, 85486) .saturating_add(RocksDbWeight::get().reads(36_u64)) .saturating_add(RocksDbWeight::get().writes(38_u64)) } @@ -1621,35 +1641,37 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `76` // Estimated: `1561` - // Minimum execution time: 33_000_000 picoseconds. - Weight::from_parts(34_000_000, 1561) + // Minimum execution time: 3_641_000 picoseconds. + Weight::from_parts(3_851_000, 1561) .saturating_add(RocksDbWeight::get().reads(1_u64)) } /// Storage: `System::EventTopics` (r:4 w:4) /// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`) /// The range of component `t` is `[0, 4]`. /// The range of component `n` is `[0, 16384]`. - fn seal_deposit_event(t: u32, _n: u32, ) -> Weight { + fn seal_deposit_event(t: u32, n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` - // Estimated: `641 + t * (2562 ±0)` - // Minimum execution time: 27_000_000 picoseconds. - Weight::from_parts(33_099_999, 641) - // Standard Error: 132_510 - .saturating_add(Weight::from_parts(28_975_000, 0).saturating_mul(t.into())) + // Estimated: `990 + t * (2475 ±0)` + // Minimum execution time: 4_143_000 picoseconds. + Weight::from_parts(4_355_459, 990) + // Standard Error: 7_907 + .saturating_add(Weight::from_parts(2_334_740, 0).saturating_mul(t.into())) + // Standard Error: 2 + .saturating_add(Weight::from_parts(28, 0).saturating_mul(n.into())) .saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(t.into()))) .saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(t.into()))) - .saturating_add(Weight::from_parts(0, 2562).saturating_mul(t.into())) + .saturating_add(Weight::from_parts(0, 2475).saturating_mul(t.into())) } /// The range of component `i` is `[0, 1048576]`. fn seal_debug_message(i: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_000_000 picoseconds. - Weight::from_parts(2_000_000, 0) - // Standard Error: 0 - .saturating_add(Weight::from_parts(425, 0).saturating_mul(i.into())) + // Minimum execution time: 436_000 picoseconds. + Weight::from_parts(464_000, 0) + // Standard Error: 10 + .saturating_add(Weight::from_parts(1_204, 0).saturating_mul(i.into())) } /// Storage: `Skipped::Metadata` (r:0 w:0) /// Proof: `Skipped::Metadata` (`max_values`: None, `max_size`: None, mode: `Measured`) @@ -1658,10 +1680,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `245` // Estimated: `245` - // Minimum execution time: 55_000_000 picoseconds. - Weight::from_parts(56_300_000, 245) - // Standard Error: 13 - .saturating_add(Weight::from_parts(286, 0).saturating_mul(n.into())) + // Minimum execution time: 7_574_000 picoseconds. + Weight::from_parts(8_651_771, 245) + // Standard Error: 1 + .saturating_add(Weight::from_parts(255, 0).saturating_mul(n.into())) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -1670,12 +1692,12 @@ impl WeightInfo for () { /// The range of component `n` is `[0, 16384]`. fn seal_set_storage_per_old_byte(n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `245 + n * (1 ±0)` - // Estimated: `245 + n * (1 ±0)` - // Minimum execution time: 55_000_000 picoseconds. - Weight::from_parts(55_300_000, 245) - // Standard Error: 17 - .saturating_add(Weight::from_parts(415, 0).saturating_mul(n.into())) + // Measured: `248 + n * (1 ±0)` + // Estimated: `248 + n * (1 ±0)` + // Minimum execution time: 7_553_000 picoseconds. + Weight::from_parts(9_223_601, 248) + // Standard Error: 2 + .saturating_add(Weight::from_parts(86, 0).saturating_mul(n.into())) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) @@ -1685,12 +1707,12 @@ impl WeightInfo for () { /// The range of component `n` is `[0, 16384]`. fn seal_clear_storage(n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `245 + n * (1 ±0)` - // Estimated: `245 + n * (1 ±0)` - // Minimum execution time: 56_000_000 picoseconds. - Weight::from_parts(61_200_000, 245) - // Standard Error: 46 - .saturating_add(Weight::from_parts(73, 0).saturating_mul(n.into())) + // Measured: `248 + n * (1 ±0)` + // Estimated: `248 + n * (1 ±0)` + // Minimum execution time: 7_856_000 picoseconds. + Weight::from_parts(9_180_008, 248) + // Standard Error: 2 + .saturating_add(Weight::from_parts(89, 0).saturating_mul(n.into())) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) @@ -1700,12 +1722,12 @@ impl WeightInfo for () { /// The range of component `n` is `[0, 16384]`. fn seal_get_storage(n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `245 + n * (1 ±0)` - // Estimated: `245 + n * (1 ±0)` - // Minimum execution time: 51_000_000 picoseconds. - Weight::from_parts(53_100_000, 245) - // Standard Error: 41 - .saturating_add(Weight::from_parts(891, 0).saturating_mul(n.into())) + // Measured: `248 + n * (1 ±0)` + // Estimated: `248 + n * (1 ±0)` + // Minimum execution time: 7_126_000 picoseconds. + Weight::from_parts(8_921_997, 248) + // Standard Error: 3 + .saturating_add(Weight::from_parts(614, 0).saturating_mul(n.into())) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) } @@ -1714,12 +1736,12 @@ impl WeightInfo for () { /// The range of component `n` is `[0, 16384]`. fn seal_contains_storage(n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `245 + n * (1 ±0)` - // Estimated: `245 + n * (1 ±0)` - // Minimum execution time: 50_000_000 picoseconds. - Weight::from_parts(50_700_000, 245) - // Standard Error: 50 - .saturating_add(Weight::from_parts(769, 0).saturating_mul(n.into())) + // Measured: `248 + n * (1 ±0)` + // Estimated: `248 + n * (1 ±0)` + // Minimum execution time: 6_715_000 picoseconds. + Weight::from_parts(7_848_323, 248) + // Standard Error: 2 + .saturating_add(Weight::from_parts(88, 0).saturating_mul(n.into())) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) } @@ -1728,12 +1750,12 @@ impl WeightInfo for () { /// The range of component `n` is `[0, 16384]`. fn seal_take_storage(n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `245 + n * (1 ±0)` - // Estimated: `245 + n * (1 ±0)` - // Minimum execution time: 57_000_000 picoseconds. - Weight::from_parts(58_400_000, 245) - // Standard Error: 32 - .saturating_add(Weight::from_parts(854, 0).saturating_mul(n.into())) + // Measured: `248 + n * (1 ±0)` + // Estimated: `248 + n * (1 ±0)` + // Minimum execution time: 8_318_000 picoseconds. + Weight::from_parts(9_990_344, 248) + // Standard Error: 5 + .saturating_add(Weight::from_parts(634, 0).saturating_mul(n.into())) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) @@ -1744,8 +1766,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `140` // Estimated: `3605` - // Minimum execution time: 99_000_000 picoseconds. - Weight::from_parts(103_000_000, 3605) + // Minimum execution time: 8_900_000 picoseconds. + Weight::from_parts(9_215_000, 3605) .saturating_add(RocksDbWeight::get().reads(1_u64)) } /// Storage: `Contracts::ContractInfoOf` (r:1 w:2) @@ -1767,14 +1789,14 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `623 + t * (280 ±0)` // Estimated: `6563 + t * (3422 ±0)` - // Minimum execution time: 1_601_000_000 picoseconds. - Weight::from_parts(1_531_399_999, 6563) - // Standard Error: 15_255_326 - .saturating_add(Weight::from_parts(460_199_999, 0).saturating_mul(t.into())) - // Standard Error: 15_255_326 - .saturating_add(Weight::from_parts(86_499_999, 0).saturating_mul(c.into())) - // Standard Error: 14 - .saturating_add(Weight::from_parts(84, 0).saturating_mul(i.into())) + // Minimum execution time: 164_943_000 picoseconds. + Weight::from_parts(164_713_349, 6563) + // Standard Error: 323_916 + .saturating_add(Weight::from_parts(43_689_556, 0).saturating_mul(t.into())) + // Standard Error: 323_916 + .saturating_add(Weight::from_parts(2_727_352, 0).saturating_mul(c.into())) + // Standard Error: 0 + .saturating_add(Weight::from_parts(7, 0).saturating_mul(i.into())) .saturating_add(RocksDbWeight::get().reads(7_u64)) .saturating_add(RocksDbWeight::get().reads((2_u64).saturating_mul(t.into()))) .saturating_add(RocksDbWeight::get().writes(4_u64)) @@ -1795,8 +1817,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `433` // Estimated: `6373` - // Minimum execution time: 1_526_000_000 picoseconds. - Weight::from_parts(1_547_000_000, 6373) + // Minimum execution time: 152_390_000 picoseconds. + Weight::from_parts(165_217_000, 6373) .saturating_add(RocksDbWeight::get().reads(6_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) } @@ -1819,85 +1841,85 @@ impl WeightInfo for () { /// The range of component `s` is `[0, 983040]`. fn seal_instantiate(t: u32, i: u32, s: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `627 + t * (102 ±0)` - // Estimated: `6567 + t * (2577 ±0)` - // Minimum execution time: 3_818_000_000 picoseconds. - Weight::from_parts(2_080_099_999, 6567) - // Standard Error: 27_716_696 - .saturating_add(Weight::from_parts(389_800_000, 0).saturating_mul(t.into())) - // Standard Error: 28 - .saturating_add(Weight::from_parts(1_471, 0).saturating_mul(i.into())) - // Standard Error: 28 - .saturating_add(Weight::from_parts(1_568, 0).saturating_mul(s.into())) + // Measured: `679 + t * (102 ±0)` + // Estimated: `6616 + t * (2565 ±1)` + // Minimum execution time: 1_709_241_000 picoseconds. + Weight::from_parts(162_472_084, 6616) + // Standard Error: 9_135_790 + .saturating_add(Weight::from_parts(119_325_657, 0).saturating_mul(t.into())) + // Standard Error: 14 + .saturating_add(Weight::from_parts(1_389, 0).saturating_mul(i.into())) + // Standard Error: 14 + .saturating_add(Weight::from_parts(1_787, 0).saturating_mul(s.into())) .saturating_add(RocksDbWeight::get().reads(10_u64)) .saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(t.into()))) .saturating_add(RocksDbWeight::get().writes(7_u64)) .saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(t.into()))) - .saturating_add(Weight::from_parts(0, 2577).saturating_mul(t.into())) + .saturating_add(Weight::from_parts(0, 2565).saturating_mul(t.into())) } /// The range of component `n` is `[0, 1048576]`. fn seal_hash_sha2_256(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 7_000_000 picoseconds. - Weight::from_parts(8_000_000, 0) - // Standard Error: 1 - .saturating_add(Weight::from_parts(3_113, 0).saturating_mul(n.into())) + // Minimum execution time: 864_000 picoseconds. + Weight::from_parts(914_000, 0) + // Standard Error: 0 + .saturating_add(Weight::from_parts(1_060, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 1048576]`. fn seal_hash_keccak_256(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 8_000_000 picoseconds. - Weight::from_parts(8_600_000, 0) - // Standard Error: 3 - .saturating_add(Weight::from_parts(4_545, 0).saturating_mul(n.into())) + // Minimum execution time: 1_305_000 picoseconds. + Weight::from_parts(1_342_000, 0) + // Standard Error: 0 + .saturating_add(Weight::from_parts(3_322, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 1048576]`. fn seal_hash_blake2_256(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 4_000_000 picoseconds. - Weight::from_parts(5_000_000, 0) - // Standard Error: 5 - .saturating_add(Weight::from_parts(1_134, 0).saturating_mul(n.into())) + // Minimum execution time: 741_000 picoseconds. + Weight::from_parts(772_000, 0) + // Standard Error: 0 + .saturating_add(Weight::from_parts(1_188, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 1048576]`. fn seal_hash_blake2_128(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 5_000_000 picoseconds. - Weight::from_parts(5_000_000, 0) - // Standard Error: 3 - .saturating_add(Weight::from_parts(1_122, 0).saturating_mul(n.into())) + // Minimum execution time: 735_000 picoseconds. + Weight::from_parts(759_000, 0) + // Standard Error: 0 + .saturating_add(Weight::from_parts(1_188, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 125697]`. fn seal_sr25519_verify(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 58_000_000 picoseconds. - Weight::from_parts(58_600_000, 0) - // Standard Error: 4 - .saturating_add(Weight::from_parts(7_695, 0).saturating_mul(n.into())) + // Minimum execution time: 44_096_000 picoseconds. + Weight::from_parts(45_203_791, 0) + // Standard Error: 7 + .saturating_add(Weight::from_parts(4_670, 0).saturating_mul(n.into())) } fn seal_ecdsa_recover() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 300_000_000 picoseconds. - Weight::from_parts(316_000_000, 0) + // Minimum execution time: 47_195_000 picoseconds. + Weight::from_parts(49_118_000, 0) } fn seal_ecdsa_to_eth_address() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 16_000_000 picoseconds. - Weight::from_parts(16_000_000, 0) + // Minimum execution time: 13_001_000 picoseconds. + Weight::from_parts(13_115_000, 0) } /// Storage: `Contracts::CodeInfoOf` (r:1 w:1) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) @@ -1911,8 +1933,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `433` // Estimated: `6373` - // Minimum execution time: 304_000_000 picoseconds. - Weight::from_parts(306_000_000, 6373) + // Minimum execution time: 31_502_000 picoseconds. + Weight::from_parts(32_325_000, 6373) .saturating_add(RocksDbWeight::get().reads(6_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) } @@ -1922,8 +1944,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `355` // Estimated: `3820` - // Minimum execution time: 79_000_000 picoseconds. - Weight::from_parts(80_000_000, 3820) + // Minimum execution time: 9_266_000 picoseconds. + Weight::from_parts(9_628_000, 3820) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -1933,8 +1955,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `355` // Estimated: `3558` - // Minimum execution time: 64_000_000 picoseconds. - Weight::from_parts(66_000_000, 3558) + // Minimum execution time: 8_125_000 picoseconds. + Weight::from_parts(8_525_000, 3558) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -1942,15 +1964,15 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_000_000 picoseconds. - Weight::from_parts(2_000_000, 0) + // Minimum execution time: 307_000 picoseconds. + Weight::from_parts(344_000, 0) } fn seal_account_reentrance_count() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_000_000 picoseconds. - Weight::from_parts(2_000_000, 0) + // Minimum execution time: 338_000 picoseconds. + Weight::from_parts(370_000, 0) } /// Storage: `Contracts::Nonce` (r:1 w:0) /// Proof: `Contracts::Nonce` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`) @@ -1958,8 +1980,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `219` // Estimated: `1704` - // Minimum execution time: 26_000_000 picoseconds. - Weight::from_parts(26_000_000, 1704) + // Minimum execution time: 2_892_000 picoseconds. + Weight::from_parts(3_126_000, 1704) .saturating_add(RocksDbWeight::get().reads(1_u64)) } /// The range of component `r` is `[0, 5000]`. @@ -1967,9 +1989,9 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 5_000_000 picoseconds. - Weight::from_parts(5_900_000, 0) - // Standard Error: 124 - .saturating_add(Weight::from_parts(71_560, 0).saturating_mul(r.into())) + // Minimum execution time: 919_000 picoseconds. + Weight::from_parts(514_641, 0) + // Standard Error: 18 + .saturating_add(Weight::from_parts(15_217, 0).saturating_mul(r.into())) } } From 41b5f3ab7b926f7908e5b5fff6d35801b8b941d2 Mon Sep 17 00:00:00 2001 From: pgherveou Date: Mon, 29 Apr 2024 14:09:37 +0200 Subject: [PATCH 15/34] add ; --- substrate/frame/contracts/src/benchmarking/mod.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/substrate/frame/contracts/src/benchmarking/mod.rs b/substrate/frame/contracts/src/benchmarking/mod.rs index 95256e78a7f0..3ef98e9fec3a 100644 --- a/substrate/frame/contracts/src/benchmarking/mod.rs +++ b/substrate/frame/contracts/src/benchmarking/mod.rs @@ -864,7 +864,7 @@ mod benchmarks { let result; #[block] { - result = BenchEnv::seal0_input(&mut runtime, &mut memory, 4, 0) + result = BenchEnv::seal0_input(&mut runtime, &mut memory, 4, 0); } assert_ok!(result); assert_eq!(&memory[4..], &vec![42u8; n as usize]); @@ -877,7 +877,7 @@ mod benchmarks { let result; #[block] { - result = BenchEnv::seal0_seal_return(&mut runtime, &mut memory, 0, 0, n) + result = BenchEnv::seal0_seal_return(&mut runtime, &mut memory, 0, 0, n); } assert!(matches!( From f4d65f6944be0913765ce9d3aaf7c700e46fc0e3 Mon Sep 17 00:00:00 2001 From: command-bot <> Date: Mon, 29 Apr 2024 12:49:48 +0000 Subject: [PATCH 16/34] ".git/.scripts/commands/bench/bench.sh" --subcommand=pallet --runtime=dev --target_dir=substrate --pallet=pallet_contracts --- substrate/frame/contracts/src/weights.rs | 776 +++++++++++------------ 1 file changed, 388 insertions(+), 388 deletions(-) diff --git a/substrate/frame/contracts/src/weights.rs b/substrate/frame/contracts/src/weights.rs index 169f2f34e410..352a84e3bddd 100644 --- a/substrate/frame/contracts/src/weights.rs +++ b/substrate/frame/contracts/src/weights.rs @@ -128,8 +128,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `142` // Estimated: `1627` - // Minimum execution time: 2_026_000 picoseconds. - Weight::from_parts(2_157_000, 1627) + // Minimum execution time: 2_077_000 picoseconds. + Weight::from_parts(2_153_000, 1627) .saturating_add(T::DbWeight::get().reads(1_u64)) } /// Storage: `Skipped::Metadata` (r:0 w:0) @@ -139,10 +139,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `452 + k * (69 ±0)` // Estimated: `442 + k * (70 ±0)` - // Minimum execution time: 12_505_000 picoseconds. - Weight::from_parts(12_905_000, 442) - // Standard Error: 1_429 - .saturating_add(Weight::from_parts(1_167_002, 0).saturating_mul(k.into())) + // Minimum execution time: 12_456_000 picoseconds. + Weight::from_parts(12_730_000, 442) + // Standard Error: 1_183 + .saturating_add(Weight::from_parts(1_096_672, 0).saturating_mul(k.into())) .saturating_add(T::DbWeight::get().reads(2_u64)) .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(k.into()))) .saturating_add(T::DbWeight::get().writes(2_u64)) @@ -156,10 +156,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `211 + c * (1 ±0)` // Estimated: `6149 + c * (1 ±0)` - // Minimum execution time: 8_257_000 picoseconds. - Weight::from_parts(8_677_638, 6149) + // Minimum execution time: 8_181_000 picoseconds. + Weight::from_parts(9_113_032, 6149) // Standard Error: 1 - .saturating_add(Weight::from_parts(1_160, 0).saturating_mul(c.into())) + .saturating_add(Weight::from_parts(1_213, 0).saturating_mul(c.into())) .saturating_add(T::DbWeight::get().reads(2_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(c.into())) @@ -172,8 +172,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `510` // Estimated: `6450` - // Minimum execution time: 17_053_000 picoseconds. - Weight::from_parts(17_518_000, 6450) + // Minimum execution time: 16_780_000 picoseconds. + Weight::from_parts(17_448_000, 6450) .saturating_add(T::DbWeight::get().reads(3_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -186,10 +186,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `171 + k * (1 ±0)` // Estimated: `3635 + k * (1 ±0)` - // Minimum execution time: 3_507_000 picoseconds. - Weight::from_parts(2_116_985, 3635) - // Standard Error: 835 - .saturating_add(Weight::from_parts(1_222_371, 0).saturating_mul(k.into())) + // Minimum execution time: 3_382_000 picoseconds. + Weight::from_parts(1_286_516, 3635) + // Standard Error: 973 + .saturating_add(Weight::from_parts(1_204_983, 0).saturating_mul(k.into())) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(2_u64)) .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(k.into()))) @@ -210,10 +210,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `328 + c * (1 ±0)` // Estimated: `6266 + c * (1 ±0)` - // Minimum execution time: 20_657_000 picoseconds. - Weight::from_parts(20_858_035, 6266) - // Standard Error: 1 - .saturating_add(Weight::from_parts(383, 0).saturating_mul(c.into())) + // Minimum execution time: 20_685_000 picoseconds. + Weight::from_parts(21_384_758, 6266) + // Standard Error: 0 + .saturating_add(Weight::from_parts(463, 0).saturating_mul(c.into())) .saturating_add(T::DbWeight::get().reads(6_u64)) .saturating_add(T::DbWeight::get().writes(2_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(c.into())) @@ -224,8 +224,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `440` // Estimated: `6380` - // Minimum execution time: 12_848_000 picoseconds. - Weight::from_parts(13_570_000, 6380) + // Minimum execution time: 13_070_000 picoseconds. + Weight::from_parts(13_535_000, 6380) .saturating_add(T::DbWeight::get().reads(2_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -239,8 +239,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `352` // Estimated: `6292` - // Minimum execution time: 46_737_000 picoseconds. - Weight::from_parts(48_131_000, 6292) + // Minimum execution time: 47_012_000 picoseconds. + Weight::from_parts(48_423_000, 6292) .saturating_add(T::DbWeight::get().reads(4_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -252,8 +252,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `594` // Estimated: `6534` - // Minimum execution time: 56_586_000 picoseconds. - Weight::from_parts(59_047_000, 6534) + // Minimum execution time: 56_207_000 picoseconds. + Weight::from_parts(57_924_000, 6534) .saturating_add(T::DbWeight::get().reads(4_u64)) .saturating_add(T::DbWeight::get().writes(2_u64)) } @@ -263,8 +263,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `409` // Estimated: `6349` - // Minimum execution time: 12_355_000 picoseconds. - Weight::from_parts(13_530_000, 6349) + // Minimum execution time: 12_075_000 picoseconds. + Weight::from_parts(12_708_000, 6349) .saturating_add(T::DbWeight::get().reads(2_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -274,8 +274,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `142` // Estimated: `1627` - // Minimum execution time: 2_441_000 picoseconds. - Weight::from_parts(2_656_000, 1627) + // Minimum execution time: 2_470_000 picoseconds. + Weight::from_parts(2_653_000, 1627) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -287,8 +287,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `166` // Estimated: `3631` - // Minimum execution time: 12_083_000 picoseconds. - Weight::from_parts(12_404_000, 3631) + // Minimum execution time: 11_935_000 picoseconds. + Weight::from_parts(12_443_000, 3631) .saturating_add(T::DbWeight::get().reads(2_u64)) .saturating_add(T::DbWeight::get().writes(2_u64)) } @@ -298,8 +298,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `142` // Estimated: `3607` - // Minimum execution time: 4_785_000 picoseconds. - Weight::from_parts(5_105_000, 3607) + // Minimum execution time: 4_706_000 picoseconds. + Weight::from_parts(4_937_000, 3607) .saturating_add(T::DbWeight::get().reads(1_u64)) } /// Storage: UNKNOWN KEY `0x4342193e496fab7ec59d615ed0dc55304e7b9012096b41c4eb3aaf947f6ea429` (r:1 w:0) @@ -310,8 +310,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `167` // Estimated: `3632` - // Minimum execution time: 6_098_000 picoseconds. - Weight::from_parts(6_424_000, 3632) + // Minimum execution time: 5_942_000 picoseconds. + Weight::from_parts(6_224_000, 3632) .saturating_add(T::DbWeight::get().reads(2_u64)) } /// Storage: UNKNOWN KEY `0x4342193e496fab7ec59d615ed0dc55304e7b9012096b41c4eb3aaf947f6ea429` (r:1 w:0) @@ -322,8 +322,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `142` // Estimated: `3607` - // Minimum execution time: 6_168_000 picoseconds. - Weight::from_parts(6_391_000, 3607) + // Minimum execution time: 6_161_000 picoseconds. + Weight::from_parts(6_476_000, 3607) .saturating_add(T::DbWeight::get().reads(2_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -348,10 +348,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `804 + c * (1 ±0)` // Estimated: `9217 + c * (1 ±0)` - // Minimum execution time: 304_486_000 picoseconds. - Weight::from_parts(281_210_403, 9217) - // Standard Error: 71 - .saturating_add(Weight::from_parts(33_632, 0).saturating_mul(c.into())) + // Minimum execution time: 367_780_000 picoseconds. + Weight::from_parts(340_082_130, 9217) + // Standard Error: 86 + .saturating_add(Weight::from_parts(34_319, 0).saturating_mul(c.into())) .saturating_add(T::DbWeight::get().reads(11_u64)) .saturating_add(T::DbWeight::get().writes(4_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(c.into())) @@ -383,14 +383,14 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `326` // Estimated: `8740` - // Minimum execution time: 4_111_986_000 picoseconds. - Weight::from_parts(381_653_579, 8740) - // Standard Error: 198 - .saturating_add(Weight::from_parts(70_030, 0).saturating_mul(c.into())) - // Standard Error: 23 - .saturating_add(Weight::from_parts(1_669, 0).saturating_mul(i.into())) - // Standard Error: 23 - .saturating_add(Weight::from_parts(1_842, 0).saturating_mul(s.into())) + // Minimum execution time: 4_288_324_000 picoseconds. + Weight::from_parts(851_698_267, 8740) + // Standard Error: 115 + .saturating_add(Weight::from_parts(68_501, 0).saturating_mul(c.into())) + // Standard Error: 13 + .saturating_add(Weight::from_parts(1_658, 0).saturating_mul(i.into())) + // Standard Error: 13 + .saturating_add(Weight::from_parts(1_666, 0).saturating_mul(s.into())) .saturating_add(T::DbWeight::get().reads(14_u64)) .saturating_add(T::DbWeight::get().writes(10_u64)) } @@ -420,12 +420,12 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `563` // Estimated: `8982` - // Minimum execution time: 1_996_742_000 picoseconds. - Weight::from_parts(2_026_648_000, 8982) - // Standard Error: 25 - .saturating_add(Weight::from_parts(849, 0).saturating_mul(i.into())) - // Standard Error: 25 - .saturating_add(Weight::from_parts(852, 0).saturating_mul(s.into())) + // Minimum execution time: 2_133_178_000 picoseconds. + Weight::from_parts(2_142_604_000, 8982) + // Standard Error: 26 + .saturating_add(Weight::from_parts(887, 0).saturating_mul(i.into())) + // Standard Error: 26 + .saturating_add(Weight::from_parts(790, 0).saturating_mul(s.into())) .saturating_add(T::DbWeight::get().reads(13_u64)) .saturating_add(T::DbWeight::get().writes(7_u64)) } @@ -449,8 +449,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `829` // Estimated: `9244` - // Minimum execution time: 206_272_000 picoseconds. - Weight::from_parts(217_655_000, 9244) + // Minimum execution time: 211_959_000 picoseconds. + Weight::from_parts(222_187_000, 9244) .saturating_add(T::DbWeight::get().reads(11_u64)) .saturating_add(T::DbWeight::get().writes(4_u64)) } @@ -471,10 +471,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `145` // Estimated: `6085` - // Minimum execution time: 277_885_000 picoseconds. - Weight::from_parts(264_589_547, 6085) - // Standard Error: 73 - .saturating_add(Weight::from_parts(33_704, 0).saturating_mul(c.into())) + // Minimum execution time: 339_757_000 picoseconds. + Weight::from_parts(351_268_427, 6085) + // Standard Error: 54 + .saturating_add(Weight::from_parts(33_161, 0).saturating_mul(c.into())) .saturating_add(T::DbWeight::get().reads(6_u64)) .saturating_add(T::DbWeight::get().writes(4_u64)) } @@ -495,10 +495,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `145` // Estimated: `6085` - // Minimum execution time: 298_636_000 picoseconds. - Weight::from_parts(271_144_699, 6085) - // Standard Error: 100 - .saturating_add(Weight::from_parts(34_478, 0).saturating_mul(c.into())) + // Minimum execution time: 351_862_000 picoseconds. + Weight::from_parts(368_816_737, 6085) + // Standard Error: 49 + .saturating_add(Weight::from_parts(33_163, 0).saturating_mul(c.into())) .saturating_add(T::DbWeight::get().reads(6_u64)) .saturating_add(T::DbWeight::get().writes(4_u64)) } @@ -516,8 +516,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `315` // Estimated: `3780` - // Minimum execution time: 46_040_000 picoseconds. - Weight::from_parts(48_079_000, 3780) + // Minimum execution time: 45_679_000 picoseconds. + Weight::from_parts(46_940_000, 3780) .saturating_add(T::DbWeight::get().reads(4_u64)) .saturating_add(T::DbWeight::get().writes(4_u64)) } @@ -533,8 +533,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `552` // Estimated: `8967` - // Minimum execution time: 34_375_000 picoseconds. - Weight::from_parts(36_222_000, 8967) + // Minimum execution time: 34_955_000 picoseconds. + Weight::from_parts(36_174_000, 8967) .saturating_add(T::DbWeight::get().reads(7_u64)) .saturating_add(T::DbWeight::get().writes(6_u64)) } @@ -543,17 +543,17 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 10_802_000 picoseconds. - Weight::from_parts(11_876_953, 0) - // Standard Error: 85 - .saturating_add(Weight::from_parts(70_319, 0).saturating_mul(r.into())) + // Minimum execution time: 9_394_000 picoseconds. + Weight::from_parts(10_159_990, 0) + // Standard Error: 56 + .saturating_add(Weight::from_parts(71_497, 0).saturating_mul(r.into())) } fn seal_caller() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 560_000 picoseconds. - Weight::from_parts(627_000, 0) + // Minimum execution time: 617_000 picoseconds. + Weight::from_parts(662_000, 0) } /// Storage: `Contracts::ContractInfoOf` (r:1 w:0) /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) @@ -561,8 +561,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `354` // Estimated: `3819` - // Minimum execution time: 6_604_000 picoseconds. - Weight::from_parts(6_824_000, 3819) + // Minimum execution time: 6_925_000 picoseconds. + Weight::from_parts(7_060_000, 3819) .saturating_add(T::DbWeight::get().reads(1_u64)) } /// Storage: `Contracts::ContractInfoOf` (r:1 w:0) @@ -571,44 +571,44 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `447` // Estimated: `3912` - // Minimum execution time: 7_697_000 picoseconds. - Weight::from_parts(8_009_000, 3912) + // Minimum execution time: 7_928_000 picoseconds. + Weight::from_parts(8_230_000, 3912) .saturating_add(T::DbWeight::get().reads(1_u64)) } fn seal_own_code_hash() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 783_000 picoseconds. - Weight::from_parts(825_000, 0) + // Minimum execution time: 818_000 picoseconds. + Weight::from_parts(864_000, 0) } fn seal_caller_is_origin() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 329_000 picoseconds. - Weight::from_parts(383_000, 0) + // Minimum execution time: 382_000 picoseconds. + Weight::from_parts(411_000, 0) } fn seal_caller_is_root() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 309_000 picoseconds. - Weight::from_parts(357_000, 0) + // Minimum execution time: 350_000 picoseconds. + Weight::from_parts(386_000, 0) } fn seal_address() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 554_000 picoseconds. - Weight::from_parts(601_000, 0) + // Minimum execution time: 613_000 picoseconds. + Weight::from_parts(654_000, 0) } fn seal_gas_left() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 639_000 picoseconds. - Weight::from_parts(693_000, 0) + // Minimum execution time: 619_000 picoseconds. + Weight::from_parts(680_000, 0) } /// Storage: `System::Account` (r:1 w:0) /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`) @@ -616,37 +616,37 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `140` // Estimated: `3605` - // Minimum execution time: 4_720_000 picoseconds. - Weight::from_parts(4_902_000, 3605) + // Minimum execution time: 4_800_000 picoseconds. + Weight::from_parts(4_992_000, 3605) .saturating_add(T::DbWeight::get().reads(1_u64)) } fn seal_value_transferred() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 538_000 picoseconds. - Weight::from_parts(586_000, 0) + // Minimum execution time: 545_000 picoseconds. + Weight::from_parts(596_000, 0) } fn seal_minimum_balance() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 509_000 picoseconds. - Weight::from_parts(571_000, 0) + // Minimum execution time: 571_000 picoseconds. + Weight::from_parts(620_000, 0) } fn seal_block_number() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 535_000 picoseconds. - Weight::from_parts(586_000, 0) + // Minimum execution time: 540_000 picoseconds. + Weight::from_parts(612_000, 0) } fn seal_now() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 578_000 picoseconds. - Weight::from_parts(637_000, 0) + // Minimum execution time: 588_000 picoseconds. + Weight::from_parts(638_000, 0) } /// Storage: `TransactionPayment::NextFeeMultiplier` (r:1 w:0) /// Proof: `TransactionPayment::NextFeeMultiplier` (`max_values`: Some(1), `max_size`: Some(16), added: 511, mode: `Measured`) @@ -654,8 +654,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `67` // Estimated: `1552` - // Minimum execution time: 4_416_000 picoseconds. - Weight::from_parts(4_611_000, 1552) + // Minimum execution time: 4_415_000 picoseconds. + Weight::from_parts(4_703_000, 1552) .saturating_add(T::DbWeight::get().reads(1_u64)) } /// The range of component `n` is `[0, 1048572]`. @@ -663,20 +663,20 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 469_000 picoseconds. - Weight::from_parts(513_000, 0) + // Minimum execution time: 484_000 picoseconds. + Weight::from_parts(508_000, 0) // Standard Error: 3 - .saturating_add(Weight::from_parts(294, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(303, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 1048572]`. fn seal_return(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 328_000 picoseconds. - Weight::from_parts(345_000, 0) + // Minimum execution time: 390_000 picoseconds. + Weight::from_parts(421_000, 0) // Standard Error: 9 - .saturating_add(Weight::from_parts(400, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(479, 0).saturating_mul(n.into())) } /// Storage: `Contracts::DeletionQueueCounter` (r:1 w:1) /// Proof: `Contracts::DeletionQueueCounter` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`) @@ -692,8 +692,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `2821` // Estimated: `85486` - // Minimum execution time: 134_982_000 picoseconds. - Weight::from_parts(137_218_000, 85486) + // Minimum execution time: 134_681_000 picoseconds. + Weight::from_parts(136_452_000, 85486) .saturating_add(T::DbWeight::get().reads(36_u64)) .saturating_add(T::DbWeight::get().writes(38_u64)) } @@ -703,8 +703,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `76` // Estimated: `1561` - // Minimum execution time: 3_641_000 picoseconds. - Weight::from_parts(3_851_000, 1561) + // Minimum execution time: 3_664_000 picoseconds. + Weight::from_parts(3_887_000, 1561) .saturating_add(T::DbWeight::get().reads(1_u64)) } /// Storage: `System::EventTopics` (r:4 w:4) @@ -715,12 +715,12 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `990 + t * (2475 ±0)` - // Minimum execution time: 4_143_000 picoseconds. - Weight::from_parts(4_355_459, 990) - // Standard Error: 7_907 - .saturating_add(Weight::from_parts(2_334_740, 0).saturating_mul(t.into())) - // Standard Error: 2 - .saturating_add(Weight::from_parts(28, 0).saturating_mul(n.into())) + // Minimum execution time: 4_150_000 picoseconds. + Weight::from_parts(4_478_017, 990) + // Standard Error: 6_791 + .saturating_add(Weight::from_parts(2_359_039, 0).saturating_mul(t.into())) + // Standard Error: 1 + .saturating_add(Weight::from_parts(19, 0).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(t.into()))) .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(t.into()))) .saturating_add(Weight::from_parts(0, 2475).saturating_mul(t.into())) @@ -730,10 +730,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 436_000 picoseconds. - Weight::from_parts(464_000, 0) + // Minimum execution time: 400_000 picoseconds. + Weight::from_parts(424_000, 0) // Standard Error: 10 - .saturating_add(Weight::from_parts(1_204, 0).saturating_mul(i.into())) + .saturating_add(Weight::from_parts(1_271, 0).saturating_mul(i.into())) } /// Storage: `Skipped::Metadata` (r:0 w:0) /// Proof: `Skipped::Metadata` (`max_values`: None, `max_size`: None, mode: `Measured`) @@ -742,10 +742,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `245` // Estimated: `245` - // Minimum execution time: 7_574_000 picoseconds. - Weight::from_parts(8_651_771, 245) + // Minimum execution time: 8_012_000 picoseconds. + Weight::from_parts(8_699_107, 245) // Standard Error: 1 - .saturating_add(Weight::from_parts(255, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(351, 0).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -756,10 +756,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `248 + n * (1 ±0)` // Estimated: `248 + n * (1 ±0)` - // Minimum execution time: 7_553_000 picoseconds. - Weight::from_parts(9_223_601, 248) + // Minimum execution time: 8_016_000 picoseconds. + Weight::from_parts(9_309_029, 248) // Standard Error: 2 - .saturating_add(Weight::from_parts(86, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(78, 0).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) @@ -771,10 +771,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `248 + n * (1 ±0)` // Estimated: `248 + n * (1 ±0)` - // Minimum execution time: 7_856_000 picoseconds. - Weight::from_parts(9_180_008, 248) + // Minimum execution time: 7_984_000 picoseconds. + Weight::from_parts(9_206_228, 248) // Standard Error: 2 - .saturating_add(Weight::from_parts(89, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(77, 0).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) @@ -786,10 +786,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `248 + n * (1 ±0)` // Estimated: `248 + n * (1 ±0)` - // Minimum execution time: 7_126_000 picoseconds. - Weight::from_parts(8_921_997, 248) - // Standard Error: 3 - .saturating_add(Weight::from_parts(614, 0).saturating_mul(n.into())) + // Minimum execution time: 7_083_000 picoseconds. + Weight::from_parts(8_815_611, 248) + // Standard Error: 2 + .saturating_add(Weight::from_parts(708, 0).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) } @@ -800,10 +800,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `248 + n * (1 ±0)` // Estimated: `248 + n * (1 ±0)` - // Minimum execution time: 6_715_000 picoseconds. - Weight::from_parts(7_848_323, 248) + // Minimum execution time: 6_708_000 picoseconds. + Weight::from_parts(8_031_454, 248) // Standard Error: 2 - .saturating_add(Weight::from_parts(88, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(78, 0).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) } @@ -814,10 +814,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `248 + n * (1 ±0)` // Estimated: `248 + n * (1 ±0)` - // Minimum execution time: 8_318_000 picoseconds. - Weight::from_parts(9_990_344, 248) - // Standard Error: 5 - .saturating_add(Weight::from_parts(634, 0).saturating_mul(n.into())) + // Minimum execution time: 8_273_000 picoseconds. + Weight::from_parts(9_872_829, 248) + // Standard Error: 3 + .saturating_add(Weight::from_parts(712, 0).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) @@ -828,8 +828,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `140` // Estimated: `3605` - // Minimum execution time: 8_900_000 picoseconds. - Weight::from_parts(9_215_000, 3605) + // Minimum execution time: 9_220_000 picoseconds. + Weight::from_parts(9_590_000, 3605) .saturating_add(T::DbWeight::get().reads(1_u64)) } /// Storage: `Contracts::ContractInfoOf` (r:1 w:2) @@ -851,14 +851,14 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `623 + t * (280 ±0)` // Estimated: `6563 + t * (3422 ±0)` - // Minimum execution time: 164_943_000 picoseconds. - Weight::from_parts(164_713_349, 6563) - // Standard Error: 323_916 - .saturating_add(Weight::from_parts(43_689_556, 0).saturating_mul(t.into())) - // Standard Error: 323_916 - .saturating_add(Weight::from_parts(2_727_352, 0).saturating_mul(c.into())) + // Minimum execution time: 171_273_000 picoseconds. + Weight::from_parts(172_294_959, 6563) + // Standard Error: 309_680 + .saturating_add(Weight::from_parts(41_035_739, 0).saturating_mul(t.into())) + // Standard Error: 309_680 + .saturating_add(Weight::from_parts(168_535, 0).saturating_mul(c.into())) // Standard Error: 0 - .saturating_add(Weight::from_parts(7, 0).saturating_mul(i.into())) + .saturating_add(Weight::from_parts(9, 0).saturating_mul(i.into())) .saturating_add(T::DbWeight::get().reads(7_u64)) .saturating_add(T::DbWeight::get().reads((2_u64).saturating_mul(t.into()))) .saturating_add(T::DbWeight::get().writes(4_u64)) @@ -879,8 +879,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `433` // Estimated: `6373` - // Minimum execution time: 152_390_000 picoseconds. - Weight::from_parts(165_217_000, 6373) + // Minimum execution time: 155_964_000 picoseconds. + Weight::from_parts(160_485_000, 6373) .saturating_add(T::DbWeight::get().reads(6_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) } @@ -905,14 +905,14 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `679 + t * (102 ±0)` // Estimated: `6616 + t * (2565 ±1)` - // Minimum execution time: 1_709_241_000 picoseconds. - Weight::from_parts(162_472_084, 6616) - // Standard Error: 9_135_790 - .saturating_add(Weight::from_parts(119_325_657, 0).saturating_mul(t.into())) - // Standard Error: 14 - .saturating_add(Weight::from_parts(1_389, 0).saturating_mul(i.into())) - // Standard Error: 14 - .saturating_add(Weight::from_parts(1_787, 0).saturating_mul(s.into())) + // Minimum execution time: 1_821_557_000 picoseconds. + Weight::from_parts(85_126_984, 6616) + // Standard Error: 6_661_370 + .saturating_add(Weight::from_parts(175_191_430, 0).saturating_mul(t.into())) + // Standard Error: 10 + .saturating_add(Weight::from_parts(1_539, 0).saturating_mul(i.into())) + // Standard Error: 10 + .saturating_add(Weight::from_parts(1_811, 0).saturating_mul(s.into())) .saturating_add(T::DbWeight::get().reads(10_u64)) .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(t.into()))) .saturating_add(T::DbWeight::get().writes(7_u64)) @@ -924,64 +924,64 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 864_000 picoseconds. - Weight::from_parts(914_000, 0) + // Minimum execution time: 834_000 picoseconds. + Weight::from_parts(891_000, 0) // Standard Error: 0 - .saturating_add(Weight::from_parts(1_060, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(1_152, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 1048576]`. fn seal_hash_keccak_256(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_305_000 picoseconds. - Weight::from_parts(1_342_000, 0) + // Minimum execution time: 1_428_000 picoseconds. + Weight::from_parts(1_493_000, 0) // Standard Error: 0 - .saturating_add(Weight::from_parts(3_322, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(3_414, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 1048576]`. fn seal_hash_blake2_256(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 741_000 picoseconds. - Weight::from_parts(772_000, 0) + // Minimum execution time: 707_000 picoseconds. + Weight::from_parts(774_000, 0) // Standard Error: 0 - .saturating_add(Weight::from_parts(1_188, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(1_280, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 1048576]`. fn seal_hash_blake2_128(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 735_000 picoseconds. - Weight::from_parts(759_000, 0) + // Minimum execution time: 763_000 picoseconds. + Weight::from_parts(822_000, 0) // Standard Error: 0 - .saturating_add(Weight::from_parts(1_188, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(1_279, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 125697]`. fn seal_sr25519_verify(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 44_096_000 picoseconds. - Weight::from_parts(45_203_791, 0) + // Minimum execution time: 45_176_000 picoseconds. + Weight::from_parts(46_961_397, 0) // Standard Error: 7 - .saturating_add(Weight::from_parts(4_670, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(4_692, 0).saturating_mul(n.into())) } fn seal_ecdsa_recover() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 47_195_000 picoseconds. - Weight::from_parts(49_118_000, 0) + // Minimum execution time: 47_301_000 picoseconds. + Weight::from_parts(48_454_000, 0) } fn seal_ecdsa_to_eth_address() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 13_001_000 picoseconds. - Weight::from_parts(13_115_000, 0) + // Minimum execution time: 13_031_000 picoseconds. + Weight::from_parts(13_300_000, 0) } /// Storage: `Contracts::CodeInfoOf` (r:1 w:1) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) @@ -995,8 +995,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `433` // Estimated: `6373` - // Minimum execution time: 31_502_000 picoseconds. - Weight::from_parts(32_325_000, 6373) + // Minimum execution time: 31_664_000 picoseconds. + Weight::from_parts(32_906_000, 6373) .saturating_add(T::DbWeight::get().reads(6_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) } @@ -1006,8 +1006,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `355` // Estimated: `3820` - // Minimum execution time: 9_266_000 picoseconds. - Weight::from_parts(9_628_000, 3820) + // Minimum execution time: 9_364_000 picoseconds. + Weight::from_parts(9_551_000, 3820) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -1017,8 +1017,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `355` // Estimated: `3558` - // Minimum execution time: 8_125_000 picoseconds. - Weight::from_parts(8_525_000, 3558) + // Minimum execution time: 8_210_000 picoseconds. + Weight::from_parts(8_551_000, 3558) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -1026,15 +1026,15 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 307_000 picoseconds. - Weight::from_parts(344_000, 0) + // Minimum execution time: 355_000 picoseconds. + Weight::from_parts(401_000, 0) } fn seal_account_reentrance_count() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 338_000 picoseconds. - Weight::from_parts(370_000, 0) + // Minimum execution time: 383_000 picoseconds. + Weight::from_parts(406_000, 0) } /// Storage: `Contracts::Nonce` (r:1 w:0) /// Proof: `Contracts::Nonce` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`) @@ -1042,8 +1042,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `219` // Estimated: `1704` - // Minimum execution time: 2_892_000 picoseconds. - Weight::from_parts(3_126_000, 1704) + // Minimum execution time: 3_011_000 picoseconds. + Weight::from_parts(3_197_000, 1704) .saturating_add(T::DbWeight::get().reads(1_u64)) } /// The range of component `r` is `[0, 5000]`. @@ -1051,10 +1051,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 919_000 picoseconds. - Weight::from_parts(514_641, 0) - // Standard Error: 18 - .saturating_add(Weight::from_parts(15_217, 0).saturating_mul(r.into())) + // Minimum execution time: 945_000 picoseconds. + Weight::from_parts(916_399, 0) + // Standard Error: 14 + .saturating_add(Weight::from_parts(14_957, 0).saturating_mul(r.into())) } } @@ -1066,8 +1066,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `142` // Estimated: `1627` - // Minimum execution time: 2_026_000 picoseconds. - Weight::from_parts(2_157_000, 1627) + // Minimum execution time: 2_077_000 picoseconds. + Weight::from_parts(2_153_000, 1627) .saturating_add(RocksDbWeight::get().reads(1_u64)) } /// Storage: `Skipped::Metadata` (r:0 w:0) @@ -1077,10 +1077,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `452 + k * (69 ±0)` // Estimated: `442 + k * (70 ±0)` - // Minimum execution time: 12_505_000 picoseconds. - Weight::from_parts(12_905_000, 442) - // Standard Error: 1_429 - .saturating_add(Weight::from_parts(1_167_002, 0).saturating_mul(k.into())) + // Minimum execution time: 12_456_000 picoseconds. + Weight::from_parts(12_730_000, 442) + // Standard Error: 1_183 + .saturating_add(Weight::from_parts(1_096_672, 0).saturating_mul(k.into())) .saturating_add(RocksDbWeight::get().reads(2_u64)) .saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(k.into()))) .saturating_add(RocksDbWeight::get().writes(2_u64)) @@ -1094,10 +1094,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `211 + c * (1 ±0)` // Estimated: `6149 + c * (1 ±0)` - // Minimum execution time: 8_257_000 picoseconds. - Weight::from_parts(8_677_638, 6149) + // Minimum execution time: 8_181_000 picoseconds. + Weight::from_parts(9_113_032, 6149) // Standard Error: 1 - .saturating_add(Weight::from_parts(1_160, 0).saturating_mul(c.into())) + .saturating_add(Weight::from_parts(1_213, 0).saturating_mul(c.into())) .saturating_add(RocksDbWeight::get().reads(2_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(c.into())) @@ -1110,8 +1110,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `510` // Estimated: `6450` - // Minimum execution time: 17_053_000 picoseconds. - Weight::from_parts(17_518_000, 6450) + // Minimum execution time: 16_780_000 picoseconds. + Weight::from_parts(17_448_000, 6450) .saturating_add(RocksDbWeight::get().reads(3_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -1124,10 +1124,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `171 + k * (1 ±0)` // Estimated: `3635 + k * (1 ±0)` - // Minimum execution time: 3_507_000 picoseconds. - Weight::from_parts(2_116_985, 3635) - // Standard Error: 835 - .saturating_add(Weight::from_parts(1_222_371, 0).saturating_mul(k.into())) + // Minimum execution time: 3_382_000 picoseconds. + Weight::from_parts(1_286_516, 3635) + // Standard Error: 973 + .saturating_add(Weight::from_parts(1_204_983, 0).saturating_mul(k.into())) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(2_u64)) .saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(k.into()))) @@ -1148,10 +1148,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `328 + c * (1 ±0)` // Estimated: `6266 + c * (1 ±0)` - // Minimum execution time: 20_657_000 picoseconds. - Weight::from_parts(20_858_035, 6266) - // Standard Error: 1 - .saturating_add(Weight::from_parts(383, 0).saturating_mul(c.into())) + // Minimum execution time: 20_685_000 picoseconds. + Weight::from_parts(21_384_758, 6266) + // Standard Error: 0 + .saturating_add(Weight::from_parts(463, 0).saturating_mul(c.into())) .saturating_add(RocksDbWeight::get().reads(6_u64)) .saturating_add(RocksDbWeight::get().writes(2_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(c.into())) @@ -1162,8 +1162,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `440` // Estimated: `6380` - // Minimum execution time: 12_848_000 picoseconds. - Weight::from_parts(13_570_000, 6380) + // Minimum execution time: 13_070_000 picoseconds. + Weight::from_parts(13_535_000, 6380) .saturating_add(RocksDbWeight::get().reads(2_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -1177,8 +1177,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `352` // Estimated: `6292` - // Minimum execution time: 46_737_000 picoseconds. - Weight::from_parts(48_131_000, 6292) + // Minimum execution time: 47_012_000 picoseconds. + Weight::from_parts(48_423_000, 6292) .saturating_add(RocksDbWeight::get().reads(4_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -1190,8 +1190,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `594` // Estimated: `6534` - // Minimum execution time: 56_586_000 picoseconds. - Weight::from_parts(59_047_000, 6534) + // Minimum execution time: 56_207_000 picoseconds. + Weight::from_parts(57_924_000, 6534) .saturating_add(RocksDbWeight::get().reads(4_u64)) .saturating_add(RocksDbWeight::get().writes(2_u64)) } @@ -1201,8 +1201,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `409` // Estimated: `6349` - // Minimum execution time: 12_355_000 picoseconds. - Weight::from_parts(13_530_000, 6349) + // Minimum execution time: 12_075_000 picoseconds. + Weight::from_parts(12_708_000, 6349) .saturating_add(RocksDbWeight::get().reads(2_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -1212,8 +1212,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `142` // Estimated: `1627` - // Minimum execution time: 2_441_000 picoseconds. - Weight::from_parts(2_656_000, 1627) + // Minimum execution time: 2_470_000 picoseconds. + Weight::from_parts(2_653_000, 1627) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -1225,8 +1225,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `166` // Estimated: `3631` - // Minimum execution time: 12_083_000 picoseconds. - Weight::from_parts(12_404_000, 3631) + // Minimum execution time: 11_935_000 picoseconds. + Weight::from_parts(12_443_000, 3631) .saturating_add(RocksDbWeight::get().reads(2_u64)) .saturating_add(RocksDbWeight::get().writes(2_u64)) } @@ -1236,8 +1236,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `142` // Estimated: `3607` - // Minimum execution time: 4_785_000 picoseconds. - Weight::from_parts(5_105_000, 3607) + // Minimum execution time: 4_706_000 picoseconds. + Weight::from_parts(4_937_000, 3607) .saturating_add(RocksDbWeight::get().reads(1_u64)) } /// Storage: UNKNOWN KEY `0x4342193e496fab7ec59d615ed0dc55304e7b9012096b41c4eb3aaf947f6ea429` (r:1 w:0) @@ -1248,8 +1248,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `167` // Estimated: `3632` - // Minimum execution time: 6_098_000 picoseconds. - Weight::from_parts(6_424_000, 3632) + // Minimum execution time: 5_942_000 picoseconds. + Weight::from_parts(6_224_000, 3632) .saturating_add(RocksDbWeight::get().reads(2_u64)) } /// Storage: UNKNOWN KEY `0x4342193e496fab7ec59d615ed0dc55304e7b9012096b41c4eb3aaf947f6ea429` (r:1 w:0) @@ -1260,8 +1260,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `142` // Estimated: `3607` - // Minimum execution time: 6_168_000 picoseconds. - Weight::from_parts(6_391_000, 3607) + // Minimum execution time: 6_161_000 picoseconds. + Weight::from_parts(6_476_000, 3607) .saturating_add(RocksDbWeight::get().reads(2_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -1286,10 +1286,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `804 + c * (1 ±0)` // Estimated: `9217 + c * (1 ±0)` - // Minimum execution time: 304_486_000 picoseconds. - Weight::from_parts(281_210_403, 9217) - // Standard Error: 71 - .saturating_add(Weight::from_parts(33_632, 0).saturating_mul(c.into())) + // Minimum execution time: 367_780_000 picoseconds. + Weight::from_parts(340_082_130, 9217) + // Standard Error: 86 + .saturating_add(Weight::from_parts(34_319, 0).saturating_mul(c.into())) .saturating_add(RocksDbWeight::get().reads(11_u64)) .saturating_add(RocksDbWeight::get().writes(4_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(c.into())) @@ -1321,14 +1321,14 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `326` // Estimated: `8740` - // Minimum execution time: 4_111_986_000 picoseconds. - Weight::from_parts(381_653_579, 8740) - // Standard Error: 198 - .saturating_add(Weight::from_parts(70_030, 0).saturating_mul(c.into())) - // Standard Error: 23 - .saturating_add(Weight::from_parts(1_669, 0).saturating_mul(i.into())) - // Standard Error: 23 - .saturating_add(Weight::from_parts(1_842, 0).saturating_mul(s.into())) + // Minimum execution time: 4_288_324_000 picoseconds. + Weight::from_parts(851_698_267, 8740) + // Standard Error: 115 + .saturating_add(Weight::from_parts(68_501, 0).saturating_mul(c.into())) + // Standard Error: 13 + .saturating_add(Weight::from_parts(1_658, 0).saturating_mul(i.into())) + // Standard Error: 13 + .saturating_add(Weight::from_parts(1_666, 0).saturating_mul(s.into())) .saturating_add(RocksDbWeight::get().reads(14_u64)) .saturating_add(RocksDbWeight::get().writes(10_u64)) } @@ -1358,12 +1358,12 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `563` // Estimated: `8982` - // Minimum execution time: 1_996_742_000 picoseconds. - Weight::from_parts(2_026_648_000, 8982) - // Standard Error: 25 - .saturating_add(Weight::from_parts(849, 0).saturating_mul(i.into())) - // Standard Error: 25 - .saturating_add(Weight::from_parts(852, 0).saturating_mul(s.into())) + // Minimum execution time: 2_133_178_000 picoseconds. + Weight::from_parts(2_142_604_000, 8982) + // Standard Error: 26 + .saturating_add(Weight::from_parts(887, 0).saturating_mul(i.into())) + // Standard Error: 26 + .saturating_add(Weight::from_parts(790, 0).saturating_mul(s.into())) .saturating_add(RocksDbWeight::get().reads(13_u64)) .saturating_add(RocksDbWeight::get().writes(7_u64)) } @@ -1387,8 +1387,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `829` // Estimated: `9244` - // Minimum execution time: 206_272_000 picoseconds. - Weight::from_parts(217_655_000, 9244) + // Minimum execution time: 211_959_000 picoseconds. + Weight::from_parts(222_187_000, 9244) .saturating_add(RocksDbWeight::get().reads(11_u64)) .saturating_add(RocksDbWeight::get().writes(4_u64)) } @@ -1409,10 +1409,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `145` // Estimated: `6085` - // Minimum execution time: 277_885_000 picoseconds. - Weight::from_parts(264_589_547, 6085) - // Standard Error: 73 - .saturating_add(Weight::from_parts(33_704, 0).saturating_mul(c.into())) + // Minimum execution time: 339_757_000 picoseconds. + Weight::from_parts(351_268_427, 6085) + // Standard Error: 54 + .saturating_add(Weight::from_parts(33_161, 0).saturating_mul(c.into())) .saturating_add(RocksDbWeight::get().reads(6_u64)) .saturating_add(RocksDbWeight::get().writes(4_u64)) } @@ -1433,10 +1433,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `145` // Estimated: `6085` - // Minimum execution time: 298_636_000 picoseconds. - Weight::from_parts(271_144_699, 6085) - // Standard Error: 100 - .saturating_add(Weight::from_parts(34_478, 0).saturating_mul(c.into())) + // Minimum execution time: 351_862_000 picoseconds. + Weight::from_parts(368_816_737, 6085) + // Standard Error: 49 + .saturating_add(Weight::from_parts(33_163, 0).saturating_mul(c.into())) .saturating_add(RocksDbWeight::get().reads(6_u64)) .saturating_add(RocksDbWeight::get().writes(4_u64)) } @@ -1454,8 +1454,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `315` // Estimated: `3780` - // Minimum execution time: 46_040_000 picoseconds. - Weight::from_parts(48_079_000, 3780) + // Minimum execution time: 45_679_000 picoseconds. + Weight::from_parts(46_940_000, 3780) .saturating_add(RocksDbWeight::get().reads(4_u64)) .saturating_add(RocksDbWeight::get().writes(4_u64)) } @@ -1471,8 +1471,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `552` // Estimated: `8967` - // Minimum execution time: 34_375_000 picoseconds. - Weight::from_parts(36_222_000, 8967) + // Minimum execution time: 34_955_000 picoseconds. + Weight::from_parts(36_174_000, 8967) .saturating_add(RocksDbWeight::get().reads(7_u64)) .saturating_add(RocksDbWeight::get().writes(6_u64)) } @@ -1481,17 +1481,17 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 10_802_000 picoseconds. - Weight::from_parts(11_876_953, 0) - // Standard Error: 85 - .saturating_add(Weight::from_parts(70_319, 0).saturating_mul(r.into())) + // Minimum execution time: 9_394_000 picoseconds. + Weight::from_parts(10_159_990, 0) + // Standard Error: 56 + .saturating_add(Weight::from_parts(71_497, 0).saturating_mul(r.into())) } fn seal_caller() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 560_000 picoseconds. - Weight::from_parts(627_000, 0) + // Minimum execution time: 617_000 picoseconds. + Weight::from_parts(662_000, 0) } /// Storage: `Contracts::ContractInfoOf` (r:1 w:0) /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) @@ -1499,8 +1499,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `354` // Estimated: `3819` - // Minimum execution time: 6_604_000 picoseconds. - Weight::from_parts(6_824_000, 3819) + // Minimum execution time: 6_925_000 picoseconds. + Weight::from_parts(7_060_000, 3819) .saturating_add(RocksDbWeight::get().reads(1_u64)) } /// Storage: `Contracts::ContractInfoOf` (r:1 w:0) @@ -1509,44 +1509,44 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `447` // Estimated: `3912` - // Minimum execution time: 7_697_000 picoseconds. - Weight::from_parts(8_009_000, 3912) + // Minimum execution time: 7_928_000 picoseconds. + Weight::from_parts(8_230_000, 3912) .saturating_add(RocksDbWeight::get().reads(1_u64)) } fn seal_own_code_hash() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 783_000 picoseconds. - Weight::from_parts(825_000, 0) + // Minimum execution time: 818_000 picoseconds. + Weight::from_parts(864_000, 0) } fn seal_caller_is_origin() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 329_000 picoseconds. - Weight::from_parts(383_000, 0) + // Minimum execution time: 382_000 picoseconds. + Weight::from_parts(411_000, 0) } fn seal_caller_is_root() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 309_000 picoseconds. - Weight::from_parts(357_000, 0) + // Minimum execution time: 350_000 picoseconds. + Weight::from_parts(386_000, 0) } fn seal_address() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 554_000 picoseconds. - Weight::from_parts(601_000, 0) + // Minimum execution time: 613_000 picoseconds. + Weight::from_parts(654_000, 0) } fn seal_gas_left() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 639_000 picoseconds. - Weight::from_parts(693_000, 0) + // Minimum execution time: 619_000 picoseconds. + Weight::from_parts(680_000, 0) } /// Storage: `System::Account` (r:1 w:0) /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`) @@ -1554,37 +1554,37 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `140` // Estimated: `3605` - // Minimum execution time: 4_720_000 picoseconds. - Weight::from_parts(4_902_000, 3605) + // Minimum execution time: 4_800_000 picoseconds. + Weight::from_parts(4_992_000, 3605) .saturating_add(RocksDbWeight::get().reads(1_u64)) } fn seal_value_transferred() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 538_000 picoseconds. - Weight::from_parts(586_000, 0) + // Minimum execution time: 545_000 picoseconds. + Weight::from_parts(596_000, 0) } fn seal_minimum_balance() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 509_000 picoseconds. - Weight::from_parts(571_000, 0) + // Minimum execution time: 571_000 picoseconds. + Weight::from_parts(620_000, 0) } fn seal_block_number() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 535_000 picoseconds. - Weight::from_parts(586_000, 0) + // Minimum execution time: 540_000 picoseconds. + Weight::from_parts(612_000, 0) } fn seal_now() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 578_000 picoseconds. - Weight::from_parts(637_000, 0) + // Minimum execution time: 588_000 picoseconds. + Weight::from_parts(638_000, 0) } /// Storage: `TransactionPayment::NextFeeMultiplier` (r:1 w:0) /// Proof: `TransactionPayment::NextFeeMultiplier` (`max_values`: Some(1), `max_size`: Some(16), added: 511, mode: `Measured`) @@ -1592,8 +1592,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `67` // Estimated: `1552` - // Minimum execution time: 4_416_000 picoseconds. - Weight::from_parts(4_611_000, 1552) + // Minimum execution time: 4_415_000 picoseconds. + Weight::from_parts(4_703_000, 1552) .saturating_add(RocksDbWeight::get().reads(1_u64)) } /// The range of component `n` is `[0, 1048572]`. @@ -1601,20 +1601,20 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 469_000 picoseconds. - Weight::from_parts(513_000, 0) + // Minimum execution time: 484_000 picoseconds. + Weight::from_parts(508_000, 0) // Standard Error: 3 - .saturating_add(Weight::from_parts(294, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(303, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 1048572]`. fn seal_return(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 328_000 picoseconds. - Weight::from_parts(345_000, 0) + // Minimum execution time: 390_000 picoseconds. + Weight::from_parts(421_000, 0) // Standard Error: 9 - .saturating_add(Weight::from_parts(400, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(479, 0).saturating_mul(n.into())) } /// Storage: `Contracts::DeletionQueueCounter` (r:1 w:1) /// Proof: `Contracts::DeletionQueueCounter` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`) @@ -1630,8 +1630,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `2821` // Estimated: `85486` - // Minimum execution time: 134_982_000 picoseconds. - Weight::from_parts(137_218_000, 85486) + // Minimum execution time: 134_681_000 picoseconds. + Weight::from_parts(136_452_000, 85486) .saturating_add(RocksDbWeight::get().reads(36_u64)) .saturating_add(RocksDbWeight::get().writes(38_u64)) } @@ -1641,8 +1641,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `76` // Estimated: `1561` - // Minimum execution time: 3_641_000 picoseconds. - Weight::from_parts(3_851_000, 1561) + // Minimum execution time: 3_664_000 picoseconds. + Weight::from_parts(3_887_000, 1561) .saturating_add(RocksDbWeight::get().reads(1_u64)) } /// Storage: `System::EventTopics` (r:4 w:4) @@ -1653,12 +1653,12 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `0` // Estimated: `990 + t * (2475 ±0)` - // Minimum execution time: 4_143_000 picoseconds. - Weight::from_parts(4_355_459, 990) - // Standard Error: 7_907 - .saturating_add(Weight::from_parts(2_334_740, 0).saturating_mul(t.into())) - // Standard Error: 2 - .saturating_add(Weight::from_parts(28, 0).saturating_mul(n.into())) + // Minimum execution time: 4_150_000 picoseconds. + Weight::from_parts(4_478_017, 990) + // Standard Error: 6_791 + .saturating_add(Weight::from_parts(2_359_039, 0).saturating_mul(t.into())) + // Standard Error: 1 + .saturating_add(Weight::from_parts(19, 0).saturating_mul(n.into())) .saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(t.into()))) .saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(t.into()))) .saturating_add(Weight::from_parts(0, 2475).saturating_mul(t.into())) @@ -1668,10 +1668,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 436_000 picoseconds. - Weight::from_parts(464_000, 0) + // Minimum execution time: 400_000 picoseconds. + Weight::from_parts(424_000, 0) // Standard Error: 10 - .saturating_add(Weight::from_parts(1_204, 0).saturating_mul(i.into())) + .saturating_add(Weight::from_parts(1_271, 0).saturating_mul(i.into())) } /// Storage: `Skipped::Metadata` (r:0 w:0) /// Proof: `Skipped::Metadata` (`max_values`: None, `max_size`: None, mode: `Measured`) @@ -1680,10 +1680,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `245` // Estimated: `245` - // Minimum execution time: 7_574_000 picoseconds. - Weight::from_parts(8_651_771, 245) + // Minimum execution time: 8_012_000 picoseconds. + Weight::from_parts(8_699_107, 245) // Standard Error: 1 - .saturating_add(Weight::from_parts(255, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(351, 0).saturating_mul(n.into())) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -1694,10 +1694,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `248 + n * (1 ±0)` // Estimated: `248 + n * (1 ±0)` - // Minimum execution time: 7_553_000 picoseconds. - Weight::from_parts(9_223_601, 248) + // Minimum execution time: 8_016_000 picoseconds. + Weight::from_parts(9_309_029, 248) // Standard Error: 2 - .saturating_add(Weight::from_parts(86, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(78, 0).saturating_mul(n.into())) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) @@ -1709,10 +1709,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `248 + n * (1 ±0)` // Estimated: `248 + n * (1 ±0)` - // Minimum execution time: 7_856_000 picoseconds. - Weight::from_parts(9_180_008, 248) + // Minimum execution time: 7_984_000 picoseconds. + Weight::from_parts(9_206_228, 248) // Standard Error: 2 - .saturating_add(Weight::from_parts(89, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(77, 0).saturating_mul(n.into())) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) @@ -1724,10 +1724,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `248 + n * (1 ±0)` // Estimated: `248 + n * (1 ±0)` - // Minimum execution time: 7_126_000 picoseconds. - Weight::from_parts(8_921_997, 248) - // Standard Error: 3 - .saturating_add(Weight::from_parts(614, 0).saturating_mul(n.into())) + // Minimum execution time: 7_083_000 picoseconds. + Weight::from_parts(8_815_611, 248) + // Standard Error: 2 + .saturating_add(Weight::from_parts(708, 0).saturating_mul(n.into())) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) } @@ -1738,10 +1738,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `248 + n * (1 ±0)` // Estimated: `248 + n * (1 ±0)` - // Minimum execution time: 6_715_000 picoseconds. - Weight::from_parts(7_848_323, 248) + // Minimum execution time: 6_708_000 picoseconds. + Weight::from_parts(8_031_454, 248) // Standard Error: 2 - .saturating_add(Weight::from_parts(88, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(78, 0).saturating_mul(n.into())) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) } @@ -1752,10 +1752,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `248 + n * (1 ±0)` // Estimated: `248 + n * (1 ±0)` - // Minimum execution time: 8_318_000 picoseconds. - Weight::from_parts(9_990_344, 248) - // Standard Error: 5 - .saturating_add(Weight::from_parts(634, 0).saturating_mul(n.into())) + // Minimum execution time: 8_273_000 picoseconds. + Weight::from_parts(9_872_829, 248) + // Standard Error: 3 + .saturating_add(Weight::from_parts(712, 0).saturating_mul(n.into())) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) @@ -1766,8 +1766,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `140` // Estimated: `3605` - // Minimum execution time: 8_900_000 picoseconds. - Weight::from_parts(9_215_000, 3605) + // Minimum execution time: 9_220_000 picoseconds. + Weight::from_parts(9_590_000, 3605) .saturating_add(RocksDbWeight::get().reads(1_u64)) } /// Storage: `Contracts::ContractInfoOf` (r:1 w:2) @@ -1789,14 +1789,14 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `623 + t * (280 ±0)` // Estimated: `6563 + t * (3422 ±0)` - // Minimum execution time: 164_943_000 picoseconds. - Weight::from_parts(164_713_349, 6563) - // Standard Error: 323_916 - .saturating_add(Weight::from_parts(43_689_556, 0).saturating_mul(t.into())) - // Standard Error: 323_916 - .saturating_add(Weight::from_parts(2_727_352, 0).saturating_mul(c.into())) + // Minimum execution time: 171_273_000 picoseconds. + Weight::from_parts(172_294_959, 6563) + // Standard Error: 309_680 + .saturating_add(Weight::from_parts(41_035_739, 0).saturating_mul(t.into())) + // Standard Error: 309_680 + .saturating_add(Weight::from_parts(168_535, 0).saturating_mul(c.into())) // Standard Error: 0 - .saturating_add(Weight::from_parts(7, 0).saturating_mul(i.into())) + .saturating_add(Weight::from_parts(9, 0).saturating_mul(i.into())) .saturating_add(RocksDbWeight::get().reads(7_u64)) .saturating_add(RocksDbWeight::get().reads((2_u64).saturating_mul(t.into()))) .saturating_add(RocksDbWeight::get().writes(4_u64)) @@ -1817,8 +1817,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `433` // Estimated: `6373` - // Minimum execution time: 152_390_000 picoseconds. - Weight::from_parts(165_217_000, 6373) + // Minimum execution time: 155_964_000 picoseconds. + Weight::from_parts(160_485_000, 6373) .saturating_add(RocksDbWeight::get().reads(6_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) } @@ -1843,14 +1843,14 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `679 + t * (102 ±0)` // Estimated: `6616 + t * (2565 ±1)` - // Minimum execution time: 1_709_241_000 picoseconds. - Weight::from_parts(162_472_084, 6616) - // Standard Error: 9_135_790 - .saturating_add(Weight::from_parts(119_325_657, 0).saturating_mul(t.into())) - // Standard Error: 14 - .saturating_add(Weight::from_parts(1_389, 0).saturating_mul(i.into())) - // Standard Error: 14 - .saturating_add(Weight::from_parts(1_787, 0).saturating_mul(s.into())) + // Minimum execution time: 1_821_557_000 picoseconds. + Weight::from_parts(85_126_984, 6616) + // Standard Error: 6_661_370 + .saturating_add(Weight::from_parts(175_191_430, 0).saturating_mul(t.into())) + // Standard Error: 10 + .saturating_add(Weight::from_parts(1_539, 0).saturating_mul(i.into())) + // Standard Error: 10 + .saturating_add(Weight::from_parts(1_811, 0).saturating_mul(s.into())) .saturating_add(RocksDbWeight::get().reads(10_u64)) .saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(t.into()))) .saturating_add(RocksDbWeight::get().writes(7_u64)) @@ -1862,64 +1862,64 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 864_000 picoseconds. - Weight::from_parts(914_000, 0) + // Minimum execution time: 834_000 picoseconds. + Weight::from_parts(891_000, 0) // Standard Error: 0 - .saturating_add(Weight::from_parts(1_060, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(1_152, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 1048576]`. fn seal_hash_keccak_256(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_305_000 picoseconds. - Weight::from_parts(1_342_000, 0) + // Minimum execution time: 1_428_000 picoseconds. + Weight::from_parts(1_493_000, 0) // Standard Error: 0 - .saturating_add(Weight::from_parts(3_322, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(3_414, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 1048576]`. fn seal_hash_blake2_256(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 741_000 picoseconds. - Weight::from_parts(772_000, 0) + // Minimum execution time: 707_000 picoseconds. + Weight::from_parts(774_000, 0) // Standard Error: 0 - .saturating_add(Weight::from_parts(1_188, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(1_280, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 1048576]`. fn seal_hash_blake2_128(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 735_000 picoseconds. - Weight::from_parts(759_000, 0) + // Minimum execution time: 763_000 picoseconds. + Weight::from_parts(822_000, 0) // Standard Error: 0 - .saturating_add(Weight::from_parts(1_188, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(1_279, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 125697]`. fn seal_sr25519_verify(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 44_096_000 picoseconds. - Weight::from_parts(45_203_791, 0) + // Minimum execution time: 45_176_000 picoseconds. + Weight::from_parts(46_961_397, 0) // Standard Error: 7 - .saturating_add(Weight::from_parts(4_670, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(4_692, 0).saturating_mul(n.into())) } fn seal_ecdsa_recover() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 47_195_000 picoseconds. - Weight::from_parts(49_118_000, 0) + // Minimum execution time: 47_301_000 picoseconds. + Weight::from_parts(48_454_000, 0) } fn seal_ecdsa_to_eth_address() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 13_001_000 picoseconds. - Weight::from_parts(13_115_000, 0) + // Minimum execution time: 13_031_000 picoseconds. + Weight::from_parts(13_300_000, 0) } /// Storage: `Contracts::CodeInfoOf` (r:1 w:1) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) @@ -1933,8 +1933,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `433` // Estimated: `6373` - // Minimum execution time: 31_502_000 picoseconds. - Weight::from_parts(32_325_000, 6373) + // Minimum execution time: 31_664_000 picoseconds. + Weight::from_parts(32_906_000, 6373) .saturating_add(RocksDbWeight::get().reads(6_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) } @@ -1944,8 +1944,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `355` // Estimated: `3820` - // Minimum execution time: 9_266_000 picoseconds. - Weight::from_parts(9_628_000, 3820) + // Minimum execution time: 9_364_000 picoseconds. + Weight::from_parts(9_551_000, 3820) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -1955,8 +1955,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `355` // Estimated: `3558` - // Minimum execution time: 8_125_000 picoseconds. - Weight::from_parts(8_525_000, 3558) + // Minimum execution time: 8_210_000 picoseconds. + Weight::from_parts(8_551_000, 3558) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -1964,15 +1964,15 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 307_000 picoseconds. - Weight::from_parts(344_000, 0) + // Minimum execution time: 355_000 picoseconds. + Weight::from_parts(401_000, 0) } fn seal_account_reentrance_count() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 338_000 picoseconds. - Weight::from_parts(370_000, 0) + // Minimum execution time: 383_000 picoseconds. + Weight::from_parts(406_000, 0) } /// Storage: `Contracts::Nonce` (r:1 w:0) /// Proof: `Contracts::Nonce` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`) @@ -1980,8 +1980,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `219` // Estimated: `1704` - // Minimum execution time: 2_892_000 picoseconds. - Weight::from_parts(3_126_000, 1704) + // Minimum execution time: 3_011_000 picoseconds. + Weight::from_parts(3_197_000, 1704) .saturating_add(RocksDbWeight::get().reads(1_u64)) } /// The range of component `r` is `[0, 5000]`. @@ -1989,9 +1989,9 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 919_000 picoseconds. - Weight::from_parts(514_641, 0) - // Standard Error: 18 - .saturating_add(Weight::from_parts(15_217, 0).saturating_mul(r.into())) + // Minimum execution time: 945_000 picoseconds. + Weight::from_parts(916_399, 0) + // Standard Error: 14 + .saturating_add(Weight::from_parts(14_957, 0).saturating_mul(r.into())) } } From 9ceb5491606543f37d2ef8ee4763484f0d86b163 Mon Sep 17 00:00:00 2001 From: pgherveou Date: Fri, 3 May 2024 11:14:12 +0200 Subject: [PATCH 17/34] Undo --- substrate/frame/contracts/README.md | 13 ------------- substrate/frame/contracts/src/benchmarking/mod.rs | 10 +++++----- 2 files changed, 5 insertions(+), 18 deletions(-) diff --git a/substrate/frame/contracts/README.md b/substrate/frame/contracts/README.md index 09dc770300ca..2e70b5c5008b 100644 --- a/substrate/frame/contracts/README.md +++ b/substrate/frame/contracts/README.md @@ -34,19 +34,6 @@ calls are reverted. Assuming correct error handling by contract A, A's other cal One `ref_time` `Weight` is defined as one picosecond of execution time on the runtime's reference machine. -#### Schedule - -The `Schedule` is where, among other things, the cost of every action a contract can do is defined. These costs are derived -from the benchmarks of this pallet. Instead of looking at the raw benchmark results it is advised to look at the `Schedule` -if one wants to manually inspect the performance characteristics. The `Schedule` can be printed like this: - -```sh -RUST_LOG=runtime::contracts=info cargo run --features runtime-benchmarks --bin substrate-node -- benchmark pallet --extra -p pallet_contracts -e print_schedule -``` - -Please note that the `Schedule` will be printed multiple times. This is because we are (ab)using a benchmark to print -the struct. - ### Revert Behaviour Contract call failures are not cascading. When failures occur in a sub-call, they do not "bubble up", and the call will diff --git a/substrate/frame/contracts/src/benchmarking/mod.rs b/substrate/frame/contracts/src/benchmarking/mod.rs index 3ef98e9fec3a..fc94cf3285df 100644 --- a/substrate/frame/contracts/src/benchmarking/mod.rs +++ b/substrate/frame/contracts/src/benchmarking/mod.rs @@ -906,7 +906,7 @@ mod benchmarks { let result; #[block] { - result = BenchEnv::seal1_terminate(&mut runtime, &mut memory, 0) + result = BenchEnv::seal1_terminate(&mut runtime, &mut memory, 0); } assert!(matches!(result, Err(crate::wasm::TrapReason::Termination))); @@ -941,7 +941,7 @@ mod benchmarks { subject_len, // subject_len subject_len + 4, // output_ptr 0, // output_len_ptr - ) + ); } assert_ok!(result); @@ -975,7 +975,7 @@ mod benchmarks { topics_len, // topics_len 4 + topics_len, // data_ptr 0, // data_len - ) + ); } assert_ok!(result); @@ -1574,7 +1574,7 @@ mod benchmarks { result = BenchEnv::seal0_reentrance_count(&mut runtime, &mut memory) } - assert!(result.unwrap() == 0); + assert_eq!(result.unwrap(), 0); } #[benchmark(pov_mode = Measured)] @@ -1589,7 +1589,7 @@ mod benchmarks { result = BenchEnv::seal0_account_reentrance_count(&mut runtime, &mut memory, 0); } - assert!(result.unwrap() == 0); + assert_eq!(result.unwrap(), 0); } #[benchmark(pov_mode = Measured)] From 28acc562a86ad7e952630fa3e65a757f56996cf5 Mon Sep 17 00:00:00 2001 From: pgherveou Date: Wed, 15 May 2024 16:43:51 +0200 Subject: [PATCH 18/34] Add PRdoc --- prdoc/pr_4233.prdoc | 12 ++++++++++++ 1 file changed, 12 insertions(+) create mode 100644 prdoc/pr_4233.prdoc diff --git a/prdoc/pr_4233.prdoc b/prdoc/pr_4233.prdoc new file mode 100644 index 000000000000..c156e084146e --- /dev/null +++ b/prdoc/pr_4233.prdoc @@ -0,0 +1,12 @@ +title: "[pallet_contracts] Update Host fn benchnmarks" + +doc: + - audience: Runtime Dev + description: | + Update how the host functions are benchmarked. + Instead of benchnarking a contract that calls the host functions, we now benchmark the host functions directly. + +crates: + - name: pallet-contracts + bump: patch + From 6d87585d72f7020ee92baec22cfecae1fb190bf9 Mon Sep 17 00:00:00 2001 From: pgherveou Date: Wed, 15 May 2024 21:20:35 +0200 Subject: [PATCH 19/34] Fix PRdoc --- prdoc/pr_4233.prdoc | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/prdoc/pr_4233.prdoc b/prdoc/pr_4233.prdoc index c156e084146e..c593fec68a66 100644 --- a/prdoc/pr_4233.prdoc +++ b/prdoc/pr_4233.prdoc @@ -8,5 +8,7 @@ doc: crates: - name: pallet-contracts - bump: patch + bump: minor + - name: pallet-contracts-proc-macro + bump: minor From 0586b4a6c73c66b7bb5489713632bf1779ea6d62 Mon Sep 17 00:00:00 2001 From: pgherveou Date: Thu, 16 May 2024 18:48:40 +0200 Subject: [PATCH 20/34] benchmarks: whitelist account_id and contract_info for the root contract --- .../frame/contracts/src/benchmarking/call_builder.rs | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/substrate/frame/contracts/src/benchmarking/call_builder.rs b/substrate/frame/contracts/src/benchmarking/call_builder.rs index 5a0a043b2e7a..5d73d825fca9 100644 --- a/substrate/frame/contracts/src/benchmarking/call_builder.rs +++ b/substrate/frame/contracts/src/benchmarking/call_builder.rs @@ -25,6 +25,7 @@ use crate::{ }; use codec::{Encode, HasCompact}; use core::fmt::Debug; +use frame_benchmarking::benchmarking; use sp_core::Get; use sp_std::prelude::*; @@ -80,6 +81,17 @@ where let storage_meter = Meter::new(&origin, None, 0u32.into()).unwrap(); + // Whitelist contract account, as it is already accounted for in the call benchmark + benchmarking::add_to_whitelist( + frame_system::Account::::hashed_key_for(&contract.account_id).into(), + ); + + // Whitelist the contract's contractInfo as it is already accounted for in the call + // benchmark + benchmarking::add_to_whitelist( + crate::ContractInfoOf::::hashed_key_for(&contract.account_id).into(), + ); + Self { contract, dest, From fbdc565b3ed8f0d91a0013b480dad85b4091dbae Mon Sep 17 00:00:00 2001 From: pgherveou Date: Thu, 16 May 2024 20:35:07 +0200 Subject: [PATCH 21/34] fix --- substrate/bin/node/runtime/src/lib.rs | 26 ++++++-------------------- 1 file changed, 6 insertions(+), 20 deletions(-) diff --git a/substrate/bin/node/runtime/src/lib.rs b/substrate/bin/node/runtime/src/lib.rs index 017ee9100f9e..ffda5ad6043d 100644 --- a/substrate/bin/node/runtime/src/lib.rs +++ b/substrate/bin/node/runtime/src/lib.rs @@ -1341,6 +1341,9 @@ impl pallet_tips::Config for Runtime { } parameter_types! { + pub const DepositPerItem: Balance = deposit(1, 0); + pub const DepositPerByte: Balance = deposit(0, 1); + pub const DefaultDepositLimit: Balance = deposit(1024, 1024 * 1024); pub Schedule: pallet_contracts::Schedule = Default::default(); pub CodeHashLockupDepositPercent: Perbill = Perbill::from_percent(30); } @@ -1358,9 +1361,9 @@ impl pallet_contracts::Config for Runtime { /// change because that would break already deployed contracts. The `Call` structure itself /// is not allowed to change the indices of existing pallets, too. type CallFilter = Nothing; - type DepositPerItem = dynamic_params::contracts::DepositPerItem; - type DepositPerByte = dynamic_params::contracts::DepositPerByte; - type DefaultDepositLimit = dynamic_params::contracts::DefaultDepositLimit; + type DepositPerItem = DepositPerItem; + type DepositPerByte = DepositPerByte; + type DefaultDepositLimit = DefaultDepositLimit; type CallStack = [pallet_contracts::Frame; 5]; type WeightPrice = pallet_transaction_payment::Pallet; type WeightInfo = pallet_contracts::weights::SubstrateWeight; @@ -2181,19 +2184,6 @@ pub mod dynamic_params { #[codec(index = 1)] pub static ByteDeposit: Balance = 1 * CENTS; } - - #[dynamic_pallet_params] - #[codec(index = 1)] - pub mod contracts { - #[codec(index = 0)] - pub static DepositPerItem: Balance = deposit(1, 0); - - #[codec(index = 1)] - pub static DepositPerByte: Balance = deposit(0, 1); - - #[codec(index = 2)] - pub static DefaultDepositLimit: Balance = deposit(1024, 1024 * 1024); - } } #[cfg(feature = "runtime-benchmarks")] @@ -2219,10 +2209,6 @@ impl EnsureOriginWithArg for DynamicParamet frame_system::ensure_root(origin.clone()).map_err(|_| origin)?; return Ok(()) }, - RuntimeParametersKey::Contracts(_) => { - frame_system::ensure_root(origin.clone()).map_err(|_| origin)?; - return Ok(()) - }, } } From 58517ee67868387112dd5bbc44964935f6b5e50e Mon Sep 17 00:00:00 2001 From: pgherveou Date: Thu, 16 May 2024 20:55:37 +0200 Subject: [PATCH 22/34] PR review merge set_storage_per_new_byte & _old_bytes --- .../frame/contracts/src/benchmarking/mod.rs | 41 +++---------------- substrate/frame/contracts/src/wasm/runtime.rs | 3 +- substrate/frame/contracts/src/weights.rs | 37 ++--------------- 3 files changed, 10 insertions(+), 71 deletions(-) diff --git a/substrate/frame/contracts/src/benchmarking/mod.rs b/substrate/frame/contracts/src/benchmarking/mod.rs index fc94cf3285df..6e0270b89f1d 100644 --- a/substrate/frame/contracts/src/benchmarking/mod.rs +++ b/substrate/frame/contracts/src/benchmarking/mod.rs @@ -1013,9 +1013,12 @@ mod benchmarks { assert_eq!(setup.debug_message().unwrap().len() as u32, i); } + // n: new byte size + // o: old byte size #[benchmark(skip_meta, pov_mode = Measured)] - fn seal_set_storage_per_new_byte( + fn seal_set_storage( n: Linear<0, { T::Schedule::get().limits.payload_len }>, + o: Linear<0, { T::Schedule::get().limits.payload_len }>, ) -> Result<(), BenchmarkError> { let max_key_len = T::MaxStorageKeyLen::get(); let key = Key::::try_from_var(vec![0u8; max_key_len as usize]) @@ -1024,7 +1027,8 @@ mod benchmarks { build_runtime!(runtime, instance, memory: [ key.to_vec(), value.clone(), ]); let info = instance.info()?; - info.write(&key, Some(vec![]), None, false) + + info.write(&key, Some(vec![42u8; o as usize]), None, false) .map_err(|_| "Failed to write to storage during setup.")?; let result; @@ -1045,39 +1049,6 @@ mod benchmarks { Ok(()) } - #[benchmark(skip_meta, pov_mode = Measured)] - fn seal_set_storage_per_old_byte( - n: Linear<0, { T::Schedule::get().limits.payload_len }>, - ) -> Result<(), BenchmarkError> { - let max_key_len = T::MaxStorageKeyLen::get(); - let key = Key::::try_from_var(vec![0u8; max_key_len as usize]) - .map_err(|_| "Key has wrong length")?; - let value = vec![1u8; n as usize]; - - build_runtime!(runtime, instance, memory: [ key.to_vec(), value.clone(), ]); - let info = instance.info()?; - - info.write(&key, Some(vec![42u8; n as usize]), None, false) - .map_err(|_| "Failed to write to storage during setup.")?; - - let result; - #[block] - { - result = BenchEnv::seal2_set_storage( - &mut runtime, - &mut memory, - 0, // key_ptr - max_key_len, // key_len - max_key_len, // value_ptr - 0, // value_len is 0 as testing vs pre-existing value len - ); - } - - assert_ok!(result); - assert!(info.read(&key).unwrap().is_empty()); - Ok(()) - } - #[benchmark(skip_meta, pov_mode = Measured)] fn seal_clear_storage( n: Linear<0, { T::Schedule::get().limits.payload_len }>, diff --git a/substrate/frame/contracts/src/wasm/runtime.rs b/substrate/frame/contracts/src/wasm/runtime.rs index 4ea54d9b56db..a993bdf5c236 100644 --- a/substrate/frame/contracts/src/wasm/runtime.rs +++ b/substrate/frame/contracts/src/wasm/runtime.rs @@ -292,8 +292,7 @@ impl Token for RuntimeCosts { DepositEvent { num_topic, len } => T::WeightInfo::seal_deposit_event(num_topic, len), DebugMessage(len) => T::WeightInfo::seal_debug_message(len), SetStorage { new_bytes, old_bytes } => - T::WeightInfo::seal_set_storage_per_new_byte(new_bytes) - .saturating_add(T::WeightInfo::seal_set_storage_per_old_byte(old_bytes)), + T::WeightInfo::seal_set_storage(new_bytes, old_bytes), ClearStorage(len) => T::WeightInfo::seal_clear_storage(len), ContainsStorage(len) => T::WeightInfo::seal_contains_storage(len), GetStorage(len) => T::WeightInfo::seal_get_storage(len), diff --git a/substrate/frame/contracts/src/weights.rs b/substrate/frame/contracts/src/weights.rs index 352a84e3bddd..59772ee6eac3 100644 --- a/substrate/frame/contracts/src/weights.rs +++ b/substrate/frame/contracts/src/weights.rs @@ -93,8 +93,7 @@ pub trait WeightInfo { fn seal_random() -> Weight; fn seal_deposit_event(t: u32, n: u32, ) -> Weight; fn seal_debug_message(i: u32, ) -> Weight; - fn seal_set_storage_per_new_byte(n: u32, ) -> Weight; - fn seal_set_storage_per_old_byte(n: u32, ) -> Weight; + fn seal_set_storage(n: u32, o: u32) -> Weight; fn seal_clear_storage(n: u32, ) -> Weight; fn seal_get_storage(n: u32, ) -> Weight; fn seal_contains_storage(n: u32, ) -> Weight; @@ -738,7 +737,7 @@ impl WeightInfo for SubstrateWeight { /// Storage: `Skipped::Metadata` (r:0 w:0) /// Proof: `Skipped::Metadata` (`max_values`: None, `max_size`: None, mode: `Measured`) /// The range of component `n` is `[0, 16384]`. - fn seal_set_storage_per_new_byte(n: u32, ) -> Weight { + fn seal_set_storage(n: u32, _o: u32) -> Weight { // Proof Size summary in bytes: // Measured: `245` // Estimated: `245` @@ -752,21 +751,6 @@ impl WeightInfo for SubstrateWeight { /// Storage: `Skipped::Metadata` (r:0 w:0) /// Proof: `Skipped::Metadata` (`max_values`: None, `max_size`: None, mode: `Measured`) /// The range of component `n` is `[0, 16384]`. - fn seal_set_storage_per_old_byte(n: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `248 + n * (1 ±0)` - // Estimated: `248 + n * (1 ±0)` - // Minimum execution time: 8_016_000 picoseconds. - Weight::from_parts(9_309_029, 248) - // Standard Error: 2 - .saturating_add(Weight::from_parts(78, 0).saturating_mul(n.into())) - .saturating_add(T::DbWeight::get().reads(1_u64)) - .saturating_add(T::DbWeight::get().writes(1_u64)) - .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) - } - /// Storage: `Skipped::Metadata` (r:0 w:0) - /// Proof: `Skipped::Metadata` (`max_values`: None, `max_size`: None, mode: `Measured`) - /// The range of component `n` is `[0, 16384]`. fn seal_clear_storage(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `248 + n * (1 ±0)` @@ -1676,7 +1660,7 @@ impl WeightInfo for () { /// Storage: `Skipped::Metadata` (r:0 w:0) /// Proof: `Skipped::Metadata` (`max_values`: None, `max_size`: None, mode: `Measured`) /// The range of component `n` is `[0, 16384]`. - fn seal_set_storage_per_new_byte(n: u32, ) -> Weight { + fn seal_set_storage(n: u32, _o: u32) -> Weight { // Proof Size summary in bytes: // Measured: `245` // Estimated: `245` @@ -1690,21 +1674,6 @@ impl WeightInfo for () { /// Storage: `Skipped::Metadata` (r:0 w:0) /// Proof: `Skipped::Metadata` (`max_values`: None, `max_size`: None, mode: `Measured`) /// The range of component `n` is `[0, 16384]`. - fn seal_set_storage_per_old_byte(n: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `248 + n * (1 ±0)` - // Estimated: `248 + n * (1 ±0)` - // Minimum execution time: 8_016_000 picoseconds. - Weight::from_parts(9_309_029, 248) - // Standard Error: 2 - .saturating_add(Weight::from_parts(78, 0).saturating_mul(n.into())) - .saturating_add(RocksDbWeight::get().reads(1_u64)) - .saturating_add(RocksDbWeight::get().writes(1_u64)) - .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) - } - /// Storage: `Skipped::Metadata` (r:0 w:0) - /// Proof: `Skipped::Metadata` (`max_values`: None, `max_size`: None, mode: `Measured`) - /// The range of component `n` is `[0, 16384]`. fn seal_clear_storage(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `248 + n * (1 ±0)` From 2cc19fb62b42893433bbde20461518c24ec1a6f6 Mon Sep 17 00:00:00 2001 From: command-bot <> Date: Thu, 16 May 2024 19:57:52 +0000 Subject: [PATCH 23/34] ".git/.scripts/commands/bench/bench.sh" --subcommand=pallet --runtime=dev --target_dir=substrate --pallet=pallet_contracts --- substrate/frame/contracts/src/weights.rs | 1016 ++++++++++------------ 1 file changed, 478 insertions(+), 538 deletions(-) diff --git a/substrate/frame/contracts/src/weights.rs b/substrate/frame/contracts/src/weights.rs index 59772ee6eac3..d7ce94298ec0 100644 --- a/substrate/frame/contracts/src/weights.rs +++ b/substrate/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 32.0.0 -//! DATE: 2024-04-29, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2024-05-16, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` //! HOSTNAME: `runner-unxyhko3-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz` //! WASM-EXECUTION: `Compiled`, CHAIN: `Some("dev")`, DB CACHE: `1024` @@ -93,7 +93,7 @@ pub trait WeightInfo { fn seal_random() -> Weight; fn seal_deposit_event(t: u32, n: u32, ) -> Weight; fn seal_debug_message(i: u32, ) -> Weight; - fn seal_set_storage(n: u32, o: u32) -> Weight; + fn seal_set_storage(n: u32, o: u32, ) -> Weight; fn seal_clear_storage(n: u32, ) -> Weight; fn seal_get_storage(n: u32, ) -> Weight; fn seal_contains_storage(n: u32, ) -> Weight; @@ -127,8 +127,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `142` // Estimated: `1627` - // Minimum execution time: 2_077_000 picoseconds. - Weight::from_parts(2_153_000, 1627) + // Minimum execution time: 2_110_000 picoseconds. + Weight::from_parts(2_251_000, 1627) .saturating_add(T::DbWeight::get().reads(1_u64)) } /// Storage: `Skipped::Metadata` (r:0 w:0) @@ -138,10 +138,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `452 + k * (69 ±0)` // Estimated: `442 + k * (70 ±0)` - // Minimum execution time: 12_456_000 picoseconds. - Weight::from_parts(12_730_000, 442) - // Standard Error: 1_183 - .saturating_add(Weight::from_parts(1_096_672, 0).saturating_mul(k.into())) + // Minimum execution time: 12_154_000 picoseconds. + Weight::from_parts(12_536_000, 442) + // Standard Error: 907 + .saturating_add(Weight::from_parts(1_102_613, 0).saturating_mul(k.into())) .saturating_add(T::DbWeight::get().reads(2_u64)) .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(k.into()))) .saturating_add(T::DbWeight::get().writes(2_u64)) @@ -155,10 +155,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `211 + c * (1 ±0)` // Estimated: `6149 + c * (1 ±0)` - // Minimum execution time: 8_181_000 picoseconds. - Weight::from_parts(9_113_032, 6149) + // Minimum execution time: 8_232_000 picoseconds. + Weight::from_parts(8_895_498, 6149) // Standard Error: 1 - .saturating_add(Weight::from_parts(1_213, 0).saturating_mul(c.into())) + .saturating_add(Weight::from_parts(1_156, 0).saturating_mul(c.into())) .saturating_add(T::DbWeight::get().reads(2_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(c.into())) @@ -171,8 +171,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `510` // Estimated: `6450` - // Minimum execution time: 16_780_000 picoseconds. - Weight::from_parts(17_448_000, 6450) + // Minimum execution time: 16_760_000 picoseconds. + Weight::from_parts(17_693_000, 6450) .saturating_add(T::DbWeight::get().reads(3_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -185,10 +185,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `171 + k * (1 ±0)` // Estimated: `3635 + k * (1 ±0)` - // Minimum execution time: 3_382_000 picoseconds. - Weight::from_parts(1_286_516, 3635) - // Standard Error: 973 - .saturating_add(Weight::from_parts(1_204_983, 0).saturating_mul(k.into())) + // Minimum execution time: 3_535_000 picoseconds. + Weight::from_parts(9_084_983, 3635) + // Standard Error: 1_564 + .saturating_add(Weight::from_parts(1_222_023, 0).saturating_mul(k.into())) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(2_u64)) .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(k.into()))) @@ -198,8 +198,6 @@ impl WeightInfo for SubstrateWeight { /// Proof: UNKNOWN KEY `0x4342193e496fab7ec59d615ed0dc553053f13fd319a03c211337c76e0fe776df` (r:2 w:0) /// Storage: UNKNOWN KEY `0x4342193e496fab7ec59d615ed0dc553022fca90611ba8b7942f8bdb3b97f6580` (r:1 w:1) /// Proof: UNKNOWN KEY `0x4342193e496fab7ec59d615ed0dc553022fca90611ba8b7942f8bdb3b97f6580` (r:1 w:1) - /// Storage: `Parameters::Parameters` (r:2 w:0) - /// Proof: `Parameters::Parameters` (`max_values`: None, `max_size`: Some(36), added: 2511, mode: `Measured`) /// Storage: `System::Account` (r:1 w:0) /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:0 w:1) @@ -207,13 +205,13 @@ impl WeightInfo for SubstrateWeight { /// The range of component `c` is `[0, 125952]`. fn v12_migration_step(c: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `328 + c * (1 ±0)` - // Estimated: `6266 + c * (1 ±0)` - // Minimum execution time: 20_685_000 picoseconds. - Weight::from_parts(21_384_758, 6266) - // Standard Error: 0 - .saturating_add(Weight::from_parts(463, 0).saturating_mul(c.into())) - .saturating_add(T::DbWeight::get().reads(6_u64)) + // Measured: `325 + c * (1 ±0)` + // Estimated: `6263 + c * (1 ±0)` + // Minimum execution time: 16_624_000 picoseconds. + Weight::from_parts(16_323_086, 6263) + // Standard Error: 1 + .saturating_add(Weight::from_parts(397, 0).saturating_mul(c.into())) + .saturating_add(T::DbWeight::get().reads(4_u64)) .saturating_add(T::DbWeight::get().writes(2_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(c.into())) } @@ -223,8 +221,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `440` // Estimated: `6380` - // Minimum execution time: 13_070_000 picoseconds. - Weight::from_parts(13_535_000, 6380) + // Minimum execution time: 12_748_000 picoseconds. + Weight::from_parts(13_278_000, 6380) .saturating_add(T::DbWeight::get().reads(2_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -238,8 +236,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `352` // Estimated: `6292` - // Minimum execution time: 47_012_000 picoseconds. - Weight::from_parts(48_423_000, 6292) + // Minimum execution time: 46_790_000 picoseconds. + Weight::from_parts(48_318_000, 6292) .saturating_add(T::DbWeight::get().reads(4_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -251,8 +249,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `594` // Estimated: `6534` - // Minimum execution time: 56_207_000 picoseconds. - Weight::from_parts(57_924_000, 6534) + // Minimum execution time: 55_028_000 picoseconds. + Weight::from_parts(57_473_000, 6534) .saturating_add(T::DbWeight::get().reads(4_u64)) .saturating_add(T::DbWeight::get().writes(2_u64)) } @@ -262,8 +260,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `409` // Estimated: `6349` - // Minimum execution time: 12_075_000 picoseconds. - Weight::from_parts(12_708_000, 6349) + // Minimum execution time: 12_073_000 picoseconds. + Weight::from_parts(12_598_000, 6349) .saturating_add(T::DbWeight::get().reads(2_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -274,7 +272,7 @@ impl WeightInfo for SubstrateWeight { // Measured: `142` // Estimated: `1627` // Minimum execution time: 2_470_000 picoseconds. - Weight::from_parts(2_653_000, 1627) + Weight::from_parts(2_587_000, 1627) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -286,8 +284,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `166` // Estimated: `3631` - // Minimum execution time: 11_935_000 picoseconds. - Weight::from_parts(12_443_000, 3631) + // Minimum execution time: 11_986_000 picoseconds. + Weight::from_parts(12_434_000, 3631) .saturating_add(T::DbWeight::get().reads(2_u64)) .saturating_add(T::DbWeight::get().writes(2_u64)) } @@ -297,8 +295,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `142` // Estimated: `3607` - // Minimum execution time: 4_706_000 picoseconds. - Weight::from_parts(4_937_000, 3607) + // Minimum execution time: 4_697_000 picoseconds. + Weight::from_parts(5_026_000, 3607) .saturating_add(T::DbWeight::get().reads(1_u64)) } /// Storage: UNKNOWN KEY `0x4342193e496fab7ec59d615ed0dc55304e7b9012096b41c4eb3aaf947f6ea429` (r:1 w:0) @@ -309,8 +307,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `167` // Estimated: `3632` - // Minimum execution time: 5_942_000 picoseconds. - Weight::from_parts(6_224_000, 3632) + // Minimum execution time: 5_963_000 picoseconds. + Weight::from_parts(6_245_000, 3632) .saturating_add(T::DbWeight::get().reads(2_u64)) } /// Storage: UNKNOWN KEY `0x4342193e496fab7ec59d615ed0dc55304e7b9012096b41c4eb3aaf947f6ea429` (r:1 w:0) @@ -321,15 +319,13 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `142` // Estimated: `3607` - // Minimum execution time: 6_161_000 picoseconds. - Weight::from_parts(6_476_000, 3607) + // Minimum execution time: 6_235_000 picoseconds. + Weight::from_parts(6_555_000, 3607) .saturating_add(T::DbWeight::get().reads(2_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } /// Storage: `Contracts::MigrationInProgress` (r:1 w:0) /// Proof: `Contracts::MigrationInProgress` (`max_values`: Some(1), `max_size`: Some(1026), added: 1521, mode: `Measured`) - /// Storage: `Parameters::Parameters` (r:3 w:0) - /// Proof: `Parameters::Parameters` (`max_values`: None, `max_size`: Some(36), added: 2511, mode: `Measured`) /// Storage: `Contracts::ContractInfoOf` (r:1 w:1) /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) @@ -345,20 +341,18 @@ 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: `804 + c * (1 ±0)` - // Estimated: `9217 + c * (1 ±0)` - // Minimum execution time: 367_780_000 picoseconds. - Weight::from_parts(340_082_130, 9217) - // Standard Error: 86 - .saturating_add(Weight::from_parts(34_319, 0).saturating_mul(c.into())) - .saturating_add(T::DbWeight::get().reads(11_u64)) + // Measured: `801 + c * (1 ±0)` + // Estimated: `6739 + c * (1 ±0)` + // Minimum execution time: 299_356_000 picoseconds. + Weight::from_parts(276_901_396, 6739) + // Standard Error: 78 + .saturating_add(Weight::from_parts(33_208, 0).saturating_mul(c.into())) + .saturating_add(T::DbWeight::get().reads(8_u64)) .saturating_add(T::DbWeight::get().writes(4_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(c.into())) } /// Storage: `Contracts::MigrationInProgress` (r:1 w:0) /// Proof: `Contracts::MigrationInProgress` (`max_values`: Some(1), `max_size`: Some(1026), added: 1521, mode: `Measured`) - /// Storage: `Parameters::Parameters` (r:3 w:0) - /// Proof: `Parameters::Parameters` (`max_values`: None, `max_size`: Some(36), added: 2511, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:1) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Balances::Holds` (r:2 w:2) @@ -380,17 +374,17 @@ 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: `326` - // Estimated: `8740` - // Minimum execution time: 4_288_324_000 picoseconds. - Weight::from_parts(851_698_267, 8740) - // Standard Error: 115 - .saturating_add(Weight::from_parts(68_501, 0).saturating_mul(c.into())) - // Standard Error: 13 - .saturating_add(Weight::from_parts(1_658, 0).saturating_mul(i.into())) - // Standard Error: 13 - .saturating_add(Weight::from_parts(1_666, 0).saturating_mul(s.into())) - .saturating_add(T::DbWeight::get().reads(14_u64)) + // Measured: `323` + // Estimated: `8737` + // Minimum execution time: 3_772_084_000 picoseconds. + Weight::from_parts(753_868_107, 8737) + // Standard Error: 130 + .saturating_add(Weight::from_parts(66_251, 0).saturating_mul(c.into())) + // Standard Error: 15 + .saturating_add(Weight::from_parts(1_437, 0).saturating_mul(i.into())) + // Standard Error: 15 + .saturating_add(Weight::from_parts(1_542, 0).saturating_mul(s.into())) + .saturating_add(T::DbWeight::get().reads(11_u64)) .saturating_add(T::DbWeight::get().writes(10_u64)) } /// Storage: `Contracts::MigrationInProgress` (r:1 w:0) @@ -399,8 +393,6 @@ impl WeightInfo for SubstrateWeight { /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1 w:0) /// Proof: `Contracts::PristineCode` (`max_values`: None, `max_size`: Some(125988), added: 128463, mode: `Measured`) - /// Storage: `Parameters::Parameters` (r:3 w:0) - /// Proof: `Parameters::Parameters` (`max_values`: None, `max_size`: Some(36), added: 2511, 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) @@ -417,21 +409,19 @@ 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: `563` - // Estimated: `8982` - // Minimum execution time: 2_133_178_000 picoseconds. - Weight::from_parts(2_142_604_000, 8982) + // Measured: `560` + // Estimated: `6504` + // Minimum execution time: 1_956_848_000 picoseconds. + Weight::from_parts(1_983_893_000, 6504) // Standard Error: 26 - .saturating_add(Weight::from_parts(887, 0).saturating_mul(i.into())) + .saturating_add(Weight::from_parts(813, 0).saturating_mul(i.into())) // Standard Error: 26 - .saturating_add(Weight::from_parts(790, 0).saturating_mul(s.into())) - .saturating_add(T::DbWeight::get().reads(13_u64)) + .saturating_add(Weight::from_parts(787, 0).saturating_mul(s.into())) + .saturating_add(T::DbWeight::get().reads(10_u64)) .saturating_add(T::DbWeight::get().writes(7_u64)) } /// Storage: `Contracts::MigrationInProgress` (r:1 w:0) /// Proof: `Contracts::MigrationInProgress` (`max_values`: Some(1), `max_size`: Some(1026), added: 1521, mode: `Measured`) - /// Storage: `Parameters::Parameters` (r:3 w:0) - /// Proof: `Parameters::Parameters` (`max_values`: None, `max_size`: Some(36), added: 2511, mode: `Measured`) /// Storage: `Contracts::ContractInfoOf` (r:1 w:1) /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) @@ -446,17 +436,15 @@ impl WeightInfo for SubstrateWeight { /// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`) fn call() -> Weight { // Proof Size summary in bytes: - // Measured: `829` - // Estimated: `9244` - // Minimum execution time: 211_959_000 picoseconds. - Weight::from_parts(222_187_000, 9244) - .saturating_add(T::DbWeight::get().reads(11_u64)) + // Measured: `826` + // Estimated: `6766` + // Minimum execution time: 199_924_000 picoseconds. + Weight::from_parts(209_592_000, 6766) + .saturating_add(T::DbWeight::get().reads(8_u64)) .saturating_add(T::DbWeight::get().writes(4_u64)) } /// Storage: `Contracts::MigrationInProgress` (r:1 w:0) /// Proof: `Contracts::MigrationInProgress` (`max_values`: Some(1), `max_size`: Some(1026), added: 1521, mode: `Measured`) - /// Storage: `Parameters::Parameters` (r:2 w:0) - /// Proof: `Parameters::Parameters` (`max_values`: None, `max_size`: Some(36), added: 2511, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:1) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Balances::Holds` (r:1 w:1) @@ -468,19 +456,17 @@ impl WeightInfo for SubstrateWeight { /// The range of component `c` is `[0, 125952]`. fn upload_code_determinism_enforced(c: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `145` - // Estimated: `6085` - // Minimum execution time: 339_757_000 picoseconds. - Weight::from_parts(351_268_427, 6085) - // Standard Error: 54 - .saturating_add(Weight::from_parts(33_161, 0).saturating_mul(c.into())) - .saturating_add(T::DbWeight::get().reads(6_u64)) + // Measured: `142` + // Estimated: `3607` + // Minimum execution time: 257_465_000 picoseconds. + Weight::from_parts(288_412_411, 3607) + // Standard Error: 44 + .saturating_add(Weight::from_parts(32_279, 0).saturating_mul(c.into())) + .saturating_add(T::DbWeight::get().reads(4_u64)) .saturating_add(T::DbWeight::get().writes(4_u64)) } /// Storage: `Contracts::MigrationInProgress` (r:1 w:0) /// Proof: `Contracts::MigrationInProgress` (`max_values`: Some(1), `max_size`: Some(1026), added: 1521, mode: `Measured`) - /// Storage: `Parameters::Parameters` (r:2 w:0) - /// Proof: `Parameters::Parameters` (`max_values`: None, `max_size`: Some(36), added: 2511, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:1) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Balances::Holds` (r:1 w:1) @@ -492,13 +478,13 @@ impl WeightInfo for SubstrateWeight { /// The range of component `c` is `[0, 125952]`. fn upload_code_determinism_relaxed(c: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `145` - // Estimated: `6085` - // Minimum execution time: 351_862_000 picoseconds. - Weight::from_parts(368_816_737, 6085) + // Measured: `142` + // Estimated: `3607` + // Minimum execution time: 281_502_000 picoseconds. + Weight::from_parts(296_208_635, 3607) // Standard Error: 49 - .saturating_add(Weight::from_parts(33_163, 0).saturating_mul(c.into())) - .saturating_add(T::DbWeight::get().reads(6_u64)) + .saturating_add(Weight::from_parts(32_646, 0).saturating_mul(c.into())) + .saturating_add(T::DbWeight::get().reads(4_u64)) .saturating_add(T::DbWeight::get().writes(4_u64)) } /// Storage: `Contracts::MigrationInProgress` (r:1 w:0) @@ -515,8 +501,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `315` // Estimated: `3780` - // Minimum execution time: 45_679_000 picoseconds. - Weight::from_parts(46_940_000, 3780) + // Minimum execution time: 45_012_000 picoseconds. + Weight::from_parts(46_216_000, 3780) .saturating_add(T::DbWeight::get().reads(4_u64)) .saturating_add(T::DbWeight::get().writes(4_u64)) } @@ -532,8 +518,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `552` // Estimated: `8967` - // Minimum execution time: 34_955_000 picoseconds. - Weight::from_parts(36_174_000, 8967) + // Minimum execution time: 34_828_000 picoseconds. + Weight::from_parts(35_904_000, 8967) .saturating_add(T::DbWeight::get().reads(7_u64)) .saturating_add(T::DbWeight::get().writes(6_u64)) } @@ -542,10 +528,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 9_394_000 picoseconds. - Weight::from_parts(10_159_990, 0) - // Standard Error: 56 - .saturating_add(Weight::from_parts(71_497, 0).saturating_mul(r.into())) + // Minimum execution time: 9_265_000 picoseconds. + Weight::from_parts(10_458_655, 0) + // Standard Error: 81 + .saturating_add(Weight::from_parts(70_250, 0).saturating_mul(r.into())) } fn seal_caller() -> Weight { // Proof Size summary in bytes: @@ -560,8 +546,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `354` // Estimated: `3819` - // Minimum execution time: 6_925_000 picoseconds. - Weight::from_parts(7_060_000, 3819) + // Minimum execution time: 6_782_000 picoseconds. + Weight::from_parts(7_244_000, 3819) .saturating_add(T::DbWeight::get().reads(1_u64)) } /// Storage: `Contracts::ContractInfoOf` (r:1 w:0) @@ -570,82 +556,79 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `447` // Estimated: `3912` - // Minimum execution time: 7_928_000 picoseconds. - Weight::from_parts(8_230_000, 3912) + // Minimum execution time: 8_038_000 picoseconds. + Weight::from_parts(8_201_000, 3912) .saturating_add(T::DbWeight::get().reads(1_u64)) } fn seal_own_code_hash() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 818_000 picoseconds. - Weight::from_parts(864_000, 0) + // Minimum execution time: 783_000 picoseconds. + Weight::from_parts(817_000, 0) } fn seal_caller_is_origin() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 382_000 picoseconds. - Weight::from_parts(411_000, 0) + // Minimum execution time: 413_000 picoseconds. + Weight::from_parts(430_000, 0) } fn seal_caller_is_root() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 350_000 picoseconds. - Weight::from_parts(386_000, 0) + // Minimum execution time: 351_000 picoseconds. + Weight::from_parts(366_000, 0) } fn seal_address() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 613_000 picoseconds. - Weight::from_parts(654_000, 0) + // Minimum execution time: 634_000 picoseconds. + Weight::from_parts(664_000, 0) } fn seal_gas_left() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 619_000 picoseconds. - Weight::from_parts(680_000, 0) + // Minimum execution time: 673_000 picoseconds. + Weight::from_parts(713_000, 0) } - /// Storage: `System::Account` (r:1 w:0) - /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`) fn seal_balance() -> Weight { // Proof Size summary in bytes: // Measured: `140` - // Estimated: `3605` - // Minimum execution time: 4_800_000 picoseconds. - Weight::from_parts(4_992_000, 3605) - .saturating_add(T::DbWeight::get().reads(1_u64)) + // Estimated: `0` + // Minimum execution time: 4_847_000 picoseconds. + Weight::from_parts(5_057_000, 0) } fn seal_value_transferred() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 545_000 picoseconds. - Weight::from_parts(596_000, 0) + // Minimum execution time: 601_000 picoseconds. + Weight::from_parts(649_000, 0) } fn seal_minimum_balance() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 571_000 picoseconds. - Weight::from_parts(620_000, 0) + // Minimum execution time: 567_000 picoseconds. + Weight::from_parts(611_000, 0) } fn seal_block_number() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 540_000 picoseconds. - Weight::from_parts(612_000, 0) + // Minimum execution time: 573_000 picoseconds. + Weight::from_parts(602_000, 0) } fn seal_now() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 588_000 picoseconds. - Weight::from_parts(638_000, 0) + // Minimum execution time: 567_000 picoseconds. + Weight::from_parts(618_000, 0) } /// Storage: `TransactionPayment::NextFeeMultiplier` (r:1 w:0) /// Proof: `TransactionPayment::NextFeeMultiplier` (`max_values`: Some(1), `max_size`: Some(16), added: 511, mode: `Measured`) @@ -653,8 +636,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `67` // Estimated: `1552` - // Minimum execution time: 4_415_000 picoseconds. - Weight::from_parts(4_703_000, 1552) + // Minimum execution time: 4_490_000 picoseconds. + Weight::from_parts(4_765_000, 1552) .saturating_add(T::DbWeight::get().reads(1_u64)) } /// The range of component `n` is `[0, 1048572]`. @@ -662,20 +645,20 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 484_000 picoseconds. - Weight::from_parts(508_000, 0) + // Minimum execution time: 483_000 picoseconds. + Weight::from_parts(498_000, 0) // Standard Error: 3 - .saturating_add(Weight::from_parts(303, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(292, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 1048572]`. fn seal_return(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 390_000 picoseconds. - Weight::from_parts(421_000, 0) + // Minimum execution time: 371_000 picoseconds. + Weight::from_parts(392_000, 0) // Standard Error: 9 - .saturating_add(Weight::from_parts(479, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(400, 0).saturating_mul(n.into())) } /// Storage: `Contracts::DeletionQueueCounter` (r:1 w:1) /// Proof: `Contracts::DeletionQueueCounter` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`) @@ -683,18 +666,16 @@ impl WeightInfo for SubstrateWeight { /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `System::EventTopics` (r:2 w:2) /// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`) - /// Storage: `Contracts::ContractInfoOf` (r:0 w:1) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::DeletionQueue` (r:0 w:1) /// Proof: `Contracts::DeletionQueue` (`max_values`: None, `max_size`: Some(142), added: 2617, mode: `Measured`) fn seal_terminate() -> Weight { // Proof Size summary in bytes: // Measured: `2821` // Estimated: `85486` - // Minimum execution time: 134_681_000 picoseconds. - Weight::from_parts(136_452_000, 85486) + // Minimum execution time: 136_837_000 picoseconds. + Weight::from_parts(139_490_000, 85486) .saturating_add(T::DbWeight::get().reads(36_u64)) - .saturating_add(T::DbWeight::get().writes(38_u64)) + .saturating_add(T::DbWeight::get().writes(37_u64)) } /// Storage: `RandomnessCollectiveFlip::RandomMaterial` (r:1 w:0) /// Proof: `RandomnessCollectiveFlip::RandomMaterial` (`max_values`: Some(1), `max_size`: Some(2594), added: 3089, mode: `Measured`) @@ -702,8 +683,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `76` // Estimated: `1561` - // Minimum execution time: 3_664_000 picoseconds. - Weight::from_parts(3_887_000, 1561) + // Minimum execution time: 3_738_000 picoseconds. + Weight::from_parts(3_910_000, 1561) .saturating_add(T::DbWeight::get().reads(1_u64)) } /// Storage: `System::EventTopics` (r:4 w:4) @@ -714,11 +695,11 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `990 + t * (2475 ±0)` - // Minimum execution time: 4_150_000 picoseconds. - Weight::from_parts(4_478_017, 990) - // Standard Error: 6_791 - .saturating_add(Weight::from_parts(2_359_039, 0).saturating_mul(t.into())) - // Standard Error: 1 + // Minimum execution time: 4_066_000 picoseconds. + Weight::from_parts(4_465_496, 990) + // Standard Error: 7_195 + .saturating_add(Weight::from_parts(2_349_432, 0).saturating_mul(t.into())) + // Standard Error: 2 .saturating_add(Weight::from_parts(19, 0).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(t.into()))) .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(t.into()))) @@ -729,24 +710,28 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 400_000 picoseconds. - Weight::from_parts(424_000, 0) + // Minimum execution time: 457_000 picoseconds. + Weight::from_parts(483_000, 0) // Standard Error: 10 - .saturating_add(Weight::from_parts(1_271, 0).saturating_mul(i.into())) + .saturating_add(Weight::from_parts(1_202, 0).saturating_mul(i.into())) } /// Storage: `Skipped::Metadata` (r:0 w:0) /// Proof: `Skipped::Metadata` (`max_values`: None, `max_size`: None, mode: `Measured`) /// The range of component `n` is `[0, 16384]`. - fn seal_set_storage(n: u32, _o: u32) -> Weight { + /// The range of component `o` is `[0, 16384]`. + fn seal_set_storage(n: u32, o: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `245` - // Estimated: `245` - // Minimum execution time: 8_012_000 picoseconds. - Weight::from_parts(8_699_107, 245) + // Measured: `250 + o * (1 ±0)` + // Estimated: `249 + o * (1 ±0)` + // Minimum execution time: 9_784_000 picoseconds. + Weight::from_parts(9_860_281, 249) // Standard Error: 1 - .saturating_add(Weight::from_parts(351, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(242, 0).saturating_mul(n.into())) + // Standard Error: 1 + .saturating_add(Weight::from_parts(62, 0).saturating_mul(o.into())) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) + .saturating_add(Weight::from_parts(0, 1).saturating_mul(o.into())) } /// Storage: `Skipped::Metadata` (r:0 w:0) /// Proof: `Skipped::Metadata` (`max_values`: None, `max_size`: None, mode: `Measured`) @@ -755,10 +740,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `248 + n * (1 ±0)` // Estimated: `248 + n * (1 ±0)` - // Minimum execution time: 7_984_000 picoseconds. - Weight::from_parts(9_206_228, 248) + // Minimum execution time: 7_785_000 picoseconds. + Weight::from_parts(9_260_270, 248) // Standard Error: 2 - .saturating_add(Weight::from_parts(77, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(83, 0).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) @@ -770,10 +755,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `248 + n * (1 ±0)` // Estimated: `248 + n * (1 ±0)` - // Minimum execution time: 7_083_000 picoseconds. - Weight::from_parts(8_815_611, 248) - // Standard Error: 2 - .saturating_add(Weight::from_parts(708, 0).saturating_mul(n.into())) + // Minimum execution time: 7_004_000 picoseconds. + Weight::from_parts(8_830_936, 248) + // Standard Error: 3 + .saturating_add(Weight::from_parts(614, 0).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) } @@ -784,10 +769,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `248 + n * (1 ±0)` // Estimated: `248 + n * (1 ±0)` - // Minimum execution time: 6_708_000 picoseconds. - Weight::from_parts(8_031_454, 248) + // Minimum execution time: 6_766_000 picoseconds. + Weight::from_parts(7_955_845, 248) // Standard Error: 2 - .saturating_add(Weight::from_parts(78, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(86, 0).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) } @@ -798,34 +783,29 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `248 + n * (1 ±0)` // Estimated: `248 + n * (1 ±0)` - // Minimum execution time: 8_273_000 picoseconds. - Weight::from_parts(9_872_829, 248) + // Minimum execution time: 8_425_000 picoseconds. + Weight::from_parts(10_053_859, 248) // Standard Error: 3 - .saturating_add(Weight::from_parts(712, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(605, 0).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) } - /// Storage: `System::Account` (r:1 w:0) - /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`) fn seal_transfer() -> Weight { // Proof Size summary in bytes: // Measured: `140` - // Estimated: `3605` - // Minimum execution time: 9_220_000 picoseconds. - Weight::from_parts(9_590_000, 3605) - .saturating_add(T::DbWeight::get().reads(1_u64)) + // Estimated: `0` + // Minimum execution time: 9_089_000 picoseconds. + Weight::from_parts(9_472_000, 0) } - /// Storage: `Contracts::ContractInfoOf` (r:1 w:2) + /// Storage: `Contracts::ContractInfoOf` (r:1 w:1) /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1 w:0) /// Proof: `Contracts::PristineCode` (`max_values`: None, `max_size`: Some(125988), added: 128463, mode: `Measured`) - /// Storage: `System::Account` (r:2 w:2) + /// Storage: `System::Account` (r:1 w:1) /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`) - /// Storage: `Parameters::Parameters` (r:2 w:0) - /// Proof: `Parameters::Parameters` (`max_values`: None, `max_size`: Some(36), added: 2511, mode: `Measured`) /// Storage: `System::EventTopics` (r:2 w:2) /// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`) /// The range of component `t` is `[0, 1]`. @@ -833,21 +813,21 @@ impl WeightInfo for SubstrateWeight { /// The range of component `i` is `[0, 1048576]`. fn seal_call(t: u32, c: u32, i: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `623 + t * (280 ±0)` - // Estimated: `6563 + t * (3422 ±0)` - // Minimum execution time: 171_273_000 picoseconds. - Weight::from_parts(172_294_959, 6563) - // Standard Error: 309_680 - .saturating_add(Weight::from_parts(41_035_739, 0).saturating_mul(t.into())) - // Standard Error: 309_680 - .saturating_add(Weight::from_parts(168_535, 0).saturating_mul(c.into())) + // Measured: `620 + t * (280 ±0)` + // Estimated: `6560 + t * (2182 ±0)` + // Minimum execution time: 158_642_000 picoseconds. + Weight::from_parts(159_204_537, 6560) + // Standard Error: 312_560 + .saturating_add(Weight::from_parts(43_721_097, 0).saturating_mul(t.into())) + // Standard Error: 312_560 + .saturating_add(Weight::from_parts(1_118_806, 0).saturating_mul(c.into())) // Standard Error: 0 - .saturating_add(Weight::from_parts(9, 0).saturating_mul(i.into())) - .saturating_add(T::DbWeight::get().reads(7_u64)) - .saturating_add(T::DbWeight::get().reads((2_u64).saturating_mul(t.into()))) - .saturating_add(T::DbWeight::get().writes(4_u64)) - .saturating_add(T::DbWeight::get().writes((2_u64).saturating_mul(t.into()))) - .saturating_add(Weight::from_parts(0, 3422).saturating_mul(t.into())) + .saturating_add(Weight::from_parts(8, 0).saturating_mul(i.into())) + .saturating_add(T::DbWeight::get().reads(5_u64)) + .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(t.into()))) + .saturating_add(T::DbWeight::get().writes(3_u64)) + .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(t.into()))) + .saturating_add(Weight::from_parts(0, 2182).saturating_mul(t.into())) } /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) @@ -855,18 +835,14 @@ impl WeightInfo for SubstrateWeight { /// Proof: `Contracts::PristineCode` (`max_values`: None, `max_size`: Some(125988), added: 128463, mode: `Measured`) /// Storage: `System::EventTopics` (r:2 w:2) /// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`) - /// Storage: `Parameters::Parameters` (r:2 w:0) - /// Proof: `Parameters::Parameters` (`max_values`: None, `max_size`: Some(36), added: 2511, mode: `Measured`) - /// Storage: `Contracts::ContractInfoOf` (r:0 w:1) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) fn seal_delegate_call() -> Weight { // Proof Size summary in bytes: - // Measured: `433` - // Estimated: `6373` - // Minimum execution time: 155_964_000 picoseconds. - Weight::from_parts(160_485_000, 6373) - .saturating_add(T::DbWeight::get().reads(6_u64)) - .saturating_add(T::DbWeight::get().writes(3_u64)) + // Measured: `430` + // Estimated: `6370` + // Minimum execution time: 145_817_000 picoseconds. + Weight::from_parts(152_499_000, 6370) + .saturating_add(T::DbWeight::get().reads(4_u64)) + .saturating_add(T::DbWeight::get().writes(2_u64)) } /// Storage: `Contracts::CodeInfoOf` (r:1 w:1) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) @@ -874,12 +850,10 @@ impl WeightInfo for SubstrateWeight { /// Proof: `Contracts::PristineCode` (`max_values`: None, `max_size`: Some(125988), added: 128463, mode: `Measured`) /// Storage: `Contracts::Nonce` (r:1 w:0) /// Proof: `Contracts::Nonce` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`) - /// Storage: `Contracts::ContractInfoOf` (r:1 w:2) + /// Storage: `Contracts::ContractInfoOf` (r:1 w:1) /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) - /// Storage: `System::Account` (r:3 w:3) + /// Storage: `System::Account` (r:2 w:2) /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`) - /// Storage: `Parameters::Parameters` (r:2 w:0) - /// Proof: `Parameters::Parameters` (`max_values`: None, `max_size`: Some(36), added: 2511, mode: `Measured`) /// Storage: `System::EventTopics` (r:2 w:2) /// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`) /// The range of component `t` is `[0, 1]`. @@ -887,101 +861,97 @@ impl WeightInfo for SubstrateWeight { /// The range of component `s` is `[0, 983040]`. fn seal_instantiate(t: u32, i: u32, s: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `679 + t * (102 ±0)` - // Estimated: `6616 + t * (2565 ±1)` - // Minimum execution time: 1_821_557_000 picoseconds. - Weight::from_parts(85_126_984, 6616) - // Standard Error: 6_661_370 - .saturating_add(Weight::from_parts(175_191_430, 0).saturating_mul(t.into())) - // Standard Error: 10 - .saturating_add(Weight::from_parts(1_539, 0).saturating_mul(i.into())) - // Standard Error: 10 - .saturating_add(Weight::from_parts(1_811, 0).saturating_mul(s.into())) - .saturating_add(T::DbWeight::get().reads(10_u64)) - .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(t.into()))) - .saturating_add(T::DbWeight::get().writes(7_u64)) - .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(t.into()))) - .saturating_add(Weight::from_parts(0, 2565).saturating_mul(t.into())) + // Measured: `676 + t * (102 ±0)` + // Estimated: `6613 + t * (90 ±1)` + // Minimum execution time: 1_654_022_000 picoseconds. + Weight::from_parts(34_582_395, 6613) + // Standard Error: 8_789_446 + .saturating_add(Weight::from_parts(213_375_982, 0).saturating_mul(t.into())) + // Standard Error: 14 + .saturating_add(Weight::from_parts(1_362, 0).saturating_mul(i.into())) + // Standard Error: 14 + .saturating_add(Weight::from_parts(1_703, 0).saturating_mul(s.into())) + .saturating_add(T::DbWeight::get().reads(8_u64)) + .saturating_add(T::DbWeight::get().writes(6_u64)) + .saturating_add(Weight::from_parts(0, 90).saturating_mul(t.into())) } /// The range of component `n` is `[0, 1048576]`. fn seal_hash_sha2_256(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 834_000 picoseconds. - Weight::from_parts(891_000, 0) + // Minimum execution time: 861_000 picoseconds. + Weight::from_parts(909_000, 0) // Standard Error: 0 - .saturating_add(Weight::from_parts(1_152, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(1_050, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 1048576]`. fn seal_hash_keccak_256(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_428_000 picoseconds. - Weight::from_parts(1_493_000, 0) + // Minimum execution time: 1_344_000 picoseconds. + Weight::from_parts(1_378_000, 0) // Standard Error: 0 - .saturating_add(Weight::from_parts(3_414, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(3_314, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 1048576]`. fn seal_hash_blake2_256(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 707_000 picoseconds. - Weight::from_parts(774_000, 0) + // Minimum execution time: 764_000 picoseconds. + Weight::from_parts(777_000, 0) // Standard Error: 0 - .saturating_add(Weight::from_parts(1_280, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(1_185, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 1048576]`. fn seal_hash_blake2_128(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 763_000 picoseconds. - Weight::from_parts(822_000, 0) + // Minimum execution time: 753_000 picoseconds. + Weight::from_parts(767_000, 0) // Standard Error: 0 - .saturating_add(Weight::from_parts(1_279, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(1_190, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 125697]`. fn seal_sr25519_verify(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 45_176_000 picoseconds. - Weight::from_parts(46_961_397, 0) - // Standard Error: 7 - .saturating_add(Weight::from_parts(4_692, 0).saturating_mul(n.into())) + // Minimum execution time: 43_241_000 picoseconds. + Weight::from_parts(48_851_058, 0) + // Standard Error: 12 + .saturating_add(Weight::from_parts(4_453, 0).saturating_mul(n.into())) } fn seal_ecdsa_recover() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 47_301_000 picoseconds. - Weight::from_parts(48_454_000, 0) + // Minimum execution time: 47_013_000 picoseconds. + Weight::from_parts(49_080_000, 0) } fn seal_ecdsa_to_eth_address() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 13_031_000 picoseconds. - Weight::from_parts(13_300_000, 0) + // Minimum execution time: 12_861_000 picoseconds. + Weight::from_parts(13_006_000, 0) } /// Storage: `Contracts::CodeInfoOf` (r:1 w:1) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1 w:0) /// Proof: `Contracts::PristineCode` (`max_values`: None, `max_size`: Some(125988), added: 128463, mode: `Measured`) - /// Storage: `Parameters::Parameters` (r:2 w:0) - /// Proof: `Parameters::Parameters` (`max_values`: None, `max_size`: Some(36), added: 2511, mode: `Measured`) /// Storage: `System::EventTopics` (r:2 w:2) /// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`) fn seal_set_code_hash() -> Weight { // Proof Size summary in bytes: - // Measured: `433` - // Estimated: `6373` - // Minimum execution time: 31_664_000 picoseconds. - Weight::from_parts(32_906_000, 6373) - .saturating_add(T::DbWeight::get().reads(6_u64)) + // Measured: `430` + // Estimated: `6370` + // Minimum execution time: 27_062_000 picoseconds. + Weight::from_parts(27_950_000, 6370) + .saturating_add(T::DbWeight::get().reads(4_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) } /// Storage: `Contracts::CodeInfoOf` (r:1 w:1) @@ -990,8 +960,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `355` // Estimated: `3820` - // Minimum execution time: 9_364_000 picoseconds. - Weight::from_parts(9_551_000, 3820) + // Minimum execution time: 9_225_000 picoseconds. + Weight::from_parts(9_644_000, 3820) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -1001,8 +971,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `355` // Estimated: `3558` - // Minimum execution time: 8_210_000 picoseconds. - Weight::from_parts(8_551_000, 3558) + // Minimum execution time: 8_209_000 picoseconds. + Weight::from_parts(8_639_000, 3558) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -1010,15 +980,15 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 355_000 picoseconds. - Weight::from_parts(401_000, 0) + // Minimum execution time: 353_000 picoseconds. + Weight::from_parts(373_000, 0) } fn seal_account_reentrance_count() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 383_000 picoseconds. - Weight::from_parts(406_000, 0) + // Minimum execution time: 369_000 picoseconds. + Weight::from_parts(395_000, 0) } /// Storage: `Contracts::Nonce` (r:1 w:0) /// Proof: `Contracts::Nonce` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`) @@ -1026,8 +996,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `219` // Estimated: `1704` - // Minimum execution time: 3_011_000 picoseconds. - Weight::from_parts(3_197_000, 1704) + // Minimum execution time: 2_985_000 picoseconds. + Weight::from_parts(3_126_000, 1704) .saturating_add(T::DbWeight::get().reads(1_u64)) } /// The range of component `r` is `[0, 5000]`. @@ -1035,10 +1005,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 945_000 picoseconds. - Weight::from_parts(916_399, 0) - // Standard Error: 14 - .saturating_add(Weight::from_parts(14_957, 0).saturating_mul(r.into())) + // Minimum execution time: 1_032_000 picoseconds. + Weight::from_parts(762_731, 0) + // Standard Error: 27 + .saturating_add(Weight::from_parts(15_049, 0).saturating_mul(r.into())) } } @@ -1050,8 +1020,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `142` // Estimated: `1627` - // Minimum execution time: 2_077_000 picoseconds. - Weight::from_parts(2_153_000, 1627) + // Minimum execution time: 2_110_000 picoseconds. + Weight::from_parts(2_251_000, 1627) .saturating_add(RocksDbWeight::get().reads(1_u64)) } /// Storage: `Skipped::Metadata` (r:0 w:0) @@ -1061,10 +1031,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `452 + k * (69 ±0)` // Estimated: `442 + k * (70 ±0)` - // Minimum execution time: 12_456_000 picoseconds. - Weight::from_parts(12_730_000, 442) - // Standard Error: 1_183 - .saturating_add(Weight::from_parts(1_096_672, 0).saturating_mul(k.into())) + // Minimum execution time: 12_154_000 picoseconds. + Weight::from_parts(12_536_000, 442) + // Standard Error: 907 + .saturating_add(Weight::from_parts(1_102_613, 0).saturating_mul(k.into())) .saturating_add(RocksDbWeight::get().reads(2_u64)) .saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(k.into()))) .saturating_add(RocksDbWeight::get().writes(2_u64)) @@ -1078,10 +1048,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `211 + c * (1 ±0)` // Estimated: `6149 + c * (1 ±0)` - // Minimum execution time: 8_181_000 picoseconds. - Weight::from_parts(9_113_032, 6149) + // Minimum execution time: 8_232_000 picoseconds. + Weight::from_parts(8_895_498, 6149) // Standard Error: 1 - .saturating_add(Weight::from_parts(1_213, 0).saturating_mul(c.into())) + .saturating_add(Weight::from_parts(1_156, 0).saturating_mul(c.into())) .saturating_add(RocksDbWeight::get().reads(2_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(c.into())) @@ -1094,8 +1064,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `510` // Estimated: `6450` - // Minimum execution time: 16_780_000 picoseconds. - Weight::from_parts(17_448_000, 6450) + // Minimum execution time: 16_760_000 picoseconds. + Weight::from_parts(17_693_000, 6450) .saturating_add(RocksDbWeight::get().reads(3_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -1108,10 +1078,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `171 + k * (1 ±0)` // Estimated: `3635 + k * (1 ±0)` - // Minimum execution time: 3_382_000 picoseconds. - Weight::from_parts(1_286_516, 3635) - // Standard Error: 973 - .saturating_add(Weight::from_parts(1_204_983, 0).saturating_mul(k.into())) + // Minimum execution time: 3_535_000 picoseconds. + Weight::from_parts(9_084_983, 3635) + // Standard Error: 1_564 + .saturating_add(Weight::from_parts(1_222_023, 0).saturating_mul(k.into())) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(2_u64)) .saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(k.into()))) @@ -1121,8 +1091,6 @@ impl WeightInfo for () { /// Proof: UNKNOWN KEY `0x4342193e496fab7ec59d615ed0dc553053f13fd319a03c211337c76e0fe776df` (r:2 w:0) /// Storage: UNKNOWN KEY `0x4342193e496fab7ec59d615ed0dc553022fca90611ba8b7942f8bdb3b97f6580` (r:1 w:1) /// Proof: UNKNOWN KEY `0x4342193e496fab7ec59d615ed0dc553022fca90611ba8b7942f8bdb3b97f6580` (r:1 w:1) - /// Storage: `Parameters::Parameters` (r:2 w:0) - /// Proof: `Parameters::Parameters` (`max_values`: None, `max_size`: Some(36), added: 2511, mode: `Measured`) /// Storage: `System::Account` (r:1 w:0) /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:0 w:1) @@ -1130,13 +1098,13 @@ impl WeightInfo for () { /// The range of component `c` is `[0, 125952]`. fn v12_migration_step(c: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `328 + c * (1 ±0)` - // Estimated: `6266 + c * (1 ±0)` - // Minimum execution time: 20_685_000 picoseconds. - Weight::from_parts(21_384_758, 6266) - // Standard Error: 0 - .saturating_add(Weight::from_parts(463, 0).saturating_mul(c.into())) - .saturating_add(RocksDbWeight::get().reads(6_u64)) + // Measured: `325 + c * (1 ±0)` + // Estimated: `6263 + c * (1 ±0)` + // Minimum execution time: 16_624_000 picoseconds. + Weight::from_parts(16_323_086, 6263) + // Standard Error: 1 + .saturating_add(Weight::from_parts(397, 0).saturating_mul(c.into())) + .saturating_add(RocksDbWeight::get().reads(4_u64)) .saturating_add(RocksDbWeight::get().writes(2_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(c.into())) } @@ -1146,8 +1114,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `440` // Estimated: `6380` - // Minimum execution time: 13_070_000 picoseconds. - Weight::from_parts(13_535_000, 6380) + // Minimum execution time: 12_748_000 picoseconds. + Weight::from_parts(13_278_000, 6380) .saturating_add(RocksDbWeight::get().reads(2_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -1161,8 +1129,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `352` // Estimated: `6292` - // Minimum execution time: 47_012_000 picoseconds. - Weight::from_parts(48_423_000, 6292) + // Minimum execution time: 46_790_000 picoseconds. + Weight::from_parts(48_318_000, 6292) .saturating_add(RocksDbWeight::get().reads(4_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -1174,8 +1142,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `594` // Estimated: `6534` - // Minimum execution time: 56_207_000 picoseconds. - Weight::from_parts(57_924_000, 6534) + // Minimum execution time: 55_028_000 picoseconds. + Weight::from_parts(57_473_000, 6534) .saturating_add(RocksDbWeight::get().reads(4_u64)) .saturating_add(RocksDbWeight::get().writes(2_u64)) } @@ -1185,8 +1153,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `409` // Estimated: `6349` - // Minimum execution time: 12_075_000 picoseconds. - Weight::from_parts(12_708_000, 6349) + // Minimum execution time: 12_073_000 picoseconds. + Weight::from_parts(12_598_000, 6349) .saturating_add(RocksDbWeight::get().reads(2_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -1197,7 +1165,7 @@ impl WeightInfo for () { // Measured: `142` // Estimated: `1627` // Minimum execution time: 2_470_000 picoseconds. - Weight::from_parts(2_653_000, 1627) + Weight::from_parts(2_587_000, 1627) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -1209,8 +1177,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `166` // Estimated: `3631` - // Minimum execution time: 11_935_000 picoseconds. - Weight::from_parts(12_443_000, 3631) + // Minimum execution time: 11_986_000 picoseconds. + Weight::from_parts(12_434_000, 3631) .saturating_add(RocksDbWeight::get().reads(2_u64)) .saturating_add(RocksDbWeight::get().writes(2_u64)) } @@ -1220,8 +1188,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `142` // Estimated: `3607` - // Minimum execution time: 4_706_000 picoseconds. - Weight::from_parts(4_937_000, 3607) + // Minimum execution time: 4_697_000 picoseconds. + Weight::from_parts(5_026_000, 3607) .saturating_add(RocksDbWeight::get().reads(1_u64)) } /// Storage: UNKNOWN KEY `0x4342193e496fab7ec59d615ed0dc55304e7b9012096b41c4eb3aaf947f6ea429` (r:1 w:0) @@ -1232,8 +1200,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `167` // Estimated: `3632` - // Minimum execution time: 5_942_000 picoseconds. - Weight::from_parts(6_224_000, 3632) + // Minimum execution time: 5_963_000 picoseconds. + Weight::from_parts(6_245_000, 3632) .saturating_add(RocksDbWeight::get().reads(2_u64)) } /// Storage: UNKNOWN KEY `0x4342193e496fab7ec59d615ed0dc55304e7b9012096b41c4eb3aaf947f6ea429` (r:1 w:0) @@ -1244,15 +1212,13 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `142` // Estimated: `3607` - // Minimum execution time: 6_161_000 picoseconds. - Weight::from_parts(6_476_000, 3607) + // Minimum execution time: 6_235_000 picoseconds. + Weight::from_parts(6_555_000, 3607) .saturating_add(RocksDbWeight::get().reads(2_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } /// Storage: `Contracts::MigrationInProgress` (r:1 w:0) /// Proof: `Contracts::MigrationInProgress` (`max_values`: Some(1), `max_size`: Some(1026), added: 1521, mode: `Measured`) - /// Storage: `Parameters::Parameters` (r:3 w:0) - /// Proof: `Parameters::Parameters` (`max_values`: None, `max_size`: Some(36), added: 2511, mode: `Measured`) /// Storage: `Contracts::ContractInfoOf` (r:1 w:1) /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) @@ -1268,20 +1234,18 @@ 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: `804 + c * (1 ±0)` - // Estimated: `9217 + c * (1 ±0)` - // Minimum execution time: 367_780_000 picoseconds. - Weight::from_parts(340_082_130, 9217) - // Standard Error: 86 - .saturating_add(Weight::from_parts(34_319, 0).saturating_mul(c.into())) - .saturating_add(RocksDbWeight::get().reads(11_u64)) + // Measured: `801 + c * (1 ±0)` + // Estimated: `6739 + c * (1 ±0)` + // Minimum execution time: 299_356_000 picoseconds. + Weight::from_parts(276_901_396, 6739) + // Standard Error: 78 + .saturating_add(Weight::from_parts(33_208, 0).saturating_mul(c.into())) + .saturating_add(RocksDbWeight::get().reads(8_u64)) .saturating_add(RocksDbWeight::get().writes(4_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(c.into())) } /// Storage: `Contracts::MigrationInProgress` (r:1 w:0) /// Proof: `Contracts::MigrationInProgress` (`max_values`: Some(1), `max_size`: Some(1026), added: 1521, mode: `Measured`) - /// Storage: `Parameters::Parameters` (r:3 w:0) - /// Proof: `Parameters::Parameters` (`max_values`: None, `max_size`: Some(36), added: 2511, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:1) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Balances::Holds` (r:2 w:2) @@ -1303,17 +1267,17 @@ 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: `326` - // Estimated: `8740` - // Minimum execution time: 4_288_324_000 picoseconds. - Weight::from_parts(851_698_267, 8740) - // Standard Error: 115 - .saturating_add(Weight::from_parts(68_501, 0).saturating_mul(c.into())) - // Standard Error: 13 - .saturating_add(Weight::from_parts(1_658, 0).saturating_mul(i.into())) - // Standard Error: 13 - .saturating_add(Weight::from_parts(1_666, 0).saturating_mul(s.into())) - .saturating_add(RocksDbWeight::get().reads(14_u64)) + // Measured: `323` + // Estimated: `8737` + // Minimum execution time: 3_772_084_000 picoseconds. + Weight::from_parts(753_868_107, 8737) + // Standard Error: 130 + .saturating_add(Weight::from_parts(66_251, 0).saturating_mul(c.into())) + // Standard Error: 15 + .saturating_add(Weight::from_parts(1_437, 0).saturating_mul(i.into())) + // Standard Error: 15 + .saturating_add(Weight::from_parts(1_542, 0).saturating_mul(s.into())) + .saturating_add(RocksDbWeight::get().reads(11_u64)) .saturating_add(RocksDbWeight::get().writes(10_u64)) } /// Storage: `Contracts::MigrationInProgress` (r:1 w:0) @@ -1322,8 +1286,6 @@ impl WeightInfo for () { /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1 w:0) /// Proof: `Contracts::PristineCode` (`max_values`: None, `max_size`: Some(125988), added: 128463, mode: `Measured`) - /// Storage: `Parameters::Parameters` (r:3 w:0) - /// Proof: `Parameters::Parameters` (`max_values`: None, `max_size`: Some(36), added: 2511, 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) @@ -1340,21 +1302,19 @@ impl WeightInfo for () { /// The range of component `s` is `[0, 1048576]`. fn instantiate(i: u32, s: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `563` - // Estimated: `8982` - // Minimum execution time: 2_133_178_000 picoseconds. - Weight::from_parts(2_142_604_000, 8982) + // Measured: `560` + // Estimated: `6504` + // Minimum execution time: 1_956_848_000 picoseconds. + Weight::from_parts(1_983_893_000, 6504) // Standard Error: 26 - .saturating_add(Weight::from_parts(887, 0).saturating_mul(i.into())) + .saturating_add(Weight::from_parts(813, 0).saturating_mul(i.into())) // Standard Error: 26 - .saturating_add(Weight::from_parts(790, 0).saturating_mul(s.into())) - .saturating_add(RocksDbWeight::get().reads(13_u64)) + .saturating_add(Weight::from_parts(787, 0).saturating_mul(s.into())) + .saturating_add(RocksDbWeight::get().reads(10_u64)) .saturating_add(RocksDbWeight::get().writes(7_u64)) } /// Storage: `Contracts::MigrationInProgress` (r:1 w:0) /// Proof: `Contracts::MigrationInProgress` (`max_values`: Some(1), `max_size`: Some(1026), added: 1521, mode: `Measured`) - /// Storage: `Parameters::Parameters` (r:3 w:0) - /// Proof: `Parameters::Parameters` (`max_values`: None, `max_size`: Some(36), added: 2511, mode: `Measured`) /// Storage: `Contracts::ContractInfoOf` (r:1 w:1) /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) @@ -1369,17 +1329,15 @@ impl WeightInfo for () { /// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`) fn call() -> Weight { // Proof Size summary in bytes: - // Measured: `829` - // Estimated: `9244` - // Minimum execution time: 211_959_000 picoseconds. - Weight::from_parts(222_187_000, 9244) - .saturating_add(RocksDbWeight::get().reads(11_u64)) + // Measured: `826` + // Estimated: `6766` + // Minimum execution time: 199_924_000 picoseconds. + Weight::from_parts(209_592_000, 6766) + .saturating_add(RocksDbWeight::get().reads(8_u64)) .saturating_add(RocksDbWeight::get().writes(4_u64)) } /// Storage: `Contracts::MigrationInProgress` (r:1 w:0) /// Proof: `Contracts::MigrationInProgress` (`max_values`: Some(1), `max_size`: Some(1026), added: 1521, mode: `Measured`) - /// Storage: `Parameters::Parameters` (r:2 w:0) - /// Proof: `Parameters::Parameters` (`max_values`: None, `max_size`: Some(36), added: 2511, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:1) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Balances::Holds` (r:1 w:1) @@ -1391,19 +1349,17 @@ impl WeightInfo for () { /// The range of component `c` is `[0, 125952]`. fn upload_code_determinism_enforced(c: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `145` - // Estimated: `6085` - // Minimum execution time: 339_757_000 picoseconds. - Weight::from_parts(351_268_427, 6085) - // Standard Error: 54 - .saturating_add(Weight::from_parts(33_161, 0).saturating_mul(c.into())) - .saturating_add(RocksDbWeight::get().reads(6_u64)) + // Measured: `142` + // Estimated: `3607` + // Minimum execution time: 257_465_000 picoseconds. + Weight::from_parts(288_412_411, 3607) + // Standard Error: 44 + .saturating_add(Weight::from_parts(32_279, 0).saturating_mul(c.into())) + .saturating_add(RocksDbWeight::get().reads(4_u64)) .saturating_add(RocksDbWeight::get().writes(4_u64)) } /// Storage: `Contracts::MigrationInProgress` (r:1 w:0) /// Proof: `Contracts::MigrationInProgress` (`max_values`: Some(1), `max_size`: Some(1026), added: 1521, mode: `Measured`) - /// Storage: `Parameters::Parameters` (r:2 w:0) - /// Proof: `Parameters::Parameters` (`max_values`: None, `max_size`: Some(36), added: 2511, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:1) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Balances::Holds` (r:1 w:1) @@ -1415,13 +1371,13 @@ impl WeightInfo for () { /// The range of component `c` is `[0, 125952]`. fn upload_code_determinism_relaxed(c: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `145` - // Estimated: `6085` - // Minimum execution time: 351_862_000 picoseconds. - Weight::from_parts(368_816_737, 6085) + // Measured: `142` + // Estimated: `3607` + // Minimum execution time: 281_502_000 picoseconds. + Weight::from_parts(296_208_635, 3607) // Standard Error: 49 - .saturating_add(Weight::from_parts(33_163, 0).saturating_mul(c.into())) - .saturating_add(RocksDbWeight::get().reads(6_u64)) + .saturating_add(Weight::from_parts(32_646, 0).saturating_mul(c.into())) + .saturating_add(RocksDbWeight::get().reads(4_u64)) .saturating_add(RocksDbWeight::get().writes(4_u64)) } /// Storage: `Contracts::MigrationInProgress` (r:1 w:0) @@ -1438,8 +1394,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `315` // Estimated: `3780` - // Minimum execution time: 45_679_000 picoseconds. - Weight::from_parts(46_940_000, 3780) + // Minimum execution time: 45_012_000 picoseconds. + Weight::from_parts(46_216_000, 3780) .saturating_add(RocksDbWeight::get().reads(4_u64)) .saturating_add(RocksDbWeight::get().writes(4_u64)) } @@ -1455,8 +1411,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `552` // Estimated: `8967` - // Minimum execution time: 34_955_000 picoseconds. - Weight::from_parts(36_174_000, 8967) + // Minimum execution time: 34_828_000 picoseconds. + Weight::from_parts(35_904_000, 8967) .saturating_add(RocksDbWeight::get().reads(7_u64)) .saturating_add(RocksDbWeight::get().writes(6_u64)) } @@ -1465,10 +1421,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 9_394_000 picoseconds. - Weight::from_parts(10_159_990, 0) - // Standard Error: 56 - .saturating_add(Weight::from_parts(71_497, 0).saturating_mul(r.into())) + // Minimum execution time: 9_265_000 picoseconds. + Weight::from_parts(10_458_655, 0) + // Standard Error: 81 + .saturating_add(Weight::from_parts(70_250, 0).saturating_mul(r.into())) } fn seal_caller() -> Weight { // Proof Size summary in bytes: @@ -1483,8 +1439,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `354` // Estimated: `3819` - // Minimum execution time: 6_925_000 picoseconds. - Weight::from_parts(7_060_000, 3819) + // Minimum execution time: 6_782_000 picoseconds. + Weight::from_parts(7_244_000, 3819) .saturating_add(RocksDbWeight::get().reads(1_u64)) } /// Storage: `Contracts::ContractInfoOf` (r:1 w:0) @@ -1493,82 +1449,79 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `447` // Estimated: `3912` - // Minimum execution time: 7_928_000 picoseconds. - Weight::from_parts(8_230_000, 3912) + // Minimum execution time: 8_038_000 picoseconds. + Weight::from_parts(8_201_000, 3912) .saturating_add(RocksDbWeight::get().reads(1_u64)) } fn seal_own_code_hash() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 818_000 picoseconds. - Weight::from_parts(864_000, 0) + // Minimum execution time: 783_000 picoseconds. + Weight::from_parts(817_000, 0) } fn seal_caller_is_origin() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 382_000 picoseconds. - Weight::from_parts(411_000, 0) + // Minimum execution time: 413_000 picoseconds. + Weight::from_parts(430_000, 0) } fn seal_caller_is_root() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 350_000 picoseconds. - Weight::from_parts(386_000, 0) + // Minimum execution time: 351_000 picoseconds. + Weight::from_parts(366_000, 0) } fn seal_address() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 613_000 picoseconds. - Weight::from_parts(654_000, 0) + // Minimum execution time: 634_000 picoseconds. + Weight::from_parts(664_000, 0) } fn seal_gas_left() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 619_000 picoseconds. - Weight::from_parts(680_000, 0) + // Minimum execution time: 673_000 picoseconds. + Weight::from_parts(713_000, 0) } - /// Storage: `System::Account` (r:1 w:0) - /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`) fn seal_balance() -> Weight { // Proof Size summary in bytes: // Measured: `140` - // Estimated: `3605` - // Minimum execution time: 4_800_000 picoseconds. - Weight::from_parts(4_992_000, 3605) - .saturating_add(RocksDbWeight::get().reads(1_u64)) + // Estimated: `0` + // Minimum execution time: 4_847_000 picoseconds. + Weight::from_parts(5_057_000, 0) } fn seal_value_transferred() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 545_000 picoseconds. - Weight::from_parts(596_000, 0) + // Minimum execution time: 601_000 picoseconds. + Weight::from_parts(649_000, 0) } fn seal_minimum_balance() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 571_000 picoseconds. - Weight::from_parts(620_000, 0) + // Minimum execution time: 567_000 picoseconds. + Weight::from_parts(611_000, 0) } fn seal_block_number() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 540_000 picoseconds. - Weight::from_parts(612_000, 0) + // Minimum execution time: 573_000 picoseconds. + Weight::from_parts(602_000, 0) } fn seal_now() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 588_000 picoseconds. - Weight::from_parts(638_000, 0) + // Minimum execution time: 567_000 picoseconds. + Weight::from_parts(618_000, 0) } /// Storage: `TransactionPayment::NextFeeMultiplier` (r:1 w:0) /// Proof: `TransactionPayment::NextFeeMultiplier` (`max_values`: Some(1), `max_size`: Some(16), added: 511, mode: `Measured`) @@ -1576,8 +1529,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `67` // Estimated: `1552` - // Minimum execution time: 4_415_000 picoseconds. - Weight::from_parts(4_703_000, 1552) + // Minimum execution time: 4_490_000 picoseconds. + Weight::from_parts(4_765_000, 1552) .saturating_add(RocksDbWeight::get().reads(1_u64)) } /// The range of component `n` is `[0, 1048572]`. @@ -1585,20 +1538,20 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 484_000 picoseconds. - Weight::from_parts(508_000, 0) + // Minimum execution time: 483_000 picoseconds. + Weight::from_parts(498_000, 0) // Standard Error: 3 - .saturating_add(Weight::from_parts(303, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(292, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 1048572]`. fn seal_return(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 390_000 picoseconds. - Weight::from_parts(421_000, 0) + // Minimum execution time: 371_000 picoseconds. + Weight::from_parts(392_000, 0) // Standard Error: 9 - .saturating_add(Weight::from_parts(479, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(400, 0).saturating_mul(n.into())) } /// Storage: `Contracts::DeletionQueueCounter` (r:1 w:1) /// Proof: `Contracts::DeletionQueueCounter` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`) @@ -1606,18 +1559,16 @@ impl WeightInfo for () { /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `System::EventTopics` (r:2 w:2) /// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`) - /// Storage: `Contracts::ContractInfoOf` (r:0 w:1) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::DeletionQueue` (r:0 w:1) /// Proof: `Contracts::DeletionQueue` (`max_values`: None, `max_size`: Some(142), added: 2617, mode: `Measured`) fn seal_terminate() -> Weight { // Proof Size summary in bytes: // Measured: `2821` // Estimated: `85486` - // Minimum execution time: 134_681_000 picoseconds. - Weight::from_parts(136_452_000, 85486) + // Minimum execution time: 136_837_000 picoseconds. + Weight::from_parts(139_490_000, 85486) .saturating_add(RocksDbWeight::get().reads(36_u64)) - .saturating_add(RocksDbWeight::get().writes(38_u64)) + .saturating_add(RocksDbWeight::get().writes(37_u64)) } /// Storage: `RandomnessCollectiveFlip::RandomMaterial` (r:1 w:0) /// Proof: `RandomnessCollectiveFlip::RandomMaterial` (`max_values`: Some(1), `max_size`: Some(2594), added: 3089, mode: `Measured`) @@ -1625,8 +1576,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `76` // Estimated: `1561` - // Minimum execution time: 3_664_000 picoseconds. - Weight::from_parts(3_887_000, 1561) + // Minimum execution time: 3_738_000 picoseconds. + Weight::from_parts(3_910_000, 1561) .saturating_add(RocksDbWeight::get().reads(1_u64)) } /// Storage: `System::EventTopics` (r:4 w:4) @@ -1637,11 +1588,11 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `0` // Estimated: `990 + t * (2475 ±0)` - // Minimum execution time: 4_150_000 picoseconds. - Weight::from_parts(4_478_017, 990) - // Standard Error: 6_791 - .saturating_add(Weight::from_parts(2_359_039, 0).saturating_mul(t.into())) - // Standard Error: 1 + // Minimum execution time: 4_066_000 picoseconds. + Weight::from_parts(4_465_496, 990) + // Standard Error: 7_195 + .saturating_add(Weight::from_parts(2_349_432, 0).saturating_mul(t.into())) + // Standard Error: 2 .saturating_add(Weight::from_parts(19, 0).saturating_mul(n.into())) .saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(t.into()))) .saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(t.into()))) @@ -1652,24 +1603,28 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 400_000 picoseconds. - Weight::from_parts(424_000, 0) + // Minimum execution time: 457_000 picoseconds. + Weight::from_parts(483_000, 0) // Standard Error: 10 - .saturating_add(Weight::from_parts(1_271, 0).saturating_mul(i.into())) + .saturating_add(Weight::from_parts(1_202, 0).saturating_mul(i.into())) } /// Storage: `Skipped::Metadata` (r:0 w:0) /// Proof: `Skipped::Metadata` (`max_values`: None, `max_size`: None, mode: `Measured`) /// The range of component `n` is `[0, 16384]`. - fn seal_set_storage(n: u32, _o: u32) -> Weight { + /// The range of component `o` is `[0, 16384]`. + fn seal_set_storage(n: u32, o: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `245` - // Estimated: `245` - // Minimum execution time: 8_012_000 picoseconds. - Weight::from_parts(8_699_107, 245) + // Measured: `250 + o * (1 ±0)` + // Estimated: `249 + o * (1 ±0)` + // Minimum execution time: 9_784_000 picoseconds. + Weight::from_parts(9_860_281, 249) // Standard Error: 1 - .saturating_add(Weight::from_parts(351, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(242, 0).saturating_mul(n.into())) + // Standard Error: 1 + .saturating_add(Weight::from_parts(62, 0).saturating_mul(o.into())) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) + .saturating_add(Weight::from_parts(0, 1).saturating_mul(o.into())) } /// Storage: `Skipped::Metadata` (r:0 w:0) /// Proof: `Skipped::Metadata` (`max_values`: None, `max_size`: None, mode: `Measured`) @@ -1678,10 +1633,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `248 + n * (1 ±0)` // Estimated: `248 + n * (1 ±0)` - // Minimum execution time: 7_984_000 picoseconds. - Weight::from_parts(9_206_228, 248) + // Minimum execution time: 7_785_000 picoseconds. + Weight::from_parts(9_260_270, 248) // Standard Error: 2 - .saturating_add(Weight::from_parts(77, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(83, 0).saturating_mul(n.into())) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) @@ -1693,10 +1648,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `248 + n * (1 ±0)` // Estimated: `248 + n * (1 ±0)` - // Minimum execution time: 7_083_000 picoseconds. - Weight::from_parts(8_815_611, 248) - // Standard Error: 2 - .saturating_add(Weight::from_parts(708, 0).saturating_mul(n.into())) + // Minimum execution time: 7_004_000 picoseconds. + Weight::from_parts(8_830_936, 248) + // Standard Error: 3 + .saturating_add(Weight::from_parts(614, 0).saturating_mul(n.into())) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) } @@ -1707,10 +1662,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `248 + n * (1 ±0)` // Estimated: `248 + n * (1 ±0)` - // Minimum execution time: 6_708_000 picoseconds. - Weight::from_parts(8_031_454, 248) + // Minimum execution time: 6_766_000 picoseconds. + Weight::from_parts(7_955_845, 248) // Standard Error: 2 - .saturating_add(Weight::from_parts(78, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(86, 0).saturating_mul(n.into())) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) } @@ -1721,34 +1676,29 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `248 + n * (1 ±0)` // Estimated: `248 + n * (1 ±0)` - // Minimum execution time: 8_273_000 picoseconds. - Weight::from_parts(9_872_829, 248) + // Minimum execution time: 8_425_000 picoseconds. + Weight::from_parts(10_053_859, 248) // Standard Error: 3 - .saturating_add(Weight::from_parts(712, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(605, 0).saturating_mul(n.into())) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) } - /// Storage: `System::Account` (r:1 w:0) - /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`) fn seal_transfer() -> Weight { // Proof Size summary in bytes: // Measured: `140` - // Estimated: `3605` - // Minimum execution time: 9_220_000 picoseconds. - Weight::from_parts(9_590_000, 3605) - .saturating_add(RocksDbWeight::get().reads(1_u64)) + // Estimated: `0` + // Minimum execution time: 9_089_000 picoseconds. + Weight::from_parts(9_472_000, 0) } - /// Storage: `Contracts::ContractInfoOf` (r:1 w:2) + /// Storage: `Contracts::ContractInfoOf` (r:1 w:1) /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1 w:0) /// Proof: `Contracts::PristineCode` (`max_values`: None, `max_size`: Some(125988), added: 128463, mode: `Measured`) - /// Storage: `System::Account` (r:2 w:2) + /// Storage: `System::Account` (r:1 w:1) /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`) - /// Storage: `Parameters::Parameters` (r:2 w:0) - /// Proof: `Parameters::Parameters` (`max_values`: None, `max_size`: Some(36), added: 2511, mode: `Measured`) /// Storage: `System::EventTopics` (r:2 w:2) /// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`) /// The range of component `t` is `[0, 1]`. @@ -1756,21 +1706,21 @@ impl WeightInfo for () { /// The range of component `i` is `[0, 1048576]`. fn seal_call(t: u32, c: u32, i: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `623 + t * (280 ±0)` - // Estimated: `6563 + t * (3422 ±0)` - // Minimum execution time: 171_273_000 picoseconds. - Weight::from_parts(172_294_959, 6563) - // Standard Error: 309_680 - .saturating_add(Weight::from_parts(41_035_739, 0).saturating_mul(t.into())) - // Standard Error: 309_680 - .saturating_add(Weight::from_parts(168_535, 0).saturating_mul(c.into())) + // Measured: `620 + t * (280 ±0)` + // Estimated: `6560 + t * (2182 ±0)` + // Minimum execution time: 158_642_000 picoseconds. + Weight::from_parts(159_204_537, 6560) + // Standard Error: 312_560 + .saturating_add(Weight::from_parts(43_721_097, 0).saturating_mul(t.into())) + // Standard Error: 312_560 + .saturating_add(Weight::from_parts(1_118_806, 0).saturating_mul(c.into())) // Standard Error: 0 - .saturating_add(Weight::from_parts(9, 0).saturating_mul(i.into())) - .saturating_add(RocksDbWeight::get().reads(7_u64)) - .saturating_add(RocksDbWeight::get().reads((2_u64).saturating_mul(t.into()))) - .saturating_add(RocksDbWeight::get().writes(4_u64)) - .saturating_add(RocksDbWeight::get().writes((2_u64).saturating_mul(t.into()))) - .saturating_add(Weight::from_parts(0, 3422).saturating_mul(t.into())) + .saturating_add(Weight::from_parts(8, 0).saturating_mul(i.into())) + .saturating_add(RocksDbWeight::get().reads(5_u64)) + .saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(t.into()))) + .saturating_add(RocksDbWeight::get().writes(3_u64)) + .saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(t.into()))) + .saturating_add(Weight::from_parts(0, 2182).saturating_mul(t.into())) } /// Storage: `Contracts::CodeInfoOf` (r:1 w:0) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) @@ -1778,18 +1728,14 @@ impl WeightInfo for () { /// Proof: `Contracts::PristineCode` (`max_values`: None, `max_size`: Some(125988), added: 128463, mode: `Measured`) /// Storage: `System::EventTopics` (r:2 w:2) /// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`) - /// Storage: `Parameters::Parameters` (r:2 w:0) - /// Proof: `Parameters::Parameters` (`max_values`: None, `max_size`: Some(36), added: 2511, mode: `Measured`) - /// Storage: `Contracts::ContractInfoOf` (r:0 w:1) - /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) fn seal_delegate_call() -> Weight { // Proof Size summary in bytes: - // Measured: `433` - // Estimated: `6373` - // Minimum execution time: 155_964_000 picoseconds. - Weight::from_parts(160_485_000, 6373) - .saturating_add(RocksDbWeight::get().reads(6_u64)) - .saturating_add(RocksDbWeight::get().writes(3_u64)) + // Measured: `430` + // Estimated: `6370` + // Minimum execution time: 145_817_000 picoseconds. + Weight::from_parts(152_499_000, 6370) + .saturating_add(RocksDbWeight::get().reads(4_u64)) + .saturating_add(RocksDbWeight::get().writes(2_u64)) } /// Storage: `Contracts::CodeInfoOf` (r:1 w:1) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) @@ -1797,12 +1743,10 @@ impl WeightInfo for () { /// Proof: `Contracts::PristineCode` (`max_values`: None, `max_size`: Some(125988), added: 128463, mode: `Measured`) /// Storage: `Contracts::Nonce` (r:1 w:0) /// Proof: `Contracts::Nonce` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`) - /// Storage: `Contracts::ContractInfoOf` (r:1 w:2) + /// Storage: `Contracts::ContractInfoOf` (r:1 w:1) /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) - /// Storage: `System::Account` (r:3 w:3) + /// Storage: `System::Account` (r:2 w:2) /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`) - /// Storage: `Parameters::Parameters` (r:2 w:0) - /// Proof: `Parameters::Parameters` (`max_values`: None, `max_size`: Some(36), added: 2511, mode: `Measured`) /// Storage: `System::EventTopics` (r:2 w:2) /// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`) /// The range of component `t` is `[0, 1]`. @@ -1810,101 +1754,97 @@ impl WeightInfo for () { /// The range of component `s` is `[0, 983040]`. fn seal_instantiate(t: u32, i: u32, s: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `679 + t * (102 ±0)` - // Estimated: `6616 + t * (2565 ±1)` - // Minimum execution time: 1_821_557_000 picoseconds. - Weight::from_parts(85_126_984, 6616) - // Standard Error: 6_661_370 - .saturating_add(Weight::from_parts(175_191_430, 0).saturating_mul(t.into())) - // Standard Error: 10 - .saturating_add(Weight::from_parts(1_539, 0).saturating_mul(i.into())) - // Standard Error: 10 - .saturating_add(Weight::from_parts(1_811, 0).saturating_mul(s.into())) - .saturating_add(RocksDbWeight::get().reads(10_u64)) - .saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(t.into()))) - .saturating_add(RocksDbWeight::get().writes(7_u64)) - .saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(t.into()))) - .saturating_add(Weight::from_parts(0, 2565).saturating_mul(t.into())) + // Measured: `676 + t * (102 ±0)` + // Estimated: `6613 + t * (90 ±1)` + // Minimum execution time: 1_654_022_000 picoseconds. + Weight::from_parts(34_582_395, 6613) + // Standard Error: 8_789_446 + .saturating_add(Weight::from_parts(213_375_982, 0).saturating_mul(t.into())) + // Standard Error: 14 + .saturating_add(Weight::from_parts(1_362, 0).saturating_mul(i.into())) + // Standard Error: 14 + .saturating_add(Weight::from_parts(1_703, 0).saturating_mul(s.into())) + .saturating_add(RocksDbWeight::get().reads(8_u64)) + .saturating_add(RocksDbWeight::get().writes(6_u64)) + .saturating_add(Weight::from_parts(0, 90).saturating_mul(t.into())) } /// The range of component `n` is `[0, 1048576]`. fn seal_hash_sha2_256(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 834_000 picoseconds. - Weight::from_parts(891_000, 0) + // Minimum execution time: 861_000 picoseconds. + Weight::from_parts(909_000, 0) // Standard Error: 0 - .saturating_add(Weight::from_parts(1_152, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(1_050, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 1048576]`. fn seal_hash_keccak_256(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_428_000 picoseconds. - Weight::from_parts(1_493_000, 0) + // Minimum execution time: 1_344_000 picoseconds. + Weight::from_parts(1_378_000, 0) // Standard Error: 0 - .saturating_add(Weight::from_parts(3_414, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(3_314, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 1048576]`. fn seal_hash_blake2_256(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 707_000 picoseconds. - Weight::from_parts(774_000, 0) + // Minimum execution time: 764_000 picoseconds. + Weight::from_parts(777_000, 0) // Standard Error: 0 - .saturating_add(Weight::from_parts(1_280, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(1_185, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 1048576]`. fn seal_hash_blake2_128(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 763_000 picoseconds. - Weight::from_parts(822_000, 0) + // Minimum execution time: 753_000 picoseconds. + Weight::from_parts(767_000, 0) // Standard Error: 0 - .saturating_add(Weight::from_parts(1_279, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(1_190, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 125697]`. fn seal_sr25519_verify(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 45_176_000 picoseconds. - Weight::from_parts(46_961_397, 0) - // Standard Error: 7 - .saturating_add(Weight::from_parts(4_692, 0).saturating_mul(n.into())) + // Minimum execution time: 43_241_000 picoseconds. + Weight::from_parts(48_851_058, 0) + // Standard Error: 12 + .saturating_add(Weight::from_parts(4_453, 0).saturating_mul(n.into())) } fn seal_ecdsa_recover() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 47_301_000 picoseconds. - Weight::from_parts(48_454_000, 0) + // Minimum execution time: 47_013_000 picoseconds. + Weight::from_parts(49_080_000, 0) } fn seal_ecdsa_to_eth_address() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 13_031_000 picoseconds. - Weight::from_parts(13_300_000, 0) + // Minimum execution time: 12_861_000 picoseconds. + Weight::from_parts(13_006_000, 0) } /// Storage: `Contracts::CodeInfoOf` (r:1 w:1) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1 w:0) /// Proof: `Contracts::PristineCode` (`max_values`: None, `max_size`: Some(125988), added: 128463, mode: `Measured`) - /// Storage: `Parameters::Parameters` (r:2 w:0) - /// Proof: `Parameters::Parameters` (`max_values`: None, `max_size`: Some(36), added: 2511, mode: `Measured`) /// Storage: `System::EventTopics` (r:2 w:2) /// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`) fn seal_set_code_hash() -> Weight { // Proof Size summary in bytes: - // Measured: `433` - // Estimated: `6373` - // Minimum execution time: 31_664_000 picoseconds. - Weight::from_parts(32_906_000, 6373) - .saturating_add(RocksDbWeight::get().reads(6_u64)) + // Measured: `430` + // Estimated: `6370` + // Minimum execution time: 27_062_000 picoseconds. + Weight::from_parts(27_950_000, 6370) + .saturating_add(RocksDbWeight::get().reads(4_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) } /// Storage: `Contracts::CodeInfoOf` (r:1 w:1) @@ -1913,8 +1853,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `355` // Estimated: `3820` - // Minimum execution time: 9_364_000 picoseconds. - Weight::from_parts(9_551_000, 3820) + // Minimum execution time: 9_225_000 picoseconds. + Weight::from_parts(9_644_000, 3820) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -1924,8 +1864,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `355` // Estimated: `3558` - // Minimum execution time: 8_210_000 picoseconds. - Weight::from_parts(8_551_000, 3558) + // Minimum execution time: 8_209_000 picoseconds. + Weight::from_parts(8_639_000, 3558) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -1933,15 +1873,15 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 355_000 picoseconds. - Weight::from_parts(401_000, 0) + // Minimum execution time: 353_000 picoseconds. + Weight::from_parts(373_000, 0) } fn seal_account_reentrance_count() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 383_000 picoseconds. - Weight::from_parts(406_000, 0) + // Minimum execution time: 369_000 picoseconds. + Weight::from_parts(395_000, 0) } /// Storage: `Contracts::Nonce` (r:1 w:0) /// Proof: `Contracts::Nonce` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`) @@ -1949,8 +1889,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `219` // Estimated: `1704` - // Minimum execution time: 3_011_000 picoseconds. - Weight::from_parts(3_197_000, 1704) + // Minimum execution time: 2_985_000 picoseconds. + Weight::from_parts(3_126_000, 1704) .saturating_add(RocksDbWeight::get().reads(1_u64)) } /// The range of component `r` is `[0, 5000]`. @@ -1958,9 +1898,9 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 945_000 picoseconds. - Weight::from_parts(916_399, 0) - // Standard Error: 14 - .saturating_add(Weight::from_parts(14_957, 0).saturating_mul(r.into())) + // Minimum execution time: 1_032_000 picoseconds. + Weight::from_parts(762_731, 0) + // Standard Error: 27 + .saturating_add(Weight::from_parts(15_049, 0).saturating_mul(r.into())) } } From a11e74bc575e4c1c8096f78d1cba2b97e753a4ed Mon Sep 17 00:00:00 2001 From: pgherveou Date: Fri, 17 May 2024 09:18:14 +0200 Subject: [PATCH 24/34] Fix terminate --- substrate/frame/contracts/src/benchmarking/mod.rs | 8 ++++---- substrate/frame/contracts/src/exec.rs | 9 +++++++++ substrate/frame/contracts/src/wasm/mod.rs | 3 +++ substrate/frame/contracts/src/wasm/runtime.rs | 10 ++++++---- substrate/frame/contracts/src/weights.rs | 6 +++--- 5 files changed, 25 insertions(+), 11 deletions(-) diff --git a/substrate/frame/contracts/src/benchmarking/mod.rs b/substrate/frame/contracts/src/benchmarking/mod.rs index 6e0270b89f1d..e930bad1dcce 100644 --- a/substrate/frame/contracts/src/benchmarking/mod.rs +++ b/substrate/frame/contracts/src/benchmarking/mod.rs @@ -886,9 +886,10 @@ mod benchmarks { )); } - // The same argument as for `seal_return` is true here. #[benchmark(pov_mode = Measured)] - fn seal_terminate() -> Result<(), BenchmarkError> { + fn seal_terminate( + n: Linear<0, { T::MaxDelegateDependencies::get() }>, + ) -> Result<(), BenchmarkError> { let beneficiary = account::("beneficiary", 0, 0); let caller = whitelisted_caller(); @@ -896,8 +897,7 @@ mod benchmarks { T::Currency::set_balance(&caller, caller_funding::()); - // Maximize the delegate_dependencies to account for the worst-case scenario. - (0..T::MaxDelegateDependencies::get()).for_each(|i| { + (0..n).for_each(|i| { let new_code = WasmModule::::dummy_with_bytes(65 + i); Contracts::::store_code_raw(new_code.code, caller.clone()).unwrap(); runtime.ext().lock_delegate_dependency(new_code.hash).unwrap(); diff --git a/substrate/frame/contracts/src/exec.rs b/substrate/frame/contracts/src/exec.rs index 061d2fc3a1d9..94f11b57fe47 100644 --- a/substrate/frame/contracts/src/exec.rs +++ b/substrate/frame/contracts/src/exec.rs @@ -365,6 +365,11 @@ pub trait Ext: sealing::Sealed { &mut self, code_hash: &CodeHash, ) -> Result<(), DispatchError>; + + /// Returns the number of locked delegate dependencies. + /// + /// Note: Requires &mut self to access the contract info. + fn locked_delegate_dependencies_count(&mut self) -> usize; } /// Describes the different functions that can be exported by an [`Executable`]. @@ -1611,6 +1616,10 @@ where .charge_deposit(frame.account_id.clone(), StorageDeposit::Refund(deposit)); Ok(()) } + + fn locked_delegate_dependencies_count(&mut self) -> usize { + self.top_frame_mut().contract_info().delegate_dependencies_count() + } } mod sealing { diff --git a/substrate/frame/contracts/src/wasm/mod.rs b/substrate/frame/contracts/src/wasm/mod.rs index 380bd366f72a..b578de284d15 100644 --- a/substrate/frame/contracts/src/wasm/mod.rs +++ b/substrate/frame/contracts/src/wasm/mod.rs @@ -807,6 +807,9 @@ mod tests { self.delegate_dependencies.borrow_mut().remove(code); Ok(()) } + fn locked_delegate_dependencies_count(&mut self) -> usize { + self.delegate_dependencies.borrow().len() + } } /// Execute the supplied code. diff --git a/substrate/frame/contracts/src/wasm/runtime.rs b/substrate/frame/contracts/src/wasm/runtime.rs index a993bdf5c236..f2468e05ff63 100644 --- a/substrate/frame/contracts/src/wasm/runtime.rs +++ b/substrate/frame/contracts/src/wasm/runtime.rs @@ -180,8 +180,8 @@ pub enum RuntimeCosts { Now, /// Weight of calling `seal_weight_to_fee`. WeightToFee, - /// Weight of calling `seal_terminate`. - Terminate, + /// Weight of calling `seal_terminate`, passing the number of locked dependencies. + Terminate(u32), /// Weight of calling `seal_random`. It includes the weight for copying the subject. Random, /// Weight of calling `seal_deposit_event` with the given number of topics and event size. @@ -287,7 +287,7 @@ impl Token for RuntimeCosts { BlockNumber => T::WeightInfo::seal_block_number(), Now => T::WeightInfo::seal_now(), WeightToFee => T::WeightInfo::seal_weight_to_fee(), - Terminate => T::WeightInfo::seal_terminate(), + Terminate(locked_dependencies) => T::WeightInfo::seal_terminate(locked_dependencies), Random => T::WeightInfo::seal_random(), DepositEvent { num_topic, len } => T::WeightInfo::seal_deposit_event(num_topic, len), DebugMessage(len) => T::WeightInfo::seal_debug_message(len), @@ -927,7 +927,9 @@ impl<'a, E: Ext + 'a> Runtime<'a, E> { } fn terminate(&mut self, memory: &[u8], beneficiary_ptr: u32) -> Result<(), TrapReason> { - self.charge_gas(RuntimeCosts::Terminate)?; + let count = self.ext.locked_delegate_dependencies_count() as _; + self.charge_gas(RuntimeCosts::Terminate(count))?; + let beneficiary: <::T as frame_system::Config>::AccountId = self.read_sandbox_memory_as(memory, beneficiary_ptr)?; self.ext.terminate(&beneficiary)?; diff --git a/substrate/frame/contracts/src/weights.rs b/substrate/frame/contracts/src/weights.rs index d7ce94298ec0..a2c739352186 100644 --- a/substrate/frame/contracts/src/weights.rs +++ b/substrate/frame/contracts/src/weights.rs @@ -89,7 +89,7 @@ pub trait WeightInfo { fn seal_weight_to_fee() -> Weight; fn seal_input(n: u32, ) -> Weight; fn seal_return(n: u32, ) -> Weight; - fn seal_terminate() -> Weight; + fn seal_terminate(n: u32) -> Weight; fn seal_random() -> Weight; fn seal_deposit_event(t: u32, n: u32, ) -> Weight; fn seal_debug_message(i: u32, ) -> Weight; @@ -668,7 +668,7 @@ impl WeightInfo for SubstrateWeight { /// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `Contracts::DeletionQueue` (r:0 w:1) /// Proof: `Contracts::DeletionQueue` (`max_values`: None, `max_size`: Some(142), added: 2617, mode: `Measured`) - fn seal_terminate() -> Weight { + fn seal_terminate(_n: u32) -> Weight { // Proof Size summary in bytes: // Measured: `2821` // Estimated: `85486` @@ -1561,7 +1561,7 @@ impl WeightInfo for () { /// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `Contracts::DeletionQueue` (r:0 w:1) /// Proof: `Contracts::DeletionQueue` (`max_values`: None, `max_size`: Some(142), added: 2617, mode: `Measured`) - fn seal_terminate() -> Weight { + fn seal_terminate(_n: u32) -> Weight { // Proof Size summary in bytes: // Measured: `2821` // Estimated: `85486` From b806834bc4bcc91dd9f7ebff63153323ffada3a6 Mon Sep 17 00:00:00 2001 From: command-bot <> Date: Fri, 17 May 2024 08:02:48 +0000 Subject: [PATCH 25/34] ".git/.scripts/commands/bench/bench.sh" --subcommand=pallet --runtime=dev --target_dir=substrate --pallet=pallet_contracts --- substrate/frame/contracts/src/weights.rs | 796 ++++++++++++----------- 1 file changed, 404 insertions(+), 392 deletions(-) diff --git a/substrate/frame/contracts/src/weights.rs b/substrate/frame/contracts/src/weights.rs index a2c739352186..638883eae9d3 100644 --- a/substrate/frame/contracts/src/weights.rs +++ b/substrate/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 32.0.0 -//! DATE: 2024-05-16, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2024-05-17, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` //! HOSTNAME: `runner-unxyhko3-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz` //! WASM-EXECUTION: `Compiled`, CHAIN: `Some("dev")`, DB CACHE: `1024` @@ -89,7 +89,7 @@ pub trait WeightInfo { fn seal_weight_to_fee() -> Weight; fn seal_input(n: u32, ) -> Weight; fn seal_return(n: u32, ) -> Weight; - fn seal_terminate(n: u32) -> Weight; + fn seal_terminate(n: u32, ) -> Weight; fn seal_random() -> Weight; fn seal_deposit_event(t: u32, n: u32, ) -> Weight; fn seal_debug_message(i: u32, ) -> Weight; @@ -127,8 +127,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `142` // Estimated: `1627` - // Minimum execution time: 2_110_000 picoseconds. - Weight::from_parts(2_251_000, 1627) + // Minimum execution time: 2_094_000 picoseconds. + Weight::from_parts(2_238_000, 1627) .saturating_add(T::DbWeight::get().reads(1_u64)) } /// Storage: `Skipped::Metadata` (r:0 w:0) @@ -138,10 +138,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `452 + k * (69 ±0)` // Estimated: `442 + k * (70 ±0)` - // Minimum execution time: 12_154_000 picoseconds. - Weight::from_parts(12_536_000, 442) - // Standard Error: 907 - .saturating_add(Weight::from_parts(1_102_613, 0).saturating_mul(k.into())) + // Minimum execution time: 12_226_000 picoseconds. + Weight::from_parts(12_508_000, 442) + // Standard Error: 1_454 + .saturating_add(Weight::from_parts(1_124_285, 0).saturating_mul(k.into())) .saturating_add(T::DbWeight::get().reads(2_u64)) .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(k.into()))) .saturating_add(T::DbWeight::get().writes(2_u64)) @@ -155,10 +155,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `211 + c * (1 ±0)` // Estimated: `6149 + c * (1 ±0)` - // Minimum execution time: 8_232_000 picoseconds. - Weight::from_parts(8_895_498, 6149) + // Minimum execution time: 8_644_000 picoseconds. + Weight::from_parts(9_027_360, 6149) // Standard Error: 1 - .saturating_add(Weight::from_parts(1_156, 0).saturating_mul(c.into())) + .saturating_add(Weight::from_parts(1_209, 0).saturating_mul(c.into())) .saturating_add(T::DbWeight::get().reads(2_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(c.into())) @@ -171,8 +171,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `510` // Estimated: `6450` - // Minimum execution time: 16_760_000 picoseconds. - Weight::from_parts(17_693_000, 6450) + // Minimum execution time: 16_756_000 picoseconds. + Weight::from_parts(17_643_000, 6450) .saturating_add(T::DbWeight::get().reads(3_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -185,10 +185,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `171 + k * (1 ±0)` // Estimated: `3635 + k * (1 ±0)` - // Minimum execution time: 3_535_000 picoseconds. - Weight::from_parts(9_084_983, 3635) - // Standard Error: 1_564 - .saturating_add(Weight::from_parts(1_222_023, 0).saturating_mul(k.into())) + // Minimum execution time: 3_444_000 picoseconds. + Weight::from_parts(3_583_000, 3635) + // Standard Error: 777 + .saturating_add(Weight::from_parts(1_222_839, 0).saturating_mul(k.into())) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(2_u64)) .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(k.into()))) @@ -207,10 +207,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `325 + c * (1 ±0)` // Estimated: `6263 + c * (1 ±0)` - // Minimum execution time: 16_624_000 picoseconds. - Weight::from_parts(16_323_086, 6263) - // Standard Error: 1 - .saturating_add(Weight::from_parts(397, 0).saturating_mul(c.into())) + // Minimum execution time: 16_786_000 picoseconds. + Weight::from_parts(17_044_074, 6263) + // Standard Error: 0 + .saturating_add(Weight::from_parts(463, 0).saturating_mul(c.into())) .saturating_add(T::DbWeight::get().reads(4_u64)) .saturating_add(T::DbWeight::get().writes(2_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(c.into())) @@ -221,8 +221,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `440` // Estimated: `6380` - // Minimum execution time: 12_748_000 picoseconds. - Weight::from_parts(13_278_000, 6380) + // Minimum execution time: 12_921_000 picoseconds. + Weight::from_parts(13_391_000, 6380) .saturating_add(T::DbWeight::get().reads(2_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -236,8 +236,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `352` // Estimated: `6292` - // Minimum execution time: 46_790_000 picoseconds. - Weight::from_parts(48_318_000, 6292) + // Minimum execution time: 47_556_000 picoseconds. + Weight::from_parts(49_386_000, 6292) .saturating_add(T::DbWeight::get().reads(4_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -249,8 +249,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `594` // Estimated: `6534` - // Minimum execution time: 55_028_000 picoseconds. - Weight::from_parts(57_473_000, 6534) + // Minimum execution time: 54_956_000 picoseconds. + Weight::from_parts(57_387_000, 6534) .saturating_add(T::DbWeight::get().reads(4_u64)) .saturating_add(T::DbWeight::get().writes(2_u64)) } @@ -260,8 +260,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `409` // Estimated: `6349` - // Minimum execution time: 12_073_000 picoseconds. - Weight::from_parts(12_598_000, 6349) + // Minimum execution time: 12_196_000 picoseconds. + Weight::from_parts(12_747_000, 6349) .saturating_add(T::DbWeight::get().reads(2_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -271,8 +271,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `142` // Estimated: `1627` - // Minimum execution time: 2_470_000 picoseconds. - Weight::from_parts(2_587_000, 1627) + // Minimum execution time: 2_500_000 picoseconds. + Weight::from_parts(2_572_000, 1627) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -284,8 +284,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `166` // Estimated: `3631` - // Minimum execution time: 11_986_000 picoseconds. - Weight::from_parts(12_434_000, 3631) + // Minimum execution time: 12_297_000 picoseconds. + Weight::from_parts(12_552_000, 3631) .saturating_add(T::DbWeight::get().reads(2_u64)) .saturating_add(T::DbWeight::get().writes(2_u64)) } @@ -295,8 +295,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `142` // Estimated: `3607` - // Minimum execution time: 4_697_000 picoseconds. - Weight::from_parts(5_026_000, 3607) + // Minimum execution time: 4_745_000 picoseconds. + Weight::from_parts(5_049_000, 3607) .saturating_add(T::DbWeight::get().reads(1_u64)) } /// Storage: UNKNOWN KEY `0x4342193e496fab7ec59d615ed0dc55304e7b9012096b41c4eb3aaf947f6ea429` (r:1 w:0) @@ -307,8 +307,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `167` // Estimated: `3632` - // Minimum execution time: 5_963_000 picoseconds. - Weight::from_parts(6_245_000, 3632) + // Minimum execution time: 6_293_000 picoseconds. + Weight::from_parts(6_465_000, 3632) .saturating_add(T::DbWeight::get().reads(2_u64)) } /// Storage: UNKNOWN KEY `0x4342193e496fab7ec59d615ed0dc55304e7b9012096b41c4eb3aaf947f6ea429` (r:1 w:0) @@ -319,8 +319,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `142` // Estimated: `3607` - // Minimum execution time: 6_235_000 picoseconds. - Weight::from_parts(6_555_000, 3607) + // Minimum execution time: 6_378_000 picoseconds. + Weight::from_parts(6_874_000, 3607) .saturating_add(T::DbWeight::get().reads(2_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -343,10 +343,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `801 + c * (1 ±0)` // Estimated: `6739 + c * (1 ±0)` - // Minimum execution time: 299_356_000 picoseconds. - Weight::from_parts(276_901_396, 6739) - // Standard Error: 78 - .saturating_add(Weight::from_parts(33_208, 0).saturating_mul(c.into())) + // Minimum execution time: 362_366_000 picoseconds. + Weight::from_parts(353_347_662, 6739) + // Standard Error: 129 + .saturating_add(Weight::from_parts(34_964, 0).saturating_mul(c.into())) .saturating_add(T::DbWeight::get().reads(8_u64)) .saturating_add(T::DbWeight::get().writes(4_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(c.into())) @@ -376,14 +376,14 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `323` // Estimated: `8737` - // Minimum execution time: 3_772_084_000 picoseconds. - Weight::from_parts(753_868_107, 8737) - // Standard Error: 130 - .saturating_add(Weight::from_parts(66_251, 0).saturating_mul(c.into())) - // Standard Error: 15 - .saturating_add(Weight::from_parts(1_437, 0).saturating_mul(i.into())) - // Standard Error: 15 - .saturating_add(Weight::from_parts(1_542, 0).saturating_mul(s.into())) + // Minimum execution time: 4_266_902_000 picoseconds. + Weight::from_parts(914_416_909, 8737) + // Standard Error: 123 + .saturating_add(Weight::from_parts(67_482, 0).saturating_mul(c.into())) + // Standard Error: 14 + .saturating_add(Weight::from_parts(1_659, 0).saturating_mul(i.into())) + // Standard Error: 14 + .saturating_add(Weight::from_parts(1_619, 0).saturating_mul(s.into())) .saturating_add(T::DbWeight::get().reads(11_u64)) .saturating_add(T::DbWeight::get().writes(10_u64)) } @@ -411,12 +411,12 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `560` // Estimated: `6504` - // Minimum execution time: 1_956_848_000 picoseconds. - Weight::from_parts(1_983_893_000, 6504) + // Minimum execution time: 2_101_015_000 picoseconds. + Weight::from_parts(2_123_733_000, 6504) // Standard Error: 26 - .saturating_add(Weight::from_parts(813, 0).saturating_mul(i.into())) + .saturating_add(Weight::from_parts(895, 0).saturating_mul(i.into())) // Standard Error: 26 - .saturating_add(Weight::from_parts(787, 0).saturating_mul(s.into())) + .saturating_add(Weight::from_parts(805, 0).saturating_mul(s.into())) .saturating_add(T::DbWeight::get().reads(10_u64)) .saturating_add(T::DbWeight::get().writes(7_u64)) } @@ -438,8 +438,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `826` // Estimated: `6766` - // Minimum execution time: 199_924_000 picoseconds. - Weight::from_parts(209_592_000, 6766) + // Minimum execution time: 205_788_000 picoseconds. + Weight::from_parts(210_371_000, 6766) .saturating_add(T::DbWeight::get().reads(8_u64)) .saturating_add(T::DbWeight::get().writes(4_u64)) } @@ -458,10 +458,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `142` // Estimated: `3607` - // Minimum execution time: 257_465_000 picoseconds. - Weight::from_parts(288_412_411, 3607) - // Standard Error: 44 - .saturating_add(Weight::from_parts(32_279, 0).saturating_mul(c.into())) + // Minimum execution time: 334_087_000 picoseconds. + Weight::from_parts(347_294_648, 3607) + // Standard Error: 75 + .saturating_add(Weight::from_parts(33_819, 0).saturating_mul(c.into())) .saturating_add(T::DbWeight::get().reads(4_u64)) .saturating_add(T::DbWeight::get().writes(4_u64)) } @@ -480,10 +480,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `142` // Estimated: `3607` - // Minimum execution time: 281_502_000 picoseconds. - Weight::from_parts(296_208_635, 3607) - // Standard Error: 49 - .saturating_add(Weight::from_parts(32_646, 0).saturating_mul(c.into())) + // Minimum execution time: 348_078_000 picoseconds. + Weight::from_parts(393_851_501, 3607) + // Standard Error: 62 + .saturating_add(Weight::from_parts(33_635, 0).saturating_mul(c.into())) .saturating_add(T::DbWeight::get().reads(4_u64)) .saturating_add(T::DbWeight::get().writes(4_u64)) } @@ -501,8 +501,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `315` // Estimated: `3780` - // Minimum execution time: 45_012_000 picoseconds. - Weight::from_parts(46_216_000, 3780) + // Minimum execution time: 45_294_000 picoseconds. + Weight::from_parts(46_148_000, 3780) .saturating_add(T::DbWeight::get().reads(4_u64)) .saturating_add(T::DbWeight::get().writes(4_u64)) } @@ -518,8 +518,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `552` // Estimated: `8967` - // Minimum execution time: 34_828_000 picoseconds. - Weight::from_parts(35_904_000, 8967) + // Minimum execution time: 34_298_000 picoseconds. + Weight::from_parts(35_728_000, 8967) .saturating_add(T::DbWeight::get().reads(7_u64)) .saturating_add(T::DbWeight::get().writes(6_u64)) } @@ -528,17 +528,17 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 9_265_000 picoseconds. - Weight::from_parts(10_458_655, 0) - // Standard Error: 81 - .saturating_add(Weight::from_parts(70_250, 0).saturating_mul(r.into())) + // Minimum execution time: 9_347_000 picoseconds. + Weight::from_parts(10_917_661, 0) + // Standard Error: 142 + .saturating_add(Weight::from_parts(70_824, 0).saturating_mul(r.into())) } fn seal_caller() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 617_000 picoseconds. - Weight::from_parts(662_000, 0) + // Minimum execution time: 600_000 picoseconds. + Weight::from_parts(650_000, 0) } /// Storage: `Contracts::ContractInfoOf` (r:1 w:0) /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) @@ -546,8 +546,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `354` // Estimated: `3819` - // Minimum execution time: 6_782_000 picoseconds. - Weight::from_parts(7_244_000, 3819) + // Minimum execution time: 6_710_000 picoseconds. + Weight::from_parts(7_005_000, 3819) .saturating_add(T::DbWeight::get().reads(1_u64)) } /// Storage: `Contracts::ContractInfoOf` (r:1 w:0) @@ -556,79 +556,79 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `447` // Estimated: `3912` - // Minimum execution time: 8_038_000 picoseconds. - Weight::from_parts(8_201_000, 3912) + // Minimum execution time: 8_112_000 picoseconds. + Weight::from_parts(8_360_000, 3912) .saturating_add(T::DbWeight::get().reads(1_u64)) } fn seal_own_code_hash() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 783_000 picoseconds. - Weight::from_parts(817_000, 0) + // Minimum execution time: 668_000 picoseconds. + Weight::from_parts(761_000, 0) } fn seal_caller_is_origin() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 413_000 picoseconds. - Weight::from_parts(430_000, 0) + // Minimum execution time: 385_000 picoseconds. + Weight::from_parts(425_000, 0) } fn seal_caller_is_root() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 351_000 picoseconds. - Weight::from_parts(366_000, 0) + // Minimum execution time: 312_000 picoseconds. + Weight::from_parts(354_000, 0) } fn seal_address() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 634_000 picoseconds. - Weight::from_parts(664_000, 0) + // Minimum execution time: 558_000 picoseconds. + Weight::from_parts(607_000, 0) } fn seal_gas_left() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 673_000 picoseconds. - Weight::from_parts(713_000, 0) + // Minimum execution time: 661_000 picoseconds. + Weight::from_parts(706_000, 0) } fn seal_balance() -> Weight { // Proof Size summary in bytes: // Measured: `140` // Estimated: `0` - // Minimum execution time: 4_847_000 picoseconds. - Weight::from_parts(5_057_000, 0) + // Minimum execution time: 4_693_000 picoseconds. + Weight::from_parts(4_872_000, 0) } fn seal_value_transferred() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 601_000 picoseconds. - Weight::from_parts(649_000, 0) + // Minimum execution time: 532_000 picoseconds. + Weight::from_parts(583_000, 0) } fn seal_minimum_balance() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 567_000 picoseconds. - Weight::from_parts(611_000, 0) + // Minimum execution time: 529_000 picoseconds. + Weight::from_parts(570_000, 0) } fn seal_block_number() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 573_000 picoseconds. - Weight::from_parts(602_000, 0) + // Minimum execution time: 557_000 picoseconds. + Weight::from_parts(597_000, 0) } fn seal_now() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 567_000 picoseconds. - Weight::from_parts(618_000, 0) + // Minimum execution time: 551_000 picoseconds. + Weight::from_parts(588_000, 0) } /// Storage: `TransactionPayment::NextFeeMultiplier` (r:1 w:0) /// Proof: `TransactionPayment::NextFeeMultiplier` (`max_values`: Some(1), `max_size`: Some(16), added: 511, mode: `Measured`) @@ -636,8 +636,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `67` // Estimated: `1552` - // Minimum execution time: 4_490_000 picoseconds. - Weight::from_parts(4_765_000, 1552) + // Minimum execution time: 4_284_000 picoseconds. + Weight::from_parts(4_564_000, 1552) .saturating_add(T::DbWeight::get().reads(1_u64)) } /// The range of component `n` is `[0, 1048572]`. @@ -645,20 +645,20 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 483_000 picoseconds. - Weight::from_parts(498_000, 0) + // Minimum execution time: 452_000 picoseconds. + Weight::from_parts(480_000, 0) // Standard Error: 3 - .saturating_add(Weight::from_parts(292, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(303, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 1048572]`. fn seal_return(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 371_000 picoseconds. - Weight::from_parts(392_000, 0) + // Minimum execution time: 322_000 picoseconds. + Weight::from_parts(349_000, 0) // Standard Error: 9 - .saturating_add(Weight::from_parts(400, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(480, 0).saturating_mul(n.into())) } /// Storage: `Contracts::DeletionQueueCounter` (r:1 w:1) /// Proof: `Contracts::DeletionQueueCounter` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`) @@ -668,14 +668,20 @@ impl WeightInfo for SubstrateWeight { /// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `Contracts::DeletionQueue` (r:0 w:1) /// Proof: `Contracts::DeletionQueue` (`max_values`: None, `max_size`: Some(142), added: 2617, mode: `Measured`) - fn seal_terminate(_n: u32) -> Weight { - // Proof Size summary in bytes: - // Measured: `2821` - // Estimated: `85486` - // Minimum execution time: 136_837_000 picoseconds. - Weight::from_parts(139_490_000, 85486) - .saturating_add(T::DbWeight::get().reads(36_u64)) - .saturating_add(T::DbWeight::get().writes(37_u64)) + /// The range of component `n` is `[0, 32]`. + fn seal_terminate(n: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `319 + n * (78 ±0)` + // Estimated: `6259 + n * (2553 ±0)` + // Minimum execution time: 21_002_000 picoseconds. + Weight::from_parts(22_620_068, 6259) + // Standard Error: 6_761 + .saturating_add(Weight::from_parts(3_676_180, 0).saturating_mul(n.into())) + .saturating_add(T::DbWeight::get().reads(4_u64)) + .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(n.into()))) + .saturating_add(T::DbWeight::get().writes(5_u64)) + .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(n.into()))) + .saturating_add(Weight::from_parts(0, 2553).saturating_mul(n.into())) } /// Storage: `RandomnessCollectiveFlip::RandomMaterial` (r:1 w:0) /// Proof: `RandomnessCollectiveFlip::RandomMaterial` (`max_values`: Some(1), `max_size`: Some(2594), added: 3089, mode: `Measured`) @@ -683,8 +689,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `76` // Estimated: `1561` - // Minimum execution time: 3_738_000 picoseconds. - Weight::from_parts(3_910_000, 1561) + // Minimum execution time: 3_622_000 picoseconds. + Weight::from_parts(3_809_000, 1561) .saturating_add(T::DbWeight::get().reads(1_u64)) } /// Storage: `System::EventTopics` (r:4 w:4) @@ -695,12 +701,12 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `990 + t * (2475 ±0)` - // Minimum execution time: 4_066_000 picoseconds. - Weight::from_parts(4_465_496, 990) - // Standard Error: 7_195 - .saturating_add(Weight::from_parts(2_349_432, 0).saturating_mul(t.into())) + // Minimum execution time: 4_029_000 picoseconds. + Weight::from_parts(4_444_994, 990) + // Standard Error: 7_216 + .saturating_add(Weight::from_parts(2_404_769, 0).saturating_mul(t.into())) // Standard Error: 2 - .saturating_add(Weight::from_parts(19, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(16, 0).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(t.into()))) .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(t.into()))) .saturating_add(Weight::from_parts(0, 2475).saturating_mul(t.into())) @@ -710,10 +716,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 457_000 picoseconds. - Weight::from_parts(483_000, 0) + // Minimum execution time: 407_000 picoseconds. + Weight::from_parts(430_000, 0) // Standard Error: 10 - .saturating_add(Weight::from_parts(1_202, 0).saturating_mul(i.into())) + .saturating_add(Weight::from_parts(1_271, 0).saturating_mul(i.into())) } /// Storage: `Skipped::Metadata` (r:0 w:0) /// Proof: `Skipped::Metadata` (`max_values`: None, `max_size`: None, mode: `Measured`) @@ -723,12 +729,12 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `250 + o * (1 ±0)` // Estimated: `249 + o * (1 ±0)` - // Minimum execution time: 9_784_000 picoseconds. - Weight::from_parts(9_860_281, 249) + // Minimum execution time: 9_907_000 picoseconds. + Weight::from_parts(9_926_136, 249) // Standard Error: 1 - .saturating_add(Weight::from_parts(242, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(334, 0).saturating_mul(n.into())) // Standard Error: 1 - .saturating_add(Weight::from_parts(62, 0).saturating_mul(o.into())) + .saturating_add(Weight::from_parts(56, 0).saturating_mul(o.into())) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(o.into())) @@ -740,10 +746,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `248 + n * (1 ±0)` // Estimated: `248 + n * (1 ±0)` - // Minimum execution time: 7_785_000 picoseconds. - Weight::from_parts(9_260_270, 248) + // Minimum execution time: 8_288_000 picoseconds. + Weight::from_parts(9_347_243, 248) // Standard Error: 2 - .saturating_add(Weight::from_parts(83, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(81, 0).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) @@ -755,10 +761,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `248 + n * (1 ±0)` // Estimated: `248 + n * (1 ±0)` - // Minimum execution time: 7_004_000 picoseconds. - Weight::from_parts(8_830_936, 248) + // Minimum execution time: 7_180_000 picoseconds. + Weight::from_parts(9_058_388, 248) // Standard Error: 3 - .saturating_add(Weight::from_parts(614, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(701, 0).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) } @@ -769,10 +775,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `248 + n * (1 ±0)` // Estimated: `248 + n * (1 ±0)` - // Minimum execution time: 6_766_000 picoseconds. - Weight::from_parts(7_955_845, 248) + // Minimum execution time: 6_868_000 picoseconds. + Weight::from_parts(8_056_732, 248) // Standard Error: 2 - .saturating_add(Weight::from_parts(86, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(81, 0).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) } @@ -783,10 +789,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `248 + n * (1 ±0)` // Estimated: `248 + n * (1 ±0)` - // Minimum execution time: 8_425_000 picoseconds. - Weight::from_parts(10_053_859, 248) - // Standard Error: 3 - .saturating_add(Weight::from_parts(605, 0).saturating_mul(n.into())) + // Minimum execution time: 8_601_000 picoseconds. + Weight::from_parts(10_124_367, 248) + // Standard Error: 2 + .saturating_add(Weight::from_parts(701, 0).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) @@ -795,8 +801,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `140` // Estimated: `0` - // Minimum execution time: 9_089_000 picoseconds. - Weight::from_parts(9_472_000, 0) + // Minimum execution time: 9_242_000 picoseconds. + Weight::from_parts(9_557_000, 0) } /// Storage: `Contracts::ContractInfoOf` (r:1 w:1) /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) @@ -815,14 +821,14 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `620 + t * (280 ±0)` // Estimated: `6560 + t * (2182 ±0)` - // Minimum execution time: 158_642_000 picoseconds. - Weight::from_parts(159_204_537, 6560) - // Standard Error: 312_560 - .saturating_add(Weight::from_parts(43_721_097, 0).saturating_mul(t.into())) - // Standard Error: 312_560 - .saturating_add(Weight::from_parts(1_118_806, 0).saturating_mul(c.into())) + // Minimum execution time: 161_170_000 picoseconds. + Weight::from_parts(165_269_982, 6560) + // Standard Error: 327_855 + .saturating_add(Weight::from_parts(42_589_388, 0).saturating_mul(t.into())) + // Standard Error: 327_855 + .saturating_add(Weight::from_parts(1_482_035, 0).saturating_mul(c.into())) // Standard Error: 0 - .saturating_add(Weight::from_parts(8, 0).saturating_mul(i.into())) + .saturating_add(Weight::from_parts(7, 0).saturating_mul(i.into())) .saturating_add(T::DbWeight::get().reads(5_u64)) .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(t.into()))) .saturating_add(T::DbWeight::get().writes(3_u64)) @@ -839,8 +845,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `430` // Estimated: `6370` - // Minimum execution time: 145_817_000 picoseconds. - Weight::from_parts(152_499_000, 6370) + // Minimum execution time: 149_765_000 picoseconds. + Weight::from_parts(159_745_000, 6370) .saturating_add(T::DbWeight::get().reads(4_u64)) .saturating_add(T::DbWeight::get().writes(2_u64)) } @@ -863,14 +869,14 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `676 + t * (102 ±0)` // Estimated: `6613 + t * (90 ±1)` - // Minimum execution time: 1_654_022_000 picoseconds. - Weight::from_parts(34_582_395, 6613) - // Standard Error: 8_789_446 - .saturating_add(Weight::from_parts(213_375_982, 0).saturating_mul(t.into())) - // Standard Error: 14 - .saturating_add(Weight::from_parts(1_362, 0).saturating_mul(i.into())) - // Standard Error: 14 - .saturating_add(Weight::from_parts(1_703, 0).saturating_mul(s.into())) + // Minimum execution time: 1_807_196_000 picoseconds. + Weight::from_parts(83_888_679, 6613) + // Standard Error: 6_713_052 + .saturating_add(Weight::from_parts(184_318_405, 0).saturating_mul(t.into())) + // Standard Error: 10 + .saturating_add(Weight::from_parts(1_532, 0).saturating_mul(i.into())) + // Standard Error: 10 + .saturating_add(Weight::from_parts(1_796, 0).saturating_mul(s.into())) .saturating_add(T::DbWeight::get().reads(8_u64)) .saturating_add(T::DbWeight::get().writes(6_u64)) .saturating_add(Weight::from_parts(0, 90).saturating_mul(t.into())) @@ -880,64 +886,64 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 861_000 picoseconds. - Weight::from_parts(909_000, 0) + // Minimum execution time: 850_000 picoseconds. + Weight::from_parts(927_000, 0) // Standard Error: 0 - .saturating_add(Weight::from_parts(1_050, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(1_146, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 1048576]`. fn seal_hash_keccak_256(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_344_000 picoseconds. - Weight::from_parts(1_378_000, 0) + // Minimum execution time: 1_318_000 picoseconds. + Weight::from_parts(1_404_000, 0) // Standard Error: 0 - .saturating_add(Weight::from_parts(3_314, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(3_405, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 1048576]`. fn seal_hash_blake2_256(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 764_000 picoseconds. - Weight::from_parts(777_000, 0) + // Minimum execution time: 709_000 picoseconds. + Weight::from_parts(736_000, 0) // Standard Error: 0 - .saturating_add(Weight::from_parts(1_185, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(1_282, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 1048576]`. fn seal_hash_blake2_128(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 753_000 picoseconds. - Weight::from_parts(767_000, 0) + // Minimum execution time: 707_000 picoseconds. + Weight::from_parts(748_000, 0) // Standard Error: 0 - .saturating_add(Weight::from_parts(1_190, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(1_280, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 125697]`. fn seal_sr25519_verify(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 43_241_000 picoseconds. - Weight::from_parts(48_851_058, 0) - // Standard Error: 12 - .saturating_add(Weight::from_parts(4_453, 0).saturating_mul(n.into())) + // Minimum execution time: 43_289_000 picoseconds. + Weight::from_parts(47_063_362, 0) + // Standard Error: 11 + .saturating_add(Weight::from_parts(4_544, 0).saturating_mul(n.into())) } fn seal_ecdsa_recover() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 47_013_000 picoseconds. - Weight::from_parts(49_080_000, 0) + // Minimum execution time: 46_432_000 picoseconds. + Weight::from_parts(48_334_000, 0) } fn seal_ecdsa_to_eth_address() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 12_861_000 picoseconds. - Weight::from_parts(13_006_000, 0) + // Minimum execution time: 12_812_000 picoseconds. + Weight::from_parts(13_019_000, 0) } /// Storage: `Contracts::CodeInfoOf` (r:1 w:1) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) @@ -949,8 +955,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `430` // Estimated: `6370` - // Minimum execution time: 27_062_000 picoseconds. - Weight::from_parts(27_950_000, 6370) + // Minimum execution time: 27_336_000 picoseconds. + Weight::from_parts(28_146_000, 6370) .saturating_add(T::DbWeight::get().reads(4_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) } @@ -960,8 +966,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `355` // Estimated: `3820` - // Minimum execution time: 9_225_000 picoseconds. - Weight::from_parts(9_644_000, 3820) + // Minimum execution time: 9_209_000 picoseconds. + Weight::from_parts(9_638_000, 3820) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -971,8 +977,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `355` // Estimated: `3558` - // Minimum execution time: 8_209_000 picoseconds. - Weight::from_parts(8_639_000, 3558) + // Minimum execution time: 8_161_000 picoseconds. + Weight::from_parts(8_449_000, 3558) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -980,15 +986,15 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 353_000 picoseconds. - Weight::from_parts(373_000, 0) + // Minimum execution time: 330_000 picoseconds. + Weight::from_parts(354_000, 0) } fn seal_account_reentrance_count() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 369_000 picoseconds. - Weight::from_parts(395_000, 0) + // Minimum execution time: 337_000 picoseconds. + Weight::from_parts(381_000, 0) } /// Storage: `Contracts::Nonce` (r:1 w:0) /// Proof: `Contracts::Nonce` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`) @@ -996,8 +1002,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `219` // Estimated: `1704` - // Minimum execution time: 2_985_000 picoseconds. - Weight::from_parts(3_126_000, 1704) + // Minimum execution time: 2_975_000 picoseconds. + Weight::from_parts(3_147_000, 1704) .saturating_add(T::DbWeight::get().reads(1_u64)) } /// The range of component `r` is `[0, 5000]`. @@ -1005,10 +1011,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_032_000 picoseconds. - Weight::from_parts(762_731, 0) - // Standard Error: 27 - .saturating_add(Weight::from_parts(15_049, 0).saturating_mul(r.into())) + // Minimum execution time: 863_000 picoseconds. + Weight::from_parts(439_219, 0) + // Standard Error: 17 + .saturating_add(Weight::from_parts(15_175, 0).saturating_mul(r.into())) } } @@ -1020,8 +1026,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `142` // Estimated: `1627` - // Minimum execution time: 2_110_000 picoseconds. - Weight::from_parts(2_251_000, 1627) + // Minimum execution time: 2_094_000 picoseconds. + Weight::from_parts(2_238_000, 1627) .saturating_add(RocksDbWeight::get().reads(1_u64)) } /// Storage: `Skipped::Metadata` (r:0 w:0) @@ -1031,10 +1037,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `452 + k * (69 ±0)` // Estimated: `442 + k * (70 ±0)` - // Minimum execution time: 12_154_000 picoseconds. - Weight::from_parts(12_536_000, 442) - // Standard Error: 907 - .saturating_add(Weight::from_parts(1_102_613, 0).saturating_mul(k.into())) + // Minimum execution time: 12_226_000 picoseconds. + Weight::from_parts(12_508_000, 442) + // Standard Error: 1_454 + .saturating_add(Weight::from_parts(1_124_285, 0).saturating_mul(k.into())) .saturating_add(RocksDbWeight::get().reads(2_u64)) .saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(k.into()))) .saturating_add(RocksDbWeight::get().writes(2_u64)) @@ -1048,10 +1054,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `211 + c * (1 ±0)` // Estimated: `6149 + c * (1 ±0)` - // Minimum execution time: 8_232_000 picoseconds. - Weight::from_parts(8_895_498, 6149) + // Minimum execution time: 8_644_000 picoseconds. + Weight::from_parts(9_027_360, 6149) // Standard Error: 1 - .saturating_add(Weight::from_parts(1_156, 0).saturating_mul(c.into())) + .saturating_add(Weight::from_parts(1_209, 0).saturating_mul(c.into())) .saturating_add(RocksDbWeight::get().reads(2_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(c.into())) @@ -1064,8 +1070,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `510` // Estimated: `6450` - // Minimum execution time: 16_760_000 picoseconds. - Weight::from_parts(17_693_000, 6450) + // Minimum execution time: 16_756_000 picoseconds. + Weight::from_parts(17_643_000, 6450) .saturating_add(RocksDbWeight::get().reads(3_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -1078,10 +1084,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `171 + k * (1 ±0)` // Estimated: `3635 + k * (1 ±0)` - // Minimum execution time: 3_535_000 picoseconds. - Weight::from_parts(9_084_983, 3635) - // Standard Error: 1_564 - .saturating_add(Weight::from_parts(1_222_023, 0).saturating_mul(k.into())) + // Minimum execution time: 3_444_000 picoseconds. + Weight::from_parts(3_583_000, 3635) + // Standard Error: 777 + .saturating_add(Weight::from_parts(1_222_839, 0).saturating_mul(k.into())) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(2_u64)) .saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(k.into()))) @@ -1100,10 +1106,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `325 + c * (1 ±0)` // Estimated: `6263 + c * (1 ±0)` - // Minimum execution time: 16_624_000 picoseconds. - Weight::from_parts(16_323_086, 6263) - // Standard Error: 1 - .saturating_add(Weight::from_parts(397, 0).saturating_mul(c.into())) + // Minimum execution time: 16_786_000 picoseconds. + Weight::from_parts(17_044_074, 6263) + // Standard Error: 0 + .saturating_add(Weight::from_parts(463, 0).saturating_mul(c.into())) .saturating_add(RocksDbWeight::get().reads(4_u64)) .saturating_add(RocksDbWeight::get().writes(2_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(c.into())) @@ -1114,8 +1120,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `440` // Estimated: `6380` - // Minimum execution time: 12_748_000 picoseconds. - Weight::from_parts(13_278_000, 6380) + // Minimum execution time: 12_921_000 picoseconds. + Weight::from_parts(13_391_000, 6380) .saturating_add(RocksDbWeight::get().reads(2_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -1129,8 +1135,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `352` // Estimated: `6292` - // Minimum execution time: 46_790_000 picoseconds. - Weight::from_parts(48_318_000, 6292) + // Minimum execution time: 47_556_000 picoseconds. + Weight::from_parts(49_386_000, 6292) .saturating_add(RocksDbWeight::get().reads(4_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -1142,8 +1148,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `594` // Estimated: `6534` - // Minimum execution time: 55_028_000 picoseconds. - Weight::from_parts(57_473_000, 6534) + // Minimum execution time: 54_956_000 picoseconds. + Weight::from_parts(57_387_000, 6534) .saturating_add(RocksDbWeight::get().reads(4_u64)) .saturating_add(RocksDbWeight::get().writes(2_u64)) } @@ -1153,8 +1159,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `409` // Estimated: `6349` - // Minimum execution time: 12_073_000 picoseconds. - Weight::from_parts(12_598_000, 6349) + // Minimum execution time: 12_196_000 picoseconds. + Weight::from_parts(12_747_000, 6349) .saturating_add(RocksDbWeight::get().reads(2_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -1164,8 +1170,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `142` // Estimated: `1627` - // Minimum execution time: 2_470_000 picoseconds. - Weight::from_parts(2_587_000, 1627) + // Minimum execution time: 2_500_000 picoseconds. + Weight::from_parts(2_572_000, 1627) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -1177,8 +1183,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `166` // Estimated: `3631` - // Minimum execution time: 11_986_000 picoseconds. - Weight::from_parts(12_434_000, 3631) + // Minimum execution time: 12_297_000 picoseconds. + Weight::from_parts(12_552_000, 3631) .saturating_add(RocksDbWeight::get().reads(2_u64)) .saturating_add(RocksDbWeight::get().writes(2_u64)) } @@ -1188,8 +1194,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `142` // Estimated: `3607` - // Minimum execution time: 4_697_000 picoseconds. - Weight::from_parts(5_026_000, 3607) + // Minimum execution time: 4_745_000 picoseconds. + Weight::from_parts(5_049_000, 3607) .saturating_add(RocksDbWeight::get().reads(1_u64)) } /// Storage: UNKNOWN KEY `0x4342193e496fab7ec59d615ed0dc55304e7b9012096b41c4eb3aaf947f6ea429` (r:1 w:0) @@ -1200,8 +1206,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `167` // Estimated: `3632` - // Minimum execution time: 5_963_000 picoseconds. - Weight::from_parts(6_245_000, 3632) + // Minimum execution time: 6_293_000 picoseconds. + Weight::from_parts(6_465_000, 3632) .saturating_add(RocksDbWeight::get().reads(2_u64)) } /// Storage: UNKNOWN KEY `0x4342193e496fab7ec59d615ed0dc55304e7b9012096b41c4eb3aaf947f6ea429` (r:1 w:0) @@ -1212,8 +1218,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `142` // Estimated: `3607` - // Minimum execution time: 6_235_000 picoseconds. - Weight::from_parts(6_555_000, 3607) + // Minimum execution time: 6_378_000 picoseconds. + Weight::from_parts(6_874_000, 3607) .saturating_add(RocksDbWeight::get().reads(2_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -1236,10 +1242,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `801 + c * (1 ±0)` // Estimated: `6739 + c * (1 ±0)` - // Minimum execution time: 299_356_000 picoseconds. - Weight::from_parts(276_901_396, 6739) - // Standard Error: 78 - .saturating_add(Weight::from_parts(33_208, 0).saturating_mul(c.into())) + // Minimum execution time: 362_366_000 picoseconds. + Weight::from_parts(353_347_662, 6739) + // Standard Error: 129 + .saturating_add(Weight::from_parts(34_964, 0).saturating_mul(c.into())) .saturating_add(RocksDbWeight::get().reads(8_u64)) .saturating_add(RocksDbWeight::get().writes(4_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(c.into())) @@ -1269,14 +1275,14 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `323` // Estimated: `8737` - // Minimum execution time: 3_772_084_000 picoseconds. - Weight::from_parts(753_868_107, 8737) - // Standard Error: 130 - .saturating_add(Weight::from_parts(66_251, 0).saturating_mul(c.into())) - // Standard Error: 15 - .saturating_add(Weight::from_parts(1_437, 0).saturating_mul(i.into())) - // Standard Error: 15 - .saturating_add(Weight::from_parts(1_542, 0).saturating_mul(s.into())) + // Minimum execution time: 4_266_902_000 picoseconds. + Weight::from_parts(914_416_909, 8737) + // Standard Error: 123 + .saturating_add(Weight::from_parts(67_482, 0).saturating_mul(c.into())) + // Standard Error: 14 + .saturating_add(Weight::from_parts(1_659, 0).saturating_mul(i.into())) + // Standard Error: 14 + .saturating_add(Weight::from_parts(1_619, 0).saturating_mul(s.into())) .saturating_add(RocksDbWeight::get().reads(11_u64)) .saturating_add(RocksDbWeight::get().writes(10_u64)) } @@ -1304,12 +1310,12 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `560` // Estimated: `6504` - // Minimum execution time: 1_956_848_000 picoseconds. - Weight::from_parts(1_983_893_000, 6504) + // Minimum execution time: 2_101_015_000 picoseconds. + Weight::from_parts(2_123_733_000, 6504) // Standard Error: 26 - .saturating_add(Weight::from_parts(813, 0).saturating_mul(i.into())) + .saturating_add(Weight::from_parts(895, 0).saturating_mul(i.into())) // Standard Error: 26 - .saturating_add(Weight::from_parts(787, 0).saturating_mul(s.into())) + .saturating_add(Weight::from_parts(805, 0).saturating_mul(s.into())) .saturating_add(RocksDbWeight::get().reads(10_u64)) .saturating_add(RocksDbWeight::get().writes(7_u64)) } @@ -1331,8 +1337,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `826` // Estimated: `6766` - // Minimum execution time: 199_924_000 picoseconds. - Weight::from_parts(209_592_000, 6766) + // Minimum execution time: 205_788_000 picoseconds. + Weight::from_parts(210_371_000, 6766) .saturating_add(RocksDbWeight::get().reads(8_u64)) .saturating_add(RocksDbWeight::get().writes(4_u64)) } @@ -1351,10 +1357,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `142` // Estimated: `3607` - // Minimum execution time: 257_465_000 picoseconds. - Weight::from_parts(288_412_411, 3607) - // Standard Error: 44 - .saturating_add(Weight::from_parts(32_279, 0).saturating_mul(c.into())) + // Minimum execution time: 334_087_000 picoseconds. + Weight::from_parts(347_294_648, 3607) + // Standard Error: 75 + .saturating_add(Weight::from_parts(33_819, 0).saturating_mul(c.into())) .saturating_add(RocksDbWeight::get().reads(4_u64)) .saturating_add(RocksDbWeight::get().writes(4_u64)) } @@ -1373,10 +1379,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `142` // Estimated: `3607` - // Minimum execution time: 281_502_000 picoseconds. - Weight::from_parts(296_208_635, 3607) - // Standard Error: 49 - .saturating_add(Weight::from_parts(32_646, 0).saturating_mul(c.into())) + // Minimum execution time: 348_078_000 picoseconds. + Weight::from_parts(393_851_501, 3607) + // Standard Error: 62 + .saturating_add(Weight::from_parts(33_635, 0).saturating_mul(c.into())) .saturating_add(RocksDbWeight::get().reads(4_u64)) .saturating_add(RocksDbWeight::get().writes(4_u64)) } @@ -1394,8 +1400,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `315` // Estimated: `3780` - // Minimum execution time: 45_012_000 picoseconds. - Weight::from_parts(46_216_000, 3780) + // Minimum execution time: 45_294_000 picoseconds. + Weight::from_parts(46_148_000, 3780) .saturating_add(RocksDbWeight::get().reads(4_u64)) .saturating_add(RocksDbWeight::get().writes(4_u64)) } @@ -1411,8 +1417,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `552` // Estimated: `8967` - // Minimum execution time: 34_828_000 picoseconds. - Weight::from_parts(35_904_000, 8967) + // Minimum execution time: 34_298_000 picoseconds. + Weight::from_parts(35_728_000, 8967) .saturating_add(RocksDbWeight::get().reads(7_u64)) .saturating_add(RocksDbWeight::get().writes(6_u64)) } @@ -1421,17 +1427,17 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 9_265_000 picoseconds. - Weight::from_parts(10_458_655, 0) - // Standard Error: 81 - .saturating_add(Weight::from_parts(70_250, 0).saturating_mul(r.into())) + // Minimum execution time: 9_347_000 picoseconds. + Weight::from_parts(10_917_661, 0) + // Standard Error: 142 + .saturating_add(Weight::from_parts(70_824, 0).saturating_mul(r.into())) } fn seal_caller() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 617_000 picoseconds. - Weight::from_parts(662_000, 0) + // Minimum execution time: 600_000 picoseconds. + Weight::from_parts(650_000, 0) } /// Storage: `Contracts::ContractInfoOf` (r:1 w:0) /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) @@ -1439,8 +1445,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `354` // Estimated: `3819` - // Minimum execution time: 6_782_000 picoseconds. - Weight::from_parts(7_244_000, 3819) + // Minimum execution time: 6_710_000 picoseconds. + Weight::from_parts(7_005_000, 3819) .saturating_add(RocksDbWeight::get().reads(1_u64)) } /// Storage: `Contracts::ContractInfoOf` (r:1 w:0) @@ -1449,79 +1455,79 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `447` // Estimated: `3912` - // Minimum execution time: 8_038_000 picoseconds. - Weight::from_parts(8_201_000, 3912) + // Minimum execution time: 8_112_000 picoseconds. + Weight::from_parts(8_360_000, 3912) .saturating_add(RocksDbWeight::get().reads(1_u64)) } fn seal_own_code_hash() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 783_000 picoseconds. - Weight::from_parts(817_000, 0) + // Minimum execution time: 668_000 picoseconds. + Weight::from_parts(761_000, 0) } fn seal_caller_is_origin() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 413_000 picoseconds. - Weight::from_parts(430_000, 0) + // Minimum execution time: 385_000 picoseconds. + Weight::from_parts(425_000, 0) } fn seal_caller_is_root() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 351_000 picoseconds. - Weight::from_parts(366_000, 0) + // Minimum execution time: 312_000 picoseconds. + Weight::from_parts(354_000, 0) } fn seal_address() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 634_000 picoseconds. - Weight::from_parts(664_000, 0) + // Minimum execution time: 558_000 picoseconds. + Weight::from_parts(607_000, 0) } fn seal_gas_left() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 673_000 picoseconds. - Weight::from_parts(713_000, 0) + // Minimum execution time: 661_000 picoseconds. + Weight::from_parts(706_000, 0) } fn seal_balance() -> Weight { // Proof Size summary in bytes: // Measured: `140` // Estimated: `0` - // Minimum execution time: 4_847_000 picoseconds. - Weight::from_parts(5_057_000, 0) + // Minimum execution time: 4_693_000 picoseconds. + Weight::from_parts(4_872_000, 0) } fn seal_value_transferred() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 601_000 picoseconds. - Weight::from_parts(649_000, 0) + // Minimum execution time: 532_000 picoseconds. + Weight::from_parts(583_000, 0) } fn seal_minimum_balance() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 567_000 picoseconds. - Weight::from_parts(611_000, 0) + // Minimum execution time: 529_000 picoseconds. + Weight::from_parts(570_000, 0) } fn seal_block_number() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 573_000 picoseconds. - Weight::from_parts(602_000, 0) + // Minimum execution time: 557_000 picoseconds. + Weight::from_parts(597_000, 0) } fn seal_now() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 567_000 picoseconds. - Weight::from_parts(618_000, 0) + // Minimum execution time: 551_000 picoseconds. + Weight::from_parts(588_000, 0) } /// Storage: `TransactionPayment::NextFeeMultiplier` (r:1 w:0) /// Proof: `TransactionPayment::NextFeeMultiplier` (`max_values`: Some(1), `max_size`: Some(16), added: 511, mode: `Measured`) @@ -1529,8 +1535,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `67` // Estimated: `1552` - // Minimum execution time: 4_490_000 picoseconds. - Weight::from_parts(4_765_000, 1552) + // Minimum execution time: 4_284_000 picoseconds. + Weight::from_parts(4_564_000, 1552) .saturating_add(RocksDbWeight::get().reads(1_u64)) } /// The range of component `n` is `[0, 1048572]`. @@ -1538,20 +1544,20 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 483_000 picoseconds. - Weight::from_parts(498_000, 0) + // Minimum execution time: 452_000 picoseconds. + Weight::from_parts(480_000, 0) // Standard Error: 3 - .saturating_add(Weight::from_parts(292, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(303, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 1048572]`. fn seal_return(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 371_000 picoseconds. - Weight::from_parts(392_000, 0) + // Minimum execution time: 322_000 picoseconds. + Weight::from_parts(349_000, 0) // Standard Error: 9 - .saturating_add(Weight::from_parts(400, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(480, 0).saturating_mul(n.into())) } /// Storage: `Contracts::DeletionQueueCounter` (r:1 w:1) /// Proof: `Contracts::DeletionQueueCounter` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`) @@ -1561,14 +1567,20 @@ impl WeightInfo for () { /// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `Contracts::DeletionQueue` (r:0 w:1) /// Proof: `Contracts::DeletionQueue` (`max_values`: None, `max_size`: Some(142), added: 2617, mode: `Measured`) - fn seal_terminate(_n: u32) -> Weight { - // Proof Size summary in bytes: - // Measured: `2821` - // Estimated: `85486` - // Minimum execution time: 136_837_000 picoseconds. - Weight::from_parts(139_490_000, 85486) - .saturating_add(RocksDbWeight::get().reads(36_u64)) - .saturating_add(RocksDbWeight::get().writes(37_u64)) + /// The range of component `n` is `[0, 32]`. + fn seal_terminate(n: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `319 + n * (78 ±0)` + // Estimated: `6259 + n * (2553 ±0)` + // Minimum execution time: 21_002_000 picoseconds. + Weight::from_parts(22_620_068, 6259) + // Standard Error: 6_761 + .saturating_add(Weight::from_parts(3_676_180, 0).saturating_mul(n.into())) + .saturating_add(RocksDbWeight::get().reads(4_u64)) + .saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(n.into()))) + .saturating_add(RocksDbWeight::get().writes(5_u64)) + .saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(n.into()))) + .saturating_add(Weight::from_parts(0, 2553).saturating_mul(n.into())) } /// Storage: `RandomnessCollectiveFlip::RandomMaterial` (r:1 w:0) /// Proof: `RandomnessCollectiveFlip::RandomMaterial` (`max_values`: Some(1), `max_size`: Some(2594), added: 3089, mode: `Measured`) @@ -1576,8 +1588,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `76` // Estimated: `1561` - // Minimum execution time: 3_738_000 picoseconds. - Weight::from_parts(3_910_000, 1561) + // Minimum execution time: 3_622_000 picoseconds. + Weight::from_parts(3_809_000, 1561) .saturating_add(RocksDbWeight::get().reads(1_u64)) } /// Storage: `System::EventTopics` (r:4 w:4) @@ -1588,12 +1600,12 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `0` // Estimated: `990 + t * (2475 ±0)` - // Minimum execution time: 4_066_000 picoseconds. - Weight::from_parts(4_465_496, 990) - // Standard Error: 7_195 - .saturating_add(Weight::from_parts(2_349_432, 0).saturating_mul(t.into())) + // Minimum execution time: 4_029_000 picoseconds. + Weight::from_parts(4_444_994, 990) + // Standard Error: 7_216 + .saturating_add(Weight::from_parts(2_404_769, 0).saturating_mul(t.into())) // Standard Error: 2 - .saturating_add(Weight::from_parts(19, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(16, 0).saturating_mul(n.into())) .saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(t.into()))) .saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(t.into()))) .saturating_add(Weight::from_parts(0, 2475).saturating_mul(t.into())) @@ -1603,10 +1615,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 457_000 picoseconds. - Weight::from_parts(483_000, 0) + // Minimum execution time: 407_000 picoseconds. + Weight::from_parts(430_000, 0) // Standard Error: 10 - .saturating_add(Weight::from_parts(1_202, 0).saturating_mul(i.into())) + .saturating_add(Weight::from_parts(1_271, 0).saturating_mul(i.into())) } /// Storage: `Skipped::Metadata` (r:0 w:0) /// Proof: `Skipped::Metadata` (`max_values`: None, `max_size`: None, mode: `Measured`) @@ -1616,12 +1628,12 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `250 + o * (1 ±0)` // Estimated: `249 + o * (1 ±0)` - // Minimum execution time: 9_784_000 picoseconds. - Weight::from_parts(9_860_281, 249) + // Minimum execution time: 9_907_000 picoseconds. + Weight::from_parts(9_926_136, 249) // Standard Error: 1 - .saturating_add(Weight::from_parts(242, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(334, 0).saturating_mul(n.into())) // Standard Error: 1 - .saturating_add(Weight::from_parts(62, 0).saturating_mul(o.into())) + .saturating_add(Weight::from_parts(56, 0).saturating_mul(o.into())) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(o.into())) @@ -1633,10 +1645,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `248 + n * (1 ±0)` // Estimated: `248 + n * (1 ±0)` - // Minimum execution time: 7_785_000 picoseconds. - Weight::from_parts(9_260_270, 248) + // Minimum execution time: 8_288_000 picoseconds. + Weight::from_parts(9_347_243, 248) // Standard Error: 2 - .saturating_add(Weight::from_parts(83, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(81, 0).saturating_mul(n.into())) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) @@ -1648,10 +1660,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `248 + n * (1 ±0)` // Estimated: `248 + n * (1 ±0)` - // Minimum execution time: 7_004_000 picoseconds. - Weight::from_parts(8_830_936, 248) + // Minimum execution time: 7_180_000 picoseconds. + Weight::from_parts(9_058_388, 248) // Standard Error: 3 - .saturating_add(Weight::from_parts(614, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(701, 0).saturating_mul(n.into())) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) } @@ -1662,10 +1674,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `248 + n * (1 ±0)` // Estimated: `248 + n * (1 ±0)` - // Minimum execution time: 6_766_000 picoseconds. - Weight::from_parts(7_955_845, 248) + // Minimum execution time: 6_868_000 picoseconds. + Weight::from_parts(8_056_732, 248) // Standard Error: 2 - .saturating_add(Weight::from_parts(86, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(81, 0).saturating_mul(n.into())) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) } @@ -1676,10 +1688,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `248 + n * (1 ±0)` // Estimated: `248 + n * (1 ±0)` - // Minimum execution time: 8_425_000 picoseconds. - Weight::from_parts(10_053_859, 248) - // Standard Error: 3 - .saturating_add(Weight::from_parts(605, 0).saturating_mul(n.into())) + // Minimum execution time: 8_601_000 picoseconds. + Weight::from_parts(10_124_367, 248) + // Standard Error: 2 + .saturating_add(Weight::from_parts(701, 0).saturating_mul(n.into())) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) @@ -1688,8 +1700,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `140` // Estimated: `0` - // Minimum execution time: 9_089_000 picoseconds. - Weight::from_parts(9_472_000, 0) + // Minimum execution time: 9_242_000 picoseconds. + Weight::from_parts(9_557_000, 0) } /// Storage: `Contracts::ContractInfoOf` (r:1 w:1) /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) @@ -1708,14 +1720,14 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `620 + t * (280 ±0)` // Estimated: `6560 + t * (2182 ±0)` - // Minimum execution time: 158_642_000 picoseconds. - Weight::from_parts(159_204_537, 6560) - // Standard Error: 312_560 - .saturating_add(Weight::from_parts(43_721_097, 0).saturating_mul(t.into())) - // Standard Error: 312_560 - .saturating_add(Weight::from_parts(1_118_806, 0).saturating_mul(c.into())) + // Minimum execution time: 161_170_000 picoseconds. + Weight::from_parts(165_269_982, 6560) + // Standard Error: 327_855 + .saturating_add(Weight::from_parts(42_589_388, 0).saturating_mul(t.into())) + // Standard Error: 327_855 + .saturating_add(Weight::from_parts(1_482_035, 0).saturating_mul(c.into())) // Standard Error: 0 - .saturating_add(Weight::from_parts(8, 0).saturating_mul(i.into())) + .saturating_add(Weight::from_parts(7, 0).saturating_mul(i.into())) .saturating_add(RocksDbWeight::get().reads(5_u64)) .saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(t.into()))) .saturating_add(RocksDbWeight::get().writes(3_u64)) @@ -1732,8 +1744,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `430` // Estimated: `6370` - // Minimum execution time: 145_817_000 picoseconds. - Weight::from_parts(152_499_000, 6370) + // Minimum execution time: 149_765_000 picoseconds. + Weight::from_parts(159_745_000, 6370) .saturating_add(RocksDbWeight::get().reads(4_u64)) .saturating_add(RocksDbWeight::get().writes(2_u64)) } @@ -1756,14 +1768,14 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `676 + t * (102 ±0)` // Estimated: `6613 + t * (90 ±1)` - // Minimum execution time: 1_654_022_000 picoseconds. - Weight::from_parts(34_582_395, 6613) - // Standard Error: 8_789_446 - .saturating_add(Weight::from_parts(213_375_982, 0).saturating_mul(t.into())) - // Standard Error: 14 - .saturating_add(Weight::from_parts(1_362, 0).saturating_mul(i.into())) - // Standard Error: 14 - .saturating_add(Weight::from_parts(1_703, 0).saturating_mul(s.into())) + // Minimum execution time: 1_807_196_000 picoseconds. + Weight::from_parts(83_888_679, 6613) + // Standard Error: 6_713_052 + .saturating_add(Weight::from_parts(184_318_405, 0).saturating_mul(t.into())) + // Standard Error: 10 + .saturating_add(Weight::from_parts(1_532, 0).saturating_mul(i.into())) + // Standard Error: 10 + .saturating_add(Weight::from_parts(1_796, 0).saturating_mul(s.into())) .saturating_add(RocksDbWeight::get().reads(8_u64)) .saturating_add(RocksDbWeight::get().writes(6_u64)) .saturating_add(Weight::from_parts(0, 90).saturating_mul(t.into())) @@ -1773,64 +1785,64 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 861_000 picoseconds. - Weight::from_parts(909_000, 0) + // Minimum execution time: 850_000 picoseconds. + Weight::from_parts(927_000, 0) // Standard Error: 0 - .saturating_add(Weight::from_parts(1_050, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(1_146, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 1048576]`. fn seal_hash_keccak_256(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_344_000 picoseconds. - Weight::from_parts(1_378_000, 0) + // Minimum execution time: 1_318_000 picoseconds. + Weight::from_parts(1_404_000, 0) // Standard Error: 0 - .saturating_add(Weight::from_parts(3_314, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(3_405, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 1048576]`. fn seal_hash_blake2_256(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 764_000 picoseconds. - Weight::from_parts(777_000, 0) + // Minimum execution time: 709_000 picoseconds. + Weight::from_parts(736_000, 0) // Standard Error: 0 - .saturating_add(Weight::from_parts(1_185, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(1_282, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 1048576]`. fn seal_hash_blake2_128(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 753_000 picoseconds. - Weight::from_parts(767_000, 0) + // Minimum execution time: 707_000 picoseconds. + Weight::from_parts(748_000, 0) // Standard Error: 0 - .saturating_add(Weight::from_parts(1_190, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(1_280, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 125697]`. fn seal_sr25519_verify(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 43_241_000 picoseconds. - Weight::from_parts(48_851_058, 0) - // Standard Error: 12 - .saturating_add(Weight::from_parts(4_453, 0).saturating_mul(n.into())) + // Minimum execution time: 43_289_000 picoseconds. + Weight::from_parts(47_063_362, 0) + // Standard Error: 11 + .saturating_add(Weight::from_parts(4_544, 0).saturating_mul(n.into())) } fn seal_ecdsa_recover() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 47_013_000 picoseconds. - Weight::from_parts(49_080_000, 0) + // Minimum execution time: 46_432_000 picoseconds. + Weight::from_parts(48_334_000, 0) } fn seal_ecdsa_to_eth_address() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 12_861_000 picoseconds. - Weight::from_parts(13_006_000, 0) + // Minimum execution time: 12_812_000 picoseconds. + Weight::from_parts(13_019_000, 0) } /// Storage: `Contracts::CodeInfoOf` (r:1 w:1) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) @@ -1842,8 +1854,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `430` // Estimated: `6370` - // Minimum execution time: 27_062_000 picoseconds. - Weight::from_parts(27_950_000, 6370) + // Minimum execution time: 27_336_000 picoseconds. + Weight::from_parts(28_146_000, 6370) .saturating_add(RocksDbWeight::get().reads(4_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) } @@ -1853,8 +1865,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `355` // Estimated: `3820` - // Minimum execution time: 9_225_000 picoseconds. - Weight::from_parts(9_644_000, 3820) + // Minimum execution time: 9_209_000 picoseconds. + Weight::from_parts(9_638_000, 3820) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -1864,8 +1876,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `355` // Estimated: `3558` - // Minimum execution time: 8_209_000 picoseconds. - Weight::from_parts(8_639_000, 3558) + // Minimum execution time: 8_161_000 picoseconds. + Weight::from_parts(8_449_000, 3558) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -1873,15 +1885,15 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 353_000 picoseconds. - Weight::from_parts(373_000, 0) + // Minimum execution time: 330_000 picoseconds. + Weight::from_parts(354_000, 0) } fn seal_account_reentrance_count() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 369_000 picoseconds. - Weight::from_parts(395_000, 0) + // Minimum execution time: 337_000 picoseconds. + Weight::from_parts(381_000, 0) } /// Storage: `Contracts::Nonce` (r:1 w:0) /// Proof: `Contracts::Nonce` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`) @@ -1889,8 +1901,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `219` // Estimated: `1704` - // Minimum execution time: 2_985_000 picoseconds. - Weight::from_parts(3_126_000, 1704) + // Minimum execution time: 2_975_000 picoseconds. + Weight::from_parts(3_147_000, 1704) .saturating_add(RocksDbWeight::get().reads(1_u64)) } /// The range of component `r` is `[0, 5000]`. @@ -1898,9 +1910,9 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_032_000 picoseconds. - Weight::from_parts(762_731, 0) - // Standard Error: 27 - .saturating_add(Weight::from_parts(15_049, 0).saturating_mul(r.into())) + // Minimum execution time: 863_000 picoseconds. + Weight::from_parts(439_219, 0) + // Standard Error: 17 + .saturating_add(Weight::from_parts(15_175, 0).saturating_mul(r.into())) } } From d235dfa864b7dc249b2cbdd8e588e268950b57ac Mon Sep 17 00:00:00 2001 From: pgherveou Date: Fri, 17 May 2024 14:18:03 +0200 Subject: [PATCH 26/34] Remove internal events --- substrate/frame/contracts/src/exec.rs | 52 ++++++++----------- substrate/frame/contracts/src/lib.rs | 24 +++++---- .../frame/contracts/src/storage/meter.rs | 30 +++++------ substrate/frame/contracts/src/wasm/mod.rs | 22 ++++---- 4 files changed, 58 insertions(+), 70 deletions(-) diff --git a/substrate/frame/contracts/src/exec.rs b/substrate/frame/contracts/src/exec.rs index 31cdadb4bb43..85aab56027a7 100644 --- a/substrate/frame/contracts/src/exec.rs +++ b/substrate/frame/contracts/src/exec.rs @@ -46,7 +46,7 @@ use sp_core::{ }; use sp_io::{crypto::secp256k1_ecdsa_recover_compressed, hashing::blake2_256}; use sp_runtime::{ - traits::{Convert, Dispatchable, Hash, Zero}, + traits::{Convert, Dispatchable, Zero}, DispatchError, }; use sp_std::{fmt::Debug, marker::PhantomData, mem, prelude::*, vec::Vec}; @@ -983,16 +983,16 @@ where let caller = self.caller().account_id()?.clone(); // Deposit an instantiation event. - Contracts::::deposit_event( - vec![T::Hashing::hash_of(&caller), T::Hashing::hash_of(account_id)], - Event::Instantiated { deployer: caller, contract: account_id.clone() }, - ); + Contracts::::deposit_event(Event::Instantiated { + deployer: caller, + contract: account_id.clone(), + }); }, (ExportedFunction::Call, Some(code_hash)) => { - Contracts::::deposit_event( - vec![T::Hashing::hash_of(account_id), T::Hashing::hash_of(&code_hash)], - Event::DelegateCalled { contract: account_id.clone(), code_hash }, - ); + Contracts::::deposit_event(Event::DelegateCalled { + contract: account_id.clone(), + code_hash, + }); }, (ExportedFunction::Call, None) => { // If a special limit was set for the sub-call, we enforce it here. @@ -1002,10 +1002,10 @@ where frame.nested_storage.enforce_subcall_limit(contract)?; let caller = self.caller(); - Contracts::::deposit_event( - vec![T::Hashing::hash_of(&caller), T::Hashing::hash_of(&account_id)], - Event::Called { caller: caller.clone(), contract: account_id.clone() }, - ); + Contracts::::deposit_event(Event::Called { + caller: caller.clone(), + contract: account_id.clone(), + }); }, } @@ -1324,13 +1324,10 @@ where .charge_deposit(frame.account_id.clone(), StorageDeposit::Refund(*deposit)); } - Contracts::::deposit_event( - vec![T::Hashing::hash_of(&frame.account_id), T::Hashing::hash_of(&beneficiary)], - Event::Terminated { - contract: frame.account_id.clone(), - beneficiary: beneficiary.clone(), - }, - ); + Contracts::::deposit_event(Event::Terminated { + contract: frame.account_id.clone(), + beneficiary: beneficiary.clone(), + }); Ok(()) } @@ -1422,7 +1419,7 @@ where } fn deposit_event(&mut self, topics: Vec, data: Vec) { - Contracts::::deposit_event( + Contracts::::deposit_indexed_event( topics, Event::ContractEmitted { contract: self.top_frame().account_id.clone(), data }, ); @@ -1527,14 +1524,11 @@ where Self::increment_refcount(hash)?; Self::decrement_refcount(prev_hash); - Contracts::::deposit_event( - vec![T::Hashing::hash_of(&frame.account_id), hash, prev_hash], - Event::ContractCodeUpdated { - contract: frame.account_id.clone(), - new_code_hash: hash, - old_code_hash: prev_hash, - }, - ); + Contracts::::deposit_event(Event::ContractCodeUpdated { + contract: frame.account_id.clone(), + new_code_hash: hash, + old_code_hash: prev_hash, + }); Ok(()) } diff --git a/substrate/frame/contracts/src/lib.rs b/substrate/frame/contracts/src/lib.rs index 3e87eb9f37ea..d20f3c15fb56 100644 --- a/substrate/frame/contracts/src/lib.rs +++ b/substrate/frame/contracts/src/lib.rs @@ -135,7 +135,7 @@ use frame_system::{ use scale_info::TypeInfo; use smallvec::Array; use sp_runtime::{ - traits::{Convert, Dispatchable, Hash, Saturating, StaticLookup, Zero}, + traits::{Convert, Dispatchable, Saturating, StaticLookup, Zero}, DispatchError, RuntimeDebug, }; use sp_std::{fmt::Debug, prelude::*}; @@ -833,14 +833,11 @@ pub mod pallet { }; >>::increment_refcount(code_hash)?; >>::decrement_refcount(contract.code_hash); - Self::deposit_event( - vec![T::Hashing::hash_of(&dest), code_hash, contract.code_hash], - Event::ContractCodeUpdated { - contract: dest.clone(), - new_code_hash: code_hash, - old_code_hash: contract.code_hash, - }, - ); + Self::deposit_event(Event::ContractCodeUpdated { + contract: dest.clone(), + new_code_hash: code_hash, + old_code_hash: contract.code_hash, + }); contract.code_hash = code_hash; Ok(()) }) @@ -1827,8 +1824,13 @@ impl Pallet { Ok(()) } - /// Deposit a pallet contracts event. Handles the conversion to the overarching event type. - fn deposit_event(topics: Vec, event: Event) { + /// Deposit a pallet contracts event. + fn deposit_event(event: Event) { + >::deposit_event(::RuntimeEvent::from(event)) + } + + /// Deposit a pallet contracts indexed event. + fn deposit_indexed_event(topics: Vec, event: Event) { >::deposit_event_indexed( &topics, ::RuntimeEvent::from(event).into(), diff --git a/substrate/frame/contracts/src/storage/meter.rs b/substrate/frame/contracts/src/storage/meter.rs index 5db9a772ad82..7c55ce5d3f0c 100644 --- a/substrate/frame/contracts/src/storage/meter.rs +++ b/substrate/frame/contracts/src/storage/meter.rs @@ -34,10 +34,10 @@ use frame_support::{ DefaultNoBound, RuntimeDebugNoBound, }; use sp_runtime::{ - traits::{Hash as HashT, Saturating, Zero}, + traits::{Saturating, Zero}, DispatchError, FixedPointNumber, FixedU128, }; -use sp_std::{fmt::Debug, marker::PhantomData, vec, vec::Vec}; +use sp_std::{fmt::Debug, marker::PhantomData, vec::Vec}; /// Deposit that uses the native fungible's balance type. pub type DepositOf = Deposit>; @@ -551,14 +551,11 @@ impl Ext for ReservingExt { Fortitude::Polite, )?; - Pallet::::deposit_event( - vec![T::Hashing::hash_of(&origin), T::Hashing::hash_of(&contract)], - Event::StorageDepositTransferredAndHeld { - from: origin.clone(), - to: contract.clone(), - amount: *amount, - }, - ); + Pallet::::deposit_event(Event::StorageDepositTransferredAndHeld { + from: origin.clone(), + to: contract.clone(), + amount: *amount, + }); }, Deposit::Refund(amount) => { let transferred = T::Currency::transfer_on_hold( @@ -571,14 +568,11 @@ impl Ext for ReservingExt { Fortitude::Polite, )?; - Pallet::::deposit_event( - vec![T::Hashing::hash_of(&contract), T::Hashing::hash_of(&origin)], - Event::StorageDepositTransferredAndReleased { - from: contract.clone(), - to: origin.clone(), - amount: transferred, - }, - ); + Pallet::::deposit_event(Event::StorageDepositTransferredAndReleased { + from: contract.clone(), + to: origin.clone(), + amount: transferred, + }); if transferred < *amount { // This should never happen, if it does it means that there is a bug in the diff --git a/substrate/frame/contracts/src/wasm/mod.rs b/substrate/frame/contracts/src/wasm/mod.rs index 8d7f928dba33..b40eb699db9e 100644 --- a/substrate/frame/contracts/src/wasm/mod.rs +++ b/substrate/frame/contracts/src/wasm/mod.rs @@ -184,10 +184,11 @@ impl WasmBlob { *existing = None; >::remove(&code_hash); - >::deposit_event( - vec![code_hash], - Event::CodeRemoved { code_hash, deposit_released, remover }, - ); + >::deposit_event(Event::CodeRemoved { + code_hash, + deposit_released, + remover, + }); Ok(()) } else { Err(>::CodeNotFound.into()) @@ -271,14 +272,11 @@ impl WasmBlob { self.code_info.refcount = 0; >::insert(code_hash, &self.code); *stored_code_info = Some(self.code_info.clone()); - >::deposit_event( - vec![code_hash], - Event::CodeStored { - code_hash, - deposit_held: deposit, - uploader: self.code_info.owner.clone(), - }, - ); + >::deposit_event(Event::CodeStored { + code_hash, + deposit_held: deposit, + uploader: self.code_info.owner.clone(), + }); Ok(deposit) }, } From 7ae8ac1dcbf81461dee71e0844e95a36158999b6 Mon Sep 17 00:00:00 2001 From: pgherveou Date: Fri, 17 May 2024 15:06:07 +0200 Subject: [PATCH 27/34] Add prdoc --- prdoc/pr_4510.prdoc | 13 +++++++++++++ 1 file changed, 13 insertions(+) create mode 100644 prdoc/pr_4510.prdoc diff --git a/prdoc/pr_4510.prdoc b/prdoc/pr_4510.prdoc new file mode 100644 index 000000000000..fbd9bf961fe9 --- /dev/null +++ b/prdoc/pr_4510.prdoc @@ -0,0 +1,13 @@ +title: "[Contracts] Remove internal topic index" + +doc: + - audience: Runtime Dev + description: | + This PR removes topics from internal events emitted by pallet_contracts. It does not touch the `deposit_event` host function used by + smart contracts that can still include topics. + Event topics incurs significant Storage costs, and are only used by light clients to index events and avoid downloading the entire block. + They are not used by Dapp or Indexers that download the whole block anyway. + +crates: + - name: pallet-contracts + bump: patch From 737e95694ae9e5d4ba7e515092158f10288d3000 Mon Sep 17 00:00:00 2001 From: PG Herveou Date: Fri, 17 May 2024 15:23:16 +0200 Subject: [PATCH 28/34] Fix tests --- substrate/frame/contracts/src/exec.rs | 6 +- substrate/frame/contracts/src/tests.rs | 78 +++++++++++--------------- 2 files changed, 36 insertions(+), 48 deletions(-) diff --git a/substrate/frame/contracts/src/exec.rs b/substrate/frame/contracts/src/exec.rs index 85aab56027a7..21ebb1e8c5f3 100644 --- a/substrate/frame/contracts/src/exec.rs +++ b/substrate/frame/contracts/src/exec.rs @@ -1633,7 +1633,7 @@ mod tests { exec::ExportedFunction::*, gas::GasMeter, tests::{ - test_utils::{get_balance, hash, place_contract, set_balance}, + test_utils::{get_balance, place_contract, set_balance}, ExtBuilder, RuntimeCall, RuntimeEvent as MetaEvent, Test, TestFilter, ALICE, BOB, CHARLIE, GAS_LIMIT, }, @@ -3158,7 +3158,7 @@ mod tests { caller: Origin::from_account_id(ALICE), contract: BOB, }), - topics: vec![hash(&Origin::::from_account_id(ALICE)), hash(&BOB)], + topics: vec![], }, ] ); @@ -3258,7 +3258,7 @@ mod tests { caller: Origin::from_account_id(ALICE), contract: BOB, }), - topics: vec![hash(&Origin::::from_account_id(ALICE)), hash(&BOB)], + topics: vec![], }, ] ); diff --git a/substrate/frame/contracts/src/tests.rs b/substrate/frame/contracts/src/tests.rs index 8fe845fcf0f8..251c037d317d 100644 --- a/substrate/frame/contracts/src/tests.rs +++ b/substrate/frame/contracts/src/tests.rs @@ -20,13 +20,13 @@ mod test_debug; use self::{ test_debug::TestDebug, - test_utils::{ensure_stored, expected_deposit, hash}, + test_utils::{ensure_stored, expected_deposit}, }; use crate::{ self as pallet_contracts, chain_extension::{ ChainExtension, Environment, Ext, InitState, RegisteredChainExtension, - Result as ExtensionResult, RetVal, ReturnFlags, SysConfig, + Result as ExtensionResult, RetVal, ReturnFlags, }, exec::{Frame, Key}, migration::codegen::LATEST_MIGRATION_VERSION, @@ -63,7 +63,7 @@ use sp_io::hashing::blake2_256; use sp_keystore::{testing::MemoryKeystore, KeystoreExt}; use sp_runtime::{ testing::H256, - traits::{BlakeTwo256, Convert, Hash, IdentityLookup}, + traits::{BlakeTwo256, Convert, IdentityLookup}, AccountId32, BuildStorage, DispatchError, Perbill, TokenError, }; @@ -97,7 +97,7 @@ macro_rules! assert_refcount { } pub mod test_utils { - use super::{Contracts, DepositPerByte, DepositPerItem, Hash, SysConfig, Test}; + use super::{Contracts, DepositPerByte, DepositPerItem, Test}; use crate::{ exec::AccountIdOf, BalanceOf, CodeHash, CodeInfo, CodeInfoOf, Config, ContractInfo, ContractInfoOf, Nonce, PristineCode, @@ -145,9 +145,6 @@ pub mod test_utils { .saturating_mul(info_size) .saturating_add(DepositPerItem::get()) } - pub fn hash(s: &S) -> <::Hashing as Hash>::Output { - <::Hashing as Hash>::hash_of(s) - } pub fn expected_deposit(code_len: usize) -> u64 { // For code_info, the deposit for max_encoded_len is taken. let code_info_len = CodeInfo::::max_encoded_len() as u64; @@ -768,7 +765,7 @@ fn instantiate_and_call_and_deposit_event() { deployer: ALICE, contract: addr.clone() }), - topics: vec![hash(&ALICE), hash(&addr)], + topics: vec![], }, EventRecord { phase: Phase::Initialization, @@ -779,7 +776,7 @@ fn instantiate_and_call_and_deposit_event() { amount: test_utils::contract_info_storage_deposit(&addr), } ), - topics: vec![hash(&ALICE), hash(&addr)], + topics: vec![], }, ] ); @@ -1039,7 +1036,7 @@ fn deploy_and_call_other_contract() { deployer: caller_addr.clone(), contract: callee_addr.clone(), }), - topics: vec![hash(&caller_addr), hash(&callee_addr)], + topics: vec![], }, EventRecord { phase: Phase::Initialization, @@ -1056,10 +1053,7 @@ fn deploy_and_call_other_contract() { caller: Origin::from_account_id(caller_addr.clone()), contract: callee_addr.clone(), }), - topics: vec![ - hash(&Origin::::from_account_id(caller_addr.clone())), - hash(&callee_addr) - ], + topics: vec![], }, EventRecord { phase: Phase::Initialization, @@ -1067,7 +1061,7 @@ fn deploy_and_call_other_contract() { caller: Origin::from_account_id(ALICE), contract: caller_addr.clone(), }), - topics: vec![hash(&Origin::::from_account_id(ALICE)), hash(&caller_addr)], + topics: vec![], }, EventRecord { phase: Phase::Initialization, @@ -1078,7 +1072,7 @@ fn deploy_and_call_other_contract() { amount: test_utils::contract_info_storage_deposit(&callee_addr), } ), - topics: vec![hash(&ALICE), hash(&callee_addr)], + topics: vec![], }, ] ); @@ -1304,7 +1298,7 @@ fn self_destruct_works() { contract: addr.clone(), beneficiary: DJANGO }), - topics: vec![hash(&addr), hash(&DJANGO)], + topics: vec![], }, EventRecord { phase: Phase::Initialization, @@ -1312,7 +1306,7 @@ fn self_destruct_works() { caller: Origin::from_account_id(ALICE), contract: addr.clone(), }), - topics: vec![hash(&Origin::::from_account_id(ALICE)), hash(&addr)], + topics: vec![], }, EventRecord { phase: Phase::Initialization, @@ -1323,7 +1317,7 @@ fn self_destruct_works() { amount: info_deposit, } ), - topics: vec![hash(&addr), hash(&ALICE)], + topics: vec![], }, EventRecord { phase: Phase::Initialization, @@ -2511,7 +2505,7 @@ fn upload_code_works() { deposit_held: deposit_expected, uploader: ALICE }), - topics: vec![code_hash], + topics: vec![], },] ); }); @@ -2599,7 +2593,7 @@ fn remove_code_works() { deposit_held: deposit_expected, uploader: ALICE }), - topics: vec![code_hash], + topics: vec![], }, EventRecord { phase: Phase::Initialization, @@ -2608,7 +2602,7 @@ fn remove_code_works() { deposit_released: deposit_expected, remover: ALICE }), - topics: vec![code_hash], + topics: vec![], }, ] ); @@ -2648,7 +2642,7 @@ fn remove_code_wrong_origin() { deposit_held: deposit_expected, uploader: ALICE }), - topics: vec![code_hash], + topics: vec![], },] ); }); @@ -2727,7 +2721,7 @@ fn instantiate_with_zero_balance_works() { deposit_held: deposit_expected, uploader: ALICE }), - topics: vec![code_hash], + topics: vec![], }, EventRecord { phase: Phase::Initialization, @@ -2759,7 +2753,7 @@ fn instantiate_with_zero_balance_works() { deployer: ALICE, contract: addr.clone(), }), - topics: vec![hash(&ALICE), hash(&addr)], + topics: vec![], }, EventRecord { phase: Phase::Initialization, @@ -2770,7 +2764,7 @@ fn instantiate_with_zero_balance_works() { amount: test_utils::contract_info_storage_deposit(&addr), } ), - topics: vec![hash(&ALICE), hash(&addr)], + topics: vec![], }, ] ); @@ -2812,7 +2806,7 @@ fn instantiate_with_below_existential_deposit_works() { deposit_held: deposit_expected, uploader: ALICE }), - topics: vec![code_hash], + topics: vec![], }, EventRecord { phase: Phase::Initialization, @@ -2853,7 +2847,7 @@ fn instantiate_with_below_existential_deposit_works() { deployer: ALICE, contract: addr.clone(), }), - topics: vec![hash(&ALICE), hash(&addr)], + topics: vec![], }, EventRecord { phase: Phase::Initialization, @@ -2864,7 +2858,7 @@ fn instantiate_with_below_existential_deposit_works() { amount: test_utils::contract_info_storage_deposit(&addr), } ), - topics: vec![hash(&ALICE), hash(&addr)], + topics: vec![], }, ] ); @@ -2925,7 +2919,7 @@ fn storage_deposit_works() { caller: Origin::from_account_id(ALICE), contract: addr.clone(), }), - topics: vec![hash(&Origin::::from_account_id(ALICE)), hash(&addr)], + topics: vec![], }, EventRecord { phase: Phase::Initialization, @@ -2936,7 +2930,7 @@ fn storage_deposit_works() { amount: charged0, } ), - topics: vec![hash(&ALICE), hash(&addr)], + topics: vec![], }, EventRecord { phase: Phase::Initialization, @@ -2944,7 +2938,7 @@ fn storage_deposit_works() { caller: Origin::from_account_id(ALICE), contract: addr.clone(), }), - topics: vec![hash(&Origin::::from_account_id(ALICE)), hash(&addr)], + topics: vec![], }, EventRecord { phase: Phase::Initialization, @@ -2955,7 +2949,7 @@ fn storage_deposit_works() { amount: charged1, } ), - topics: vec![hash(&ALICE), hash(&addr)], + topics: vec![], }, EventRecord { phase: Phase::Initialization, @@ -2963,7 +2957,7 @@ fn storage_deposit_works() { caller: Origin::from_account_id(ALICE), contract: addr.clone(), }), - topics: vec![hash(&Origin::::from_account_id(ALICE)), hash(&addr)], + topics: vec![], }, EventRecord { phase: Phase::Initialization, @@ -2974,7 +2968,7 @@ fn storage_deposit_works() { amount: refunded0, } ), - topics: vec![hash(&addr.clone()), hash(&ALICE)], + topics: vec![], }, ] ); @@ -3078,7 +3072,7 @@ fn set_code_extrinsic() { new_code_hash, old_code_hash: code_hash, }), - topics: vec![hash(&addr), new_code_hash, code_hash], + topics: vec![], },] ); }); @@ -3230,7 +3224,7 @@ fn set_code_hash() { new_code_hash, old_code_hash: code_hash, }), - topics: vec![hash(&contract_addr), new_code_hash, code_hash], + topics: vec![], }, EventRecord { phase: Phase::Initialization, @@ -3238,10 +3232,7 @@ fn set_code_hash() { caller: Origin::from_account_id(ALICE), contract: contract_addr.clone(), }), - topics: vec![ - hash(&Origin::::from_account_id(ALICE)), - hash(&contract_addr) - ], + topics: vec![], }, EventRecord { phase: Phase::Initialization, @@ -3249,10 +3240,7 @@ fn set_code_hash() { caller: Origin::from_account_id(ALICE), contract: contract_addr.clone(), }), - topics: vec![ - hash(&Origin::::from_account_id(ALICE)), - hash(&contract_addr) - ], + topics: vec![], }, ], ); From 2f34c0fda6ef68141b8df8657586975c2c2d62be Mon Sep 17 00:00:00 2001 From: pgherveou Date: Fri, 17 May 2024 16:21:04 +0200 Subject: [PATCH 29/34] use whitelisted root contract origin for cross contract benchmarks --- substrate/frame/contracts/src/benchmarking/mod.rs | 13 +++++++++++-- 1 file changed, 11 insertions(+), 2 deletions(-) diff --git a/substrate/frame/contracts/src/benchmarking/mod.rs b/substrate/frame/contracts/src/benchmarking/mod.rs index e930bad1dcce..4797e851faa1 100644 --- a/substrate/frame/contracts/src/benchmarking/mod.rs +++ b/substrate/frame/contracts/src/benchmarking/mod.rs @@ -1219,8 +1219,9 @@ mod benchmarks { let mut setup = CallSetup::::default(); setup.set_storage_deposit_limit(deposit); - setup.set_data(vec![42; i as usize]); + setup.set_origin(Origin::from_account_id(setup.contract().account_id.clone())); + let (mut ext, _) = setup.ext(); let mut runtime = crate::wasm::Runtime::new(&mut ext, vec![]); let mut memory = memory!(callee_bytes, deposit_bytes, value_bytes,); @@ -1252,7 +1253,13 @@ mod benchmarks { #[benchmark(pov_mode = Measured)] fn seal_delegate_call() -> Result<(), BenchmarkError> { let hash = Contract::::with_index(1, WasmModule::dummy(), vec![])?.info()?.code_hash; - build_runtime!(runtime, memory: [hash.encode(), ]); + + let mut setup = CallSetup::::default(); + setup.set_origin(Origin::from_account_id(setup.contract().account_id.clone())); + + let (mut ext, _) = setup.ext(); + let mut runtime = crate::wasm::Runtime::new(&mut ext, vec![]); + let mut memory = memory!(hash.encode(),); let result; #[block] @@ -1295,7 +1302,9 @@ mod benchmarks { let deposit_len = deposit_bytes.len() as u32; let mut setup = CallSetup::::default(); + setup.set_origin(Origin::from_account_id(setup.contract().account_id.clone())); setup.set_balance(value + (Pallet::::min_balance() * 2u32.into())); + let account_id = &setup.contract().account_id.clone(); let (mut ext, _) = setup.ext(); let mut runtime = crate::wasm::Runtime::new(&mut ext, vec![]); From 2926901b04decc4006baaa5e8af1de447415802f Mon Sep 17 00:00:00 2001 From: command-bot <> Date: Fri, 17 May 2024 15:23:40 +0000 Subject: [PATCH 30/34] ".git/.scripts/commands/bench/bench.sh" --subcommand=pallet --runtime=dev --target_dir=substrate --pallet=pallet_contracts --- substrate/frame/contracts/src/weights.rs | 960 +++++++++++------------ 1 file changed, 452 insertions(+), 508 deletions(-) diff --git a/substrate/frame/contracts/src/weights.rs b/substrate/frame/contracts/src/weights.rs index 638883eae9d3..35dddc052aba 100644 --- a/substrate/frame/contracts/src/weights.rs +++ b/substrate/frame/contracts/src/weights.rs @@ -127,8 +127,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `142` // Estimated: `1627` - // Minimum execution time: 2_094_000 picoseconds. - Weight::from_parts(2_238_000, 1627) + // Minimum execution time: 2_024_000 picoseconds. + Weight::from_parts(2_252_000, 1627) .saturating_add(T::DbWeight::get().reads(1_u64)) } /// Storage: `Skipped::Metadata` (r:0 w:0) @@ -138,10 +138,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `452 + k * (69 ±0)` // Estimated: `442 + k * (70 ±0)` - // Minimum execution time: 12_226_000 picoseconds. - Weight::from_parts(12_508_000, 442) - // Standard Error: 1_454 - .saturating_add(Weight::from_parts(1_124_285, 0).saturating_mul(k.into())) + // Minimum execution time: 12_431_000 picoseconds. + Weight::from_parts(12_776_000, 442) + // Standard Error: 1_067 + .saturating_add(Weight::from_parts(1_151_178, 0).saturating_mul(k.into())) .saturating_add(T::DbWeight::get().reads(2_u64)) .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(k.into()))) .saturating_add(T::DbWeight::get().writes(2_u64)) @@ -155,10 +155,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `211 + c * (1 ±0)` // Estimated: `6149 + c * (1 ±0)` - // Minimum execution time: 8_644_000 picoseconds. - Weight::from_parts(9_027_360, 6149) + // Minimum execution time: 8_449_000 picoseconds. + Weight::from_parts(8_973_080, 6149) // Standard Error: 1 - .saturating_add(Weight::from_parts(1_209, 0).saturating_mul(c.into())) + .saturating_add(Weight::from_parts(1_159, 0).saturating_mul(c.into())) .saturating_add(T::DbWeight::get().reads(2_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(c.into())) @@ -171,8 +171,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `510` // Estimated: `6450` - // Minimum execution time: 16_756_000 picoseconds. - Weight::from_parts(17_643_000, 6450) + // Minimum execution time: 16_720_000 picoseconds. + Weight::from_parts(17_514_000, 6450) .saturating_add(T::DbWeight::get().reads(3_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -185,10 +185,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `171 + k * (1 ±0)` // Estimated: `3635 + k * (1 ±0)` - // Minimum execution time: 3_444_000 picoseconds. - Weight::from_parts(3_583_000, 3635) - // Standard Error: 777 - .saturating_add(Weight::from_parts(1_222_839, 0).saturating_mul(k.into())) + // Minimum execution time: 3_540_000 picoseconds. + Weight::from_parts(40_895, 3635) + // Standard Error: 1_472 + .saturating_add(Weight::from_parts(1_232_021, 0).saturating_mul(k.into())) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(2_u64)) .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(k.into()))) @@ -207,10 +207,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `325 + c * (1 ±0)` // Estimated: `6263 + c * (1 ±0)` - // Minimum execution time: 16_786_000 picoseconds. - Weight::from_parts(17_044_074, 6263) - // Standard Error: 0 - .saturating_add(Weight::from_parts(463, 0).saturating_mul(c.into())) + // Minimum execution time: 16_770_000 picoseconds. + Weight::from_parts(16_902_655, 6263) + // Standard Error: 1 + .saturating_add(Weight::from_parts(377, 0).saturating_mul(c.into())) .saturating_add(T::DbWeight::get().reads(4_u64)) .saturating_add(T::DbWeight::get().writes(2_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(c.into())) @@ -221,8 +221,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `440` // Estimated: `6380` - // Minimum execution time: 12_921_000 picoseconds. - Weight::from_parts(13_391_000, 6380) + // Minimum execution time: 12_617_000 picoseconds. + Weight::from_parts(13_253_000, 6380) .saturating_add(T::DbWeight::get().reads(2_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -236,8 +236,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `352` // Estimated: `6292` - // Minimum execution time: 47_556_000 picoseconds. - Weight::from_parts(49_386_000, 6292) + // Minimum execution time: 47_835_000 picoseconds. + Weight::from_parts(49_254_000, 6292) .saturating_add(T::DbWeight::get().reads(4_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -249,8 +249,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `594` // Estimated: `6534` - // Minimum execution time: 54_956_000 picoseconds. - Weight::from_parts(57_387_000, 6534) + // Minimum execution time: 55_489_000 picoseconds. + Weight::from_parts(57_136_000, 6534) .saturating_add(T::DbWeight::get().reads(4_u64)) .saturating_add(T::DbWeight::get().writes(2_u64)) } @@ -260,8 +260,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `409` // Estimated: `6349` - // Minimum execution time: 12_196_000 picoseconds. - Weight::from_parts(12_747_000, 6349) + // Minimum execution time: 11_795_000 picoseconds. + Weight::from_parts(12_655_000, 6349) .saturating_add(T::DbWeight::get().reads(2_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -271,8 +271,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `142` // Estimated: `1627` - // Minimum execution time: 2_500_000 picoseconds. - Weight::from_parts(2_572_000, 1627) + // Minimum execution time: 2_448_000 picoseconds. + Weight::from_parts(2_608_000, 1627) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -284,8 +284,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `166` // Estimated: `3631` - // Minimum execution time: 12_297_000 picoseconds. - Weight::from_parts(12_552_000, 3631) + // Minimum execution time: 12_208_000 picoseconds. + Weight::from_parts(12_653_000, 3631) .saturating_add(T::DbWeight::get().reads(2_u64)) .saturating_add(T::DbWeight::get().writes(2_u64)) } @@ -295,8 +295,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `142` // Estimated: `3607` - // Minimum execution time: 4_745_000 picoseconds. - Weight::from_parts(5_049_000, 3607) + // Minimum execution time: 4_830_000 picoseconds. + Weight::from_parts(5_026_000, 3607) .saturating_add(T::DbWeight::get().reads(1_u64)) } /// Storage: UNKNOWN KEY `0x4342193e496fab7ec59d615ed0dc55304e7b9012096b41c4eb3aaf947f6ea429` (r:1 w:0) @@ -307,8 +307,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `167` // Estimated: `3632` - // Minimum execution time: 6_293_000 picoseconds. - Weight::from_parts(6_465_000, 3632) + // Minimum execution time: 6_178_000 picoseconds. + Weight::from_parts(6_485_000, 3632) .saturating_add(T::DbWeight::get().reads(2_u64)) } /// Storage: UNKNOWN KEY `0x4342193e496fab7ec59d615ed0dc55304e7b9012096b41c4eb3aaf947f6ea429` (r:1 w:0) @@ -319,8 +319,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `142` // Estimated: `3607` - // Minimum execution time: 6_378_000 picoseconds. - Weight::from_parts(6_874_000, 3607) + // Minimum execution time: 6_203_000 picoseconds. + Weight::from_parts(6_533_000, 3607) .saturating_add(T::DbWeight::get().reads(2_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -336,19 +336,17 @@ impl WeightInfo for SubstrateWeight { /// Proof: `Timestamp::Now` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`) /// Storage: `System::Account` (r:1 w:1) /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`) - /// Storage: `System::EventTopics` (r:2 w:2) - /// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`) /// The range of component `c` is `[0, 125952]`. fn call_with_code_per_byte(c: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `801 + c * (1 ±0)` - // Estimated: `6739 + c * (1 ±0)` - // Minimum execution time: 362_366_000 picoseconds. - Weight::from_parts(353_347_662, 6739) - // Standard Error: 129 - .saturating_add(Weight::from_parts(34_964, 0).saturating_mul(c.into())) - .saturating_add(T::DbWeight::get().reads(8_u64)) - .saturating_add(T::DbWeight::get().writes(4_u64)) + // Estimated: `4264 + c * (1 ±0)` + // Minimum execution time: 290_448_000 picoseconds. + Weight::from_parts(274_301_376, 4264) + // Standard Error: 64 + .saturating_add(Weight::from_parts(32_946, 0).saturating_mul(c.into())) + .saturating_add(T::DbWeight::get().reads(6_u64)) + .saturating_add(T::DbWeight::get().writes(2_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(c.into())) } /// Storage: `Contracts::MigrationInProgress` (r:1 w:0) @@ -357,8 +355,6 @@ impl WeightInfo for SubstrateWeight { /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Balances::Holds` (r:2 w:2) /// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(193), added: 2668, mode: `Measured`) - /// Storage: `System::EventTopics` (r:3 w:3) - /// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `Contracts::Nonce` (r:1 w:1) /// Proof: `Contracts::Nonce` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`) /// Storage: `Contracts::ContractInfoOf` (r:1 w:1) @@ -375,17 +371,17 @@ impl WeightInfo for SubstrateWeight { fn instantiate_with_code(c: u32, i: u32, s: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `323` - // Estimated: `8737` - // Minimum execution time: 4_266_902_000 picoseconds. - Weight::from_parts(914_416_909, 8737) - // Standard Error: 123 - .saturating_add(Weight::from_parts(67_482, 0).saturating_mul(c.into())) - // Standard Error: 14 - .saturating_add(Weight::from_parts(1_659, 0).saturating_mul(i.into())) - // Standard Error: 14 - .saturating_add(Weight::from_parts(1_619, 0).saturating_mul(s.into())) - .saturating_add(T::DbWeight::get().reads(11_u64)) - .saturating_add(T::DbWeight::get().writes(10_u64)) + // Estimated: `6262` + // Minimum execution time: 3_777_124_000 picoseconds. + Weight::from_parts(858_828_640, 6262) + // Standard Error: 158 + .saturating_add(Weight::from_parts(67_299, 0).saturating_mul(c.into())) + // Standard Error: 19 + .saturating_add(Weight::from_parts(1_353, 0).saturating_mul(i.into())) + // Standard Error: 19 + .saturating_add(Weight::from_parts(1_580, 0).saturating_mul(s.into())) + .saturating_add(T::DbWeight::get().reads(8_u64)) + .saturating_add(T::DbWeight::get().writes(7_u64)) } /// Storage: `Contracts::MigrationInProgress` (r:1 w:0) /// Proof: `Contracts::MigrationInProgress` (`max_values`: Some(1), `max_size`: Some(1026), added: 1521, mode: `Measured`) @@ -401,8 +397,6 @@ impl WeightInfo for SubstrateWeight { /// Proof: `Timestamp::Now` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`) /// Storage: `System::Account` (r:1 w:1) /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`) - /// Storage: `System::EventTopics` (r:2 w:2) - /// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `Balances::Holds` (r:1 w:1) /// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(193), added: 2668, mode: `Measured`) /// The range of component `i` is `[0, 1048576]`. @@ -410,15 +404,15 @@ impl WeightInfo for SubstrateWeight { fn instantiate(i: u32, s: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `560` - // Estimated: `6504` - // Minimum execution time: 2_101_015_000 picoseconds. - Weight::from_parts(2_123_733_000, 6504) + // Estimated: `4029` + // Minimum execution time: 1_960_317_000 picoseconds. + Weight::from_parts(1_985_571_000, 4029) // Standard Error: 26 - .saturating_add(Weight::from_parts(895, 0).saturating_mul(i.into())) + .saturating_add(Weight::from_parts(849, 0).saturating_mul(i.into())) // Standard Error: 26 - .saturating_add(Weight::from_parts(805, 0).saturating_mul(s.into())) - .saturating_add(T::DbWeight::get().reads(10_u64)) - .saturating_add(T::DbWeight::get().writes(7_u64)) + .saturating_add(Weight::from_parts(813, 0).saturating_mul(s.into())) + .saturating_add(T::DbWeight::get().reads(8_u64)) + .saturating_add(T::DbWeight::get().writes(5_u64)) } /// Storage: `Contracts::MigrationInProgress` (r:1 w:0) /// Proof: `Contracts::MigrationInProgress` (`max_values`: Some(1), `max_size`: Some(1026), added: 1521, mode: `Measured`) @@ -432,16 +426,14 @@ impl WeightInfo for SubstrateWeight { /// Proof: `Timestamp::Now` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`) /// Storage: `System::Account` (r:1 w:1) /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`) - /// Storage: `System::EventTopics` (r:2 w:2) - /// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`) fn call() -> Weight { // Proof Size summary in bytes: // Measured: `826` - // Estimated: `6766` - // Minimum execution time: 205_788_000 picoseconds. - Weight::from_parts(210_371_000, 6766) - .saturating_add(T::DbWeight::get().reads(8_u64)) - .saturating_add(T::DbWeight::get().writes(4_u64)) + // Estimated: `4291` + // Minimum execution time: 195_828_000 picoseconds. + Weight::from_parts(203_985_000, 4291) + .saturating_add(T::DbWeight::get().reads(6_u64)) + .saturating_add(T::DbWeight::get().writes(2_u64)) } /// Storage: `Contracts::MigrationInProgress` (r:1 w:0) /// Proof: `Contracts::MigrationInProgress` (`max_values`: Some(1), `max_size`: Some(1026), added: 1521, mode: `Measured`) @@ -449,8 +441,6 @@ impl WeightInfo for SubstrateWeight { /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Balances::Holds` (r:1 w:1) /// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(193), added: 2668, mode: `Measured`) - /// Storage: `System::EventTopics` (r:1 w:1) - /// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:0 w:1) /// Proof: `Contracts::PristineCode` (`max_values`: None, `max_size`: Some(125988), added: 128463, mode: `Measured`) /// The range of component `c` is `[0, 125952]`. @@ -458,12 +448,12 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `142` // Estimated: `3607` - // Minimum execution time: 334_087_000 picoseconds. - Weight::from_parts(347_294_648, 3607) - // Standard Error: 75 - .saturating_add(Weight::from_parts(33_819, 0).saturating_mul(c.into())) - .saturating_add(T::DbWeight::get().reads(4_u64)) - .saturating_add(T::DbWeight::get().writes(4_u64)) + // Minimum execution time: 263_760_000 picoseconds. + Weight::from_parts(269_484_033, 3607) + // Standard Error: 54 + .saturating_add(Weight::from_parts(32_487, 0).saturating_mul(c.into())) + .saturating_add(T::DbWeight::get().reads(3_u64)) + .saturating_add(T::DbWeight::get().writes(3_u64)) } /// Storage: `Contracts::MigrationInProgress` (r:1 w:0) /// Proof: `Contracts::MigrationInProgress` (`max_values`: Some(1), `max_size`: Some(1026), added: 1521, mode: `Measured`) @@ -471,8 +461,6 @@ impl WeightInfo for SubstrateWeight { /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Balances::Holds` (r:1 w:1) /// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(193), added: 2668, mode: `Measured`) - /// Storage: `System::EventTopics` (r:1 w:1) - /// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:0 w:1) /// Proof: `Contracts::PristineCode` (`max_values`: None, `max_size`: Some(125988), added: 128463, mode: `Measured`) /// The range of component `c` is `[0, 125952]`. @@ -480,12 +468,12 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `142` // Estimated: `3607` - // Minimum execution time: 348_078_000 picoseconds. - Weight::from_parts(393_851_501, 3607) - // Standard Error: 62 - .saturating_add(Weight::from_parts(33_635, 0).saturating_mul(c.into())) - .saturating_add(T::DbWeight::get().reads(4_u64)) - .saturating_add(T::DbWeight::get().writes(4_u64)) + // Minimum execution time: 274_929_000 picoseconds. + Weight::from_parts(285_405_269, 3607) + // Standard Error: 52 + .saturating_add(Weight::from_parts(32_658, 0).saturating_mul(c.into())) + .saturating_add(T::DbWeight::get().reads(3_u64)) + .saturating_add(T::DbWeight::get().writes(3_u64)) } /// Storage: `Contracts::MigrationInProgress` (r:1 w:0) /// Proof: `Contracts::MigrationInProgress` (`max_values`: Some(1), `max_size`: Some(1026), added: 1521, mode: `Measured`) @@ -493,18 +481,16 @@ impl WeightInfo for SubstrateWeight { /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Balances::Holds` (r:1 w:1) /// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(193), added: 2668, mode: `Measured`) - /// Storage: `System::EventTopics` (r:1 w:1) - /// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:0 w:1) /// Proof: `Contracts::PristineCode` (`max_values`: None, `max_size`: Some(125988), added: 128463, mode: `Measured`) fn remove_code() -> Weight { // Proof Size summary in bytes: // Measured: `315` // Estimated: `3780` - // Minimum execution time: 45_294_000 picoseconds. - Weight::from_parts(46_148_000, 3780) - .saturating_add(T::DbWeight::get().reads(4_u64)) - .saturating_add(T::DbWeight::get().writes(4_u64)) + // Minimum execution time: 42_693_000 picoseconds. + Weight::from_parts(43_590_000, 3780) + .saturating_add(T::DbWeight::get().reads(3_u64)) + .saturating_add(T::DbWeight::get().writes(3_u64)) } /// Storage: `Contracts::MigrationInProgress` (r:1 w:0) /// Proof: `Contracts::MigrationInProgress` (`max_values`: Some(1), `max_size`: Some(1026), added: 1521, mode: `Measured`) @@ -512,33 +498,31 @@ impl WeightInfo for SubstrateWeight { /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:2 w:2) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) - /// Storage: `System::EventTopics` (r:3 w:3) - /// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`) fn set_code() -> Weight { // Proof Size summary in bytes: // Measured: `552` - // Estimated: `8967` - // Minimum execution time: 34_298_000 picoseconds. - Weight::from_parts(35_728_000, 8967) - .saturating_add(T::DbWeight::get().reads(7_u64)) - .saturating_add(T::DbWeight::get().writes(6_u64)) + // Estimated: `6492` + // Minimum execution time: 26_126_000 picoseconds. + Weight::from_parts(27_456_000, 6492) + .saturating_add(T::DbWeight::get().reads(4_u64)) + .saturating_add(T::DbWeight::get().writes(3_u64)) } /// The range of component `r` is `[0, 1600]`. fn noop_host_fn(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 9_347_000 picoseconds. - Weight::from_parts(10_917_661, 0) - // Standard Error: 142 - .saturating_add(Weight::from_parts(70_824, 0).saturating_mul(r.into())) + // Minimum execution time: 9_933_000 picoseconds. + Weight::from_parts(10_586_445, 0) + // Standard Error: 74 + .saturating_add(Weight::from_parts(73_229, 0).saturating_mul(r.into())) } fn seal_caller() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 600_000 picoseconds. - Weight::from_parts(650_000, 0) + // Minimum execution time: 621_000 picoseconds. + Weight::from_parts(667_000, 0) } /// Storage: `Contracts::ContractInfoOf` (r:1 w:0) /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) @@ -546,8 +530,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `354` // Estimated: `3819` - // Minimum execution time: 6_710_000 picoseconds. - Weight::from_parts(7_005_000, 3819) + // Minimum execution time: 6_594_000 picoseconds. + Weight::from_parts(6_855_000, 3819) .saturating_add(T::DbWeight::get().reads(1_u64)) } /// Storage: `Contracts::ContractInfoOf` (r:1 w:0) @@ -556,79 +540,79 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `447` // Estimated: `3912` - // Minimum execution time: 8_112_000 picoseconds. - Weight::from_parts(8_360_000, 3912) + // Minimum execution time: 7_893_000 picoseconds. + Weight::from_parts(8_172_000, 3912) .saturating_add(T::DbWeight::get().reads(1_u64)) } fn seal_own_code_hash() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 668_000 picoseconds. - Weight::from_parts(761_000, 0) + // Minimum execution time: 772_000 picoseconds. + Weight::from_parts(826_000, 0) } fn seal_caller_is_origin() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 385_000 picoseconds. - Weight::from_parts(425_000, 0) + // Minimum execution time: 409_000 picoseconds. + Weight::from_parts(431_000, 0) } fn seal_caller_is_root() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 312_000 picoseconds. - Weight::from_parts(354_000, 0) + // Minimum execution time: 333_000 picoseconds. + Weight::from_parts(360_000, 0) } fn seal_address() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 558_000 picoseconds. - Weight::from_parts(607_000, 0) + // Minimum execution time: 609_000 picoseconds. + Weight::from_parts(628_000, 0) } fn seal_gas_left() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 661_000 picoseconds. - Weight::from_parts(706_000, 0) + // Minimum execution time: 669_000 picoseconds. + Weight::from_parts(741_000, 0) } fn seal_balance() -> Weight { // Proof Size summary in bytes: // Measured: `140` // Estimated: `0` - // Minimum execution time: 4_693_000 picoseconds. - Weight::from_parts(4_872_000, 0) + // Minimum execution time: 4_778_000 picoseconds. + Weight::from_parts(4_985_000, 0) } fn seal_value_transferred() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 532_000 picoseconds. - Weight::from_parts(583_000, 0) + // Minimum execution time: 585_000 picoseconds. + Weight::from_parts(610_000, 0) } fn seal_minimum_balance() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 529_000 picoseconds. - Weight::from_parts(570_000, 0) + // Minimum execution time: 567_000 picoseconds. + Weight::from_parts(601_000, 0) } fn seal_block_number() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 557_000 picoseconds. - Weight::from_parts(597_000, 0) + // Minimum execution time: 592_000 picoseconds. + Weight::from_parts(627_000, 0) } fn seal_now() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 551_000 picoseconds. - Weight::from_parts(588_000, 0) + // Minimum execution time: 576_000 picoseconds. + Weight::from_parts(616_000, 0) } /// Storage: `TransactionPayment::NextFeeMultiplier` (r:1 w:0) /// Proof: `TransactionPayment::NextFeeMultiplier` (`max_values`: Some(1), `max_size`: Some(16), added: 511, mode: `Measured`) @@ -636,8 +620,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `67` // Estimated: `1552` - // Minimum execution time: 4_284_000 picoseconds. - Weight::from_parts(4_564_000, 1552) + // Minimum execution time: 4_477_000 picoseconds. + Weight::from_parts(4_706_000, 1552) .saturating_add(T::DbWeight::get().reads(1_u64)) } /// The range of component `n` is `[0, 1048572]`. @@ -645,41 +629,39 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 452_000 picoseconds. - Weight::from_parts(480_000, 0) + // Minimum execution time: 503_000 picoseconds. + Weight::from_parts(528_000, 0) // Standard Error: 3 - .saturating_add(Weight::from_parts(303, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(292, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 1048572]`. fn seal_return(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 322_000 picoseconds. - Weight::from_parts(349_000, 0) + // Minimum execution time: 333_000 picoseconds. + Weight::from_parts(371_000, 0) // Standard Error: 9 - .saturating_add(Weight::from_parts(480, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(398, 0).saturating_mul(n.into())) } /// Storage: `Contracts::DeletionQueueCounter` (r:1 w:1) /// Proof: `Contracts::DeletionQueueCounter` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:33 w:33) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) - /// Storage: `System::EventTopics` (r:2 w:2) - /// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `Contracts::DeletionQueue` (r:0 w:1) /// Proof: `Contracts::DeletionQueue` (`max_values`: None, `max_size`: Some(142), added: 2617, mode: `Measured`) /// The range of component `n` is `[0, 32]`. fn seal_terminate(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `319 + n * (78 ±0)` - // Estimated: `6259 + n * (2553 ±0)` - // Minimum execution time: 21_002_000 picoseconds. - Weight::from_parts(22_620_068, 6259) - // Standard Error: 6_761 - .saturating_add(Weight::from_parts(3_676_180, 0).saturating_mul(n.into())) - .saturating_add(T::DbWeight::get().reads(4_u64)) + // Estimated: `3784 + n * (2553 ±0)` + // Minimum execution time: 14_468_000 picoseconds. + Weight::from_parts(16_793_355, 3784) + // Standard Error: 8_365 + .saturating_add(Weight::from_parts(3_694_281, 0).saturating_mul(n.into())) + .saturating_add(T::DbWeight::get().reads(2_u64)) .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(n.into()))) - .saturating_add(T::DbWeight::get().writes(5_u64)) + .saturating_add(T::DbWeight::get().writes(3_u64)) .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(n.into()))) .saturating_add(Weight::from_parts(0, 2553).saturating_mul(n.into())) } @@ -689,8 +671,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `76` // Estimated: `1561` - // Minimum execution time: 3_622_000 picoseconds. - Weight::from_parts(3_809_000, 1561) + // Minimum execution time: 3_563_000 picoseconds. + Weight::from_parts(3_784_000, 1561) .saturating_add(T::DbWeight::get().reads(1_u64)) } /// Storage: `System::EventTopics` (r:4 w:4) @@ -701,12 +683,12 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `990 + t * (2475 ±0)` - // Minimum execution time: 4_029_000 picoseconds. - Weight::from_parts(4_444_994, 990) - // Standard Error: 7_216 - .saturating_add(Weight::from_parts(2_404_769, 0).saturating_mul(t.into())) + // Minimum execution time: 4_064_000 picoseconds. + Weight::from_parts(4_551_057, 990) + // Standard Error: 7_249 + .saturating_add(Weight::from_parts(2_342_414, 0).saturating_mul(t.into())) // Standard Error: 2 - .saturating_add(Weight::from_parts(16, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(9, 0).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(t.into()))) .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(t.into()))) .saturating_add(Weight::from_parts(0, 2475).saturating_mul(t.into())) @@ -716,10 +698,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 407_000 picoseconds. - Weight::from_parts(430_000, 0) + // Minimum execution time: 436_000 picoseconds. + Weight::from_parts(440_000, 0) // Standard Error: 10 - .saturating_add(Weight::from_parts(1_271, 0).saturating_mul(i.into())) + .saturating_add(Weight::from_parts(1_201, 0).saturating_mul(i.into())) } /// Storage: `Skipped::Metadata` (r:0 w:0) /// Proof: `Skipped::Metadata` (`max_values`: None, `max_size`: None, mode: `Measured`) @@ -729,12 +711,12 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `250 + o * (1 ±0)` // Estimated: `249 + o * (1 ±0)` - // Minimum execution time: 9_907_000 picoseconds. - Weight::from_parts(9_926_136, 249) + // Minimum execution time: 10_097_000 picoseconds. + Weight::from_parts(9_877_776, 249) // Standard Error: 1 - .saturating_add(Weight::from_parts(334, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(241, 0).saturating_mul(n.into())) // Standard Error: 1 - .saturating_add(Weight::from_parts(56, 0).saturating_mul(o.into())) + .saturating_add(Weight::from_parts(58, 0).saturating_mul(o.into())) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(o.into())) @@ -746,10 +728,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `248 + n * (1 ±0)` // Estimated: `248 + n * (1 ±0)` - // Minimum execution time: 8_288_000 picoseconds. - Weight::from_parts(9_347_243, 248) + // Minimum execution time: 8_068_000 picoseconds. + Weight::from_parts(9_298_830, 248) // Standard Error: 2 - .saturating_add(Weight::from_parts(81, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(77, 0).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) @@ -761,10 +743,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `248 + n * (1 ±0)` // Estimated: `248 + n * (1 ±0)` - // Minimum execution time: 7_180_000 picoseconds. - Weight::from_parts(9_058_388, 248) + // Minimum execution time: 7_315_000 picoseconds. + Weight::from_parts(9_026_712, 248) // Standard Error: 3 - .saturating_add(Weight::from_parts(701, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(595, 0).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) } @@ -775,10 +757,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `248 + n * (1 ±0)` // Estimated: `248 + n * (1 ±0)` - // Minimum execution time: 6_868_000 picoseconds. - Weight::from_parts(8_056_732, 248) + // Minimum execution time: 6_833_000 picoseconds. + Weight::from_parts(7_980_890, 248) // Standard Error: 2 - .saturating_add(Weight::from_parts(81, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(85, 0).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) } @@ -789,10 +771,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `248 + n * (1 ±0)` // Estimated: `248 + n * (1 ±0)` - // Minimum execution time: 8_601_000 picoseconds. - Weight::from_parts(10_124_367, 248) - // Standard Error: 2 - .saturating_add(Weight::from_parts(701, 0).saturating_mul(n.into())) + // Minimum execution time: 8_250_000 picoseconds. + Weight::from_parts(10_058_209, 248) + // Standard Error: 3 + .saturating_add(Weight::from_parts(607, 0).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) @@ -801,8 +783,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `140` // Estimated: `0` - // Minimum execution time: 9_242_000 picoseconds. - Weight::from_parts(9_557_000, 0) + // Minimum execution time: 8_858_000 picoseconds. + Weight::from_parts(9_238_000, 0) } /// Storage: `Contracts::ContractInfoOf` (r:1 w:1) /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) @@ -812,26 +794,24 @@ impl WeightInfo for SubstrateWeight { /// Proof: `Contracts::PristineCode` (`max_values`: None, `max_size`: Some(125988), added: 128463, mode: `Measured`) /// Storage: `System::Account` (r:1 w:1) /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`) - /// Storage: `System::EventTopics` (r:2 w:2) - /// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`) /// The range of component `t` is `[0, 1]`. /// The range of component `c` is `[0, 1]`. /// The range of component `i` is `[0, 1048576]`. fn seal_call(t: u32, c: u32, i: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `620 + t * (280 ±0)` - // Estimated: `6560 + t * (2182 ±0)` - // Minimum execution time: 161_170_000 picoseconds. - Weight::from_parts(165_269_982, 6560) - // Standard Error: 327_855 - .saturating_add(Weight::from_parts(42_589_388, 0).saturating_mul(t.into())) - // Standard Error: 327_855 - .saturating_add(Weight::from_parts(1_482_035, 0).saturating_mul(c.into())) + // Estimated: `4085 + t * (2182 ±0)` + // Minimum execution time: 153_417_000 picoseconds. + Weight::from_parts(154_858_902, 4085) + // Standard Error: 339_920 + .saturating_add(Weight::from_parts(45_327_013, 0).saturating_mul(t.into())) + // Standard Error: 339_920 + .saturating_add(Weight::from_parts(1_016_817, 0).saturating_mul(c.into())) // Standard Error: 0 .saturating_add(Weight::from_parts(7, 0).saturating_mul(i.into())) - .saturating_add(T::DbWeight::get().reads(5_u64)) + .saturating_add(T::DbWeight::get().reads(3_u64)) .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(t.into()))) - .saturating_add(T::DbWeight::get().writes(3_u64)) + .saturating_add(T::DbWeight::get().writes(1_u64)) .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(t.into()))) .saturating_add(Weight::from_parts(0, 2182).saturating_mul(t.into())) } @@ -839,16 +819,13 @@ impl WeightInfo for SubstrateWeight { /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1 w:0) /// Proof: `Contracts::PristineCode` (`max_values`: None, `max_size`: Some(125988), added: 128463, mode: `Measured`) - /// Storage: `System::EventTopics` (r:2 w:2) - /// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`) fn seal_delegate_call() -> Weight { // Proof Size summary in bytes: // Measured: `430` - // Estimated: `6370` - // Minimum execution time: 149_765_000 picoseconds. - Weight::from_parts(159_745_000, 6370) - .saturating_add(T::DbWeight::get().reads(4_u64)) - .saturating_add(T::DbWeight::get().writes(2_u64)) + // Estimated: `3895` + // Minimum execution time: 140_613_000 picoseconds. + Weight::from_parts(149_663_000, 3895) + .saturating_add(T::DbWeight::get().reads(2_u64)) } /// Storage: `Contracts::CodeInfoOf` (r:1 w:1) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) @@ -858,107 +835,102 @@ impl WeightInfo for SubstrateWeight { /// 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(1795), added: 4270, mode: `Measured`) - /// Storage: `System::Account` (r:2 w:2) + /// Storage: `System::Account` (r:1 w:1) /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`) - /// Storage: `System::EventTopics` (r:2 w:2) - /// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`) /// The range of component `t` is `[0, 1]`. /// The range of component `i` is `[0, 983040]`. /// The range of component `s` is `[0, 983040]`. fn seal_instantiate(t: u32, i: u32, s: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `676 + t * (102 ±0)` - // Estimated: `6613 + t * (90 ±1)` - // Minimum execution time: 1_807_196_000 picoseconds. - Weight::from_parts(83_888_679, 6613) - // Standard Error: 6_713_052 - .saturating_add(Weight::from_parts(184_318_405, 0).saturating_mul(t.into())) - // Standard Error: 10 - .saturating_add(Weight::from_parts(1_532, 0).saturating_mul(i.into())) - // Standard Error: 10 - .saturating_add(Weight::from_parts(1_796, 0).saturating_mul(s.into())) - .saturating_add(T::DbWeight::get().reads(8_u64)) - .saturating_add(T::DbWeight::get().writes(6_u64)) - .saturating_add(Weight::from_parts(0, 90).saturating_mul(t.into())) + // Measured: `676` + // Estimated: `4138` + // Minimum execution time: 1_637_633_000 picoseconds. + Weight::from_parts(1_668_892, 4138) + // Standard Error: 8_487_760 + .saturating_add(Weight::from_parts(210_998_534, 0).saturating_mul(t.into())) + // Standard Error: 13 + .saturating_add(Weight::from_parts(1_392, 0).saturating_mul(i.into())) + // Standard Error: 13 + .saturating_add(Weight::from_parts(1_733, 0).saturating_mul(s.into())) + .saturating_add(T::DbWeight::get().reads(5_u64)) + .saturating_add(T::DbWeight::get().writes(3_u64)) } /// The range of component `n` is `[0, 1048576]`. fn seal_hash_sha2_256(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 850_000 picoseconds. - Weight::from_parts(927_000, 0) + // Minimum execution time: 868_000 picoseconds. + Weight::from_parts(882_000, 0) // Standard Error: 0 - .saturating_add(Weight::from_parts(1_146, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(1_051, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 1048576]`. fn seal_hash_keccak_256(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_318_000 picoseconds. - Weight::from_parts(1_404_000, 0) + // Minimum execution time: 1_404_000 picoseconds. + Weight::from_parts(1_490_000, 0) // Standard Error: 0 - .saturating_add(Weight::from_parts(3_405, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(3_316, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 1048576]`. fn seal_hash_blake2_256(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 709_000 picoseconds. - Weight::from_parts(736_000, 0) + // Minimum execution time: 849_000 picoseconds. + Weight::from_parts(913_000, 0) // Standard Error: 0 - .saturating_add(Weight::from_parts(1_282, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(1_186, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 1048576]`. fn seal_hash_blake2_128(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 707_000 picoseconds. - Weight::from_parts(748_000, 0) + // Minimum execution time: 697_000 picoseconds. + Weight::from_parts(772_000, 0) // Standard Error: 0 - .saturating_add(Weight::from_parts(1_280, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(1_186, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 125697]`. fn seal_sr25519_verify(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 43_289_000 picoseconds. - Weight::from_parts(47_063_362, 0) - // Standard Error: 11 - .saturating_add(Weight::from_parts(4_544, 0).saturating_mul(n.into())) + // Minimum execution time: 42_862_000 picoseconds. + Weight::from_parts(48_510_759, 0) + // Standard Error: 10 + .saturating_add(Weight::from_parts(4_451, 0).saturating_mul(n.into())) } fn seal_ecdsa_recover() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 46_432_000 picoseconds. - Weight::from_parts(48_334_000, 0) + // Minimum execution time: 47_180_000 picoseconds. + Weight::from_parts(48_679_000, 0) } fn seal_ecdsa_to_eth_address() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 12_812_000 picoseconds. - Weight::from_parts(13_019_000, 0) + // Minimum execution time: 13_057_000 picoseconds. + Weight::from_parts(13_227_000, 0) } /// Storage: `Contracts::CodeInfoOf` (r:1 w:1) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1 w:0) /// Proof: `Contracts::PristineCode` (`max_values`: None, `max_size`: Some(125988), added: 128463, mode: `Measured`) - /// Storage: `System::EventTopics` (r:2 w:2) - /// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`) fn seal_set_code_hash() -> Weight { // Proof Size summary in bytes: // Measured: `430` - // Estimated: `6370` - // Minimum execution time: 27_336_000 picoseconds. - Weight::from_parts(28_146_000, 6370) - .saturating_add(T::DbWeight::get().reads(4_u64)) - .saturating_add(T::DbWeight::get().writes(3_u64)) + // Estimated: `3895` + // Minimum execution time: 19_335_000 picoseconds. + Weight::from_parts(20_225_000, 3895) + .saturating_add(T::DbWeight::get().reads(2_u64)) + .saturating_add(T::DbWeight::get().writes(1_u64)) } /// Storage: `Contracts::CodeInfoOf` (r:1 w:1) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) @@ -966,8 +938,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `355` // Estimated: `3820` - // Minimum execution time: 9_209_000 picoseconds. - Weight::from_parts(9_638_000, 3820) + // Minimum execution time: 9_400_000 picoseconds. + Weight::from_parts(9_743_000, 3820) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -977,8 +949,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `355` // Estimated: `3558` - // Minimum execution time: 8_161_000 picoseconds. - Weight::from_parts(8_449_000, 3558) + // Minimum execution time: 8_125_000 picoseconds. + Weight::from_parts(8_491_000, 3558) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -987,14 +959,14 @@ impl WeightInfo for SubstrateWeight { // Measured: `0` // Estimated: `0` // Minimum execution time: 330_000 picoseconds. - Weight::from_parts(354_000, 0) + Weight::from_parts(383_000, 0) } fn seal_account_reentrance_count() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 337_000 picoseconds. - Weight::from_parts(381_000, 0) + // Minimum execution time: 349_000 picoseconds. + Weight::from_parts(380_000, 0) } /// Storage: `Contracts::Nonce` (r:1 w:0) /// Proof: `Contracts::Nonce` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`) @@ -1002,8 +974,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `219` // Estimated: `1704` - // Minimum execution time: 2_975_000 picoseconds. - Weight::from_parts(3_147_000, 1704) + // Minimum execution time: 3_083_000 picoseconds. + Weight::from_parts(3_248_000, 1704) .saturating_add(T::DbWeight::get().reads(1_u64)) } /// The range of component `r` is `[0, 5000]`. @@ -1011,10 +983,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 863_000 picoseconds. - Weight::from_parts(439_219, 0) - // Standard Error: 17 - .saturating_add(Weight::from_parts(15_175, 0).saturating_mul(r.into())) + // Minimum execution time: 918_000 picoseconds. + Weight::from_parts(1_027_293, 0) + // Standard Error: 23 + .saturating_add(Weight::from_parts(14_764, 0).saturating_mul(r.into())) } } @@ -1026,8 +998,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `142` // Estimated: `1627` - // Minimum execution time: 2_094_000 picoseconds. - Weight::from_parts(2_238_000, 1627) + // Minimum execution time: 2_024_000 picoseconds. + Weight::from_parts(2_252_000, 1627) .saturating_add(RocksDbWeight::get().reads(1_u64)) } /// Storage: `Skipped::Metadata` (r:0 w:0) @@ -1037,10 +1009,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `452 + k * (69 ±0)` // Estimated: `442 + k * (70 ±0)` - // Minimum execution time: 12_226_000 picoseconds. - Weight::from_parts(12_508_000, 442) - // Standard Error: 1_454 - .saturating_add(Weight::from_parts(1_124_285, 0).saturating_mul(k.into())) + // Minimum execution time: 12_431_000 picoseconds. + Weight::from_parts(12_776_000, 442) + // Standard Error: 1_067 + .saturating_add(Weight::from_parts(1_151_178, 0).saturating_mul(k.into())) .saturating_add(RocksDbWeight::get().reads(2_u64)) .saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(k.into()))) .saturating_add(RocksDbWeight::get().writes(2_u64)) @@ -1054,10 +1026,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `211 + c * (1 ±0)` // Estimated: `6149 + c * (1 ±0)` - // Minimum execution time: 8_644_000 picoseconds. - Weight::from_parts(9_027_360, 6149) + // Minimum execution time: 8_449_000 picoseconds. + Weight::from_parts(8_973_080, 6149) // Standard Error: 1 - .saturating_add(Weight::from_parts(1_209, 0).saturating_mul(c.into())) + .saturating_add(Weight::from_parts(1_159, 0).saturating_mul(c.into())) .saturating_add(RocksDbWeight::get().reads(2_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(c.into())) @@ -1070,8 +1042,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `510` // Estimated: `6450` - // Minimum execution time: 16_756_000 picoseconds. - Weight::from_parts(17_643_000, 6450) + // Minimum execution time: 16_720_000 picoseconds. + Weight::from_parts(17_514_000, 6450) .saturating_add(RocksDbWeight::get().reads(3_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -1084,10 +1056,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `171 + k * (1 ±0)` // Estimated: `3635 + k * (1 ±0)` - // Minimum execution time: 3_444_000 picoseconds. - Weight::from_parts(3_583_000, 3635) - // Standard Error: 777 - .saturating_add(Weight::from_parts(1_222_839, 0).saturating_mul(k.into())) + // Minimum execution time: 3_540_000 picoseconds. + Weight::from_parts(40_895, 3635) + // Standard Error: 1_472 + .saturating_add(Weight::from_parts(1_232_021, 0).saturating_mul(k.into())) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(2_u64)) .saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(k.into()))) @@ -1106,10 +1078,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `325 + c * (1 ±0)` // Estimated: `6263 + c * (1 ±0)` - // Minimum execution time: 16_786_000 picoseconds. - Weight::from_parts(17_044_074, 6263) - // Standard Error: 0 - .saturating_add(Weight::from_parts(463, 0).saturating_mul(c.into())) + // Minimum execution time: 16_770_000 picoseconds. + Weight::from_parts(16_902_655, 6263) + // Standard Error: 1 + .saturating_add(Weight::from_parts(377, 0).saturating_mul(c.into())) .saturating_add(RocksDbWeight::get().reads(4_u64)) .saturating_add(RocksDbWeight::get().writes(2_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(c.into())) @@ -1120,8 +1092,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `440` // Estimated: `6380` - // Minimum execution time: 12_921_000 picoseconds. - Weight::from_parts(13_391_000, 6380) + // Minimum execution time: 12_617_000 picoseconds. + Weight::from_parts(13_253_000, 6380) .saturating_add(RocksDbWeight::get().reads(2_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -1135,8 +1107,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `352` // Estimated: `6292` - // Minimum execution time: 47_556_000 picoseconds. - Weight::from_parts(49_386_000, 6292) + // Minimum execution time: 47_835_000 picoseconds. + Weight::from_parts(49_254_000, 6292) .saturating_add(RocksDbWeight::get().reads(4_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -1148,8 +1120,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `594` // Estimated: `6534` - // Minimum execution time: 54_956_000 picoseconds. - Weight::from_parts(57_387_000, 6534) + // Minimum execution time: 55_489_000 picoseconds. + Weight::from_parts(57_136_000, 6534) .saturating_add(RocksDbWeight::get().reads(4_u64)) .saturating_add(RocksDbWeight::get().writes(2_u64)) } @@ -1159,8 +1131,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `409` // Estimated: `6349` - // Minimum execution time: 12_196_000 picoseconds. - Weight::from_parts(12_747_000, 6349) + // Minimum execution time: 11_795_000 picoseconds. + Weight::from_parts(12_655_000, 6349) .saturating_add(RocksDbWeight::get().reads(2_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -1170,8 +1142,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `142` // Estimated: `1627` - // Minimum execution time: 2_500_000 picoseconds. - Weight::from_parts(2_572_000, 1627) + // Minimum execution time: 2_448_000 picoseconds. + Weight::from_parts(2_608_000, 1627) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -1183,8 +1155,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `166` // Estimated: `3631` - // Minimum execution time: 12_297_000 picoseconds. - Weight::from_parts(12_552_000, 3631) + // Minimum execution time: 12_208_000 picoseconds. + Weight::from_parts(12_653_000, 3631) .saturating_add(RocksDbWeight::get().reads(2_u64)) .saturating_add(RocksDbWeight::get().writes(2_u64)) } @@ -1194,8 +1166,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `142` // Estimated: `3607` - // Minimum execution time: 4_745_000 picoseconds. - Weight::from_parts(5_049_000, 3607) + // Minimum execution time: 4_830_000 picoseconds. + Weight::from_parts(5_026_000, 3607) .saturating_add(RocksDbWeight::get().reads(1_u64)) } /// Storage: UNKNOWN KEY `0x4342193e496fab7ec59d615ed0dc55304e7b9012096b41c4eb3aaf947f6ea429` (r:1 w:0) @@ -1206,8 +1178,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `167` // Estimated: `3632` - // Minimum execution time: 6_293_000 picoseconds. - Weight::from_parts(6_465_000, 3632) + // Minimum execution time: 6_178_000 picoseconds. + Weight::from_parts(6_485_000, 3632) .saturating_add(RocksDbWeight::get().reads(2_u64)) } /// Storage: UNKNOWN KEY `0x4342193e496fab7ec59d615ed0dc55304e7b9012096b41c4eb3aaf947f6ea429` (r:1 w:0) @@ -1218,8 +1190,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `142` // Estimated: `3607` - // Minimum execution time: 6_378_000 picoseconds. - Weight::from_parts(6_874_000, 3607) + // Minimum execution time: 6_203_000 picoseconds. + Weight::from_parts(6_533_000, 3607) .saturating_add(RocksDbWeight::get().reads(2_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -1235,19 +1207,17 @@ impl WeightInfo for () { /// Proof: `Timestamp::Now` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`) /// Storage: `System::Account` (r:1 w:1) /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`) - /// Storage: `System::EventTopics` (r:2 w:2) - /// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`) /// The range of component `c` is `[0, 125952]`. fn call_with_code_per_byte(c: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `801 + c * (1 ±0)` - // Estimated: `6739 + c * (1 ±0)` - // Minimum execution time: 362_366_000 picoseconds. - Weight::from_parts(353_347_662, 6739) - // Standard Error: 129 - .saturating_add(Weight::from_parts(34_964, 0).saturating_mul(c.into())) - .saturating_add(RocksDbWeight::get().reads(8_u64)) - .saturating_add(RocksDbWeight::get().writes(4_u64)) + // Estimated: `4264 + c * (1 ±0)` + // Minimum execution time: 290_448_000 picoseconds. + Weight::from_parts(274_301_376, 4264) + // Standard Error: 64 + .saturating_add(Weight::from_parts(32_946, 0).saturating_mul(c.into())) + .saturating_add(RocksDbWeight::get().reads(6_u64)) + .saturating_add(RocksDbWeight::get().writes(2_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(c.into())) } /// Storage: `Contracts::MigrationInProgress` (r:1 w:0) @@ -1256,8 +1226,6 @@ impl WeightInfo for () { /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Balances::Holds` (r:2 w:2) /// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(193), added: 2668, mode: `Measured`) - /// Storage: `System::EventTopics` (r:3 w:3) - /// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `Contracts::Nonce` (r:1 w:1) /// Proof: `Contracts::Nonce` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`) /// Storage: `Contracts::ContractInfoOf` (r:1 w:1) @@ -1274,17 +1242,17 @@ impl WeightInfo for () { fn instantiate_with_code(c: u32, i: u32, s: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `323` - // Estimated: `8737` - // Minimum execution time: 4_266_902_000 picoseconds. - Weight::from_parts(914_416_909, 8737) - // Standard Error: 123 - .saturating_add(Weight::from_parts(67_482, 0).saturating_mul(c.into())) - // Standard Error: 14 - .saturating_add(Weight::from_parts(1_659, 0).saturating_mul(i.into())) - // Standard Error: 14 - .saturating_add(Weight::from_parts(1_619, 0).saturating_mul(s.into())) - .saturating_add(RocksDbWeight::get().reads(11_u64)) - .saturating_add(RocksDbWeight::get().writes(10_u64)) + // Estimated: `6262` + // Minimum execution time: 3_777_124_000 picoseconds. + Weight::from_parts(858_828_640, 6262) + // Standard Error: 158 + .saturating_add(Weight::from_parts(67_299, 0).saturating_mul(c.into())) + // Standard Error: 19 + .saturating_add(Weight::from_parts(1_353, 0).saturating_mul(i.into())) + // Standard Error: 19 + .saturating_add(Weight::from_parts(1_580, 0).saturating_mul(s.into())) + .saturating_add(RocksDbWeight::get().reads(8_u64)) + .saturating_add(RocksDbWeight::get().writes(7_u64)) } /// Storage: `Contracts::MigrationInProgress` (r:1 w:0) /// Proof: `Contracts::MigrationInProgress` (`max_values`: Some(1), `max_size`: Some(1026), added: 1521, mode: `Measured`) @@ -1300,8 +1268,6 @@ impl WeightInfo for () { /// Proof: `Timestamp::Now` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`) /// Storage: `System::Account` (r:1 w:1) /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`) - /// Storage: `System::EventTopics` (r:2 w:2) - /// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `Balances::Holds` (r:1 w:1) /// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(193), added: 2668, mode: `Measured`) /// The range of component `i` is `[0, 1048576]`. @@ -1309,15 +1275,15 @@ impl WeightInfo for () { fn instantiate(i: u32, s: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `560` - // Estimated: `6504` - // Minimum execution time: 2_101_015_000 picoseconds. - Weight::from_parts(2_123_733_000, 6504) + // Estimated: `4029` + // Minimum execution time: 1_960_317_000 picoseconds. + Weight::from_parts(1_985_571_000, 4029) // Standard Error: 26 - .saturating_add(Weight::from_parts(895, 0).saturating_mul(i.into())) + .saturating_add(Weight::from_parts(849, 0).saturating_mul(i.into())) // Standard Error: 26 - .saturating_add(Weight::from_parts(805, 0).saturating_mul(s.into())) - .saturating_add(RocksDbWeight::get().reads(10_u64)) - .saturating_add(RocksDbWeight::get().writes(7_u64)) + .saturating_add(Weight::from_parts(813, 0).saturating_mul(s.into())) + .saturating_add(RocksDbWeight::get().reads(8_u64)) + .saturating_add(RocksDbWeight::get().writes(5_u64)) } /// Storage: `Contracts::MigrationInProgress` (r:1 w:0) /// Proof: `Contracts::MigrationInProgress` (`max_values`: Some(1), `max_size`: Some(1026), added: 1521, mode: `Measured`) @@ -1331,16 +1297,14 @@ impl WeightInfo for () { /// Proof: `Timestamp::Now` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`) /// Storage: `System::Account` (r:1 w:1) /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`) - /// Storage: `System::EventTopics` (r:2 w:2) - /// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`) fn call() -> Weight { // Proof Size summary in bytes: // Measured: `826` - // Estimated: `6766` - // Minimum execution time: 205_788_000 picoseconds. - Weight::from_parts(210_371_000, 6766) - .saturating_add(RocksDbWeight::get().reads(8_u64)) - .saturating_add(RocksDbWeight::get().writes(4_u64)) + // Estimated: `4291` + // Minimum execution time: 195_828_000 picoseconds. + Weight::from_parts(203_985_000, 4291) + .saturating_add(RocksDbWeight::get().reads(6_u64)) + .saturating_add(RocksDbWeight::get().writes(2_u64)) } /// Storage: `Contracts::MigrationInProgress` (r:1 w:0) /// Proof: `Contracts::MigrationInProgress` (`max_values`: Some(1), `max_size`: Some(1026), added: 1521, mode: `Measured`) @@ -1348,8 +1312,6 @@ impl WeightInfo for () { /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Balances::Holds` (r:1 w:1) /// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(193), added: 2668, mode: `Measured`) - /// Storage: `System::EventTopics` (r:1 w:1) - /// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:0 w:1) /// Proof: `Contracts::PristineCode` (`max_values`: None, `max_size`: Some(125988), added: 128463, mode: `Measured`) /// The range of component `c` is `[0, 125952]`. @@ -1357,12 +1319,12 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `142` // Estimated: `3607` - // Minimum execution time: 334_087_000 picoseconds. - Weight::from_parts(347_294_648, 3607) - // Standard Error: 75 - .saturating_add(Weight::from_parts(33_819, 0).saturating_mul(c.into())) - .saturating_add(RocksDbWeight::get().reads(4_u64)) - .saturating_add(RocksDbWeight::get().writes(4_u64)) + // Minimum execution time: 263_760_000 picoseconds. + Weight::from_parts(269_484_033, 3607) + // Standard Error: 54 + .saturating_add(Weight::from_parts(32_487, 0).saturating_mul(c.into())) + .saturating_add(RocksDbWeight::get().reads(3_u64)) + .saturating_add(RocksDbWeight::get().writes(3_u64)) } /// Storage: `Contracts::MigrationInProgress` (r:1 w:0) /// Proof: `Contracts::MigrationInProgress` (`max_values`: Some(1), `max_size`: Some(1026), added: 1521, mode: `Measured`) @@ -1370,8 +1332,6 @@ impl WeightInfo for () { /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Balances::Holds` (r:1 w:1) /// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(193), added: 2668, mode: `Measured`) - /// Storage: `System::EventTopics` (r:1 w:1) - /// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:0 w:1) /// Proof: `Contracts::PristineCode` (`max_values`: None, `max_size`: Some(125988), added: 128463, mode: `Measured`) /// The range of component `c` is `[0, 125952]`. @@ -1379,12 +1339,12 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `142` // Estimated: `3607` - // Minimum execution time: 348_078_000 picoseconds. - Weight::from_parts(393_851_501, 3607) - // Standard Error: 62 - .saturating_add(Weight::from_parts(33_635, 0).saturating_mul(c.into())) - .saturating_add(RocksDbWeight::get().reads(4_u64)) - .saturating_add(RocksDbWeight::get().writes(4_u64)) + // Minimum execution time: 274_929_000 picoseconds. + Weight::from_parts(285_405_269, 3607) + // Standard Error: 52 + .saturating_add(Weight::from_parts(32_658, 0).saturating_mul(c.into())) + .saturating_add(RocksDbWeight::get().reads(3_u64)) + .saturating_add(RocksDbWeight::get().writes(3_u64)) } /// Storage: `Contracts::MigrationInProgress` (r:1 w:0) /// Proof: `Contracts::MigrationInProgress` (`max_values`: Some(1), `max_size`: Some(1026), added: 1521, mode: `Measured`) @@ -1392,18 +1352,16 @@ impl WeightInfo for () { /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Balances::Holds` (r:1 w:1) /// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(193), added: 2668, mode: `Measured`) - /// Storage: `System::EventTopics` (r:1 w:1) - /// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:0 w:1) /// Proof: `Contracts::PristineCode` (`max_values`: None, `max_size`: Some(125988), added: 128463, mode: `Measured`) fn remove_code() -> Weight { // Proof Size summary in bytes: // Measured: `315` // Estimated: `3780` - // Minimum execution time: 45_294_000 picoseconds. - Weight::from_parts(46_148_000, 3780) - .saturating_add(RocksDbWeight::get().reads(4_u64)) - .saturating_add(RocksDbWeight::get().writes(4_u64)) + // Minimum execution time: 42_693_000 picoseconds. + Weight::from_parts(43_590_000, 3780) + .saturating_add(RocksDbWeight::get().reads(3_u64)) + .saturating_add(RocksDbWeight::get().writes(3_u64)) } /// Storage: `Contracts::MigrationInProgress` (r:1 w:0) /// Proof: `Contracts::MigrationInProgress` (`max_values`: Some(1), `max_size`: Some(1026), added: 1521, mode: `Measured`) @@ -1411,33 +1369,31 @@ impl WeightInfo for () { /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:2 w:2) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) - /// Storage: `System::EventTopics` (r:3 w:3) - /// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`) fn set_code() -> Weight { // Proof Size summary in bytes: // Measured: `552` - // Estimated: `8967` - // Minimum execution time: 34_298_000 picoseconds. - Weight::from_parts(35_728_000, 8967) - .saturating_add(RocksDbWeight::get().reads(7_u64)) - .saturating_add(RocksDbWeight::get().writes(6_u64)) + // Estimated: `6492` + // Minimum execution time: 26_126_000 picoseconds. + Weight::from_parts(27_456_000, 6492) + .saturating_add(RocksDbWeight::get().reads(4_u64)) + .saturating_add(RocksDbWeight::get().writes(3_u64)) } /// The range of component `r` is `[0, 1600]`. fn noop_host_fn(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 9_347_000 picoseconds. - Weight::from_parts(10_917_661, 0) - // Standard Error: 142 - .saturating_add(Weight::from_parts(70_824, 0).saturating_mul(r.into())) + // Minimum execution time: 9_933_000 picoseconds. + Weight::from_parts(10_586_445, 0) + // Standard Error: 74 + .saturating_add(Weight::from_parts(73_229, 0).saturating_mul(r.into())) } fn seal_caller() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 600_000 picoseconds. - Weight::from_parts(650_000, 0) + // Minimum execution time: 621_000 picoseconds. + Weight::from_parts(667_000, 0) } /// Storage: `Contracts::ContractInfoOf` (r:1 w:0) /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) @@ -1445,8 +1401,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `354` // Estimated: `3819` - // Minimum execution time: 6_710_000 picoseconds. - Weight::from_parts(7_005_000, 3819) + // Minimum execution time: 6_594_000 picoseconds. + Weight::from_parts(6_855_000, 3819) .saturating_add(RocksDbWeight::get().reads(1_u64)) } /// Storage: `Contracts::ContractInfoOf` (r:1 w:0) @@ -1455,79 +1411,79 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `447` // Estimated: `3912` - // Minimum execution time: 8_112_000 picoseconds. - Weight::from_parts(8_360_000, 3912) + // Minimum execution time: 7_893_000 picoseconds. + Weight::from_parts(8_172_000, 3912) .saturating_add(RocksDbWeight::get().reads(1_u64)) } fn seal_own_code_hash() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 668_000 picoseconds. - Weight::from_parts(761_000, 0) + // Minimum execution time: 772_000 picoseconds. + Weight::from_parts(826_000, 0) } fn seal_caller_is_origin() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 385_000 picoseconds. - Weight::from_parts(425_000, 0) + // Minimum execution time: 409_000 picoseconds. + Weight::from_parts(431_000, 0) } fn seal_caller_is_root() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 312_000 picoseconds. - Weight::from_parts(354_000, 0) + // Minimum execution time: 333_000 picoseconds. + Weight::from_parts(360_000, 0) } fn seal_address() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 558_000 picoseconds. - Weight::from_parts(607_000, 0) + // Minimum execution time: 609_000 picoseconds. + Weight::from_parts(628_000, 0) } fn seal_gas_left() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 661_000 picoseconds. - Weight::from_parts(706_000, 0) + // Minimum execution time: 669_000 picoseconds. + Weight::from_parts(741_000, 0) } fn seal_balance() -> Weight { // Proof Size summary in bytes: // Measured: `140` // Estimated: `0` - // Minimum execution time: 4_693_000 picoseconds. - Weight::from_parts(4_872_000, 0) + // Minimum execution time: 4_778_000 picoseconds. + Weight::from_parts(4_985_000, 0) } fn seal_value_transferred() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 532_000 picoseconds. - Weight::from_parts(583_000, 0) + // Minimum execution time: 585_000 picoseconds. + Weight::from_parts(610_000, 0) } fn seal_minimum_balance() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 529_000 picoseconds. - Weight::from_parts(570_000, 0) + // Minimum execution time: 567_000 picoseconds. + Weight::from_parts(601_000, 0) } fn seal_block_number() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 557_000 picoseconds. - Weight::from_parts(597_000, 0) + // Minimum execution time: 592_000 picoseconds. + Weight::from_parts(627_000, 0) } fn seal_now() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 551_000 picoseconds. - Weight::from_parts(588_000, 0) + // Minimum execution time: 576_000 picoseconds. + Weight::from_parts(616_000, 0) } /// Storage: `TransactionPayment::NextFeeMultiplier` (r:1 w:0) /// Proof: `TransactionPayment::NextFeeMultiplier` (`max_values`: Some(1), `max_size`: Some(16), added: 511, mode: `Measured`) @@ -1535,8 +1491,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `67` // Estimated: `1552` - // Minimum execution time: 4_284_000 picoseconds. - Weight::from_parts(4_564_000, 1552) + // Minimum execution time: 4_477_000 picoseconds. + Weight::from_parts(4_706_000, 1552) .saturating_add(RocksDbWeight::get().reads(1_u64)) } /// The range of component `n` is `[0, 1048572]`. @@ -1544,41 +1500,39 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 452_000 picoseconds. - Weight::from_parts(480_000, 0) + // Minimum execution time: 503_000 picoseconds. + Weight::from_parts(528_000, 0) // Standard Error: 3 - .saturating_add(Weight::from_parts(303, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(292, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 1048572]`. fn seal_return(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 322_000 picoseconds. - Weight::from_parts(349_000, 0) + // Minimum execution time: 333_000 picoseconds. + Weight::from_parts(371_000, 0) // Standard Error: 9 - .saturating_add(Weight::from_parts(480, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(398, 0).saturating_mul(n.into())) } /// Storage: `Contracts::DeletionQueueCounter` (r:1 w:1) /// Proof: `Contracts::DeletionQueueCounter` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`) /// Storage: `Contracts::CodeInfoOf` (r:33 w:33) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) - /// Storage: `System::EventTopics` (r:2 w:2) - /// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `Contracts::DeletionQueue` (r:0 w:1) /// Proof: `Contracts::DeletionQueue` (`max_values`: None, `max_size`: Some(142), added: 2617, mode: `Measured`) /// The range of component `n` is `[0, 32]`. fn seal_terminate(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `319 + n * (78 ±0)` - // Estimated: `6259 + n * (2553 ±0)` - // Minimum execution time: 21_002_000 picoseconds. - Weight::from_parts(22_620_068, 6259) - // Standard Error: 6_761 - .saturating_add(Weight::from_parts(3_676_180, 0).saturating_mul(n.into())) - .saturating_add(RocksDbWeight::get().reads(4_u64)) + // Estimated: `3784 + n * (2553 ±0)` + // Minimum execution time: 14_468_000 picoseconds. + Weight::from_parts(16_793_355, 3784) + // Standard Error: 8_365 + .saturating_add(Weight::from_parts(3_694_281, 0).saturating_mul(n.into())) + .saturating_add(RocksDbWeight::get().reads(2_u64)) .saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(n.into()))) - .saturating_add(RocksDbWeight::get().writes(5_u64)) + .saturating_add(RocksDbWeight::get().writes(3_u64)) .saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(n.into()))) .saturating_add(Weight::from_parts(0, 2553).saturating_mul(n.into())) } @@ -1588,8 +1542,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `76` // Estimated: `1561` - // Minimum execution time: 3_622_000 picoseconds. - Weight::from_parts(3_809_000, 1561) + // Minimum execution time: 3_563_000 picoseconds. + Weight::from_parts(3_784_000, 1561) .saturating_add(RocksDbWeight::get().reads(1_u64)) } /// Storage: `System::EventTopics` (r:4 w:4) @@ -1600,12 +1554,12 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `0` // Estimated: `990 + t * (2475 ±0)` - // Minimum execution time: 4_029_000 picoseconds. - Weight::from_parts(4_444_994, 990) - // Standard Error: 7_216 - .saturating_add(Weight::from_parts(2_404_769, 0).saturating_mul(t.into())) + // Minimum execution time: 4_064_000 picoseconds. + Weight::from_parts(4_551_057, 990) + // Standard Error: 7_249 + .saturating_add(Weight::from_parts(2_342_414, 0).saturating_mul(t.into())) // Standard Error: 2 - .saturating_add(Weight::from_parts(16, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(9, 0).saturating_mul(n.into())) .saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(t.into()))) .saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(t.into()))) .saturating_add(Weight::from_parts(0, 2475).saturating_mul(t.into())) @@ -1615,10 +1569,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 407_000 picoseconds. - Weight::from_parts(430_000, 0) + // Minimum execution time: 436_000 picoseconds. + Weight::from_parts(440_000, 0) // Standard Error: 10 - .saturating_add(Weight::from_parts(1_271, 0).saturating_mul(i.into())) + .saturating_add(Weight::from_parts(1_201, 0).saturating_mul(i.into())) } /// Storage: `Skipped::Metadata` (r:0 w:0) /// Proof: `Skipped::Metadata` (`max_values`: None, `max_size`: None, mode: `Measured`) @@ -1628,12 +1582,12 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `250 + o * (1 ±0)` // Estimated: `249 + o * (1 ±0)` - // Minimum execution time: 9_907_000 picoseconds. - Weight::from_parts(9_926_136, 249) + // Minimum execution time: 10_097_000 picoseconds. + Weight::from_parts(9_877_776, 249) // Standard Error: 1 - .saturating_add(Weight::from_parts(334, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(241, 0).saturating_mul(n.into())) // Standard Error: 1 - .saturating_add(Weight::from_parts(56, 0).saturating_mul(o.into())) + .saturating_add(Weight::from_parts(58, 0).saturating_mul(o.into())) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(o.into())) @@ -1645,10 +1599,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `248 + n * (1 ±0)` // Estimated: `248 + n * (1 ±0)` - // Minimum execution time: 8_288_000 picoseconds. - Weight::from_parts(9_347_243, 248) + // Minimum execution time: 8_068_000 picoseconds. + Weight::from_parts(9_298_830, 248) // Standard Error: 2 - .saturating_add(Weight::from_parts(81, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(77, 0).saturating_mul(n.into())) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) @@ -1660,10 +1614,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `248 + n * (1 ±0)` // Estimated: `248 + n * (1 ±0)` - // Minimum execution time: 7_180_000 picoseconds. - Weight::from_parts(9_058_388, 248) + // Minimum execution time: 7_315_000 picoseconds. + Weight::from_parts(9_026_712, 248) // Standard Error: 3 - .saturating_add(Weight::from_parts(701, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(595, 0).saturating_mul(n.into())) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) } @@ -1674,10 +1628,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `248 + n * (1 ±0)` // Estimated: `248 + n * (1 ±0)` - // Minimum execution time: 6_868_000 picoseconds. - Weight::from_parts(8_056_732, 248) + // Minimum execution time: 6_833_000 picoseconds. + Weight::from_parts(7_980_890, 248) // Standard Error: 2 - .saturating_add(Weight::from_parts(81, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(85, 0).saturating_mul(n.into())) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) } @@ -1688,10 +1642,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `248 + n * (1 ±0)` // Estimated: `248 + n * (1 ±0)` - // Minimum execution time: 8_601_000 picoseconds. - Weight::from_parts(10_124_367, 248) - // Standard Error: 2 - .saturating_add(Weight::from_parts(701, 0).saturating_mul(n.into())) + // Minimum execution time: 8_250_000 picoseconds. + Weight::from_parts(10_058_209, 248) + // Standard Error: 3 + .saturating_add(Weight::from_parts(607, 0).saturating_mul(n.into())) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) @@ -1700,8 +1654,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `140` // Estimated: `0` - // Minimum execution time: 9_242_000 picoseconds. - Weight::from_parts(9_557_000, 0) + // Minimum execution time: 8_858_000 picoseconds. + Weight::from_parts(9_238_000, 0) } /// Storage: `Contracts::ContractInfoOf` (r:1 w:1) /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) @@ -1711,26 +1665,24 @@ impl WeightInfo for () { /// Proof: `Contracts::PristineCode` (`max_values`: None, `max_size`: Some(125988), added: 128463, mode: `Measured`) /// Storage: `System::Account` (r:1 w:1) /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`) - /// Storage: `System::EventTopics` (r:2 w:2) - /// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`) /// The range of component `t` is `[0, 1]`. /// The range of component `c` is `[0, 1]`. /// The range of component `i` is `[0, 1048576]`. fn seal_call(t: u32, c: u32, i: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `620 + t * (280 ±0)` - // Estimated: `6560 + t * (2182 ±0)` - // Minimum execution time: 161_170_000 picoseconds. - Weight::from_parts(165_269_982, 6560) - // Standard Error: 327_855 - .saturating_add(Weight::from_parts(42_589_388, 0).saturating_mul(t.into())) - // Standard Error: 327_855 - .saturating_add(Weight::from_parts(1_482_035, 0).saturating_mul(c.into())) + // Estimated: `4085 + t * (2182 ±0)` + // Minimum execution time: 153_417_000 picoseconds. + Weight::from_parts(154_858_902, 4085) + // Standard Error: 339_920 + .saturating_add(Weight::from_parts(45_327_013, 0).saturating_mul(t.into())) + // Standard Error: 339_920 + .saturating_add(Weight::from_parts(1_016_817, 0).saturating_mul(c.into())) // Standard Error: 0 .saturating_add(Weight::from_parts(7, 0).saturating_mul(i.into())) - .saturating_add(RocksDbWeight::get().reads(5_u64)) + .saturating_add(RocksDbWeight::get().reads(3_u64)) .saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(t.into()))) - .saturating_add(RocksDbWeight::get().writes(3_u64)) + .saturating_add(RocksDbWeight::get().writes(1_u64)) .saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(t.into()))) .saturating_add(Weight::from_parts(0, 2182).saturating_mul(t.into())) } @@ -1738,16 +1690,13 @@ impl WeightInfo for () { /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1 w:0) /// Proof: `Contracts::PristineCode` (`max_values`: None, `max_size`: Some(125988), added: 128463, mode: `Measured`) - /// Storage: `System::EventTopics` (r:2 w:2) - /// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`) fn seal_delegate_call() -> Weight { // Proof Size summary in bytes: // Measured: `430` - // Estimated: `6370` - // Minimum execution time: 149_765_000 picoseconds. - Weight::from_parts(159_745_000, 6370) - .saturating_add(RocksDbWeight::get().reads(4_u64)) - .saturating_add(RocksDbWeight::get().writes(2_u64)) + // Estimated: `3895` + // Minimum execution time: 140_613_000 picoseconds. + Weight::from_parts(149_663_000, 3895) + .saturating_add(RocksDbWeight::get().reads(2_u64)) } /// Storage: `Contracts::CodeInfoOf` (r:1 w:1) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) @@ -1757,107 +1706,102 @@ impl WeightInfo for () { /// 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(1795), added: 4270, mode: `Measured`) - /// Storage: `System::Account` (r:2 w:2) + /// Storage: `System::Account` (r:1 w:1) /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`) - /// Storage: `System::EventTopics` (r:2 w:2) - /// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`) /// The range of component `t` is `[0, 1]`. /// The range of component `i` is `[0, 983040]`. /// The range of component `s` is `[0, 983040]`. fn seal_instantiate(t: u32, i: u32, s: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `676 + t * (102 ±0)` - // Estimated: `6613 + t * (90 ±1)` - // Minimum execution time: 1_807_196_000 picoseconds. - Weight::from_parts(83_888_679, 6613) - // Standard Error: 6_713_052 - .saturating_add(Weight::from_parts(184_318_405, 0).saturating_mul(t.into())) - // Standard Error: 10 - .saturating_add(Weight::from_parts(1_532, 0).saturating_mul(i.into())) - // Standard Error: 10 - .saturating_add(Weight::from_parts(1_796, 0).saturating_mul(s.into())) - .saturating_add(RocksDbWeight::get().reads(8_u64)) - .saturating_add(RocksDbWeight::get().writes(6_u64)) - .saturating_add(Weight::from_parts(0, 90).saturating_mul(t.into())) + // Measured: `676` + // Estimated: `4138` + // Minimum execution time: 1_637_633_000 picoseconds. + Weight::from_parts(1_668_892, 4138) + // Standard Error: 8_487_760 + .saturating_add(Weight::from_parts(210_998_534, 0).saturating_mul(t.into())) + // Standard Error: 13 + .saturating_add(Weight::from_parts(1_392, 0).saturating_mul(i.into())) + // Standard Error: 13 + .saturating_add(Weight::from_parts(1_733, 0).saturating_mul(s.into())) + .saturating_add(RocksDbWeight::get().reads(5_u64)) + .saturating_add(RocksDbWeight::get().writes(3_u64)) } /// The range of component `n` is `[0, 1048576]`. fn seal_hash_sha2_256(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 850_000 picoseconds. - Weight::from_parts(927_000, 0) + // Minimum execution time: 868_000 picoseconds. + Weight::from_parts(882_000, 0) // Standard Error: 0 - .saturating_add(Weight::from_parts(1_146, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(1_051, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 1048576]`. fn seal_hash_keccak_256(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_318_000 picoseconds. - Weight::from_parts(1_404_000, 0) + // Minimum execution time: 1_404_000 picoseconds. + Weight::from_parts(1_490_000, 0) // Standard Error: 0 - .saturating_add(Weight::from_parts(3_405, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(3_316, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 1048576]`. fn seal_hash_blake2_256(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 709_000 picoseconds. - Weight::from_parts(736_000, 0) + // Minimum execution time: 849_000 picoseconds. + Weight::from_parts(913_000, 0) // Standard Error: 0 - .saturating_add(Weight::from_parts(1_282, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(1_186, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 1048576]`. fn seal_hash_blake2_128(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 707_000 picoseconds. - Weight::from_parts(748_000, 0) + // Minimum execution time: 697_000 picoseconds. + Weight::from_parts(772_000, 0) // Standard Error: 0 - .saturating_add(Weight::from_parts(1_280, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(1_186, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 125697]`. fn seal_sr25519_verify(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 43_289_000 picoseconds. - Weight::from_parts(47_063_362, 0) - // Standard Error: 11 - .saturating_add(Weight::from_parts(4_544, 0).saturating_mul(n.into())) + // Minimum execution time: 42_862_000 picoseconds. + Weight::from_parts(48_510_759, 0) + // Standard Error: 10 + .saturating_add(Weight::from_parts(4_451, 0).saturating_mul(n.into())) } fn seal_ecdsa_recover() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 46_432_000 picoseconds. - Weight::from_parts(48_334_000, 0) + // Minimum execution time: 47_180_000 picoseconds. + Weight::from_parts(48_679_000, 0) } fn seal_ecdsa_to_eth_address() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 12_812_000 picoseconds. - Weight::from_parts(13_019_000, 0) + // Minimum execution time: 13_057_000 picoseconds. + Weight::from_parts(13_227_000, 0) } /// Storage: `Contracts::CodeInfoOf` (r:1 w:1) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) /// Storage: `Contracts::PristineCode` (r:1 w:0) /// Proof: `Contracts::PristineCode` (`max_values`: None, `max_size`: Some(125988), added: 128463, mode: `Measured`) - /// Storage: `System::EventTopics` (r:2 w:2) - /// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`) fn seal_set_code_hash() -> Weight { // Proof Size summary in bytes: // Measured: `430` - // Estimated: `6370` - // Minimum execution time: 27_336_000 picoseconds. - Weight::from_parts(28_146_000, 6370) - .saturating_add(RocksDbWeight::get().reads(4_u64)) - .saturating_add(RocksDbWeight::get().writes(3_u64)) + // Estimated: `3895` + // Minimum execution time: 19_335_000 picoseconds. + Weight::from_parts(20_225_000, 3895) + .saturating_add(RocksDbWeight::get().reads(2_u64)) + .saturating_add(RocksDbWeight::get().writes(1_u64)) } /// Storage: `Contracts::CodeInfoOf` (r:1 w:1) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) @@ -1865,8 +1809,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `355` // Estimated: `3820` - // Minimum execution time: 9_209_000 picoseconds. - Weight::from_parts(9_638_000, 3820) + // Minimum execution time: 9_400_000 picoseconds. + Weight::from_parts(9_743_000, 3820) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -1876,8 +1820,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `355` // Estimated: `3558` - // Minimum execution time: 8_161_000 picoseconds. - Weight::from_parts(8_449_000, 3558) + // Minimum execution time: 8_125_000 picoseconds. + Weight::from_parts(8_491_000, 3558) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -1886,14 +1830,14 @@ impl WeightInfo for () { // Measured: `0` // Estimated: `0` // Minimum execution time: 330_000 picoseconds. - Weight::from_parts(354_000, 0) + Weight::from_parts(383_000, 0) } fn seal_account_reentrance_count() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 337_000 picoseconds. - Weight::from_parts(381_000, 0) + // Minimum execution time: 349_000 picoseconds. + Weight::from_parts(380_000, 0) } /// Storage: `Contracts::Nonce` (r:1 w:0) /// Proof: `Contracts::Nonce` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`) @@ -1901,8 +1845,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `219` // Estimated: `1704` - // Minimum execution time: 2_975_000 picoseconds. - Weight::from_parts(3_147_000, 1704) + // Minimum execution time: 3_083_000 picoseconds. + Weight::from_parts(3_248_000, 1704) .saturating_add(RocksDbWeight::get().reads(1_u64)) } /// The range of component `r` is `[0, 5000]`. @@ -1910,9 +1854,9 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 863_000 picoseconds. - Weight::from_parts(439_219, 0) - // Standard Error: 17 - .saturating_add(Weight::from_parts(15_175, 0).saturating_mul(r.into())) + // Minimum execution time: 918_000 picoseconds. + Weight::from_parts(1_027_293, 0) + // Standard Error: 23 + .saturating_add(Weight::from_parts(14_764, 0).saturating_mul(r.into())) } } From 6b4eea3c341922d5c915fc7287d30eb365eaa4c0 Mon Sep 17 00:00:00 2001 From: command-bot <> Date: Sun, 19 May 2024 20:06:40 +0000 Subject: [PATCH 31/34] ".git/.scripts/commands/bench/bench.sh" --subcommand=pallet --runtime=dev --target_dir=substrate --pallet=pallet_contracts --- substrate/frame/contracts/src/weights.rs | 754 +++++++++++------------ 1 file changed, 375 insertions(+), 379 deletions(-) diff --git a/substrate/frame/contracts/src/weights.rs b/substrate/frame/contracts/src/weights.rs index 35dddc052aba..6be41a09ef1d 100644 --- a/substrate/frame/contracts/src/weights.rs +++ b/substrate/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 32.0.0 -//! DATE: 2024-05-17, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2024-05-19, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` //! HOSTNAME: `runner-unxyhko3-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz` //! WASM-EXECUTION: `Compiled`, CHAIN: `Some("dev")`, DB CACHE: `1024` @@ -127,8 +127,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `142` // Estimated: `1627` - // Minimum execution time: 2_024_000 picoseconds. - Weight::from_parts(2_252_000, 1627) + // Minimum execution time: 2_074_000 picoseconds. + Weight::from_parts(2_166_000, 1627) .saturating_add(T::DbWeight::get().reads(1_u64)) } /// Storage: `Skipped::Metadata` (r:0 w:0) @@ -138,10 +138,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `452 + k * (69 ±0)` // Estimated: `442 + k * (70 ±0)` - // Minimum execution time: 12_431_000 picoseconds. - Weight::from_parts(12_776_000, 442) - // Standard Error: 1_067 - .saturating_add(Weight::from_parts(1_151_178, 0).saturating_mul(k.into())) + // Minimum execution time: 12_411_000 picoseconds. + Weight::from_parts(12_587_000, 442) + // Standard Error: 1_213 + .saturating_add(Weight::from_parts(1_149_896, 0).saturating_mul(k.into())) .saturating_add(T::DbWeight::get().reads(2_u64)) .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(k.into()))) .saturating_add(T::DbWeight::get().writes(2_u64)) @@ -155,10 +155,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `211 + c * (1 ±0)` // Estimated: `6149 + c * (1 ±0)` - // Minimum execution time: 8_449_000 picoseconds. - Weight::from_parts(8_973_080, 6149) - // Standard Error: 1 - .saturating_add(Weight::from_parts(1_159, 0).saturating_mul(c.into())) + // Minimum execution time: 8_308_000 picoseconds. + Weight::from_parts(9_014_393, 6149) + // Standard Error: 0 + .saturating_add(Weight::from_parts(1_169, 0).saturating_mul(c.into())) .saturating_add(T::DbWeight::get().reads(2_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(c.into())) @@ -171,8 +171,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `510` // Estimated: `6450` - // Minimum execution time: 16_720_000 picoseconds. - Weight::from_parts(17_514_000, 6450) + // Minimum execution time: 16_847_000 picoseconds. + Weight::from_parts(17_478_000, 6450) .saturating_add(T::DbWeight::get().reads(3_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -185,10 +185,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `171 + k * (1 ±0)` // Estimated: `3635 + k * (1 ±0)` - // Minimum execution time: 3_540_000 picoseconds. - Weight::from_parts(40_895, 3635) - // Standard Error: 1_472 - .saturating_add(Weight::from_parts(1_232_021, 0).saturating_mul(k.into())) + // Minimum execution time: 3_456_000 picoseconds. + Weight::from_parts(3_534_000, 3635) + // Standard Error: 679 + .saturating_add(Weight::from_parts(1_224_649, 0).saturating_mul(k.into())) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(2_u64)) .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(k.into()))) @@ -207,10 +207,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `325 + c * (1 ±0)` // Estimated: `6263 + c * (1 ±0)` - // Minimum execution time: 16_770_000 picoseconds. - Weight::from_parts(16_902_655, 6263) - // Standard Error: 1 - .saturating_add(Weight::from_parts(377, 0).saturating_mul(c.into())) + // Minimum execution time: 16_933_000 picoseconds. + Weight::from_parts(16_929_238, 6263) + // Standard Error: 0 + .saturating_add(Weight::from_parts(405, 0).saturating_mul(c.into())) .saturating_add(T::DbWeight::get().reads(4_u64)) .saturating_add(T::DbWeight::get().writes(2_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(c.into())) @@ -221,8 +221,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `440` // Estimated: `6380` - // Minimum execution time: 12_617_000 picoseconds. - Weight::from_parts(13_253_000, 6380) + // Minimum execution time: 12_826_000 picoseconds. + Weight::from_parts(13_566_000, 6380) .saturating_add(T::DbWeight::get().reads(2_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -236,8 +236,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `352` // Estimated: `6292` - // Minimum execution time: 47_835_000 picoseconds. - Weight::from_parts(49_254_000, 6292) + // Minimum execution time: 48_129_000 picoseconds. + Weight::from_parts(49_472_000, 6292) .saturating_add(T::DbWeight::get().reads(4_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -249,8 +249,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `594` // Estimated: `6534` - // Minimum execution time: 55_489_000 picoseconds. - Weight::from_parts(57_136_000, 6534) + // Minimum execution time: 55_401_000 picoseconds. + Weight::from_parts(57_543_000, 6534) .saturating_add(T::DbWeight::get().reads(4_u64)) .saturating_add(T::DbWeight::get().writes(2_u64)) } @@ -260,8 +260,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `409` // Estimated: `6349` - // Minimum execution time: 11_795_000 picoseconds. - Weight::from_parts(12_655_000, 6349) + // Minimum execution time: 12_066_000 picoseconds. + Weight::from_parts(12_386_000, 6349) .saturating_add(T::DbWeight::get().reads(2_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -271,8 +271,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `142` // Estimated: `1627` - // Minimum execution time: 2_448_000 picoseconds. - Weight::from_parts(2_608_000, 1627) + // Minimum execution time: 2_394_000 picoseconds. + Weight::from_parts(2_695_000, 1627) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -284,8 +284,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `166` // Estimated: `3631` - // Minimum execution time: 12_208_000 picoseconds. - Weight::from_parts(12_653_000, 3631) + // Minimum execution time: 12_286_000 picoseconds. + Weight::from_parts(12_764_000, 3631) .saturating_add(T::DbWeight::get().reads(2_u64)) .saturating_add(T::DbWeight::get().writes(2_u64)) } @@ -295,8 +295,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `142` // Estimated: `3607` - // Minimum execution time: 4_830_000 picoseconds. - Weight::from_parts(5_026_000, 3607) + // Minimum execution time: 4_888_000 picoseconds. + Weight::from_parts(5_192_000, 3607) .saturating_add(T::DbWeight::get().reads(1_u64)) } /// Storage: UNKNOWN KEY `0x4342193e496fab7ec59d615ed0dc55304e7b9012096b41c4eb3aaf947f6ea429` (r:1 w:0) @@ -307,8 +307,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `167` // Estimated: `3632` - // Minimum execution time: 6_178_000 picoseconds. - Weight::from_parts(6_485_000, 3632) + // Minimum execution time: 6_033_000 picoseconds. + Weight::from_parts(6_404_000, 3632) .saturating_add(T::DbWeight::get().reads(2_u64)) } /// Storage: UNKNOWN KEY `0x4342193e496fab7ec59d615ed0dc55304e7b9012096b41c4eb3aaf947f6ea429` (r:1 w:0) @@ -319,8 +319,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `142` // Estimated: `3607` - // Minimum execution time: 6_203_000 picoseconds. - Weight::from_parts(6_533_000, 3607) + // Minimum execution time: 6_260_000 picoseconds. + Weight::from_parts(6_761_000, 3607) .saturating_add(T::DbWeight::get().reads(2_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -341,10 +341,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `801 + c * (1 ±0)` // Estimated: `4264 + c * (1 ±0)` - // Minimum execution time: 290_448_000 picoseconds. - Weight::from_parts(274_301_376, 4264) - // Standard Error: 64 - .saturating_add(Weight::from_parts(32_946, 0).saturating_mul(c.into())) + // Minimum execution time: 282_827_000 picoseconds. + Weight::from_parts(268_595_710, 4264) + // Standard Error: 74 + .saturating_add(Weight::from_parts(33_961, 0).saturating_mul(c.into())) .saturating_add(T::DbWeight::get().reads(6_u64)) .saturating_add(T::DbWeight::get().writes(2_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(c.into())) @@ -372,14 +372,14 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `323` // Estimated: `6262` - // Minimum execution time: 3_777_124_000 picoseconds. - Weight::from_parts(858_828_640, 6262) - // Standard Error: 158 - .saturating_add(Weight::from_parts(67_299, 0).saturating_mul(c.into())) - // Standard Error: 19 - .saturating_add(Weight::from_parts(1_353, 0).saturating_mul(i.into())) - // Standard Error: 19 - .saturating_add(Weight::from_parts(1_580, 0).saturating_mul(s.into())) + // Minimum execution time: 4_039_064_000 picoseconds. + Weight::from_parts(511_488_092, 6262) + // Standard Error: 154 + .saturating_add(Weight::from_parts(68_951, 0).saturating_mul(c.into())) + // Standard Error: 18 + .saturating_add(Weight::from_parts(1_740, 0).saturating_mul(i.into())) + // Standard Error: 18 + .saturating_add(Weight::from_parts(1_737, 0).saturating_mul(s.into())) .saturating_add(T::DbWeight::get().reads(8_u64)) .saturating_add(T::DbWeight::get().writes(7_u64)) } @@ -405,12 +405,12 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `560` // Estimated: `4029` - // Minimum execution time: 1_960_317_000 picoseconds. - Weight::from_parts(1_985_571_000, 4029) + // Minimum execution time: 2_043_035_000 picoseconds. + Weight::from_parts(2_056_535_000, 4029) // Standard Error: 26 - .saturating_add(Weight::from_parts(849, 0).saturating_mul(i.into())) + .saturating_add(Weight::from_parts(907, 0).saturating_mul(i.into())) // Standard Error: 26 - .saturating_add(Weight::from_parts(813, 0).saturating_mul(s.into())) + .saturating_add(Weight::from_parts(797, 0).saturating_mul(s.into())) .saturating_add(T::DbWeight::get().reads(8_u64)) .saturating_add(T::DbWeight::get().writes(5_u64)) } @@ -430,8 +430,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `826` // Estimated: `4291` - // Minimum execution time: 195_828_000 picoseconds. - Weight::from_parts(203_985_000, 4291) + // Minimum execution time: 197_670_000 picoseconds. + Weight::from_parts(207_490_000, 4291) .saturating_add(T::DbWeight::get().reads(6_u64)) .saturating_add(T::DbWeight::get().writes(2_u64)) } @@ -448,10 +448,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `142` // Estimated: `3607` - // Minimum execution time: 263_760_000 picoseconds. - Weight::from_parts(269_484_033, 3607) - // Standard Error: 54 - .saturating_add(Weight::from_parts(32_487, 0).saturating_mul(c.into())) + // Minimum execution time: 268_742_000 picoseconds. + Weight::from_parts(271_032_265, 3607) + // Standard Error: 67 + .saturating_add(Weight::from_parts(33_877, 0).saturating_mul(c.into())) .saturating_add(T::DbWeight::get().reads(3_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) } @@ -468,10 +468,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `142` // Estimated: `3607` - // Minimum execution time: 274_929_000 picoseconds. - Weight::from_parts(285_405_269, 3607) - // Standard Error: 52 - .saturating_add(Weight::from_parts(32_658, 0).saturating_mul(c.into())) + // Minimum execution time: 262_093_000 picoseconds. + Weight::from_parts(284_700_466, 3607) + // Standard Error: 64 + .saturating_add(Weight::from_parts(33_947, 0).saturating_mul(c.into())) .saturating_add(T::DbWeight::get().reads(3_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) } @@ -487,8 +487,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `315` // Estimated: `3780` - // Minimum execution time: 42_693_000 picoseconds. - Weight::from_parts(43_590_000, 3780) + // Minimum execution time: 41_895_000 picoseconds. + Weight::from_parts(43_710_000, 3780) .saturating_add(T::DbWeight::get().reads(3_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) } @@ -502,8 +502,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `552` // Estimated: `6492` - // Minimum execution time: 26_126_000 picoseconds. - Weight::from_parts(27_456_000, 6492) + // Minimum execution time: 26_308_000 picoseconds. + Weight::from_parts(27_330_000, 6492) .saturating_add(T::DbWeight::get().reads(4_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) } @@ -512,17 +512,17 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 9_933_000 picoseconds. - Weight::from_parts(10_586_445, 0) + // Minimum execution time: 9_599_000 picoseconds. + Weight::from_parts(9_964_505, 0) // Standard Error: 74 - .saturating_add(Weight::from_parts(73_229, 0).saturating_mul(r.into())) + .saturating_add(Weight::from_parts(71_132, 0).saturating_mul(r.into())) } fn seal_caller() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` // Minimum execution time: 621_000 picoseconds. - Weight::from_parts(667_000, 0) + Weight::from_parts(669_000, 0) } /// Storage: `Contracts::ContractInfoOf` (r:1 w:0) /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) @@ -530,8 +530,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `354` // Estimated: `3819` - // Minimum execution time: 6_594_000 picoseconds. - Weight::from_parts(6_855_000, 3819) + // Minimum execution time: 6_787_000 picoseconds. + Weight::from_parts(7_039_000, 3819) .saturating_add(T::DbWeight::get().reads(1_u64)) } /// Storage: `Contracts::ContractInfoOf` (r:1 w:0) @@ -540,79 +540,79 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `447` // Estimated: `3912` - // Minimum execution time: 7_893_000 picoseconds. - Weight::from_parts(8_172_000, 3912) + // Minimum execution time: 7_839_000 picoseconds. + Weight::from_parts(8_154_000, 3912) .saturating_add(T::DbWeight::get().reads(1_u64)) } fn seal_own_code_hash() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 772_000 picoseconds. - Weight::from_parts(826_000, 0) + // Minimum execution time: 729_000 picoseconds. + Weight::from_parts(805_000, 0) } fn seal_caller_is_origin() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 409_000 picoseconds. - Weight::from_parts(431_000, 0) + // Minimum execution time: 422_000 picoseconds. + Weight::from_parts(442_000, 0) } fn seal_caller_is_root() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 333_000 picoseconds. - Weight::from_parts(360_000, 0) + // Minimum execution time: 327_000 picoseconds. + Weight::from_parts(361_000, 0) } fn seal_address() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 609_000 picoseconds. - Weight::from_parts(628_000, 0) + // Minimum execution time: 572_000 picoseconds. + Weight::from_parts(627_000, 0) } fn seal_gas_left() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 669_000 picoseconds. - Weight::from_parts(741_000, 0) + // Minimum execution time: 698_000 picoseconds. + Weight::from_parts(731_000, 0) } fn seal_balance() -> Weight { // Proof Size summary in bytes: // Measured: `140` // Estimated: `0` - // Minimum execution time: 4_778_000 picoseconds. - Weight::from_parts(4_985_000, 0) + // Minimum execution time: 4_569_000 picoseconds. + Weight::from_parts(4_823_000, 0) } fn seal_value_transferred() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 585_000 picoseconds. - Weight::from_parts(610_000, 0) + // Minimum execution time: 563_000 picoseconds. + Weight::from_parts(591_000, 0) } fn seal_minimum_balance() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` // Minimum execution time: 567_000 picoseconds. - Weight::from_parts(601_000, 0) + Weight::from_parts(592_000, 0) } fn seal_block_number() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 592_000 picoseconds. - Weight::from_parts(627_000, 0) + // Minimum execution time: 534_000 picoseconds. + Weight::from_parts(586_000, 0) } fn seal_now() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 576_000 picoseconds. - Weight::from_parts(616_000, 0) + // Minimum execution time: 507_000 picoseconds. + Weight::from_parts(577_000, 0) } /// Storage: `TransactionPayment::NextFeeMultiplier` (r:1 w:0) /// Proof: `TransactionPayment::NextFeeMultiplier` (`max_values`: Some(1), `max_size`: Some(16), added: 511, mode: `Measured`) @@ -620,8 +620,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `67` // Estimated: `1552` - // Minimum execution time: 4_477_000 picoseconds. - Weight::from_parts(4_706_000, 1552) + // Minimum execution time: 4_331_000 picoseconds. + Weight::from_parts(4_582_000, 1552) .saturating_add(T::DbWeight::get().reads(1_u64)) } /// The range of component `n` is `[0, 1048572]`. @@ -629,20 +629,20 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 503_000 picoseconds. - Weight::from_parts(528_000, 0) + // Minimum execution time: 435_000 picoseconds. + Weight::from_parts(500_000, 0) // Standard Error: 3 - .saturating_add(Weight::from_parts(292, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(303, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 1048572]`. fn seal_return(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 333_000 picoseconds. - Weight::from_parts(371_000, 0) + // Minimum execution time: 331_000 picoseconds. + Weight::from_parts(356_000, 0) // Standard Error: 9 - .saturating_add(Weight::from_parts(398, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(423, 0).saturating_mul(n.into())) } /// Storage: `Contracts::DeletionQueueCounter` (r:1 w:1) /// Proof: `Contracts::DeletionQueueCounter` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`) @@ -655,10 +655,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `319 + n * (78 ±0)` // Estimated: `3784 + n * (2553 ±0)` - // Minimum execution time: 14_468_000 picoseconds. - Weight::from_parts(16_793_355, 3784) - // Standard Error: 8_365 - .saturating_add(Weight::from_parts(3_694_281, 0).saturating_mul(n.into())) + // Minimum execution time: 14_488_000 picoseconds. + Weight::from_parts(16_354_601, 3784) + // Standard Error: 7_864 + .saturating_add(Weight::from_parts(3_700_384, 0).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads(2_u64)) .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(n.into()))) .saturating_add(T::DbWeight::get().writes(3_u64)) @@ -671,8 +671,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `76` // Estimated: `1561` - // Minimum execution time: 3_563_000 picoseconds. - Weight::from_parts(3_784_000, 1561) + // Minimum execution time: 3_470_000 picoseconds. + Weight::from_parts(3_637_000, 1561) .saturating_add(T::DbWeight::get().reads(1_u64)) } /// Storage: `System::EventTopics` (r:4 w:4) @@ -683,12 +683,12 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `990 + t * (2475 ±0)` - // Minimum execution time: 4_064_000 picoseconds. - Weight::from_parts(4_551_057, 990) - // Standard Error: 7_249 - .saturating_add(Weight::from_parts(2_342_414, 0).saturating_mul(t.into())) + // Minimum execution time: 4_046_000 picoseconds. + Weight::from_parts(4_233_938, 990) + // Standard Error: 7_203 + .saturating_add(Weight::from_parts(2_402_117, 0).saturating_mul(t.into())) // Standard Error: 2 - .saturating_add(Weight::from_parts(9, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(27, 0).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(t.into()))) .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(t.into()))) .saturating_add(Weight::from_parts(0, 2475).saturating_mul(t.into())) @@ -698,10 +698,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 436_000 picoseconds. - Weight::from_parts(440_000, 0) + // Minimum execution time: 421_000 picoseconds. + Weight::from_parts(456_000, 0) // Standard Error: 10 - .saturating_add(Weight::from_parts(1_201, 0).saturating_mul(i.into())) + .saturating_add(Weight::from_parts(1_217, 0).saturating_mul(i.into())) } /// Storage: `Skipped::Metadata` (r:0 w:0) /// Proof: `Skipped::Metadata` (`max_values`: None, `max_size`: None, mode: `Measured`) @@ -711,12 +711,12 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `250 + o * (1 ±0)` // Estimated: `249 + o * (1 ±0)` - // Minimum execution time: 10_097_000 picoseconds. - Weight::from_parts(9_877_776, 249) + // Minimum execution time: 9_900_000 picoseconds. + Weight::from_parts(9_611_602, 249) // Standard Error: 1 - .saturating_add(Weight::from_parts(241, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(282, 0).saturating_mul(n.into())) // Standard Error: 1 - .saturating_add(Weight::from_parts(58, 0).saturating_mul(o.into())) + .saturating_add(Weight::from_parts(70, 0).saturating_mul(o.into())) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(o.into())) @@ -728,10 +728,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `248 + n * (1 ±0)` // Estimated: `248 + n * (1 ±0)` - // Minimum execution time: 8_068_000 picoseconds. - Weight::from_parts(9_298_830, 248) + // Minimum execution time: 7_965_000 picoseconds. + Weight::from_parts(9_211_072, 248) // Standard Error: 2 - .saturating_add(Weight::from_parts(77, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(82, 0).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) @@ -743,10 +743,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `248 + n * (1 ±0)` // Estimated: `248 + n * (1 ±0)` - // Minimum execution time: 7_315_000 picoseconds. - Weight::from_parts(9_026_712, 248) + // Minimum execution time: 6_851_000 picoseconds. + Weight::from_parts(8_930_522, 248) // Standard Error: 3 - .saturating_add(Weight::from_parts(595, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(647, 0).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) } @@ -757,8 +757,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `248 + n * (1 ±0)` // Estimated: `248 + n * (1 ±0)` - // Minimum execution time: 6_833_000 picoseconds. - Weight::from_parts(7_980_890, 248) + // Minimum execution time: 6_602_000 picoseconds. + Weight::from_parts(7_843_808, 248) // Standard Error: 2 .saturating_add(Weight::from_parts(85, 0).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads(1_u64)) @@ -771,10 +771,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `248 + n * (1 ±0)` // Estimated: `248 + n * (1 ±0)` - // Minimum execution time: 8_250_000 picoseconds. - Weight::from_parts(10_058_209, 248) - // Standard Error: 3 - .saturating_add(Weight::from_parts(607, 0).saturating_mul(n.into())) + // Minimum execution time: 8_245_000 picoseconds. + Weight::from_parts(9_953_659, 248) + // Standard Error: 2 + .saturating_add(Weight::from_parts(654, 0).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) @@ -783,8 +783,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `140` // Estimated: `0` - // Minimum execution time: 8_858_000 picoseconds. - Weight::from_parts(9_238_000, 0) + // Minimum execution time: 8_993_000 picoseconds. + Weight::from_parts(9_445_000, 0) } /// Storage: `Contracts::ContractInfoOf` (r:1 w:1) /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) @@ -797,18 +797,16 @@ impl WeightInfo for SubstrateWeight { /// The range of component `t` is `[0, 1]`. /// The range of component `c` is `[0, 1]`. /// The range of component `i` is `[0, 1048576]`. - fn seal_call(t: u32, c: u32, i: u32, ) -> Weight { + fn seal_call(t: u32, _c: u32, i: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `620 + t * (280 ±0)` // Estimated: `4085 + t * (2182 ±0)` - // Minimum execution time: 153_417_000 picoseconds. - Weight::from_parts(154_858_902, 4085) - // Standard Error: 339_920 - .saturating_add(Weight::from_parts(45_327_013, 0).saturating_mul(t.into())) - // Standard Error: 339_920 - .saturating_add(Weight::from_parts(1_016_817, 0).saturating_mul(c.into())) + // Minimum execution time: 151_051_000 picoseconds. + Weight::from_parts(164_928_785, 4085) + // Standard Error: 344_718 + .saturating_add(Weight::from_parts(40_015_500, 0).saturating_mul(t.into())) // Standard Error: 0 - .saturating_add(Weight::from_parts(7, 0).saturating_mul(i.into())) + .saturating_add(Weight::from_parts(2, 0).saturating_mul(i.into())) .saturating_add(T::DbWeight::get().reads(3_u64)) .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(t.into()))) .saturating_add(T::DbWeight::get().writes(1_u64)) @@ -823,8 +821,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `430` // Estimated: `3895` - // Minimum execution time: 140_613_000 picoseconds. - Weight::from_parts(149_663_000, 3895) + // Minimum execution time: 138_670_000 picoseconds. + Weight::from_parts(144_148_000, 3895) .saturating_add(T::DbWeight::get().reads(2_u64)) } /// Storage: `Contracts::CodeInfoOf` (r:1 w:1) @@ -844,14 +842,14 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `676` // Estimated: `4138` - // Minimum execution time: 1_637_633_000 picoseconds. - Weight::from_parts(1_668_892, 4138) - // Standard Error: 8_487_760 - .saturating_add(Weight::from_parts(210_998_534, 0).saturating_mul(t.into())) - // Standard Error: 13 - .saturating_add(Weight::from_parts(1_392, 0).saturating_mul(i.into())) - // Standard Error: 13 - .saturating_add(Weight::from_parts(1_733, 0).saturating_mul(s.into())) + // Minimum execution time: 1_744_236_000 picoseconds. + Weight::from_parts(67_596_989, 4138) + // Standard Error: 6_993_227 + .saturating_add(Weight::from_parts(156_283_395, 0).saturating_mul(t.into())) + // Standard Error: 11 + .saturating_add(Weight::from_parts(1_489, 0).saturating_mul(i.into())) + // Standard Error: 11 + .saturating_add(Weight::from_parts(1_781, 0).saturating_mul(s.into())) .saturating_add(T::DbWeight::get().reads(5_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) } @@ -860,64 +858,64 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 868_000 picoseconds. - Weight::from_parts(882_000, 0) + // Minimum execution time: 838_000 picoseconds. + Weight::from_parts(855_000, 0) // Standard Error: 0 - .saturating_add(Weight::from_parts(1_051, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(1_083, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 1048576]`. fn seal_hash_keccak_256(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_404_000 picoseconds. - Weight::from_parts(1_490_000, 0) + // Minimum execution time: 1_449_000 picoseconds. + Weight::from_parts(1_466_000, 0) // Standard Error: 0 - .saturating_add(Weight::from_parts(3_316, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(3_350, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 1048576]`. fn seal_hash_blake2_256(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 849_000 picoseconds. - Weight::from_parts(913_000, 0) + // Minimum execution time: 759_000 picoseconds. + Weight::from_parts(800_000, 0) // Standard Error: 0 - .saturating_add(Weight::from_parts(1_186, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(1_218, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 1048576]`. fn seal_hash_blake2_128(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 697_000 picoseconds. - Weight::from_parts(772_000, 0) + // Minimum execution time: 714_000 picoseconds. + Weight::from_parts(733_000, 0) // Standard Error: 0 - .saturating_add(Weight::from_parts(1_186, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(1_220, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 125697]`. fn seal_sr25519_verify(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 42_862_000 picoseconds. - Weight::from_parts(48_510_759, 0) - // Standard Error: 10 - .saturating_add(Weight::from_parts(4_451, 0).saturating_mul(n.into())) + // Minimum execution time: 47_253_000 picoseconds. + Weight::from_parts(51_184_900, 0) + // Standard Error: 9 + .saturating_add(Weight::from_parts(4_602, 0).saturating_mul(n.into())) } fn seal_ecdsa_recover() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 47_180_000 picoseconds. - Weight::from_parts(48_679_000, 0) + // Minimum execution time: 47_378_000 picoseconds. + Weight::from_parts(49_505_000, 0) } fn seal_ecdsa_to_eth_address() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 13_057_000 picoseconds. - Weight::from_parts(13_227_000, 0) + // Minimum execution time: 13_088_000 picoseconds. + Weight::from_parts(13_299_000, 0) } /// Storage: `Contracts::CodeInfoOf` (r:1 w:1) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) @@ -927,8 +925,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `430` // Estimated: `3895` - // Minimum execution time: 19_335_000 picoseconds. - Weight::from_parts(20_225_000, 3895) + // Minimum execution time: 19_326_000 picoseconds. + Weight::from_parts(20_179_000, 3895) .saturating_add(T::DbWeight::get().reads(2_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -938,8 +936,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `355` // Estimated: `3820` - // Minimum execution time: 9_400_000 picoseconds. - Weight::from_parts(9_743_000, 3820) + // Minimum execution time: 9_432_000 picoseconds. + Weight::from_parts(9_851_000, 3820) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -949,8 +947,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `355` // Estimated: `3558` - // Minimum execution time: 8_125_000 picoseconds. - Weight::from_parts(8_491_000, 3558) + // Minimum execution time: 8_359_000 picoseconds. + Weight::from_parts(8_676_000, 3558) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -958,15 +956,15 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 330_000 picoseconds. - Weight::from_parts(383_000, 0) + // Minimum execution time: 320_000 picoseconds. + Weight::from_parts(366_000, 0) } fn seal_account_reentrance_count() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 349_000 picoseconds. - Weight::from_parts(380_000, 0) + // Minimum execution time: 342_000 picoseconds. + Weight::from_parts(379_000, 0) } /// Storage: `Contracts::Nonce` (r:1 w:0) /// Proof: `Contracts::Nonce` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`) @@ -974,8 +972,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `219` // Estimated: `1704` - // Minimum execution time: 3_083_000 picoseconds. - Weight::from_parts(3_248_000, 1704) + // Minimum execution time: 3_001_000 picoseconds. + Weight::from_parts(3_163_000, 1704) .saturating_add(T::DbWeight::get().reads(1_u64)) } /// The range of component `r` is `[0, 5000]`. @@ -983,10 +981,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 918_000 picoseconds. - Weight::from_parts(1_027_293, 0) - // Standard Error: 23 - .saturating_add(Weight::from_parts(14_764, 0).saturating_mul(r.into())) + // Minimum execution time: 952_000 picoseconds. + Weight::from_parts(571_197, 0) + // Standard Error: 19 + .saturating_add(Weight::from_parts(14_886, 0).saturating_mul(r.into())) } } @@ -998,8 +996,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `142` // Estimated: `1627` - // Minimum execution time: 2_024_000 picoseconds. - Weight::from_parts(2_252_000, 1627) + // Minimum execution time: 2_074_000 picoseconds. + Weight::from_parts(2_166_000, 1627) .saturating_add(RocksDbWeight::get().reads(1_u64)) } /// Storage: `Skipped::Metadata` (r:0 w:0) @@ -1009,10 +1007,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `452 + k * (69 ±0)` // Estimated: `442 + k * (70 ±0)` - // Minimum execution time: 12_431_000 picoseconds. - Weight::from_parts(12_776_000, 442) - // Standard Error: 1_067 - .saturating_add(Weight::from_parts(1_151_178, 0).saturating_mul(k.into())) + // Minimum execution time: 12_411_000 picoseconds. + Weight::from_parts(12_587_000, 442) + // Standard Error: 1_213 + .saturating_add(Weight::from_parts(1_149_896, 0).saturating_mul(k.into())) .saturating_add(RocksDbWeight::get().reads(2_u64)) .saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(k.into()))) .saturating_add(RocksDbWeight::get().writes(2_u64)) @@ -1026,10 +1024,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `211 + c * (1 ±0)` // Estimated: `6149 + c * (1 ±0)` - // Minimum execution time: 8_449_000 picoseconds. - Weight::from_parts(8_973_080, 6149) - // Standard Error: 1 - .saturating_add(Weight::from_parts(1_159, 0).saturating_mul(c.into())) + // Minimum execution time: 8_308_000 picoseconds. + Weight::from_parts(9_014_393, 6149) + // Standard Error: 0 + .saturating_add(Weight::from_parts(1_169, 0).saturating_mul(c.into())) .saturating_add(RocksDbWeight::get().reads(2_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(c.into())) @@ -1042,8 +1040,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `510` // Estimated: `6450` - // Minimum execution time: 16_720_000 picoseconds. - Weight::from_parts(17_514_000, 6450) + // Minimum execution time: 16_847_000 picoseconds. + Weight::from_parts(17_478_000, 6450) .saturating_add(RocksDbWeight::get().reads(3_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -1056,10 +1054,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `171 + k * (1 ±0)` // Estimated: `3635 + k * (1 ±0)` - // Minimum execution time: 3_540_000 picoseconds. - Weight::from_parts(40_895, 3635) - // Standard Error: 1_472 - .saturating_add(Weight::from_parts(1_232_021, 0).saturating_mul(k.into())) + // Minimum execution time: 3_456_000 picoseconds. + Weight::from_parts(3_534_000, 3635) + // Standard Error: 679 + .saturating_add(Weight::from_parts(1_224_649, 0).saturating_mul(k.into())) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(2_u64)) .saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(k.into()))) @@ -1078,10 +1076,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `325 + c * (1 ±0)` // Estimated: `6263 + c * (1 ±0)` - // Minimum execution time: 16_770_000 picoseconds. - Weight::from_parts(16_902_655, 6263) - // Standard Error: 1 - .saturating_add(Weight::from_parts(377, 0).saturating_mul(c.into())) + // Minimum execution time: 16_933_000 picoseconds. + Weight::from_parts(16_929_238, 6263) + // Standard Error: 0 + .saturating_add(Weight::from_parts(405, 0).saturating_mul(c.into())) .saturating_add(RocksDbWeight::get().reads(4_u64)) .saturating_add(RocksDbWeight::get().writes(2_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(c.into())) @@ -1092,8 +1090,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `440` // Estimated: `6380` - // Minimum execution time: 12_617_000 picoseconds. - Weight::from_parts(13_253_000, 6380) + // Minimum execution time: 12_826_000 picoseconds. + Weight::from_parts(13_566_000, 6380) .saturating_add(RocksDbWeight::get().reads(2_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -1107,8 +1105,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `352` // Estimated: `6292` - // Minimum execution time: 47_835_000 picoseconds. - Weight::from_parts(49_254_000, 6292) + // Minimum execution time: 48_129_000 picoseconds. + Weight::from_parts(49_472_000, 6292) .saturating_add(RocksDbWeight::get().reads(4_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -1120,8 +1118,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `594` // Estimated: `6534` - // Minimum execution time: 55_489_000 picoseconds. - Weight::from_parts(57_136_000, 6534) + // Minimum execution time: 55_401_000 picoseconds. + Weight::from_parts(57_543_000, 6534) .saturating_add(RocksDbWeight::get().reads(4_u64)) .saturating_add(RocksDbWeight::get().writes(2_u64)) } @@ -1131,8 +1129,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `409` // Estimated: `6349` - // Minimum execution time: 11_795_000 picoseconds. - Weight::from_parts(12_655_000, 6349) + // Minimum execution time: 12_066_000 picoseconds. + Weight::from_parts(12_386_000, 6349) .saturating_add(RocksDbWeight::get().reads(2_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -1142,8 +1140,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `142` // Estimated: `1627` - // Minimum execution time: 2_448_000 picoseconds. - Weight::from_parts(2_608_000, 1627) + // Minimum execution time: 2_394_000 picoseconds. + Weight::from_parts(2_695_000, 1627) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -1155,8 +1153,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `166` // Estimated: `3631` - // Minimum execution time: 12_208_000 picoseconds. - Weight::from_parts(12_653_000, 3631) + // Minimum execution time: 12_286_000 picoseconds. + Weight::from_parts(12_764_000, 3631) .saturating_add(RocksDbWeight::get().reads(2_u64)) .saturating_add(RocksDbWeight::get().writes(2_u64)) } @@ -1166,8 +1164,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `142` // Estimated: `3607` - // Minimum execution time: 4_830_000 picoseconds. - Weight::from_parts(5_026_000, 3607) + // Minimum execution time: 4_888_000 picoseconds. + Weight::from_parts(5_192_000, 3607) .saturating_add(RocksDbWeight::get().reads(1_u64)) } /// Storage: UNKNOWN KEY `0x4342193e496fab7ec59d615ed0dc55304e7b9012096b41c4eb3aaf947f6ea429` (r:1 w:0) @@ -1178,8 +1176,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `167` // Estimated: `3632` - // Minimum execution time: 6_178_000 picoseconds. - Weight::from_parts(6_485_000, 3632) + // Minimum execution time: 6_033_000 picoseconds. + Weight::from_parts(6_404_000, 3632) .saturating_add(RocksDbWeight::get().reads(2_u64)) } /// Storage: UNKNOWN KEY `0x4342193e496fab7ec59d615ed0dc55304e7b9012096b41c4eb3aaf947f6ea429` (r:1 w:0) @@ -1190,8 +1188,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `142` // Estimated: `3607` - // Minimum execution time: 6_203_000 picoseconds. - Weight::from_parts(6_533_000, 3607) + // Minimum execution time: 6_260_000 picoseconds. + Weight::from_parts(6_761_000, 3607) .saturating_add(RocksDbWeight::get().reads(2_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -1212,10 +1210,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `801 + c * (1 ±0)` // Estimated: `4264 + c * (1 ±0)` - // Minimum execution time: 290_448_000 picoseconds. - Weight::from_parts(274_301_376, 4264) - // Standard Error: 64 - .saturating_add(Weight::from_parts(32_946, 0).saturating_mul(c.into())) + // Minimum execution time: 282_827_000 picoseconds. + Weight::from_parts(268_595_710, 4264) + // Standard Error: 74 + .saturating_add(Weight::from_parts(33_961, 0).saturating_mul(c.into())) .saturating_add(RocksDbWeight::get().reads(6_u64)) .saturating_add(RocksDbWeight::get().writes(2_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(c.into())) @@ -1243,14 +1241,14 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `323` // Estimated: `6262` - // Minimum execution time: 3_777_124_000 picoseconds. - Weight::from_parts(858_828_640, 6262) - // Standard Error: 158 - .saturating_add(Weight::from_parts(67_299, 0).saturating_mul(c.into())) - // Standard Error: 19 - .saturating_add(Weight::from_parts(1_353, 0).saturating_mul(i.into())) - // Standard Error: 19 - .saturating_add(Weight::from_parts(1_580, 0).saturating_mul(s.into())) + // Minimum execution time: 4_039_064_000 picoseconds. + Weight::from_parts(511_488_092, 6262) + // Standard Error: 154 + .saturating_add(Weight::from_parts(68_951, 0).saturating_mul(c.into())) + // Standard Error: 18 + .saturating_add(Weight::from_parts(1_740, 0).saturating_mul(i.into())) + // Standard Error: 18 + .saturating_add(Weight::from_parts(1_737, 0).saturating_mul(s.into())) .saturating_add(RocksDbWeight::get().reads(8_u64)) .saturating_add(RocksDbWeight::get().writes(7_u64)) } @@ -1276,12 +1274,12 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `560` // Estimated: `4029` - // Minimum execution time: 1_960_317_000 picoseconds. - Weight::from_parts(1_985_571_000, 4029) + // Minimum execution time: 2_043_035_000 picoseconds. + Weight::from_parts(2_056_535_000, 4029) // Standard Error: 26 - .saturating_add(Weight::from_parts(849, 0).saturating_mul(i.into())) + .saturating_add(Weight::from_parts(907, 0).saturating_mul(i.into())) // Standard Error: 26 - .saturating_add(Weight::from_parts(813, 0).saturating_mul(s.into())) + .saturating_add(Weight::from_parts(797, 0).saturating_mul(s.into())) .saturating_add(RocksDbWeight::get().reads(8_u64)) .saturating_add(RocksDbWeight::get().writes(5_u64)) } @@ -1301,8 +1299,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `826` // Estimated: `4291` - // Minimum execution time: 195_828_000 picoseconds. - Weight::from_parts(203_985_000, 4291) + // Minimum execution time: 197_670_000 picoseconds. + Weight::from_parts(207_490_000, 4291) .saturating_add(RocksDbWeight::get().reads(6_u64)) .saturating_add(RocksDbWeight::get().writes(2_u64)) } @@ -1319,10 +1317,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `142` // Estimated: `3607` - // Minimum execution time: 263_760_000 picoseconds. - Weight::from_parts(269_484_033, 3607) - // Standard Error: 54 - .saturating_add(Weight::from_parts(32_487, 0).saturating_mul(c.into())) + // Minimum execution time: 268_742_000 picoseconds. + Weight::from_parts(271_032_265, 3607) + // Standard Error: 67 + .saturating_add(Weight::from_parts(33_877, 0).saturating_mul(c.into())) .saturating_add(RocksDbWeight::get().reads(3_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) } @@ -1339,10 +1337,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `142` // Estimated: `3607` - // Minimum execution time: 274_929_000 picoseconds. - Weight::from_parts(285_405_269, 3607) - // Standard Error: 52 - .saturating_add(Weight::from_parts(32_658, 0).saturating_mul(c.into())) + // Minimum execution time: 262_093_000 picoseconds. + Weight::from_parts(284_700_466, 3607) + // Standard Error: 64 + .saturating_add(Weight::from_parts(33_947, 0).saturating_mul(c.into())) .saturating_add(RocksDbWeight::get().reads(3_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) } @@ -1358,8 +1356,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `315` // Estimated: `3780` - // Minimum execution time: 42_693_000 picoseconds. - Weight::from_parts(43_590_000, 3780) + // Minimum execution time: 41_895_000 picoseconds. + Weight::from_parts(43_710_000, 3780) .saturating_add(RocksDbWeight::get().reads(3_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) } @@ -1373,8 +1371,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `552` // Estimated: `6492` - // Minimum execution time: 26_126_000 picoseconds. - Weight::from_parts(27_456_000, 6492) + // Minimum execution time: 26_308_000 picoseconds. + Weight::from_parts(27_330_000, 6492) .saturating_add(RocksDbWeight::get().reads(4_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) } @@ -1383,17 +1381,17 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 9_933_000 picoseconds. - Weight::from_parts(10_586_445, 0) + // Minimum execution time: 9_599_000 picoseconds. + Weight::from_parts(9_964_505, 0) // Standard Error: 74 - .saturating_add(Weight::from_parts(73_229, 0).saturating_mul(r.into())) + .saturating_add(Weight::from_parts(71_132, 0).saturating_mul(r.into())) } fn seal_caller() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` // Minimum execution time: 621_000 picoseconds. - Weight::from_parts(667_000, 0) + Weight::from_parts(669_000, 0) } /// Storage: `Contracts::ContractInfoOf` (r:1 w:0) /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) @@ -1401,8 +1399,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `354` // Estimated: `3819` - // Minimum execution time: 6_594_000 picoseconds. - Weight::from_parts(6_855_000, 3819) + // Minimum execution time: 6_787_000 picoseconds. + Weight::from_parts(7_039_000, 3819) .saturating_add(RocksDbWeight::get().reads(1_u64)) } /// Storage: `Contracts::ContractInfoOf` (r:1 w:0) @@ -1411,79 +1409,79 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `447` // Estimated: `3912` - // Minimum execution time: 7_893_000 picoseconds. - Weight::from_parts(8_172_000, 3912) + // Minimum execution time: 7_839_000 picoseconds. + Weight::from_parts(8_154_000, 3912) .saturating_add(RocksDbWeight::get().reads(1_u64)) } fn seal_own_code_hash() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 772_000 picoseconds. - Weight::from_parts(826_000, 0) + // Minimum execution time: 729_000 picoseconds. + Weight::from_parts(805_000, 0) } fn seal_caller_is_origin() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 409_000 picoseconds. - Weight::from_parts(431_000, 0) + // Minimum execution time: 422_000 picoseconds. + Weight::from_parts(442_000, 0) } fn seal_caller_is_root() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 333_000 picoseconds. - Weight::from_parts(360_000, 0) + // Minimum execution time: 327_000 picoseconds. + Weight::from_parts(361_000, 0) } fn seal_address() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 609_000 picoseconds. - Weight::from_parts(628_000, 0) + // Minimum execution time: 572_000 picoseconds. + Weight::from_parts(627_000, 0) } fn seal_gas_left() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 669_000 picoseconds. - Weight::from_parts(741_000, 0) + // Minimum execution time: 698_000 picoseconds. + Weight::from_parts(731_000, 0) } fn seal_balance() -> Weight { // Proof Size summary in bytes: // Measured: `140` // Estimated: `0` - // Minimum execution time: 4_778_000 picoseconds. - Weight::from_parts(4_985_000, 0) + // Minimum execution time: 4_569_000 picoseconds. + Weight::from_parts(4_823_000, 0) } fn seal_value_transferred() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 585_000 picoseconds. - Weight::from_parts(610_000, 0) + // Minimum execution time: 563_000 picoseconds. + Weight::from_parts(591_000, 0) } fn seal_minimum_balance() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` // Minimum execution time: 567_000 picoseconds. - Weight::from_parts(601_000, 0) + Weight::from_parts(592_000, 0) } fn seal_block_number() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 592_000 picoseconds. - Weight::from_parts(627_000, 0) + // Minimum execution time: 534_000 picoseconds. + Weight::from_parts(586_000, 0) } fn seal_now() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 576_000 picoseconds. - Weight::from_parts(616_000, 0) + // Minimum execution time: 507_000 picoseconds. + Weight::from_parts(577_000, 0) } /// Storage: `TransactionPayment::NextFeeMultiplier` (r:1 w:0) /// Proof: `TransactionPayment::NextFeeMultiplier` (`max_values`: Some(1), `max_size`: Some(16), added: 511, mode: `Measured`) @@ -1491,8 +1489,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `67` // Estimated: `1552` - // Minimum execution time: 4_477_000 picoseconds. - Weight::from_parts(4_706_000, 1552) + // Minimum execution time: 4_331_000 picoseconds. + Weight::from_parts(4_582_000, 1552) .saturating_add(RocksDbWeight::get().reads(1_u64)) } /// The range of component `n` is `[0, 1048572]`. @@ -1500,20 +1498,20 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 503_000 picoseconds. - Weight::from_parts(528_000, 0) + // Minimum execution time: 435_000 picoseconds. + Weight::from_parts(500_000, 0) // Standard Error: 3 - .saturating_add(Weight::from_parts(292, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(303, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 1048572]`. fn seal_return(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 333_000 picoseconds. - Weight::from_parts(371_000, 0) + // Minimum execution time: 331_000 picoseconds. + Weight::from_parts(356_000, 0) // Standard Error: 9 - .saturating_add(Weight::from_parts(398, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(423, 0).saturating_mul(n.into())) } /// Storage: `Contracts::DeletionQueueCounter` (r:1 w:1) /// Proof: `Contracts::DeletionQueueCounter` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`) @@ -1526,10 +1524,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `319 + n * (78 ±0)` // Estimated: `3784 + n * (2553 ±0)` - // Minimum execution time: 14_468_000 picoseconds. - Weight::from_parts(16_793_355, 3784) - // Standard Error: 8_365 - .saturating_add(Weight::from_parts(3_694_281, 0).saturating_mul(n.into())) + // Minimum execution time: 14_488_000 picoseconds. + Weight::from_parts(16_354_601, 3784) + // Standard Error: 7_864 + .saturating_add(Weight::from_parts(3_700_384, 0).saturating_mul(n.into())) .saturating_add(RocksDbWeight::get().reads(2_u64)) .saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(n.into()))) .saturating_add(RocksDbWeight::get().writes(3_u64)) @@ -1542,8 +1540,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `76` // Estimated: `1561` - // Minimum execution time: 3_563_000 picoseconds. - Weight::from_parts(3_784_000, 1561) + // Minimum execution time: 3_470_000 picoseconds. + Weight::from_parts(3_637_000, 1561) .saturating_add(RocksDbWeight::get().reads(1_u64)) } /// Storage: `System::EventTopics` (r:4 w:4) @@ -1554,12 +1552,12 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `0` // Estimated: `990 + t * (2475 ±0)` - // Minimum execution time: 4_064_000 picoseconds. - Weight::from_parts(4_551_057, 990) - // Standard Error: 7_249 - .saturating_add(Weight::from_parts(2_342_414, 0).saturating_mul(t.into())) + // Minimum execution time: 4_046_000 picoseconds. + Weight::from_parts(4_233_938, 990) + // Standard Error: 7_203 + .saturating_add(Weight::from_parts(2_402_117, 0).saturating_mul(t.into())) // Standard Error: 2 - .saturating_add(Weight::from_parts(9, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(27, 0).saturating_mul(n.into())) .saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(t.into()))) .saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(t.into()))) .saturating_add(Weight::from_parts(0, 2475).saturating_mul(t.into())) @@ -1569,10 +1567,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 436_000 picoseconds. - Weight::from_parts(440_000, 0) + // Minimum execution time: 421_000 picoseconds. + Weight::from_parts(456_000, 0) // Standard Error: 10 - .saturating_add(Weight::from_parts(1_201, 0).saturating_mul(i.into())) + .saturating_add(Weight::from_parts(1_217, 0).saturating_mul(i.into())) } /// Storage: `Skipped::Metadata` (r:0 w:0) /// Proof: `Skipped::Metadata` (`max_values`: None, `max_size`: None, mode: `Measured`) @@ -1582,12 +1580,12 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `250 + o * (1 ±0)` // Estimated: `249 + o * (1 ±0)` - // Minimum execution time: 10_097_000 picoseconds. - Weight::from_parts(9_877_776, 249) + // Minimum execution time: 9_900_000 picoseconds. + Weight::from_parts(9_611_602, 249) // Standard Error: 1 - .saturating_add(Weight::from_parts(241, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(282, 0).saturating_mul(n.into())) // Standard Error: 1 - .saturating_add(Weight::from_parts(58, 0).saturating_mul(o.into())) + .saturating_add(Weight::from_parts(70, 0).saturating_mul(o.into())) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(o.into())) @@ -1599,10 +1597,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `248 + n * (1 ±0)` // Estimated: `248 + n * (1 ±0)` - // Minimum execution time: 8_068_000 picoseconds. - Weight::from_parts(9_298_830, 248) + // Minimum execution time: 7_965_000 picoseconds. + Weight::from_parts(9_211_072, 248) // Standard Error: 2 - .saturating_add(Weight::from_parts(77, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(82, 0).saturating_mul(n.into())) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) @@ -1614,10 +1612,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `248 + n * (1 ±0)` // Estimated: `248 + n * (1 ±0)` - // Minimum execution time: 7_315_000 picoseconds. - Weight::from_parts(9_026_712, 248) + // Minimum execution time: 6_851_000 picoseconds. + Weight::from_parts(8_930_522, 248) // Standard Error: 3 - .saturating_add(Weight::from_parts(595, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(647, 0).saturating_mul(n.into())) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) } @@ -1628,8 +1626,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `248 + n * (1 ±0)` // Estimated: `248 + n * (1 ±0)` - // Minimum execution time: 6_833_000 picoseconds. - Weight::from_parts(7_980_890, 248) + // Minimum execution time: 6_602_000 picoseconds. + Weight::from_parts(7_843_808, 248) // Standard Error: 2 .saturating_add(Weight::from_parts(85, 0).saturating_mul(n.into())) .saturating_add(RocksDbWeight::get().reads(1_u64)) @@ -1642,10 +1640,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `248 + n * (1 ±0)` // Estimated: `248 + n * (1 ±0)` - // Minimum execution time: 8_250_000 picoseconds. - Weight::from_parts(10_058_209, 248) - // Standard Error: 3 - .saturating_add(Weight::from_parts(607, 0).saturating_mul(n.into())) + // Minimum execution time: 8_245_000 picoseconds. + Weight::from_parts(9_953_659, 248) + // Standard Error: 2 + .saturating_add(Weight::from_parts(654, 0).saturating_mul(n.into())) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) @@ -1654,8 +1652,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `140` // Estimated: `0` - // Minimum execution time: 8_858_000 picoseconds. - Weight::from_parts(9_238_000, 0) + // Minimum execution time: 8_993_000 picoseconds. + Weight::from_parts(9_445_000, 0) } /// Storage: `Contracts::ContractInfoOf` (r:1 w:1) /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) @@ -1668,18 +1666,16 @@ impl WeightInfo for () { /// The range of component `t` is `[0, 1]`. /// The range of component `c` is `[0, 1]`. /// The range of component `i` is `[0, 1048576]`. - fn seal_call(t: u32, c: u32, i: u32, ) -> Weight { + fn seal_call(t: u32, _c: u32, i: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `620 + t * (280 ±0)` // Estimated: `4085 + t * (2182 ±0)` - // Minimum execution time: 153_417_000 picoseconds. - Weight::from_parts(154_858_902, 4085) - // Standard Error: 339_920 - .saturating_add(Weight::from_parts(45_327_013, 0).saturating_mul(t.into())) - // Standard Error: 339_920 - .saturating_add(Weight::from_parts(1_016_817, 0).saturating_mul(c.into())) + // Minimum execution time: 151_051_000 picoseconds. + Weight::from_parts(164_928_785, 4085) + // Standard Error: 344_718 + .saturating_add(Weight::from_parts(40_015_500, 0).saturating_mul(t.into())) // Standard Error: 0 - .saturating_add(Weight::from_parts(7, 0).saturating_mul(i.into())) + .saturating_add(Weight::from_parts(2, 0).saturating_mul(i.into())) .saturating_add(RocksDbWeight::get().reads(3_u64)) .saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(t.into()))) .saturating_add(RocksDbWeight::get().writes(1_u64)) @@ -1694,8 +1690,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `430` // Estimated: `3895` - // Minimum execution time: 140_613_000 picoseconds. - Weight::from_parts(149_663_000, 3895) + // Minimum execution time: 138_670_000 picoseconds. + Weight::from_parts(144_148_000, 3895) .saturating_add(RocksDbWeight::get().reads(2_u64)) } /// Storage: `Contracts::CodeInfoOf` (r:1 w:1) @@ -1715,14 +1711,14 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `676` // Estimated: `4138` - // Minimum execution time: 1_637_633_000 picoseconds. - Weight::from_parts(1_668_892, 4138) - // Standard Error: 8_487_760 - .saturating_add(Weight::from_parts(210_998_534, 0).saturating_mul(t.into())) - // Standard Error: 13 - .saturating_add(Weight::from_parts(1_392, 0).saturating_mul(i.into())) - // Standard Error: 13 - .saturating_add(Weight::from_parts(1_733, 0).saturating_mul(s.into())) + // Minimum execution time: 1_744_236_000 picoseconds. + Weight::from_parts(67_596_989, 4138) + // Standard Error: 6_993_227 + .saturating_add(Weight::from_parts(156_283_395, 0).saturating_mul(t.into())) + // Standard Error: 11 + .saturating_add(Weight::from_parts(1_489, 0).saturating_mul(i.into())) + // Standard Error: 11 + .saturating_add(Weight::from_parts(1_781, 0).saturating_mul(s.into())) .saturating_add(RocksDbWeight::get().reads(5_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) } @@ -1731,64 +1727,64 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 868_000 picoseconds. - Weight::from_parts(882_000, 0) + // Minimum execution time: 838_000 picoseconds. + Weight::from_parts(855_000, 0) // Standard Error: 0 - .saturating_add(Weight::from_parts(1_051, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(1_083, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 1048576]`. fn seal_hash_keccak_256(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_404_000 picoseconds. - Weight::from_parts(1_490_000, 0) + // Minimum execution time: 1_449_000 picoseconds. + Weight::from_parts(1_466_000, 0) // Standard Error: 0 - .saturating_add(Weight::from_parts(3_316, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(3_350, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 1048576]`. fn seal_hash_blake2_256(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 849_000 picoseconds. - Weight::from_parts(913_000, 0) + // Minimum execution time: 759_000 picoseconds. + Weight::from_parts(800_000, 0) // Standard Error: 0 - .saturating_add(Weight::from_parts(1_186, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(1_218, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 1048576]`. fn seal_hash_blake2_128(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 697_000 picoseconds. - Weight::from_parts(772_000, 0) + // Minimum execution time: 714_000 picoseconds. + Weight::from_parts(733_000, 0) // Standard Error: 0 - .saturating_add(Weight::from_parts(1_186, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(1_220, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 125697]`. fn seal_sr25519_verify(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 42_862_000 picoseconds. - Weight::from_parts(48_510_759, 0) - // Standard Error: 10 - .saturating_add(Weight::from_parts(4_451, 0).saturating_mul(n.into())) + // Minimum execution time: 47_253_000 picoseconds. + Weight::from_parts(51_184_900, 0) + // Standard Error: 9 + .saturating_add(Weight::from_parts(4_602, 0).saturating_mul(n.into())) } fn seal_ecdsa_recover() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 47_180_000 picoseconds. - Weight::from_parts(48_679_000, 0) + // Minimum execution time: 47_378_000 picoseconds. + Weight::from_parts(49_505_000, 0) } fn seal_ecdsa_to_eth_address() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 13_057_000 picoseconds. - Weight::from_parts(13_227_000, 0) + // Minimum execution time: 13_088_000 picoseconds. + Weight::from_parts(13_299_000, 0) } /// Storage: `Contracts::CodeInfoOf` (r:1 w:1) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) @@ -1798,8 +1794,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `430` // Estimated: `3895` - // Minimum execution time: 19_335_000 picoseconds. - Weight::from_parts(20_225_000, 3895) + // Minimum execution time: 19_326_000 picoseconds. + Weight::from_parts(20_179_000, 3895) .saturating_add(RocksDbWeight::get().reads(2_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -1809,8 +1805,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `355` // Estimated: `3820` - // Minimum execution time: 9_400_000 picoseconds. - Weight::from_parts(9_743_000, 3820) + // Minimum execution time: 9_432_000 picoseconds. + Weight::from_parts(9_851_000, 3820) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -1820,8 +1816,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `355` // Estimated: `3558` - // Minimum execution time: 8_125_000 picoseconds. - Weight::from_parts(8_491_000, 3558) + // Minimum execution time: 8_359_000 picoseconds. + Weight::from_parts(8_676_000, 3558) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -1829,15 +1825,15 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 330_000 picoseconds. - Weight::from_parts(383_000, 0) + // Minimum execution time: 320_000 picoseconds. + Weight::from_parts(366_000, 0) } fn seal_account_reentrance_count() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 349_000 picoseconds. - Weight::from_parts(380_000, 0) + // Minimum execution time: 342_000 picoseconds. + Weight::from_parts(379_000, 0) } /// Storage: `Contracts::Nonce` (r:1 w:0) /// Proof: `Contracts::Nonce` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`) @@ -1845,8 +1841,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `219` // Estimated: `1704` - // Minimum execution time: 3_083_000 picoseconds. - Weight::from_parts(3_248_000, 1704) + // Minimum execution time: 3_001_000 picoseconds. + Weight::from_parts(3_163_000, 1704) .saturating_add(RocksDbWeight::get().reads(1_u64)) } /// The range of component `r` is `[0, 5000]`. @@ -1854,9 +1850,9 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 918_000 picoseconds. - Weight::from_parts(1_027_293, 0) - // Standard Error: 23 - .saturating_add(Weight::from_parts(14_764, 0).saturating_mul(r.into())) + // Minimum execution time: 952_000 picoseconds. + Weight::from_parts(571_197, 0) + // Standard Error: 19 + .saturating_add(Weight::from_parts(14_886, 0).saturating_mul(r.into())) } } From 2fa8edc7c998950c41038d59c2dcf20d9b846352 Mon Sep 17 00:00:00 2001 From: pgherveou Date: Mon, 20 May 2024 15:50:39 +0200 Subject: [PATCH 32/34] Simplify clone call --- .../frame/contracts/src/benchmarking/mod.rs | 29 +++++++------------ substrate/frame/contracts/src/wasm/runtime.rs | 6 ++-- 2 files changed, 14 insertions(+), 21 deletions(-) diff --git a/substrate/frame/contracts/src/benchmarking/mod.rs b/substrate/frame/contracts/src/benchmarking/mod.rs index 4797e851faa1..7c993bc9a771 100644 --- a/substrate/frame/contracts/src/benchmarking/mod.rs +++ b/substrate/frame/contracts/src/benchmarking/mod.rs @@ -1196,15 +1196,10 @@ mod benchmarks { assert_ok!(result); } - // c: with or without clone flag // t: with or without some value to transfer // i: size of the input data #[benchmark(pov_mode = Measured)] - fn seal_call( - t: Linear<0, 1>, - c: Linear<0, 1>, - i: Linear<0, { code::max_pages::() * 64 * 1024 }>, - ) { + fn seal_call(t: Linear<0, 1>, i: Linear<0, { code::max_pages::() * 64 * 1024 }>) { let Contract { account_id: callee, .. } = Contract::::with_index(1, WasmModule::dummy(), vec![]).unwrap(); let callee_bytes = callee.encode(); @@ -1226,24 +1221,22 @@ mod benchmarks { let mut runtime = crate::wasm::Runtime::new(&mut ext, vec![]); let mut memory = memory!(callee_bytes, deposit_bytes, value_bytes,); - let flags = if c == 1 { CallFlags::CLONE_INPUT } else { CallFlags::empty() }; - let result; #[block] { result = BenchEnv::seal2_call( &mut runtime, &mut memory, - flags.bits(), // flags - 0, // callee_ptr - 0, // ref_time_limit - 0, // proof_size_limit - callee_len, // deposit_ptr - callee_len + deposit_len, // value_ptr - 0, // input_data_ptr - 0, // input_data_len - SENTINEL, // output_ptr - 0, // output_len_ptr + CallFlags::CLONE_INPUT.bits(), // flags + 0, // callee_ptr + 0, // ref_time_limit + 0, // proof_size_limit + callee_len, // deposit_ptr + callee_len + deposit_len, // value_ptr + 0, // input_data_ptr + 0, // input_data_len + SENTINEL, // output_ptr + 0, // output_len_ptr ); } diff --git a/substrate/frame/contracts/src/wasm/runtime.rs b/substrate/frame/contracts/src/wasm/runtime.rs index f2468e05ff63..39b15c867c6a 100644 --- a/substrate/frame/contracts/src/wasm/runtime.rs +++ b/substrate/frame/contracts/src/wasm/runtime.rs @@ -298,10 +298,10 @@ impl Token for RuntimeCosts { GetStorage(len) => T::WeightInfo::seal_get_storage(len), TakeStorage(len) => T::WeightInfo::seal_take_storage(len), Transfer => T::WeightInfo::seal_transfer(), - CallBase => T::WeightInfo::seal_call(0, 0, 0), + CallBase => T::WeightInfo::seal_call(0, 0), DelegateCallBase => T::WeightInfo::seal_delegate_call(), - CallTransferSurcharge => cost_args!(seal_call, 1, 0, 0), - CallInputCloned(len) => cost_args!(seal_call, 0, 1, len), + CallTransferSurcharge => cost_args!(seal_call, 1, 0), + CallInputCloned(len) => cost_args!(seal_call, 0, len), InstantiateBase { input_data_len, salt_len } => T::WeightInfo::seal_instantiate(0, input_data_len, salt_len), InstantiateTransferSurcharge => cost_args!(seal_instantiate, 1, 0, 0), From 46650ca9e929a12e61c510df019ffa6a5038804d Mon Sep 17 00:00:00 2001 From: pgherveou Date: Mon, 20 May 2024 16:06:18 +0200 Subject: [PATCH 33/34] Fix weights --- substrate/frame/contracts/src/weights.rs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/substrate/frame/contracts/src/weights.rs b/substrate/frame/contracts/src/weights.rs index 6be41a09ef1d..9f01c4287ce3 100644 --- a/substrate/frame/contracts/src/weights.rs +++ b/substrate/frame/contracts/src/weights.rs @@ -99,7 +99,7 @@ pub trait WeightInfo { fn seal_contains_storage(n: u32, ) -> Weight; fn seal_take_storage(n: u32, ) -> Weight; fn seal_transfer() -> Weight; - fn seal_call(t: u32, c: u32, i: u32, ) -> Weight; + fn seal_call(t: u32, i: u32, ) -> Weight; fn seal_delegate_call() -> Weight; fn seal_instantiate(t: u32, i: u32, s: u32, ) -> Weight; fn seal_hash_sha2_256(n: u32, ) -> Weight; @@ -797,7 +797,7 @@ impl WeightInfo for SubstrateWeight { /// The range of component `t` is `[0, 1]`. /// The range of component `c` is `[0, 1]`. /// The range of component `i` is `[0, 1048576]`. - fn seal_call(t: u32, _c: u32, i: u32, ) -> Weight { + fn seal_call(t: u32, i: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `620 + t * (280 ±0)` // Estimated: `4085 + t * (2182 ±0)` @@ -1666,7 +1666,7 @@ impl WeightInfo for () { /// The range of component `t` is `[0, 1]`. /// The range of component `c` is `[0, 1]`. /// The range of component `i` is `[0, 1048576]`. - fn seal_call(t: u32, _c: u32, i: u32, ) -> Weight { + fn seal_call(t: u32, i: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `620 + t * (280 ±0)` // Estimated: `4085 + t * (2182 ±0)` From 8f15947e328465043f7c08fec27e90c9b50b606f Mon Sep 17 00:00:00 2001 From: command-bot <> Date: Mon, 20 May 2024 14:48:21 +0000 Subject: [PATCH 34/34] ".git/.scripts/commands/bench/bench.sh" --subcommand=pallet --runtime=dev --target_dir=substrate --pallet=pallet_contracts --- substrate/frame/contracts/src/weights.rs | 754 +++++++++++------------ 1 file changed, 376 insertions(+), 378 deletions(-) diff --git a/substrate/frame/contracts/src/weights.rs b/substrate/frame/contracts/src/weights.rs index 9f01c4287ce3..2e9c2cd15af8 100644 --- a/substrate/frame/contracts/src/weights.rs +++ b/substrate/frame/contracts/src/weights.rs @@ -18,9 +18,9 @@ //! Autogenerated weights for `pallet_contracts` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 32.0.0 -//! DATE: 2024-05-19, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2024-05-20, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` -//! HOSTNAME: `runner-unxyhko3-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz` +//! HOSTNAME: `runner-vicqj8em-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz` //! WASM-EXECUTION: `Compiled`, CHAIN: `Some("dev")`, DB CACHE: `1024` // Executed Command: @@ -127,8 +127,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `142` // Estimated: `1627` - // Minimum execution time: 2_074_000 picoseconds. - Weight::from_parts(2_166_000, 1627) + // Minimum execution time: 2_000_000 picoseconds. + Weight::from_parts(2_142_000, 1627) .saturating_add(T::DbWeight::get().reads(1_u64)) } /// Storage: `Skipped::Metadata` (r:0 w:0) @@ -138,10 +138,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `452 + k * (69 ±0)` // Estimated: `442 + k * (70 ±0)` - // Minimum execution time: 12_411_000 picoseconds. - Weight::from_parts(12_587_000, 442) - // Standard Error: 1_213 - .saturating_add(Weight::from_parts(1_149_896, 0).saturating_mul(k.into())) + // Minimum execution time: 12_095_000 picoseconds. + Weight::from_parts(12_699_000, 442) + // Standard Error: 891 + .saturating_add(Weight::from_parts(1_114_063, 0).saturating_mul(k.into())) .saturating_add(T::DbWeight::get().reads(2_u64)) .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(k.into()))) .saturating_add(T::DbWeight::get().writes(2_u64)) @@ -155,10 +155,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `211 + c * (1 ±0)` // Estimated: `6149 + c * (1 ±0)` - // Minimum execution time: 8_308_000 picoseconds. - Weight::from_parts(9_014_393, 6149) - // Standard Error: 0 - .saturating_add(Weight::from_parts(1_169, 0).saturating_mul(c.into())) + // Minimum execution time: 8_433_000 picoseconds. + Weight::from_parts(8_992_328, 6149) + // Standard Error: 1 + .saturating_add(Weight::from_parts(1_207, 0).saturating_mul(c.into())) .saturating_add(T::DbWeight::get().reads(2_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(c.into())) @@ -171,8 +171,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `510` // Estimated: `6450` - // Minimum execution time: 16_847_000 picoseconds. - Weight::from_parts(17_478_000, 6450) + // Minimum execution time: 16_415_000 picoseconds. + Weight::from_parts(17_348_000, 6450) .saturating_add(T::DbWeight::get().reads(3_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -185,10 +185,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `171 + k * (1 ±0)` // Estimated: `3635 + k * (1 ±0)` - // Minimum execution time: 3_456_000 picoseconds. - Weight::from_parts(3_534_000, 3635) - // Standard Error: 679 - .saturating_add(Weight::from_parts(1_224_649, 0).saturating_mul(k.into())) + // Minimum execution time: 3_433_000 picoseconds. + Weight::from_parts(3_490_000, 3635) + // Standard Error: 1_043 + .saturating_add(Weight::from_parts(1_225_953, 0).saturating_mul(k.into())) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(2_u64)) .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(k.into()))) @@ -207,10 +207,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `325 + c * (1 ±0)` // Estimated: `6263 + c * (1 ±0)` - // Minimum execution time: 16_933_000 picoseconds. - Weight::from_parts(16_929_238, 6263) + // Minimum execution time: 16_421_000 picoseconds. + Weight::from_parts(16_822_963, 6263) // Standard Error: 0 - .saturating_add(Weight::from_parts(405, 0).saturating_mul(c.into())) + .saturating_add(Weight::from_parts(456, 0).saturating_mul(c.into())) .saturating_add(T::DbWeight::get().reads(4_u64)) .saturating_add(T::DbWeight::get().writes(2_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(c.into())) @@ -221,8 +221,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `440` // Estimated: `6380` - // Minimum execution time: 12_826_000 picoseconds. - Weight::from_parts(13_566_000, 6380) + // Minimum execution time: 12_569_000 picoseconds. + Weight::from_parts(13_277_000, 6380) .saturating_add(T::DbWeight::get().reads(2_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -236,8 +236,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `352` // Estimated: `6292` - // Minimum execution time: 48_129_000 picoseconds. - Weight::from_parts(49_472_000, 6292) + // Minimum execution time: 46_777_000 picoseconds. + Weight::from_parts(47_690_000, 6292) .saturating_add(T::DbWeight::get().reads(4_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -249,8 +249,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `594` // Estimated: `6534` - // Minimum execution time: 55_401_000 picoseconds. - Weight::from_parts(57_543_000, 6534) + // Minimum execution time: 55_280_000 picoseconds. + Weight::from_parts(57_081_000, 6534) .saturating_add(T::DbWeight::get().reads(4_u64)) .saturating_add(T::DbWeight::get().writes(2_u64)) } @@ -260,8 +260,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `409` // Estimated: `6349` - // Minimum execution time: 12_066_000 picoseconds. - Weight::from_parts(12_386_000, 6349) + // Minimum execution time: 12_077_000 picoseconds. + Weight::from_parts(12_647_000, 6349) .saturating_add(T::DbWeight::get().reads(2_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -271,8 +271,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `142` // Estimated: `1627` - // Minimum execution time: 2_394_000 picoseconds. - Weight::from_parts(2_695_000, 1627) + // Minimum execution time: 2_559_000 picoseconds. + Weight::from_parts(2_711_000, 1627) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -284,8 +284,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `166` // Estimated: `3631` - // Minimum execution time: 12_286_000 picoseconds. - Weight::from_parts(12_764_000, 3631) + // Minimum execution time: 12_238_000 picoseconds. + Weight::from_parts(12_627_000, 3631) .saturating_add(T::DbWeight::get().reads(2_u64)) .saturating_add(T::DbWeight::get().writes(2_u64)) } @@ -295,8 +295,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `142` // Estimated: `3607` - // Minimum execution time: 4_888_000 picoseconds. - Weight::from_parts(5_192_000, 3607) + // Minimum execution time: 4_836_000 picoseconds. + Weight::from_parts(5_086_000, 3607) .saturating_add(T::DbWeight::get().reads(1_u64)) } /// Storage: UNKNOWN KEY `0x4342193e496fab7ec59d615ed0dc55304e7b9012096b41c4eb3aaf947f6ea429` (r:1 w:0) @@ -307,8 +307,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `167` // Estimated: `3632` - // Minimum execution time: 6_033_000 picoseconds. - Weight::from_parts(6_404_000, 3632) + // Minimum execution time: 6_147_000 picoseconds. + Weight::from_parts(6_380_000, 3632) .saturating_add(T::DbWeight::get().reads(2_u64)) } /// Storage: UNKNOWN KEY `0x4342193e496fab7ec59d615ed0dc55304e7b9012096b41c4eb3aaf947f6ea429` (r:1 w:0) @@ -319,8 +319,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `142` // Estimated: `3607` - // Minimum execution time: 6_260_000 picoseconds. - Weight::from_parts(6_761_000, 3607) + // Minimum execution time: 6_140_000 picoseconds. + Weight::from_parts(6_670_000, 3607) .saturating_add(T::DbWeight::get().reads(2_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -341,10 +341,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `801 + c * (1 ±0)` // Estimated: `4264 + c * (1 ±0)` - // Minimum execution time: 282_827_000 picoseconds. - Weight::from_parts(268_595_710, 4264) - // Standard Error: 74 - .saturating_add(Weight::from_parts(33_961, 0).saturating_mul(c.into())) + // Minimum execution time: 354_459_000 picoseconds. + Weight::from_parts(332_397_871, 4264) + // Standard Error: 70 + .saturating_add(Weight::from_parts(33_775, 0).saturating_mul(c.into())) .saturating_add(T::DbWeight::get().reads(6_u64)) .saturating_add(T::DbWeight::get().writes(2_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(c.into())) @@ -372,14 +372,14 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `323` // Estimated: `6262` - // Minimum execution time: 4_039_064_000 picoseconds. - Weight::from_parts(511_488_092, 6262) - // Standard Error: 154 - .saturating_add(Weight::from_parts(68_951, 0).saturating_mul(c.into())) - // Standard Error: 18 - .saturating_add(Weight::from_parts(1_740, 0).saturating_mul(i.into())) - // Standard Error: 18 - .saturating_add(Weight::from_parts(1_737, 0).saturating_mul(s.into())) + // Minimum execution time: 4_239_452_000 picoseconds. + Weight::from_parts(800_849_282, 6262) + // Standard Error: 117 + .saturating_add(Weight::from_parts(68_435, 0).saturating_mul(c.into())) + // Standard Error: 14 + .saturating_add(Weight::from_parts(1_653, 0).saturating_mul(i.into())) + // Standard Error: 14 + .saturating_add(Weight::from_parts(1_668, 0).saturating_mul(s.into())) .saturating_add(T::DbWeight::get().reads(8_u64)) .saturating_add(T::DbWeight::get().writes(7_u64)) } @@ -405,12 +405,12 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `560` // Estimated: `4029` - // Minimum execution time: 2_043_035_000 picoseconds. - Weight::from_parts(2_056_535_000, 4029) + // Minimum execution time: 2_085_570_000 picoseconds. + Weight::from_parts(2_112_501_000, 4029) // Standard Error: 26 - .saturating_add(Weight::from_parts(907, 0).saturating_mul(i.into())) + .saturating_add(Weight::from_parts(888, 0).saturating_mul(i.into())) // Standard Error: 26 - .saturating_add(Weight::from_parts(797, 0).saturating_mul(s.into())) + .saturating_add(Weight::from_parts(795, 0).saturating_mul(s.into())) .saturating_add(T::DbWeight::get().reads(8_u64)) .saturating_add(T::DbWeight::get().writes(5_u64)) } @@ -430,8 +430,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `826` // Estimated: `4291` - // Minimum execution time: 197_670_000 picoseconds. - Weight::from_parts(207_490_000, 4291) + // Minimum execution time: 201_900_000 picoseconds. + Weight::from_parts(206_738_000, 4291) .saturating_add(T::DbWeight::get().reads(6_u64)) .saturating_add(T::DbWeight::get().writes(2_u64)) } @@ -448,10 +448,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `142` // Estimated: `3607` - // Minimum execution time: 268_742_000 picoseconds. - Weight::from_parts(271_032_265, 3607) - // Standard Error: 67 - .saturating_add(Weight::from_parts(33_877, 0).saturating_mul(c.into())) + // Minimum execution time: 330_704_000 picoseconds. + Weight::from_parts(345_129_342, 3607) + // Standard Error: 51 + .saturating_add(Weight::from_parts(33_126, 0).saturating_mul(c.into())) .saturating_add(T::DbWeight::get().reads(3_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) } @@ -468,10 +468,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `142` // Estimated: `3607` - // Minimum execution time: 262_093_000 picoseconds. - Weight::from_parts(284_700_466, 3607) - // Standard Error: 64 - .saturating_add(Weight::from_parts(33_947, 0).saturating_mul(c.into())) + // Minimum execution time: 343_339_000 picoseconds. + Weight::from_parts(356_479_729, 3607) + // Standard Error: 49 + .saturating_add(Weight::from_parts(33_404, 0).saturating_mul(c.into())) .saturating_add(T::DbWeight::get().reads(3_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) } @@ -487,8 +487,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `315` // Estimated: `3780` - // Minimum execution time: 41_895_000 picoseconds. - Weight::from_parts(43_710_000, 3780) + // Minimum execution time: 42_241_000 picoseconds. + Weight::from_parts(43_365_000, 3780) .saturating_add(T::DbWeight::get().reads(3_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) } @@ -502,8 +502,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `552` // Estimated: `6492` - // Minimum execution time: 26_308_000 picoseconds. - Weight::from_parts(27_330_000, 6492) + // Minimum execution time: 26_318_000 picoseconds. + Weight::from_parts(27_840_000, 6492) .saturating_add(T::DbWeight::get().reads(4_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) } @@ -512,17 +512,17 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 9_599_000 picoseconds. - Weight::from_parts(9_964_505, 0) - // Standard Error: 74 - .saturating_add(Weight::from_parts(71_132, 0).saturating_mul(r.into())) + // Minimum execution time: 9_397_000 picoseconds. + Weight::from_parts(9_318_986, 0) + // Standard Error: 72 + .saturating_add(Weight::from_parts(72_994, 0).saturating_mul(r.into())) } fn seal_caller() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 621_000 picoseconds. - Weight::from_parts(669_000, 0) + // Minimum execution time: 644_000 picoseconds. + Weight::from_parts(687_000, 0) } /// Storage: `Contracts::ContractInfoOf` (r:1 w:0) /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) @@ -530,8 +530,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `354` // Estimated: `3819` - // Minimum execution time: 6_787_000 picoseconds. - Weight::from_parts(7_039_000, 3819) + // Minimum execution time: 6_465_000 picoseconds. + Weight::from_parts(6_850_000, 3819) .saturating_add(T::DbWeight::get().reads(1_u64)) } /// Storage: `Contracts::ContractInfoOf` (r:1 w:0) @@ -540,79 +540,79 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `447` // Estimated: `3912` - // Minimum execution time: 7_839_000 picoseconds. - Weight::from_parts(8_154_000, 3912) + // Minimum execution time: 7_735_000 picoseconds. + Weight::from_parts(8_115_000, 3912) .saturating_add(T::DbWeight::get().reads(1_u64)) } fn seal_own_code_hash() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 729_000 picoseconds. - Weight::from_parts(805_000, 0) + // Minimum execution time: 717_000 picoseconds. + Weight::from_parts(791_000, 0) } fn seal_caller_is_origin() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 422_000 picoseconds. - Weight::from_parts(442_000, 0) + // Minimum execution time: 365_000 picoseconds. + Weight::from_parts(427_000, 0) } fn seal_caller_is_root() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 327_000 picoseconds. - Weight::from_parts(361_000, 0) + // Minimum execution time: 331_000 picoseconds. + Weight::from_parts(363_000, 0) } fn seal_address() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 572_000 picoseconds. - Weight::from_parts(627_000, 0) + // Minimum execution time: 586_000 picoseconds. + Weight::from_parts(625_000, 0) } fn seal_gas_left() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 698_000 picoseconds. - Weight::from_parts(731_000, 0) + // Minimum execution time: 680_000 picoseconds. + Weight::from_parts(734_000, 0) } fn seal_balance() -> Weight { // Proof Size summary in bytes: // Measured: `140` // Estimated: `0` - // Minimum execution time: 4_569_000 picoseconds. - Weight::from_parts(4_823_000, 0) + // Minimum execution time: 4_732_000 picoseconds. + Weight::from_parts(5_008_000, 0) } fn seal_value_transferred() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 563_000 picoseconds. - Weight::from_parts(591_000, 0) + // Minimum execution time: 608_000 picoseconds. + Weight::from_parts(635_000, 0) } fn seal_minimum_balance() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 567_000 picoseconds. - Weight::from_parts(592_000, 0) + // Minimum execution time: 571_000 picoseconds. + Weight::from_parts(606_000, 0) } fn seal_block_number() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 534_000 picoseconds. - Weight::from_parts(586_000, 0) + // Minimum execution time: 511_000 picoseconds. + Weight::from_parts(584_000, 0) } fn seal_now() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 507_000 picoseconds. - Weight::from_parts(577_000, 0) + // Minimum execution time: 552_000 picoseconds. + Weight::from_parts(612_000, 0) } /// Storage: `TransactionPayment::NextFeeMultiplier` (r:1 w:0) /// Proof: `TransactionPayment::NextFeeMultiplier` (`max_values`: Some(1), `max_size`: Some(16), added: 511, mode: `Measured`) @@ -620,8 +620,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `67` // Estimated: `1552` - // Minimum execution time: 4_331_000 picoseconds. - Weight::from_parts(4_582_000, 1552) + // Minimum execution time: 4_396_000 picoseconds. + Weight::from_parts(4_630_000, 1552) .saturating_add(T::DbWeight::get().reads(1_u64)) } /// The range of component `n` is `[0, 1048572]`. @@ -629,8 +629,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 435_000 picoseconds. - Weight::from_parts(500_000, 0) + // Minimum execution time: 494_000 picoseconds. + Weight::from_parts(510_000, 0) // Standard Error: 3 .saturating_add(Weight::from_parts(303, 0).saturating_mul(n.into())) } @@ -639,10 +639,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 331_000 picoseconds. - Weight::from_parts(356_000, 0) + // Minimum execution time: 311_000 picoseconds. + Weight::from_parts(346_000, 0) // Standard Error: 9 - .saturating_add(Weight::from_parts(423, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(480, 0).saturating_mul(n.into())) } /// Storage: `Contracts::DeletionQueueCounter` (r:1 w:1) /// Proof: `Contracts::DeletionQueueCounter` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`) @@ -655,10 +655,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `319 + n * (78 ±0)` // Estimated: `3784 + n * (2553 ±0)` - // Minimum execution time: 14_488_000 picoseconds. - Weight::from_parts(16_354_601, 3784) - // Standard Error: 7_864 - .saturating_add(Weight::from_parts(3_700_384, 0).saturating_mul(n.into())) + // Minimum execution time: 14_403_000 picoseconds. + Weight::from_parts(16_478_113, 3784) + // Standard Error: 6_667 + .saturating_add(Weight::from_parts(3_641_603, 0).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads(2_u64)) .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(n.into()))) .saturating_add(T::DbWeight::get().writes(3_u64)) @@ -671,8 +671,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `76` // Estimated: `1561` - // Minimum execution time: 3_470_000 picoseconds. - Weight::from_parts(3_637_000, 1561) + // Minimum execution time: 3_639_000 picoseconds. + Weight::from_parts(3_801_000, 1561) .saturating_add(T::DbWeight::get().reads(1_u64)) } /// Storage: `System::EventTopics` (r:4 w:4) @@ -683,12 +683,12 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `990 + t * (2475 ±0)` - // Minimum execution time: 4_046_000 picoseconds. - Weight::from_parts(4_233_938, 990) - // Standard Error: 7_203 - .saturating_add(Weight::from_parts(2_402_117, 0).saturating_mul(t.into())) - // Standard Error: 2 - .saturating_add(Weight::from_parts(27, 0).saturating_mul(n.into())) + // Minimum execution time: 4_102_000 picoseconds. + Weight::from_parts(4_256_984, 990) + // Standard Error: 6_777 + .saturating_add(Weight::from_parts(2_331_893, 0).saturating_mul(t.into())) + // Standard Error: 1 + .saturating_add(Weight::from_parts(31, 0).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(t.into()))) .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(t.into()))) .saturating_add(Weight::from_parts(0, 2475).saturating_mul(t.into())) @@ -698,10 +698,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 421_000 picoseconds. - Weight::from_parts(456_000, 0) + // Minimum execution time: 385_000 picoseconds. + Weight::from_parts(427_000, 0) // Standard Error: 10 - .saturating_add(Weight::from_parts(1_217, 0).saturating_mul(i.into())) + .saturating_add(Weight::from_parts(1_272, 0).saturating_mul(i.into())) } /// Storage: `Skipped::Metadata` (r:0 w:0) /// Proof: `Skipped::Metadata` (`max_values`: None, `max_size`: None, mode: `Measured`) @@ -711,12 +711,12 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `250 + o * (1 ±0)` // Estimated: `249 + o * (1 ±0)` - // Minimum execution time: 9_900_000 picoseconds. - Weight::from_parts(9_611_602, 249) + // Minimum execution time: 10_128_000 picoseconds. + Weight::from_parts(9_963_519, 249) // Standard Error: 1 - .saturating_add(Weight::from_parts(282, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(327, 0).saturating_mul(n.into())) // Standard Error: 1 - .saturating_add(Weight::from_parts(70, 0).saturating_mul(o.into())) + .saturating_add(Weight::from_parts(58, 0).saturating_mul(o.into())) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(o.into())) @@ -728,10 +728,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `248 + n * (1 ±0)` // Estimated: `248 + n * (1 ±0)` - // Minimum execution time: 7_965_000 picoseconds. - Weight::from_parts(9_211_072, 248) + // Minimum execution time: 7_921_000 picoseconds. + Weight::from_parts(9_290_526, 248) // Standard Error: 2 - .saturating_add(Weight::from_parts(82, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(77, 0).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) @@ -743,10 +743,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `248 + n * (1 ±0)` // Estimated: `248 + n * (1 ±0)` - // Minimum execution time: 6_851_000 picoseconds. - Weight::from_parts(8_930_522, 248) + // Minimum execution time: 7_403_000 picoseconds. + Weight::from_parts(8_815_037, 248) // Standard Error: 3 - .saturating_add(Weight::from_parts(647, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(701, 0).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) } @@ -757,10 +757,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `248 + n * (1 ±0)` // Estimated: `248 + n * (1 ±0)` - // Minimum execution time: 6_602_000 picoseconds. - Weight::from_parts(7_843_808, 248) + // Minimum execution time: 6_590_000 picoseconds. + Weight::from_parts(7_949_861, 248) // Standard Error: 2 - .saturating_add(Weight::from_parts(85, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(76, 0).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) } @@ -771,10 +771,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `248 + n * (1 ±0)` // Estimated: `248 + n * (1 ±0)` - // Minimum execution time: 8_245_000 picoseconds. - Weight::from_parts(9_953_659, 248) - // Standard Error: 2 - .saturating_add(Weight::from_parts(654, 0).saturating_mul(n.into())) + // Minimum execution time: 7_900_000 picoseconds. + Weight::from_parts(9_988_151, 248) + // Standard Error: 3 + .saturating_add(Weight::from_parts(703, 0).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) @@ -783,8 +783,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `140` // Estimated: `0` - // Minimum execution time: 8_993_000 picoseconds. - Weight::from_parts(9_445_000, 0) + // Minimum execution time: 9_023_000 picoseconds. + Weight::from_parts(9_375_000, 0) } /// Storage: `Contracts::ContractInfoOf` (r:1 w:1) /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) @@ -795,18 +795,17 @@ impl WeightInfo for SubstrateWeight { /// Storage: `System::Account` (r:1 w:1) /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`) /// The range of component `t` is `[0, 1]`. - /// The range of component `c` is `[0, 1]`. /// The range of component `i` is `[0, 1048576]`. fn seal_call(t: u32, i: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `620 + t * (280 ±0)` // Estimated: `4085 + t * (2182 ±0)` - // Minimum execution time: 151_051_000 picoseconds. - Weight::from_parts(164_928_785, 4085) - // Standard Error: 344_718 - .saturating_add(Weight::from_parts(40_015_500, 0).saturating_mul(t.into())) + // Minimum execution time: 157_109_000 picoseconds. + Weight::from_parts(159_458_069, 4085) + // Standard Error: 339_702 + .saturating_add(Weight::from_parts(44_066_869, 0).saturating_mul(t.into())) // Standard Error: 0 - .saturating_add(Weight::from_parts(2, 0).saturating_mul(i.into())) + .saturating_add(Weight::from_parts(6, 0).saturating_mul(i.into())) .saturating_add(T::DbWeight::get().reads(3_u64)) .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(t.into()))) .saturating_add(T::DbWeight::get().writes(1_u64)) @@ -821,8 +820,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `430` // Estimated: `3895` - // Minimum execution time: 138_670_000 picoseconds. - Weight::from_parts(144_148_000, 3895) + // Minimum execution time: 143_384_000 picoseconds. + Weight::from_parts(147_554_000, 3895) .saturating_add(T::DbWeight::get().reads(2_u64)) } /// Storage: `Contracts::CodeInfoOf` (r:1 w:1) @@ -842,14 +841,14 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `676` // Estimated: `4138` - // Minimum execution time: 1_744_236_000 picoseconds. - Weight::from_parts(67_596_989, 4138) - // Standard Error: 6_993_227 - .saturating_add(Weight::from_parts(156_283_395, 0).saturating_mul(t.into())) - // Standard Error: 11 - .saturating_add(Weight::from_parts(1_489, 0).saturating_mul(i.into())) - // Standard Error: 11 - .saturating_add(Weight::from_parts(1_781, 0).saturating_mul(s.into())) + // Minimum execution time: 1_798_243_000 picoseconds. + Weight::from_parts(82_642_573, 4138) + // Standard Error: 6_831_260 + .saturating_add(Weight::from_parts(159_867_027, 0).saturating_mul(t.into())) + // Standard Error: 10 + .saturating_add(Weight::from_parts(1_534, 0).saturating_mul(i.into())) + // Standard Error: 10 + .saturating_add(Weight::from_parts(1_809, 0).saturating_mul(s.into())) .saturating_add(T::DbWeight::get().reads(5_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) } @@ -858,64 +857,64 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 838_000 picoseconds. - Weight::from_parts(855_000, 0) + // Minimum execution time: 875_000 picoseconds. + Weight::from_parts(904_000, 0) // Standard Error: 0 - .saturating_add(Weight::from_parts(1_083, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(1_145, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 1048576]`. fn seal_hash_keccak_256(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_449_000 picoseconds. - Weight::from_parts(1_466_000, 0) + // Minimum execution time: 1_475_000 picoseconds. + Weight::from_parts(1_551_000, 0) // Standard Error: 0 - .saturating_add(Weight::from_parts(3_350, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(3_410, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 1048576]`. fn seal_hash_blake2_256(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 759_000 picoseconds. - Weight::from_parts(800_000, 0) + // Minimum execution time: 821_000 picoseconds. + Weight::from_parts(850_000, 0) // Standard Error: 0 - .saturating_add(Weight::from_parts(1_218, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(1_279, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 1048576]`. fn seal_hash_blake2_128(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 714_000 picoseconds. - Weight::from_parts(733_000, 0) + // Minimum execution time: 747_000 picoseconds. + Weight::from_parts(773_000, 0) // Standard Error: 0 - .saturating_add(Weight::from_parts(1_220, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(1_276, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 125697]`. fn seal_sr25519_verify(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 47_253_000 picoseconds. - Weight::from_parts(51_184_900, 0) + // Minimum execution time: 43_154_000 picoseconds. + Weight::from_parts(45_087_558, 0) // Standard Error: 9 - .saturating_add(Weight::from_parts(4_602, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(4_628, 0).saturating_mul(n.into())) } fn seal_ecdsa_recover() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 47_378_000 picoseconds. - Weight::from_parts(49_505_000, 0) + // Minimum execution time: 47_193_000 picoseconds. + Weight::from_parts(48_514_000, 0) } fn seal_ecdsa_to_eth_address() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 13_088_000 picoseconds. - Weight::from_parts(13_299_000, 0) + // Minimum execution time: 13_083_000 picoseconds. + Weight::from_parts(13_218_000, 0) } /// Storage: `Contracts::CodeInfoOf` (r:1 w:1) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) @@ -925,8 +924,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `430` // Estimated: `3895` - // Minimum execution time: 19_326_000 picoseconds. - Weight::from_parts(20_179_000, 3895) + // Minimum execution time: 19_308_000 picoseconds. + Weight::from_parts(20_116_000, 3895) .saturating_add(T::DbWeight::get().reads(2_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -936,8 +935,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `355` // Estimated: `3820` - // Minimum execution time: 9_432_000 picoseconds. - Weight::from_parts(9_851_000, 3820) + // Minimum execution time: 9_271_000 picoseconds. + Weight::from_parts(9_640_000, 3820) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -947,8 +946,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `355` // Estimated: `3558` - // Minimum execution time: 8_359_000 picoseconds. - Weight::from_parts(8_676_000, 3558) + // Minimum execution time: 8_182_000 picoseconds. + Weight::from_parts(8_343_000, 3558) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -957,14 +956,14 @@ impl WeightInfo for SubstrateWeight { // Measured: `0` // Estimated: `0` // Minimum execution time: 320_000 picoseconds. - Weight::from_parts(366_000, 0) + Weight::from_parts(347_000, 0) } fn seal_account_reentrance_count() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 342_000 picoseconds. - Weight::from_parts(379_000, 0) + // Minimum execution time: 345_000 picoseconds. + Weight::from_parts(370_000, 0) } /// Storage: `Contracts::Nonce` (r:1 w:0) /// Proof: `Contracts::Nonce` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`) @@ -972,8 +971,8 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `219` // Estimated: `1704` - // Minimum execution time: 3_001_000 picoseconds. - Weight::from_parts(3_163_000, 1704) + // Minimum execution time: 2_998_000 picoseconds. + Weight::from_parts(3_221_000, 1704) .saturating_add(T::DbWeight::get().reads(1_u64)) } /// The range of component `r` is `[0, 5000]`. @@ -981,10 +980,10 @@ impl WeightInfo for SubstrateWeight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 952_000 picoseconds. - Weight::from_parts(571_197, 0) - // Standard Error: 19 - .saturating_add(Weight::from_parts(14_886, 0).saturating_mul(r.into())) + // Minimum execution time: 1_002_000 picoseconds. + Weight::from_parts(1_094_958, 0) + // Standard Error: 12 + .saturating_add(Weight::from_parts(14_531, 0).saturating_mul(r.into())) } } @@ -996,8 +995,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `142` // Estimated: `1627` - // Minimum execution time: 2_074_000 picoseconds. - Weight::from_parts(2_166_000, 1627) + // Minimum execution time: 2_000_000 picoseconds. + Weight::from_parts(2_142_000, 1627) .saturating_add(RocksDbWeight::get().reads(1_u64)) } /// Storage: `Skipped::Metadata` (r:0 w:0) @@ -1007,10 +1006,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `452 + k * (69 ±0)` // Estimated: `442 + k * (70 ±0)` - // Minimum execution time: 12_411_000 picoseconds. - Weight::from_parts(12_587_000, 442) - // Standard Error: 1_213 - .saturating_add(Weight::from_parts(1_149_896, 0).saturating_mul(k.into())) + // Minimum execution time: 12_095_000 picoseconds. + Weight::from_parts(12_699_000, 442) + // Standard Error: 891 + .saturating_add(Weight::from_parts(1_114_063, 0).saturating_mul(k.into())) .saturating_add(RocksDbWeight::get().reads(2_u64)) .saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(k.into()))) .saturating_add(RocksDbWeight::get().writes(2_u64)) @@ -1024,10 +1023,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `211 + c * (1 ±0)` // Estimated: `6149 + c * (1 ±0)` - // Minimum execution time: 8_308_000 picoseconds. - Weight::from_parts(9_014_393, 6149) - // Standard Error: 0 - .saturating_add(Weight::from_parts(1_169, 0).saturating_mul(c.into())) + // Minimum execution time: 8_433_000 picoseconds. + Weight::from_parts(8_992_328, 6149) + // Standard Error: 1 + .saturating_add(Weight::from_parts(1_207, 0).saturating_mul(c.into())) .saturating_add(RocksDbWeight::get().reads(2_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(c.into())) @@ -1040,8 +1039,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `510` // Estimated: `6450` - // Minimum execution time: 16_847_000 picoseconds. - Weight::from_parts(17_478_000, 6450) + // Minimum execution time: 16_415_000 picoseconds. + Weight::from_parts(17_348_000, 6450) .saturating_add(RocksDbWeight::get().reads(3_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -1054,10 +1053,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `171 + k * (1 ±0)` // Estimated: `3635 + k * (1 ±0)` - // Minimum execution time: 3_456_000 picoseconds. - Weight::from_parts(3_534_000, 3635) - // Standard Error: 679 - .saturating_add(Weight::from_parts(1_224_649, 0).saturating_mul(k.into())) + // Minimum execution time: 3_433_000 picoseconds. + Weight::from_parts(3_490_000, 3635) + // Standard Error: 1_043 + .saturating_add(Weight::from_parts(1_225_953, 0).saturating_mul(k.into())) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(2_u64)) .saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(k.into()))) @@ -1076,10 +1075,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `325 + c * (1 ±0)` // Estimated: `6263 + c * (1 ±0)` - // Minimum execution time: 16_933_000 picoseconds. - Weight::from_parts(16_929_238, 6263) + // Minimum execution time: 16_421_000 picoseconds. + Weight::from_parts(16_822_963, 6263) // Standard Error: 0 - .saturating_add(Weight::from_parts(405, 0).saturating_mul(c.into())) + .saturating_add(Weight::from_parts(456, 0).saturating_mul(c.into())) .saturating_add(RocksDbWeight::get().reads(4_u64)) .saturating_add(RocksDbWeight::get().writes(2_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(c.into())) @@ -1090,8 +1089,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `440` // Estimated: `6380` - // Minimum execution time: 12_826_000 picoseconds. - Weight::from_parts(13_566_000, 6380) + // Minimum execution time: 12_569_000 picoseconds. + Weight::from_parts(13_277_000, 6380) .saturating_add(RocksDbWeight::get().reads(2_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -1105,8 +1104,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `352` // Estimated: `6292` - // Minimum execution time: 48_129_000 picoseconds. - Weight::from_parts(49_472_000, 6292) + // Minimum execution time: 46_777_000 picoseconds. + Weight::from_parts(47_690_000, 6292) .saturating_add(RocksDbWeight::get().reads(4_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -1118,8 +1117,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `594` // Estimated: `6534` - // Minimum execution time: 55_401_000 picoseconds. - Weight::from_parts(57_543_000, 6534) + // Minimum execution time: 55_280_000 picoseconds. + Weight::from_parts(57_081_000, 6534) .saturating_add(RocksDbWeight::get().reads(4_u64)) .saturating_add(RocksDbWeight::get().writes(2_u64)) } @@ -1129,8 +1128,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `409` // Estimated: `6349` - // Minimum execution time: 12_066_000 picoseconds. - Weight::from_parts(12_386_000, 6349) + // Minimum execution time: 12_077_000 picoseconds. + Weight::from_parts(12_647_000, 6349) .saturating_add(RocksDbWeight::get().reads(2_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -1140,8 +1139,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `142` // Estimated: `1627` - // Minimum execution time: 2_394_000 picoseconds. - Weight::from_parts(2_695_000, 1627) + // Minimum execution time: 2_559_000 picoseconds. + Weight::from_parts(2_711_000, 1627) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -1153,8 +1152,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `166` // Estimated: `3631` - // Minimum execution time: 12_286_000 picoseconds. - Weight::from_parts(12_764_000, 3631) + // Minimum execution time: 12_238_000 picoseconds. + Weight::from_parts(12_627_000, 3631) .saturating_add(RocksDbWeight::get().reads(2_u64)) .saturating_add(RocksDbWeight::get().writes(2_u64)) } @@ -1164,8 +1163,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `142` // Estimated: `3607` - // Minimum execution time: 4_888_000 picoseconds. - Weight::from_parts(5_192_000, 3607) + // Minimum execution time: 4_836_000 picoseconds. + Weight::from_parts(5_086_000, 3607) .saturating_add(RocksDbWeight::get().reads(1_u64)) } /// Storage: UNKNOWN KEY `0x4342193e496fab7ec59d615ed0dc55304e7b9012096b41c4eb3aaf947f6ea429` (r:1 w:0) @@ -1176,8 +1175,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `167` // Estimated: `3632` - // Minimum execution time: 6_033_000 picoseconds. - Weight::from_parts(6_404_000, 3632) + // Minimum execution time: 6_147_000 picoseconds. + Weight::from_parts(6_380_000, 3632) .saturating_add(RocksDbWeight::get().reads(2_u64)) } /// Storage: UNKNOWN KEY `0x4342193e496fab7ec59d615ed0dc55304e7b9012096b41c4eb3aaf947f6ea429` (r:1 w:0) @@ -1188,8 +1187,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `142` // Estimated: `3607` - // Minimum execution time: 6_260_000 picoseconds. - Weight::from_parts(6_761_000, 3607) + // Minimum execution time: 6_140_000 picoseconds. + Weight::from_parts(6_670_000, 3607) .saturating_add(RocksDbWeight::get().reads(2_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -1210,10 +1209,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `801 + c * (1 ±0)` // Estimated: `4264 + c * (1 ±0)` - // Minimum execution time: 282_827_000 picoseconds. - Weight::from_parts(268_595_710, 4264) - // Standard Error: 74 - .saturating_add(Weight::from_parts(33_961, 0).saturating_mul(c.into())) + // Minimum execution time: 354_459_000 picoseconds. + Weight::from_parts(332_397_871, 4264) + // Standard Error: 70 + .saturating_add(Weight::from_parts(33_775, 0).saturating_mul(c.into())) .saturating_add(RocksDbWeight::get().reads(6_u64)) .saturating_add(RocksDbWeight::get().writes(2_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(c.into())) @@ -1241,14 +1240,14 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `323` // Estimated: `6262` - // Minimum execution time: 4_039_064_000 picoseconds. - Weight::from_parts(511_488_092, 6262) - // Standard Error: 154 - .saturating_add(Weight::from_parts(68_951, 0).saturating_mul(c.into())) - // Standard Error: 18 - .saturating_add(Weight::from_parts(1_740, 0).saturating_mul(i.into())) - // Standard Error: 18 - .saturating_add(Weight::from_parts(1_737, 0).saturating_mul(s.into())) + // Minimum execution time: 4_239_452_000 picoseconds. + Weight::from_parts(800_849_282, 6262) + // Standard Error: 117 + .saturating_add(Weight::from_parts(68_435, 0).saturating_mul(c.into())) + // Standard Error: 14 + .saturating_add(Weight::from_parts(1_653, 0).saturating_mul(i.into())) + // Standard Error: 14 + .saturating_add(Weight::from_parts(1_668, 0).saturating_mul(s.into())) .saturating_add(RocksDbWeight::get().reads(8_u64)) .saturating_add(RocksDbWeight::get().writes(7_u64)) } @@ -1274,12 +1273,12 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `560` // Estimated: `4029` - // Minimum execution time: 2_043_035_000 picoseconds. - Weight::from_parts(2_056_535_000, 4029) + // Minimum execution time: 2_085_570_000 picoseconds. + Weight::from_parts(2_112_501_000, 4029) // Standard Error: 26 - .saturating_add(Weight::from_parts(907, 0).saturating_mul(i.into())) + .saturating_add(Weight::from_parts(888, 0).saturating_mul(i.into())) // Standard Error: 26 - .saturating_add(Weight::from_parts(797, 0).saturating_mul(s.into())) + .saturating_add(Weight::from_parts(795, 0).saturating_mul(s.into())) .saturating_add(RocksDbWeight::get().reads(8_u64)) .saturating_add(RocksDbWeight::get().writes(5_u64)) } @@ -1299,8 +1298,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `826` // Estimated: `4291` - // Minimum execution time: 197_670_000 picoseconds. - Weight::from_parts(207_490_000, 4291) + // Minimum execution time: 201_900_000 picoseconds. + Weight::from_parts(206_738_000, 4291) .saturating_add(RocksDbWeight::get().reads(6_u64)) .saturating_add(RocksDbWeight::get().writes(2_u64)) } @@ -1317,10 +1316,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `142` // Estimated: `3607` - // Minimum execution time: 268_742_000 picoseconds. - Weight::from_parts(271_032_265, 3607) - // Standard Error: 67 - .saturating_add(Weight::from_parts(33_877, 0).saturating_mul(c.into())) + // Minimum execution time: 330_704_000 picoseconds. + Weight::from_parts(345_129_342, 3607) + // Standard Error: 51 + .saturating_add(Weight::from_parts(33_126, 0).saturating_mul(c.into())) .saturating_add(RocksDbWeight::get().reads(3_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) } @@ -1337,10 +1336,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `142` // Estimated: `3607` - // Minimum execution time: 262_093_000 picoseconds. - Weight::from_parts(284_700_466, 3607) - // Standard Error: 64 - .saturating_add(Weight::from_parts(33_947, 0).saturating_mul(c.into())) + // Minimum execution time: 343_339_000 picoseconds. + Weight::from_parts(356_479_729, 3607) + // Standard Error: 49 + .saturating_add(Weight::from_parts(33_404, 0).saturating_mul(c.into())) .saturating_add(RocksDbWeight::get().reads(3_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) } @@ -1356,8 +1355,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `315` // Estimated: `3780` - // Minimum execution time: 41_895_000 picoseconds. - Weight::from_parts(43_710_000, 3780) + // Minimum execution time: 42_241_000 picoseconds. + Weight::from_parts(43_365_000, 3780) .saturating_add(RocksDbWeight::get().reads(3_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) } @@ -1371,8 +1370,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `552` // Estimated: `6492` - // Minimum execution time: 26_308_000 picoseconds. - Weight::from_parts(27_330_000, 6492) + // Minimum execution time: 26_318_000 picoseconds. + Weight::from_parts(27_840_000, 6492) .saturating_add(RocksDbWeight::get().reads(4_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) } @@ -1381,17 +1380,17 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 9_599_000 picoseconds. - Weight::from_parts(9_964_505, 0) - // Standard Error: 74 - .saturating_add(Weight::from_parts(71_132, 0).saturating_mul(r.into())) + // Minimum execution time: 9_397_000 picoseconds. + Weight::from_parts(9_318_986, 0) + // Standard Error: 72 + .saturating_add(Weight::from_parts(72_994, 0).saturating_mul(r.into())) } fn seal_caller() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 621_000 picoseconds. - Weight::from_parts(669_000, 0) + // Minimum execution time: 644_000 picoseconds. + Weight::from_parts(687_000, 0) } /// Storage: `Contracts::ContractInfoOf` (r:1 w:0) /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) @@ -1399,8 +1398,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `354` // Estimated: `3819` - // Minimum execution time: 6_787_000 picoseconds. - Weight::from_parts(7_039_000, 3819) + // Minimum execution time: 6_465_000 picoseconds. + Weight::from_parts(6_850_000, 3819) .saturating_add(RocksDbWeight::get().reads(1_u64)) } /// Storage: `Contracts::ContractInfoOf` (r:1 w:0) @@ -1409,79 +1408,79 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `447` // Estimated: `3912` - // Minimum execution time: 7_839_000 picoseconds. - Weight::from_parts(8_154_000, 3912) + // Minimum execution time: 7_735_000 picoseconds. + Weight::from_parts(8_115_000, 3912) .saturating_add(RocksDbWeight::get().reads(1_u64)) } fn seal_own_code_hash() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 729_000 picoseconds. - Weight::from_parts(805_000, 0) + // Minimum execution time: 717_000 picoseconds. + Weight::from_parts(791_000, 0) } fn seal_caller_is_origin() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 422_000 picoseconds. - Weight::from_parts(442_000, 0) + // Minimum execution time: 365_000 picoseconds. + Weight::from_parts(427_000, 0) } fn seal_caller_is_root() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 327_000 picoseconds. - Weight::from_parts(361_000, 0) + // Minimum execution time: 331_000 picoseconds. + Weight::from_parts(363_000, 0) } fn seal_address() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 572_000 picoseconds. - Weight::from_parts(627_000, 0) + // Minimum execution time: 586_000 picoseconds. + Weight::from_parts(625_000, 0) } fn seal_gas_left() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 698_000 picoseconds. - Weight::from_parts(731_000, 0) + // Minimum execution time: 680_000 picoseconds. + Weight::from_parts(734_000, 0) } fn seal_balance() -> Weight { // Proof Size summary in bytes: // Measured: `140` // Estimated: `0` - // Minimum execution time: 4_569_000 picoseconds. - Weight::from_parts(4_823_000, 0) + // Minimum execution time: 4_732_000 picoseconds. + Weight::from_parts(5_008_000, 0) } fn seal_value_transferred() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 563_000 picoseconds. - Weight::from_parts(591_000, 0) + // Minimum execution time: 608_000 picoseconds. + Weight::from_parts(635_000, 0) } fn seal_minimum_balance() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 567_000 picoseconds. - Weight::from_parts(592_000, 0) + // Minimum execution time: 571_000 picoseconds. + Weight::from_parts(606_000, 0) } fn seal_block_number() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 534_000 picoseconds. - Weight::from_parts(586_000, 0) + // Minimum execution time: 511_000 picoseconds. + Weight::from_parts(584_000, 0) } fn seal_now() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 507_000 picoseconds. - Weight::from_parts(577_000, 0) + // Minimum execution time: 552_000 picoseconds. + Weight::from_parts(612_000, 0) } /// Storage: `TransactionPayment::NextFeeMultiplier` (r:1 w:0) /// Proof: `TransactionPayment::NextFeeMultiplier` (`max_values`: Some(1), `max_size`: Some(16), added: 511, mode: `Measured`) @@ -1489,8 +1488,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `67` // Estimated: `1552` - // Minimum execution time: 4_331_000 picoseconds. - Weight::from_parts(4_582_000, 1552) + // Minimum execution time: 4_396_000 picoseconds. + Weight::from_parts(4_630_000, 1552) .saturating_add(RocksDbWeight::get().reads(1_u64)) } /// The range of component `n` is `[0, 1048572]`. @@ -1498,8 +1497,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 435_000 picoseconds. - Weight::from_parts(500_000, 0) + // Minimum execution time: 494_000 picoseconds. + Weight::from_parts(510_000, 0) // Standard Error: 3 .saturating_add(Weight::from_parts(303, 0).saturating_mul(n.into())) } @@ -1508,10 +1507,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 331_000 picoseconds. - Weight::from_parts(356_000, 0) + // Minimum execution time: 311_000 picoseconds. + Weight::from_parts(346_000, 0) // Standard Error: 9 - .saturating_add(Weight::from_parts(423, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(480, 0).saturating_mul(n.into())) } /// Storage: `Contracts::DeletionQueueCounter` (r:1 w:1) /// Proof: `Contracts::DeletionQueueCounter` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`) @@ -1524,10 +1523,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `319 + n * (78 ±0)` // Estimated: `3784 + n * (2553 ±0)` - // Minimum execution time: 14_488_000 picoseconds. - Weight::from_parts(16_354_601, 3784) - // Standard Error: 7_864 - .saturating_add(Weight::from_parts(3_700_384, 0).saturating_mul(n.into())) + // Minimum execution time: 14_403_000 picoseconds. + Weight::from_parts(16_478_113, 3784) + // Standard Error: 6_667 + .saturating_add(Weight::from_parts(3_641_603, 0).saturating_mul(n.into())) .saturating_add(RocksDbWeight::get().reads(2_u64)) .saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(n.into()))) .saturating_add(RocksDbWeight::get().writes(3_u64)) @@ -1540,8 +1539,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `76` // Estimated: `1561` - // Minimum execution time: 3_470_000 picoseconds. - Weight::from_parts(3_637_000, 1561) + // Minimum execution time: 3_639_000 picoseconds. + Weight::from_parts(3_801_000, 1561) .saturating_add(RocksDbWeight::get().reads(1_u64)) } /// Storage: `System::EventTopics` (r:4 w:4) @@ -1552,12 +1551,12 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `0` // Estimated: `990 + t * (2475 ±0)` - // Minimum execution time: 4_046_000 picoseconds. - Weight::from_parts(4_233_938, 990) - // Standard Error: 7_203 - .saturating_add(Weight::from_parts(2_402_117, 0).saturating_mul(t.into())) - // Standard Error: 2 - .saturating_add(Weight::from_parts(27, 0).saturating_mul(n.into())) + // Minimum execution time: 4_102_000 picoseconds. + Weight::from_parts(4_256_984, 990) + // Standard Error: 6_777 + .saturating_add(Weight::from_parts(2_331_893, 0).saturating_mul(t.into())) + // Standard Error: 1 + .saturating_add(Weight::from_parts(31, 0).saturating_mul(n.into())) .saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(t.into()))) .saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(t.into()))) .saturating_add(Weight::from_parts(0, 2475).saturating_mul(t.into())) @@ -1567,10 +1566,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 421_000 picoseconds. - Weight::from_parts(456_000, 0) + // Minimum execution time: 385_000 picoseconds. + Weight::from_parts(427_000, 0) // Standard Error: 10 - .saturating_add(Weight::from_parts(1_217, 0).saturating_mul(i.into())) + .saturating_add(Weight::from_parts(1_272, 0).saturating_mul(i.into())) } /// Storage: `Skipped::Metadata` (r:0 w:0) /// Proof: `Skipped::Metadata` (`max_values`: None, `max_size`: None, mode: `Measured`) @@ -1580,12 +1579,12 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `250 + o * (1 ±0)` // Estimated: `249 + o * (1 ±0)` - // Minimum execution time: 9_900_000 picoseconds. - Weight::from_parts(9_611_602, 249) + // Minimum execution time: 10_128_000 picoseconds. + Weight::from_parts(9_963_519, 249) // Standard Error: 1 - .saturating_add(Weight::from_parts(282, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(327, 0).saturating_mul(n.into())) // Standard Error: 1 - .saturating_add(Weight::from_parts(70, 0).saturating_mul(o.into())) + .saturating_add(Weight::from_parts(58, 0).saturating_mul(o.into())) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(o.into())) @@ -1597,10 +1596,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `248 + n * (1 ±0)` // Estimated: `248 + n * (1 ±0)` - // Minimum execution time: 7_965_000 picoseconds. - Weight::from_parts(9_211_072, 248) + // Minimum execution time: 7_921_000 picoseconds. + Weight::from_parts(9_290_526, 248) // Standard Error: 2 - .saturating_add(Weight::from_parts(82, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(77, 0).saturating_mul(n.into())) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) @@ -1612,10 +1611,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `248 + n * (1 ±0)` // Estimated: `248 + n * (1 ±0)` - // Minimum execution time: 6_851_000 picoseconds. - Weight::from_parts(8_930_522, 248) + // Minimum execution time: 7_403_000 picoseconds. + Weight::from_parts(8_815_037, 248) // Standard Error: 3 - .saturating_add(Weight::from_parts(647, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(701, 0).saturating_mul(n.into())) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) } @@ -1626,10 +1625,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `248 + n * (1 ±0)` // Estimated: `248 + n * (1 ±0)` - // Minimum execution time: 6_602_000 picoseconds. - Weight::from_parts(7_843_808, 248) + // Minimum execution time: 6_590_000 picoseconds. + Weight::from_parts(7_949_861, 248) // Standard Error: 2 - .saturating_add(Weight::from_parts(85, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(76, 0).saturating_mul(n.into())) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) } @@ -1640,10 +1639,10 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `248 + n * (1 ±0)` // Estimated: `248 + n * (1 ±0)` - // Minimum execution time: 8_245_000 picoseconds. - Weight::from_parts(9_953_659, 248) - // Standard Error: 2 - .saturating_add(Weight::from_parts(654, 0).saturating_mul(n.into())) + // Minimum execution time: 7_900_000 picoseconds. + Weight::from_parts(9_988_151, 248) + // Standard Error: 3 + .saturating_add(Weight::from_parts(703, 0).saturating_mul(n.into())) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) @@ -1652,8 +1651,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `140` // Estimated: `0` - // Minimum execution time: 8_993_000 picoseconds. - Weight::from_parts(9_445_000, 0) + // Minimum execution time: 9_023_000 picoseconds. + Weight::from_parts(9_375_000, 0) } /// Storage: `Contracts::ContractInfoOf` (r:1 w:1) /// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`) @@ -1664,18 +1663,17 @@ impl WeightInfo for () { /// Storage: `System::Account` (r:1 w:1) /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`) /// The range of component `t` is `[0, 1]`. - /// The range of component `c` is `[0, 1]`. /// The range of component `i` is `[0, 1048576]`. fn seal_call(t: u32, i: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `620 + t * (280 ±0)` // Estimated: `4085 + t * (2182 ±0)` - // Minimum execution time: 151_051_000 picoseconds. - Weight::from_parts(164_928_785, 4085) - // Standard Error: 344_718 - .saturating_add(Weight::from_parts(40_015_500, 0).saturating_mul(t.into())) + // Minimum execution time: 157_109_000 picoseconds. + Weight::from_parts(159_458_069, 4085) + // Standard Error: 339_702 + .saturating_add(Weight::from_parts(44_066_869, 0).saturating_mul(t.into())) // Standard Error: 0 - .saturating_add(Weight::from_parts(2, 0).saturating_mul(i.into())) + .saturating_add(Weight::from_parts(6, 0).saturating_mul(i.into())) .saturating_add(RocksDbWeight::get().reads(3_u64)) .saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(t.into()))) .saturating_add(RocksDbWeight::get().writes(1_u64)) @@ -1690,8 +1688,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `430` // Estimated: `3895` - // Minimum execution time: 138_670_000 picoseconds. - Weight::from_parts(144_148_000, 3895) + // Minimum execution time: 143_384_000 picoseconds. + Weight::from_parts(147_554_000, 3895) .saturating_add(RocksDbWeight::get().reads(2_u64)) } /// Storage: `Contracts::CodeInfoOf` (r:1 w:1) @@ -1711,14 +1709,14 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `676` // Estimated: `4138` - // Minimum execution time: 1_744_236_000 picoseconds. - Weight::from_parts(67_596_989, 4138) - // Standard Error: 6_993_227 - .saturating_add(Weight::from_parts(156_283_395, 0).saturating_mul(t.into())) - // Standard Error: 11 - .saturating_add(Weight::from_parts(1_489, 0).saturating_mul(i.into())) - // Standard Error: 11 - .saturating_add(Weight::from_parts(1_781, 0).saturating_mul(s.into())) + // Minimum execution time: 1_798_243_000 picoseconds. + Weight::from_parts(82_642_573, 4138) + // Standard Error: 6_831_260 + .saturating_add(Weight::from_parts(159_867_027, 0).saturating_mul(t.into())) + // Standard Error: 10 + .saturating_add(Weight::from_parts(1_534, 0).saturating_mul(i.into())) + // Standard Error: 10 + .saturating_add(Weight::from_parts(1_809, 0).saturating_mul(s.into())) .saturating_add(RocksDbWeight::get().reads(5_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) } @@ -1727,64 +1725,64 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 838_000 picoseconds. - Weight::from_parts(855_000, 0) + // Minimum execution time: 875_000 picoseconds. + Weight::from_parts(904_000, 0) // Standard Error: 0 - .saturating_add(Weight::from_parts(1_083, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(1_145, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 1048576]`. fn seal_hash_keccak_256(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_449_000 picoseconds. - Weight::from_parts(1_466_000, 0) + // Minimum execution time: 1_475_000 picoseconds. + Weight::from_parts(1_551_000, 0) // Standard Error: 0 - .saturating_add(Weight::from_parts(3_350, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(3_410, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 1048576]`. fn seal_hash_blake2_256(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 759_000 picoseconds. - Weight::from_parts(800_000, 0) + // Minimum execution time: 821_000 picoseconds. + Weight::from_parts(850_000, 0) // Standard Error: 0 - .saturating_add(Weight::from_parts(1_218, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(1_279, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 1048576]`. fn seal_hash_blake2_128(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 714_000 picoseconds. - Weight::from_parts(733_000, 0) + // Minimum execution time: 747_000 picoseconds. + Weight::from_parts(773_000, 0) // Standard Error: 0 - .saturating_add(Weight::from_parts(1_220, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(1_276, 0).saturating_mul(n.into())) } /// The range of component `n` is `[0, 125697]`. fn seal_sr25519_verify(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 47_253_000 picoseconds. - Weight::from_parts(51_184_900, 0) + // Minimum execution time: 43_154_000 picoseconds. + Weight::from_parts(45_087_558, 0) // Standard Error: 9 - .saturating_add(Weight::from_parts(4_602, 0).saturating_mul(n.into())) + .saturating_add(Weight::from_parts(4_628, 0).saturating_mul(n.into())) } fn seal_ecdsa_recover() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 47_378_000 picoseconds. - Weight::from_parts(49_505_000, 0) + // Minimum execution time: 47_193_000 picoseconds. + Weight::from_parts(48_514_000, 0) } fn seal_ecdsa_to_eth_address() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 13_088_000 picoseconds. - Weight::from_parts(13_299_000, 0) + // Minimum execution time: 13_083_000 picoseconds. + Weight::from_parts(13_218_000, 0) } /// Storage: `Contracts::CodeInfoOf` (r:1 w:1) /// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`) @@ -1794,8 +1792,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `430` // Estimated: `3895` - // Minimum execution time: 19_326_000 picoseconds. - Weight::from_parts(20_179_000, 3895) + // Minimum execution time: 19_308_000 picoseconds. + Weight::from_parts(20_116_000, 3895) .saturating_add(RocksDbWeight::get().reads(2_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -1805,8 +1803,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `355` // Estimated: `3820` - // Minimum execution time: 9_432_000 picoseconds. - Weight::from_parts(9_851_000, 3820) + // Minimum execution time: 9_271_000 picoseconds. + Weight::from_parts(9_640_000, 3820) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -1816,8 +1814,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `355` // Estimated: `3558` - // Minimum execution time: 8_359_000 picoseconds. - Weight::from_parts(8_676_000, 3558) + // Minimum execution time: 8_182_000 picoseconds. + Weight::from_parts(8_343_000, 3558) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -1826,14 +1824,14 @@ impl WeightInfo for () { // Measured: `0` // Estimated: `0` // Minimum execution time: 320_000 picoseconds. - Weight::from_parts(366_000, 0) + Weight::from_parts(347_000, 0) } fn seal_account_reentrance_count() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 342_000 picoseconds. - Weight::from_parts(379_000, 0) + // Minimum execution time: 345_000 picoseconds. + Weight::from_parts(370_000, 0) } /// Storage: `Contracts::Nonce` (r:1 w:0) /// Proof: `Contracts::Nonce` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`) @@ -1841,8 +1839,8 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `219` // Estimated: `1704` - // Minimum execution time: 3_001_000 picoseconds. - Weight::from_parts(3_163_000, 1704) + // Minimum execution time: 2_998_000 picoseconds. + Weight::from_parts(3_221_000, 1704) .saturating_add(RocksDbWeight::get().reads(1_u64)) } /// The range of component `r` is `[0, 5000]`. @@ -1850,9 +1848,9 @@ impl WeightInfo for () { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 952_000 picoseconds. - Weight::from_parts(571_197, 0) - // Standard Error: 19 - .saturating_add(Weight::from_parts(14_886, 0).saturating_mul(r.into())) + // Minimum execution time: 1_002_000 picoseconds. + Weight::from_parts(1_094_958, 0) + // Standard Error: 12 + .saturating_add(Weight::from_parts(14_531, 0).saturating_mul(r.into())) } }